Added tools for anthropic

Author: djthorpe

pkg/anthropic/message.go

@@ -20,16 +20,26 @@ import (
 // TYPES
 
 type reqMessage struct {
-	Model     string            `json:"model"`
-	Messages  []*schema.Message `json:"messages,omitempty"`
-	Stream    bool              `json:"stream,omitempty"`
-	System    string            `json:"system,omitempty"`
-	MaxTokens int               `json:"max_tokens,omitempty"`
+	Model         string            `json:"model"`
+	Messages      []*schema.Message `json:"messages,omitempty"`
+	Stream        bool              `json:"stream,omitempty"`
+	System        string            `json:"system,omitempty"`
+	MaxTokens     int               `json:"max_tokens,omitempty"`
+	Metadata      *reqMetadata      `json:"metadata,omitempty"`
+	StopSequences []string          `json:"stop_sequences,omitempty"`
+	Temperature   float64           `json:"temperature,omitempty"`
+	TopK          int               `json:"top_k,omitempty"`
+	TopP          float64           `json:"top_p,omitempty"`
+	Tools         []schema.Tool     `json:"tools,omitempty"`
 
 	// Callbacks
 	delta Callback `json:"-"`
 }
 
+type reqMetadata struct {
+	User string `json:"user_id,omitempty"`
+}
+
 type respMessage struct {
 	Id      string           `json:"id"`
 	Type    string           `json:"type,omitempty"`
@@ -87,7 +97,7 @@ const (
 // Send a structured list of input messages with text and/or image content,
 // and the model will generate the next message in the conversation. Use
 // a context to cancel the request, instead of the client-related timeout.
-func (c *Client) Messages(ctx context.Context, messages []*schema.Message, opt ...Opt) (*schema.Content, error) {
+func (c *Client) Messages(ctx context.Context, messages []*schema.Message, opt ...Opt) ([]schema.Content, error) {
 	var request reqMessage
 	var response respMessage
 
@@ -120,10 +130,10 @@ func (c *Client) Messages(ctx context.Context, messages []*schema.Message, opt .
 		return nil, ErrInternalAppError.With("No content returned")
 	}
 
-	// TODO: Somehow return Usage and Stop information
+	// TODO: Somehow return Usage and Stop information back to the caller
 
 	// Return success
-	return &response.Content[0], nil
+	return response.Content, nil
 }
 
 ///////////////////////////////////////////////////////////////////////////////

pkg/anthropic/message_test.go

@@ -17,8 +17,9 @@ func Test_message_001(t *testing.T) {
 	assert.NoError(err)
 	assert.NotNil(client)
 	msg := schema.NewMessage("user", "What is the weather today")
-	_, err = client.Messages(context.Background(), []*schema.Message{msg})
+	content, err := client.Messages(context.Background(), []*schema.Message{msg})
 	assert.NoError(err)
+	t.Log(content)
 }
 
 func Test_message_002(t *testing.T) {
@@ -27,8 +28,26 @@ func Test_message_002(t *testing.T) {
 	assert.NoError(err)
 	assert.NotNil(client)
 	msg := schema.NewMessage("user", "What is the weather today")
-	_, err = client.Messages(context.Background(), []*schema.Message{msg}, anthropic.OptStream(func(v *anthropic.Delta) {
+	content, err := client.Messages(context.Background(), []*schema.Message{msg}, anthropic.OptStream(func(v *anthropic.Delta) {
 		t.Log(v)
 	}))
 	assert.NoError(err)
+	t.Log(content)
+}
+
+func Test_message_003(t *testing.T) {
+	assert := assert.New(t)
+	client, err := anthropic.New(GetApiKey(t), opts.OptTrace(os.Stderr, true), opts.OptHeader("Anthropic-Beta", "tools-2024-04-04"))
+	assert.NoError(err)
+	assert.NotNil(client)
+	msg := schema.NewMessage("user", "What is the weather today in Berlin, Germany")
+
+	// Create the weather tool
+	weather := schema.NewTool("weather", "Get the weather for a location")
+	weather.AddParameter("location", "The location to get the weather for", true)
+
+	// Request -> Response
+	content, err := client.Messages(context.Background(), []*schema.Message{msg}, anthropic.OptTool(weather))
+	assert.NoError(err)
+	t.Log(content)
 }

pkg/anthropic/opts.go

@@ -1,5 +1,11 @@
 package anthropic
 
+import (
+	// Namespace imports
+	. "github.com/djthorpe/go-errors"
+	"github.com/mutablelogic/go-client/pkg/openai/schema"
+)
+
 ///////////////////////////////////////////////////////////////////////////////
 // TYPES
 
@@ -45,3 +51,42 @@ func OptSystem(prompt string) Opt {
 		return nil
 	}
 }
+
+// An external identifier for the user who is associated with the request.
+func OptUser(v string) Opt {
+	return func(o *reqMessage) error {
+		o.Metadata = &reqMetadata{User: v}
+		return nil
+	}
+}
+
+// Custom text sequence that will cause the model to stop generating.
+func OptStopSequence(v string) Opt {
+	return func(o *reqMessage) error {
+		o.StopSequences = append(o.StopSequences, v)
+		return nil
+	}
+}
+
+// Amount of randomness injected into the response.
+func OptTemperature(v float64) Opt {
+	return func(o *reqMessage) error {
+		if v < 0.0 || v > 1.0 {
+			return ErrBadParameter.With("OptTemperature")
+		}
+		o.Temperature = v
+		return nil
+	}
+}
+
+// Add a tool
+func OptTool(tool *schema.Tool) Opt {
+	return func(o *reqMessage) error {
+		if tool == nil {
+			return ErrBadParameter.With("OptTool")
+		} else {
+			o.Tools = append(o.Tools, *tool)
+		}
+		return nil
+	}
+}

pkg/openai/schema/message.go

@@ -41,9 +41,11 @@ type MessageChoice struct {
 
 // Message Content
 type Content struct {
+	Id     string         `json:"id,omitempty"`
 	Type   string         `json:"type,width:4"`
-	Text   string         `json:"text,wrap,width:60"`
+	Text   string         `json:"text,omitempty,wrap,width:60"`
 	Source *contentSource `json:"source,omitempty"`
+	toolUse
 }
 
 // Content Source
@@ -53,6 +55,12 @@ type contentSource struct {
 	Data      string `json:"data,omitempty"`
 }
 
+// Tool arguments
+type toolUse struct {
+	Name  string         `json:"name,omitempty"`
+	Input map[string]any `json:"input,omitempty"`
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // LIFECYCLE
 

pkg/openai/schema/providers.go

@@ -0,0 +1,78 @@
+package schema
+
+import (
+	"encoding/json"
+
+	// Namespace imports
+	. "github.com/djthorpe/go-errors"
+)
+
+///////////////////////////////////////////////////////////////////////////////
+// TYPES
+
+// A tool function
+type Tool struct {
+	Name        string          `json:"name"`
+	Description string          `json:"description"`
+	Parameters  *toolParameters `json:"input_schema,omitempty"`
+}
+
+// Tool function parameters
+type toolParameters struct {
+	Type       string                   `json:"type,omitempty"`
+	Properties map[string]toolParameter `json:"properties,omitempty"`
+	Required   []string                 `json:"required"`
+}
+
+// Tool function call parameter
+type toolParameter struct {
+	Name        string   `json:"-"`
+	Type        string   `json:"type"`
+	Enum        []string `json:"enum,omitempty"`
+	Description string   `json:"description"`
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// LIFECYCLE
+
+func NewTool(name, description string) *Tool {
+	return &Tool{
+		Name:        name,
+		Description: description,
+		Parameters: &toolParameters{
+			Type:       "object",
+			Properties: make(map[string]toolParameter),
+		},
+	}
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// STRINGIFY
+
+func (t Tool) String() string {
+	data, _ := json.MarshalIndent(t, "", "  ")
+	return string(data)
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// PUBLIC METHODS
+
+func (t *Tool) AddParameter(name, description string, required bool) error {
+	if name == "" {
+		return ErrBadParameter.With("missing name")
+	}
+	if _, exists := t.Parameters.Properties[name]; exists {
+		return ErrDuplicateEntry.With(name)
+	}
+	t.Parameters.Properties[name] = toolParameter{
+		Name:        name,
+		Type:        "string",
+		Description: description,
+	}
+	if required {
+		t.Parameters.Required = append(t.Parameters.Required, name)
+	}
+
+	// Return success
+	return nil
+}

pkg/openai/schema/tool.go

@@ -0,0 +1,16 @@
+package schema_test
+
+import (
+	"testing"
+
+	"github.com/mutablelogic/go-client/pkg/openai/schema"
+	"github.com/stretchr/testify/assert"
+)
+
+func Test_tool_001(t *testing.T) {
+	assert := assert.New(t)
+	tool := schema.NewTool("get_stock_price", "Get the current stock price for a given ticker symbol.")
+	assert.NotNil(tool)
+	assert.NoError(tool.AddParameter("ticker", "The stock ticker symbol, e.g. AAPL for Apple Inc.", true))
+	t.Log(tool)
+}