Updated

Author: djthorpe

cmd/agent/generate.go

@@ -16,7 +16,8 @@ import (
 // TYPES
 
 type GenerateCmd struct {
-	Model string `arg:"" help:"Model name"`
+	Model    string `arg:"" help:"Model name"`
+	NoStream bool   `flag:"nostream" help:"Disable streaming"`
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -35,7 +36,10 @@ func (cmd *GenerateCmd) Run(globals *Globals) error {
 		}
 
 		// Create a session
-		session := model.Context()
+		session, err := model.Context(agent.WithStream(!cmd.NoStream))
+		if err != nil {
+			return err
+		}
 
 		// Continue looping until end of input
 		for {
@@ -58,14 +62,7 @@ func (cmd *GenerateCmd) Run(globals *Globals) error {
 			if err != nil {
 				return err
 			}
-			fmt.Println("RESPONSE=", response.Text())
+			fmt.Println(response.Text())
 		}
-		/*
-			// Generate the content
-
-
-			// Print the response
-			return nil
-		*/
 	})
 }

model.go

@@ -6,5 +6,5 @@ type Model interface {
 	Name() string
 
 	// Return a context object, and set options
-	Context(...Opt) Context
+	Context(...Opt) (Context, error)
 }

pkg/agent/generate.go

@@ -23,13 +23,15 @@ func (a *Agent) Generate(ctx context.Context, m llm.Model, context llm.Context,
 		agent = agent_
 	}
 
+	// Get the options
+
 	// Apply the options
-	opts, err := translate(agent, opts...)
-	if err != nil {
-		return nil, err
-	}
+	//opts, err := translate(agent, opts...)
+	//if err != nil {
+	//	return nil, err
+	//}
 
-	log.Print("agent.Generate =>", context, opts)
+	log.Print("agent.Generate =>", context)
 
 	// Call Generate for the agent
 	return agent.Generate(ctx, m, context, opts...)

pkg/agent/opt.go

@@ -2,6 +2,8 @@ package agent
 
 import (
 	// Packages
+	"fmt"
+
 	client "github.com/mutablelogic/go-client"
 	llm "github.com/mutablelogic/go-llm"
 	anthropic "github.com/mutablelogic/go-llm/pkg/anthropic"
@@ -15,9 +17,9 @@ type opt struct {
 	agents map[string]llm.Agent
 	tools  map[string]llm.Tool
 
-	// Selected agent
-	agent llm.Agent
-	opts  []llm.Opt
+	// Translated options for each agent implementation
+	ollama    []llm.Opt
+	anthropic []llm.Opt
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -35,28 +37,6 @@ func apply(opts ...llm.Opt) (*opt, error) {
 	return o, nil
 }
 
-// Translate options from general to agent-specific
-func translate(agent llm.Agent, opts ...llm.Opt) ([]llm.Opt, error) {
-	o := new(opt)
-
-	// Set agent
-	if agent == nil {
-		return nil, llm.ErrBadParameter.With("agent")
-	} else {
-		o.agent = agent
-	}
-
-	// Apply options
-	for _, opt := range opts {
-		if err := opt(o); err != nil {
-			return nil, err
-		}
-	}
-
-	// Return translated options
-	return o.opts, nil
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // PUBLIC METHODS
 
@@ -82,6 +62,7 @@ func WithAnthropic(key string, opts ...client.ClientOpt) llm.Opt {
 	}
 }
 
+// Append tools
 func WithTools(tools ...llm.Tool) llm.Opt {
 	return func(o any) error {
 		for _, tool := range tools {
@@ -96,6 +77,19 @@ func WithTools(tools ...llm.Tool) llm.Opt {
 	}
 }
 
+// Set streaming function
+func WithStream(v bool) llm.Opt {
+	return func(o any) error {
+		o.(*opt).ollama = append(o.(*opt).ollama, ollama.WithStream(func(r *ollama.Response) {
+			fmt.Println(r)
+		}))
+		o.(*opt).anthropic = append(o.(*opt).anthropic, anthropic.WithStream(func(r *anthropic.Response) {
+			fmt.Println(r)
+		}))
+		return nil
+	}
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // PRIVATE METHODS
 

pkg/anthropic/context.go

@@ -18,9 +18,9 @@ var _ llm.Context = (*session)(nil)
 ///////////////////////////////////////////////////////////////////////////////
 // LIFECYCLE
 
-func (*model) Context(...llm.Opt) llm.Context {
+func (*model) Context(...llm.Opt) (llm.Context, error) {
 	// TODO: Currently ignoring options
-	return &session{}
+	return &session{}, nil
 }
 
 ///////////////////////////////////////////////////////////////////////////////

pkg/ollama/context.go

@@ -12,6 +12,7 @@ import (
 
 // Implementation of a message session, which is a sequence of messages
 type session struct {
+	*opt
 	seq []*MessageMeta
 }
 
@@ -20,9 +21,17 @@ var _ llm.Context = (*session)(nil)
 ///////////////////////////////////////////////////////////////////////////////
 // LIFECYCLE
 
-func (*model) Context(...llm.Opt) llm.Context {
-	// TODO: Currently ignoring options
-	return &session{}
+func (*model) Context(opts ...llm.Opt) (llm.Context, error) {
+	// Apply options
+	opt, err := apply(opts...)
+	if err != nil {
+		return nil, err
+	}
+
+	// Return an empty session
+	return &session{
+		opt: opt,
+	}, nil
 }
 
 ///////////////////////////////////////////////////////////////////////////////

pkg/ollama/opt.go

@@ -80,13 +80,13 @@ func WithPullStatus(fn func(*PullStatus)) llm.Opt {
 }
 
 // Chat: Stream the response as it is received.
-func WithChatStream(fn func(*Response)) llm.Opt {
+func WithStream(fn func(*Response)) llm.Opt {
 	return func(o any) error {
 		if fn == nil {
 			return llm.ErrBadParameter.With("callback required")
 		}
 		if len(o.(*opt).tools) > 0 {
-			return llm.ErrBadParameter.With("tools not supported with streaming")
+			return llm.ErrBadParameter.With("streaming not supported with tools")
 		}
 		o.(*opt).stream = true
 		o.(*opt).chatcallback = fn
@@ -99,7 +99,7 @@ func WithTool(v *Tool) llm.Opt {
 	return func(o any) error {
 		// We can't use streaming when tools are included
 		if o.(*opt).stream {
-			return llm.ErrBadParameter.With("streaming not supported with tools")
+			return llm.ErrBadParameter.With("tools not supported with streaming")
 		}
 		if v != nil {
 			o.(*opt).tools = append(o.(*opt).tools, v)