Tool migration

Author: djthorpe

.DS_Store

@@ -7,17 +7,20 @@ import "context"
 
 // Context is fed to the agent to generate a response
 type Context interface {
-	// Return the role, which can be system, assistant, user, tool, tool_result, ...
+	// Return the current session role, which can be system, assistant, user, tool, tool_result, ...
 	Role() string
 
-	// Return the text of the context
+	// Return the current session text, or empty string if no text was returned
 	Text() string
 
+	// Return the current session tool calls, or empty if no tool calls were made
+	ToolCalls() []ToolCall
+
 	// Generate a response from a user prompt (with attachments and
 	// other empheral options
-	FromUser(context.Context, string, ...Opt) (Context, error)
+	FromUser(context.Context, string, ...Opt) error
 
 	// Generate a response from a tool, passing the call identifier or
 	// function name, and the result
-	FromTool(context.Context, string, any, ...Opt) (Context, error)
+	FromTool(context.Context, string, any, ...Opt) error
 }

context.go

@@ -58,6 +58,7 @@ func (r opt) String() string {
 type reqMessages struct {
 	Model    string         `json:"model"`
 	Messages []*MessageMeta `json:"messages"`
+	Tools    []llm.Tool     `json:"tools,omitempty"`
 	opt
 }
 
@@ -77,6 +78,7 @@ func (anthropic *Client) Messages(ctx context.Context, context llm.Context, opts
 	req, err := client.NewJSONRequest(reqMessages{
 		Model:    context.(*session).model.Name(),
 		Messages: context.(*session).seq,
+		Tools:    opt.Tools(),
 		opt:      *opt,
 	})
 	if err != nil {

pkg/anthropic/messages.go

@@ -15,6 +15,7 @@ import (
 
 // model is the implementation of the llm.Model interface
 type model struct {
+	client *Client
 	ModelMeta
 }
 
@@ -38,14 +39,13 @@ func (anthropic *Client) Models(ctx context.Context) ([]llm.Model, error) {
 
 // Get a model by name
 func (anthropic *Client) GetModel(ctx context.Context, name string) (llm.Model, error) {
-
 	var response ModelMeta
 	if err := anthropic.DoWithContext(ctx, nil, &response, client.OptPath("models", name)); err != nil {
 		return nil, err
 	}
 
 	// Return success
-	return &model{ModelMeta: response}, nil
+	return &model{client: anthropic, ModelMeta: response}, nil
 }
 
 // List models
@@ -68,6 +68,7 @@ func (anthropic *Client) ListModels(ctx context.Context) ([]llm.Model, error) {
 		// Convert to llm.Model
 		for _, meta := range response.Body {
 			result = append(result, &model{
+				client:    anthropic,
 				ModelMeta: meta,
 			})
 		}

pkg/anthropic/model.go

@@ -5,6 +5,7 @@ import (
 
 	// Packages
 	llm "github.com/mutablelogic/go-llm"
+	tool "github.com/mutablelogic/go-llm/pkg/tool"
 )
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -19,10 +20,10 @@ type opt struct {
 	Temperature   float64      `json:"temperature,omitempty"`
 	TopK          uint         `json:"top_k,omitempty"`
 	TopP          float64      `json:"top_p,omitempty"`
-	Tools         []*Tool      `json:"tools,omitempty"`
 
 	data     []*Content      // Additional message content
 	callback func(*Response) // Streaming callback
+	toolkit  *tool.ToolKit   // Toolkit for tools
 }
 
 type optmetadata struct {
@@ -42,6 +43,17 @@ func apply(opts ...llm.Opt) (*opt, error) {
 	return o, nil
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// PUBLIC METHODS
+
+func (o *opt) Tools() []llm.Tool {
+	if o.toolkit == nil {
+		return nil
+	} else {
+		return o.toolkit.Tools()
+	}
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // OPTIONS
 
@@ -122,11 +134,11 @@ func WithTopK(v uint) llm.Opt {
 	}
 }
 
-// Messages: Append a tool to the request.
-func WithTool(v *Tool) llm.Opt {
+// Messages: Append a toolkit to the request
+func WithToolKit(v *tool.ToolKit) llm.Opt {
 	return func(o any) error {
 		if v != nil {
-			o.(*opt).Tools = append(o.(*opt).Tools, v)
+			o.(*opt).toolkit = v
 		}
 		return nil
 	}

pkg/anthropic/opt.go

@@ -22,39 +22,29 @@ var _ llm.Context = (*session)(nil)
 ///////////////////////////////////////////////////////////////////////////////
 // LIFECYCLE
 
-// Return am empty session context object for the model,
-// setting session options
+// Return an empty session context object for the model, setting session options
 func (model *model) Context(opts ...llm.Opt) llm.Context {
 	return &session{
 		model: model,
 		opts:  opts,
 	}
 }
 
-// Convenience method to create a session context object
-// with a user prompt, which panics on error
+// Convenience method to create a session context object with a user prompt, which
+// panics on error
 func (model *model) UserPrompt(prompt string, opts ...llm.Opt) llm.Context {
-	// Apply attachments
-	opt, err := apply(opts...)
+	context := model.Context(opts...)
+
+	meta, err := userPrompt(prompt, opts...)
 	if err != nil {
 		panic(err)
 	}
 
-	meta := MessageMeta{
-		Role:    "user",
-		Content: make([]*Content, 1, len(opt.data)+1),
-	}
-
-	// Append the text
-	meta.Content[0] = NewTextContent(prompt)
-
-	// Append any additional data
-	for _, data := range opt.data {
-		meta.Content = append(meta.Content, data)
-	}
+	// Add to the sequence
+	context.(*session).seq = append(context.(*session).seq, meta)
 
 	// Return success
-	return nil
+	return context
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -98,14 +88,85 @@ func (session *session) Text() string {
 	return string(data)
 }
 
-// Generate a response from a user prompt (with attachments and
+// Return the current session tool calls, or empty if no tool calls were made
+func (session *session) ToolCalls() []llm.ToolCall {
+	// Sanity check for tool call
+	if len(session.seq) == 0 {
+		return nil
+	}
+	meta := session.seq[len(session.seq)-1]
+	if meta.Role != "assistant" {
+		return nil
+	}
+
+	// Gather tool calls
+	var result []llm.ToolCall
+	for _, content := range meta.Content {
+		if content.Type == "tool_use" {
+			result = append(result, NewToolCall(content))
+		}
+	}
+	return result
+}
+
+// Generate a response from a user prompt (with attachments) and
 // other empheral options
-func (session *session) FromUser(context.Context, string, ...llm.Opt) (llm.Context, error) {
-	return nil, llm.ErrNotImplemented
+func (session *session) FromUser(ctx context.Context, prompt string, opts ...llm.Opt) error {
+	// Append the user prompt to the sequence
+	meta, err := userPrompt(prompt, opts...)
+	if err != nil {
+		return err
+	} else {
+		session.seq = append(session.seq, meta)
+	}
+
+	// The options come from the session options and the user options
+	chatopts := make([]llm.Opt, 0, len(session.opts)+len(opts))
+	chatopts = append(chatopts, session.opts...)
+	chatopts = append(chatopts, opts...)
+
+	// Call the 'chat' method
+	client := session.model.client
+	r, err := client.Messages(ctx, session, chatopts...)
+	if err != nil {
+		return err
+	} else {
+		session.seq = append(session.seq, &r.MessageMeta)
+	}
+
+	// Return success
+	return nil
 }
 
 // Generate a response from a tool, passing the call identifier or
 // function name, and the result
-func (session *session) FromTool(context.Context, string, any, ...llm.Opt) (llm.Context, error) {
-	return nil, llm.ErrNotImplemented
+func (session *session) FromTool(context.Context, string, any, ...llm.Opt) error {
+	return llm.ErrNotImplemented
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// PRIVATE METHODS
+
+func userPrompt(prompt string, opts ...llm.Opt) (*MessageMeta, error) {
+	// Apply attachments
+	opt, err := apply(opts...)
+	if err != nil {
+		return nil, err
+	}
+
+	meta := MessageMeta{
+		Role:    "user",
+		Content: make([]*Content, 1, len(opt.data)+1),
+	}
+
+	// Append the text
+	meta.Content[0] = NewTextContent(prompt)
+
+	// Append any additional data
+	for _, data := range opt.data {
+		meta.Content = append(meta.Content, data)
+	}
+
+	// Return success
+	return &meta, nil
 }

pkg/anthropic/session.go

@@ -0,0 +1,88 @@
+package anthropic_test
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	// Packages
+	opts "github.com/mutablelogic/go-client"
+	anthropic "github.com/mutablelogic/go-llm/pkg/anthropic"
+	assert "github.com/stretchr/testify/assert"
+)
+
+func Test_session_001(t *testing.T) {
+	client, err := anthropic.New(GetApiKey(t), opts.OptTrace(os.Stderr, true))
+	if err != nil {
+		t.FailNow()
+	}
+
+	model, err := client.GetModel(context.TODO(), "claude-3-haiku-20240307")
+	if err != nil {
+		t.FailNow()
+	}
+
+	// Session with a single user prompt - streaming
+	t.Run("stream", func(t *testing.T) {
+		assert := assert.New(t)
+		session := model.Context(anthropic.WithStream(func(stream *anthropic.Response) {
+			t.Log("SESSION DELTA", stream)
+		}))
+		assert.NotNil(session)
+
+		err := session.FromUser(context.TODO(), "Why is the grass green?")
+		if !assert.NoError(err) {
+			t.FailNow()
+		}
+		assert.Equal("assistant", session.Role())
+		assert.NotEmpty(session.Text())
+	})
+
+	// Session with a single user prompt - not streaming
+	t.Run("nostream", func(t *testing.T) {
+		assert := assert.New(t)
+		session := model.Context()
+		assert.NotNil(session)
+
+		err := session.FromUser(context.TODO(), "Why is the sky blue?")
+		if !assert.NoError(err) {
+			t.FailNow()
+		}
+		assert.Equal("assistant", session.Role())
+		assert.NotEmpty(session.Text())
+	})
+}
+
+func Test_session_002(t *testing.T) {
+	client, err := anthropic.New(GetApiKey(t), opts.OptTrace(os.Stderr, true))
+	if err != nil {
+		t.FailNow()
+	}
+
+	model, err := client.GetModel(context.TODO(), "claude-3-haiku-20240307")
+	if err != nil {
+		t.FailNow()
+	}
+
+	// Session with a tool call
+	t.Run("toolcall", func(t *testing.T) {
+		assert := assert.New(t)
+
+		tool, err := anthropic.NewTool("get_weather", "Return the current weather", nil)
+		if !assert.NoError(err) {
+			t.FailNow()
+		}
+
+		session := model.Context(anthropic.WithTool(tool))
+		assert.NotNil(session)
+
+		err = session.FromUser(context.TODO(), "What is today's weather?")
+		if !assert.NoError(err) {
+			t.FailNow()
+		}
+
+		toolcalls := session.ToolCalls()
+		assert.NotEmpty(toolcalls)
+		t.Log(toolcalls)
+	})
+}