Added samantha which can retrieve the weather

Author: djthorpe

cmd/api/main.go

@@ -22,6 +22,7 @@ func main() {
 	anthropicRegister(flags)
 	newsapiRegister(flags)
 	weatherapiRegister(flags)
+	samRegister(flags)
 
 	// Parse command line and return function to run
 	fn, args, err := flags.Parse(os.Args[1:])

cmd/api/samantha.go

@@ -0,0 +1,135 @@
+package main
+
+import (
+	"bufio"
+	"context"
+	"encoding/json"
+	"fmt"
+	"os"
+	"strings"
+
+	// Packages
+	"github.com/djthorpe/go-tablewriter"
+	"github.com/mutablelogic/go-client"
+	"github.com/mutablelogic/go-client/pkg/anthropic"
+	"github.com/mutablelogic/go-client/pkg/openai/schema"
+)
+
+///////////////////////////////////////////////////////////////////////////////
+// GLOBALS
+
+var (
+	samName         = "sam"
+	samWeatherTool  = schema.NewTool("get_weather", "Get the weather for a location")
+	samSystemPrompt = "Your name is Samantha, you are a friendly AI assistant, here to help you with anything you need. Your responses should be short and to the point, and you should always be polite."
+)
+
+///////////////////////////////////////////////////////////////////////////////
+// LIFECYCLE
+
+func samRegister(flags *Flags) {
+	flags.Register(Cmd{
+		Name:        samName,
+		Description: "Interact with Samantha, a friendly AI assistant",
+		Parse:       samParse,
+		Fn: []Fn{
+			{Name: "chat", Call: samChat, Description: "Chat with Sam"},
+		},
+	})
+}
+
+func samParse(flags *Flags, opts ...client.ClientOpt) error {
+	// Initialize weather
+	if err := weatherapiParse(flags, opts...); err != nil {
+		return err
+	}
+
+	// Initialize anthropic
+	opts = append(opts, client.OptHeader("Anthropic-Beta", "tools-2024-04-04"))
+	if err := anthropicParse(flags, opts...); err != nil {
+		return err
+	}
+
+	// Add tool parameters
+	if err := samWeatherTool.AddParameter("location", "The city to get the weather for", true); err != nil {
+		return err
+	}
+
+	// Return success
+	return nil
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// METHODS
+
+func samChat(ctx context.Context, w *tablewriter.Writer, _ []string) error {
+	var toolResult bool
+
+	messages := []*schema.Message{}
+	for {
+		if ctx.Err() != nil {
+			return nil
+		}
+
+		// Read if there hasn't been any tool results yet
+		if !toolResult {
+			reader := bufio.NewReader(os.Stdin)
+			fmt.Print("Chat: ")
+			text, err := reader.ReadString('\n')
+			if err != nil {
+				return err
+			}
+			messages = append(messages, schema.NewMessage("user", schema.Text(strings.TrimSpace(text))))
+		}
+
+		// Request -> Response
+		responses, err := anthropicClient.Messages(ctx, messages, anthropic.OptSystem(samSystemPrompt), anthropic.OptTool(samWeatherTool))
+		if err != nil {
+			return err
+		}
+		toolResult = false
+
+		for _, response := range responses {
+			switch response.Type {
+			case "text":
+				messages = samAppend(messages, schema.NewMessage("assistant", schema.Text(response.Text)))
+				fmt.Println(response.Text)
+				fmt.Println("")
+			case "tool_use":
+				messages = samAppend(messages, schema.NewMessage("assistant", response))
+				result := samCall(ctx, response)
+				messages = samAppend(messages, schema.NewMessage("user", result))
+				toolResult = true
+			}
+		}
+	}
+}
+
+func samCall(_ context.Context, content schema.Content) *schema.Content {
+	if content.Type != "tool_use" {
+		return schema.ToolResult(content.Id, fmt.Sprint("unexpected content type:", content.Type))
+	}
+	switch content.Name {
+	case samWeatherTool.Name:
+		if location, exists := content.GetString(content.Name, "location"); exists {
+			if weather, err := weatherapiClient.Current(location); err != nil {
+				return schema.ToolResult(content.Id, fmt.Sprint("Unable to get the current weather, the error is ", err))
+			} else if data, err := json.MarshalIndent(weather, "", "  "); err != nil {
+				return schema.ToolResult(content.Id, fmt.Sprint("Unable to marshal the weather data, the error is ", err))
+			} else {
+				return schema.ToolResult(content.Id, string(data))
+			}
+		}
+	}
+	return schema.ToolResult(content.Id, fmt.Sprint("unable to call:", content.Name))
+}
+
+func samAppend(messages []*schema.Message, message *schema.Message) []*schema.Message {
+	// if the previous message was of the same role, then append the new message to the previous one
+	if len(messages) > 0 && messages[len(messages)-1].Role == message.Role {
+		messages[len(messages)-1].Add(message.Content)
+		return messages
+	} else {
+		return append(messages, message)
+	}
+}

pkg/openai/schema/message.go

@@ -46,6 +46,9 @@ type Content struct {
 	Text   string         `json:"text,omitempty,wrap,width:60"`
 	Source *contentSource `json:"source,omitempty"`
 	toolUse
+
+	ToolId string `json:"tool_use_id,omitempty"`
+	Result string `json:"content,omitempty"`
 }
 
 // Content Source
@@ -55,12 +58,18 @@ type contentSource struct {
 	Data      string `json:"data,omitempty"`
 }
 
-// Tool arguments
+// Tool call
 type toolUse struct {
 	Name  string         `json:"name,omitempty"`
 	Input map[string]any `json:"input,omitempty"`
 }
 
+// Tool result
+type toolResult struct {
+	ToolId string `json:"tool_use_id,omitempty"`
+	Result string `json:"content,omitempty"`
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // LIFECYCLE
 
@@ -112,6 +121,11 @@ func ImageData(path string) (*Content, error) {
 	return Image(r)
 }
 
+// Return a tool result
+func ToolResult(id string, result string) *Content {
+	return &Content{Type: "tool_result", ToolId: id, Result: result}
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // STRINGIFY
 
@@ -148,6 +162,19 @@ func (m *Message) Add(content ...any) *Message {
 	return m
 }
 
+// Return an input parameter as a string, returns false if the name
+// is incorrect or the input doesn't exist
+func (c Content) GetString(name, input string) (string, bool) {
+	if c.Name == name {
+		if value, exists := c.Input[input]; exists {
+			if value, ok := value.(string); ok {
+				return value, true
+			}
+		}
+	}
+	return "", false
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // PRIVATE METHODS
 
@@ -210,6 +237,10 @@ func (m *Message) append(v any) error {
 			// []Content, Content => []Content
 			m.Content = append(m.Content.([]Content), v)
 			return nil
+		case []Content:
+			// []Content, []Content => []Content
+			m.Content = append(m.Content.([]Content), v...)
+			return nil
 		}
 	}
 	return ErrBadParameter.With("append: not implemented for ", reflect.TypeOf(m.Content), ",", reflect.TypeOf(v))
@@ -218,16 +249,16 @@ func (m *Message) append(v any) error {
 // Set the message content
 func (m *Message) set(v any) error {
 	// Append content to messages,
-	// m.Content will be of type string, []string, Content or []Content
+	// m.Content will be of type string, []string or []Content
 	switch v := v.(type) {
 	case string:
 		m.Content = v
 	case []string:
 		m.Content = v
 	case *Content:
-		m.Content = *v
+		m.Content = []Content{*v}
 	case Content:
-		m.Content = v
+		m.Content = []Content{v}
 	case []*Content:
 		if len(v) > 0 {
 			m.Content = make([]Content, 0, len(v))