Updated llm

Author: djthorpe

cmd/agent/chat.go

@@ -79,8 +79,10 @@ func (cmd *ChatCmd) Run(globals *Globals) error {
 			calls := session.ToolCalls()
 			if results, err := globals.toolkit.Run(ctx, calls...); err != nil {
 				return err
+			} else if err := session.FromTool(ctx, results...); err != nil {
+				return err
 			} else {
-				fmt.Println(results)
+				fmt.Println(session.Text())
 			}
 		}
 	})

context.go

@@ -22,10 +22,10 @@ type Context interface {
 	ContextContent
 
 	// Generate a response from a user prompt (with attachments and
-	// other empheral options
+	// other options)
 	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) error
+	// Generate a response from a tool, passing the results
+	// from the tool call
+	FromTool(context.Context, ...ToolResult) error
 }

pkg/anthropic/message.go

@@ -46,8 +46,8 @@ type ContentAttachment struct {
 }
 
 type ContentToolResult struct {
-	Id      string     `json:"tool_use_id,omitempty"` // tool id
-	Content []*Content `json:"content,omitempty"`
+	Id      string `json:"tool_use_id,omitempty"` // tool id
+	Content any    `json:"content,omitempty"`
 }
 
 type contentsource struct {
@@ -75,6 +75,24 @@ func NewTextContent(v string) *Content {
 	return content
 }
 
+// Return a Content object with tool result
+func NewToolResultContent(v llm.ToolResult) *Content {
+	content := new(Content)
+	content.Type = "tool_result"
+	content.ContentToolResult.Id = v.Call().Id()
+	//	content.ContentToolResult.Name = v.Call().Name()
+
+	// We only support JSON encoding for the moment
+	data, err := json.Marshal(v.Value())
+	if err != nil {
+		content.ContentToolResult.Content = err.Error()
+	} else {
+		content.ContentToolResult.Content = string(data)
+	}
+
+	return content
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // STRINGIFY
 

pkg/anthropic/session.go

@@ -141,8 +141,25 @@ func (session *session) FromUser(ctx context.Context, prompt string, opts ...llm
 
 // 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) error {
-	return llm.ErrNotImplemented
+func (session *session) FromTool(ctx context.Context, results ...llm.ToolResult) error {
+	meta, err := toolResults(results...)
+	if err != nil {
+		return err
+	} else {
+		session.seq = append(session.seq, meta)
+	}
+
+	// Call the 'chat' method
+	client := session.model.client
+	r, err := client.Messages(ctx, session, session.opts...)
+	if err != nil {
+		return err
+	} else {
+		session.seq = append(session.seq, &r.MessageMeta)
+	}
+
+	// Return success
+	return nil
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -179,3 +196,22 @@ func userPrompt(prompt string, opts ...llm.Opt) (*MessageMeta, error) {
 	// Return success
 	return &meta, nil
 }
+
+func toolResults(results ...llm.ToolResult) (*MessageMeta, error) {
+	// Check for no results
+	if len(results) == 0 {
+		return nil, llm.ErrBadParameter.Withf("No tool results")
+	}
+
+	// Create user message
+	meta := MessageMeta{
+		Role:    "user",
+		Content: make([]*Content, 0, len(results)),
+	}
+	for _, result := range results {
+		meta.Content = append(meta.Content, NewToolResultContent(result))
+	}
+
+	// Return success
+	return &meta, nil
+}

pkg/ollama/session.go

@@ -91,21 +91,20 @@ func (s *session) FromUser(ctx context.Context, prompt string, opts ...llm.Opt)
 }
 
 // Generate a response from a tool calling result
-func (s *session) FromTool(ctx context.Context, call string, result any, opts ...llm.Opt) error {
-	// Append the tool result
-	if message, err := toolResult(call, result); err != nil {
-		return err
-	} else {
-		s.seq[len(s.seq)-1] = message
+func (s *session) FromTool(ctx context.Context, results ...llm.ToolResult) error {
+	if len(results) == 0 {
+		return llm.ErrConflict.Withf("No tool results")
 	}
 
-	// The options come from the session options and the user options
-	chatopts := make([]llm.Opt, 0, len(s.opts)+len(opts))
-	chatopts = append(chatopts, s.opts...)
-	chatopts = append(chatopts, opts...)
+	// Append the tool results
+	for _, result := range results {
+		if message, err := toolResult(result); err != nil {
+			s.seq = append(s.seq, message)
+		}
+	}
 
 	// Call the 'chat' method
-	r, err := s.model.client.Chat(ctx, s, chatopts...)
+	r, err := s.model.client.Chat(ctx, s, s.opts...)
 	if err != nil {
 		return err
 	} else {
@@ -177,17 +176,17 @@ func userPrompt(prompt string, opts ...llm.Opt) (*MessageMeta, error) {
 	return &meta, nil
 }
 
-func toolResult(name string, result any) (*MessageMeta, error) {
+func toolResult(result llm.ToolResult) (*MessageMeta, error) {
 	// Turn result into JSON
-	data, err := json.Marshal(result)
+	data, err := json.Marshal(result.Value())
 	if err != nil {
 		return nil, err
 	}
 
 	// Create a new message
 	var meta MessageMeta
 	meta.Role = "tool"
-	meta.FunctionName = name
+	meta.FunctionName = result.Call().Name()
 	meta.Content = string(data)
 
 	// Return success

pkg/tool/call.go

@@ -35,6 +35,10 @@ func NewCall(id, name string, input map[string]any) *call {
 ///////////////////////////////////////////////////////////////////////////////
 // STRINGIFY
 
+func (t call) MarshalJSON() ([]byte, error) {
+	return json.Marshal(t.meta)
+}
+
 func (t call) String() string {
 	data, err := json.MarshalIndent(t.meta, "", "  ")
 	if err != nil {

pkg/tool/result.go

@@ -10,22 +10,38 @@ import (
 ///////////////////////////////////////////////////////////////////////////////
 // TYPES
 
+type ResultMeta struct {
+	Call  llm.ToolCall `json:"call"`
+	Value any          `json:"result"`
+}
+
 type result struct {
-	call  llm.ToolCall
-	value any
+	meta ResultMeta
 }
 
 var _ llm.ToolResult = (*result)(nil)
 
+///////////////////////////////////////////////////////////////////////////////
+// LIFECYCLE
+
+func NewResult(call llm.ToolCall, value any) llm.ToolResult {
+	return &result{
+		meta: ResultMeta{
+			Call:  call,
+			Value: value,
+		},
+	}
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // STRINGIFY
 
+func (r result) MarshalJSON() ([]byte, error) {
+	return json.Marshal(r.meta)
+}
+
 func (r result) String() string {
-	type j struct {
-		Call   llm.ToolCall `json:"call"`
-		Result any          `json:"result"`
-	}
-	data, err := json.MarshalIndent(j{r.call, r.value}, "", "  ")
+	data, err := json.MarshalIndent(r.meta, "", "  ")
 	if err != nil {
 		return err.Error()
 	}
@@ -37,10 +53,10 @@ func (r result) String() string {
 
 // The call associated with the result
 func (r result) Call() llm.ToolCall {
-	return r.call
+	return r.meta.Call
 }
 
 // The result, which can be encoded into json
-func (r result) Result() any {
-	return r.value
+func (r result) Value() any {
+	return r.meta.Value
 }

pkg/tool/toolkit.go

@@ -125,7 +125,7 @@ func (kit *ToolKit) Run(ctx context.Context, calls ...llm.ToolCall) ([]llm.ToolR
 			} else if out, err := kit.functions[name].Tool.Run(ctx); err != nil {
 				errs = errors.Join(errs, err)
 			} else {
-				toolresult = append(toolresult, &result{call, out})
+				toolresult = append(toolresult, NewResult(call, out))
 			}
 		}(call)
 	}

toolkit.go

@@ -50,5 +50,5 @@ type ToolResult interface {
 	Call() ToolCall
 
 	// The result, which can be encoded into json
-	Result() any
+	Value() any
 }