Updated

Author: djthorpe

cmd/agent/generate.go

@@ -37,9 +37,6 @@ func (cmd *GenerateCmd) Run(globals *Globals) error {
 
 		// Create a session
 		session := model.Context(agent.WithStream(!cmd.NoStream))
-		if err != nil {
-			return err
-		}
 
 		// Continue looping until end of input
 		for {
@@ -57,14 +54,10 @@ func (cmd *GenerateCmd) Run(globals *Globals) error {
 			}
 
 			// Feed input into the model
-			response, err := session.FromUser(ctx, input)
-			if err != nil {
+			if err := session.FromUser(ctx, input); err != nil {
 				return err
 			}
-			fmt.Println(response.Text())
-
-			// Update session
-			session = response
+			fmt.Println(session.Text())
 		}
 	})
 }

cmd/agent/models.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
 
 	// Packages
@@ -48,9 +49,18 @@ func (*ListAgentsCmd) Run(globals *Globals) error {
 		if !ok {
 			return fmt.Errorf("No agents found")
 		}
+
+		var agents []string
 		for _, agent := range agent.Agents() {
-			fmt.Println(agent)
+			agents = append(agents, agent.Name())
+		}
+
+		data, err := json.MarshalIndent(agents, "", "  ")
+		if err != nil {
+			return err
 		}
+		fmt.Println(string(data))
+
 		return nil
 	})
 }

pkg/agent/agent.go

@@ -66,11 +66,14 @@ func (a *Agent) Agents() []llm.Agent {
 
 // Return a list of tool names
 func (a *Agent) Tools() []string {
-	var keys []string
-	for k := range a.tools {
-		keys = append(keys, k)
+	if a.toolkit == nil {
+		return nil
+	}
+	var result []string
+	for _, t := range a.toolkit.Tools(a) {
+		result = append(result, t.Name())
 	}
-	return keys
+	return result
 }
 
 // Return a comma-separated list of agent names
@@ -121,7 +124,9 @@ func (a *Agent) ListModels(ctx context.Context, agents ...string) ([]llm.Model,
 // If multiple agents are specified, then the first model found is returned.
 func (a *Agent) GetModel(ctx context.Context, name string, agents ...string) (llm.Model, error) {
 	if len(agents) == 0 {
-		agents = a.Agents()
+		for _, agent := range a.agents {
+			agents = append(agents, agent.Name())
+		}
 	}
 
 	// Ensure all agents are valid
@@ -155,11 +160,6 @@ func (a *Agent) Embedding(context.Context, llm.Model, string, ...llm.Opt) ([]flo
 	return nil, llm.ErrNotImplemented
 }
 
-// Create the result of calling a tool
-func (a *Agent) ToolResult(id string, opts ...llm.Opt) llm.Context {
-	return nil
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 // PRIVATE METHODS
 

pkg/agent/context.go

@@ -8,14 +8,15 @@ import (
 	llm "github.com/mutablelogic/go-llm"
 	anthropic "github.com/mutablelogic/go-llm/pkg/anthropic"
 	ollama "github.com/mutablelogic/go-llm/pkg/ollama"
+	"github.com/mutablelogic/go-llm/pkg/tool"
 )
 
 ////////////////////////////////////////////////////////////////////////////////
 // TYPES
 
 type opt struct {
-	agents map[string]llm.Agent
-	tools  map[string]llm.Tool
+	agents  map[string]llm.Agent
+	toolkit *tool.ToolKit
 
 	// Translated options for each agent implementation
 	ollama    []llm.Opt
@@ -62,17 +63,12 @@ func WithAnthropic(key string, opts ...client.ClientOpt) llm.Opt {
 	}
 }
 
-// Append tools
-func WithTools(tools ...llm.Tool) llm.Opt {
+// Append toolkit
+func WithToolKit(toolkit *tool.ToolKit) llm.Opt {
 	return func(o any) error {
-		for _, tool := range tools {
-			name := tool.Name()
-			if _, exists := o.(*opt).tools[name]; exists {
-				return llm.ErrConflict.Withf("Tool %q already exists", name)
-			}
-			o.(*opt).tools[name] = tool
-		}
-		// Return success
+		o.(*opt).toolkit = toolkit
+		o.(*opt).ollama = append(o.(*opt).ollama, ollama.WithToolKit(toolkit))
+		o.(*opt).anthropic = append(o.(*opt).anthropic, anthropic.WithToolKit(toolkit))
 		return nil
 	}
 }