Updated LLM

Author: djthorpe

cmd/agent/generate.go

@@ -2,7 +2,10 @@ package main
 
 import (
 	"context"
+	"errors"
 	"fmt"
+	"io"
+	"strings"
 
 	// Packages
 	llm "github.com/mutablelogic/go-llm"
@@ -14,7 +17,6 @@ import (
 
 type GenerateCmd struct {
 	Model string `arg:"" help:"Model name"`
-	Text  string `arg:"" help:"Text to generate a response for"`
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -23,7 +25,6 @@ type GenerateCmd struct {
 func (cmd *GenerateCmd) Run(globals *Globals) error {
 	return runagent(globals, func(ctx context.Context, client llm.Agent) error {
 		// Get the model
-		// TODO: Model should be cached
 		agent, ok := client.(*agent.Agent)
 		if !ok {
 			return fmt.Errorf("No agents found")
@@ -33,14 +34,38 @@ func (cmd *GenerateCmd) Run(globals *Globals) error {
 			return err
 		}
 
-		// Generate the content
-		response, err := agent.Generate(ctx, model, model.UserPrompt(cmd.Text))
-		if err != nil {
-			return err
+		// Create a session
+		session := model.Context()
+
+		// Continue looping until end of input
+		for {
+			input, err := globals.term.ReadLine(model.Name() + "> ")
+			if errors.Is(err, io.EOF) {
+				return nil
+			} else if err != nil {
+				return err
+			} else if err := session.AppendUserPrompt(strings.TrimSpace(input)); err != nil {
+				return err
+			}
+
+			// Ignore empty import
+			if session.Text() == "" {
+				continue
+			}
+
+			// Feed input into the model
+			response, err := agent.Generate(ctx, model, session)
+			if err != nil {
+				return err
+			}
+			fmt.Println("RESPONSE=", response.Text())
 		}
+		/*
+			// Generate the content
+
 
-		// Print the response
-		fmt.Println("RESPONSE=", response)
-		return nil
+			// Print the response
+			return nil
+		*/
 	})
 }

cmd/agent/main.go

@@ -11,7 +11,7 @@ import (
 	kong "github.com/alecthomas/kong"
 	client "github.com/mutablelogic/go-client"
 	llm "github.com/mutablelogic/go-llm"
-	"github.com/mutablelogic/go-llm/pkg/agent"
+	agent "github.com/mutablelogic/go-llm/pkg/agent"
 )
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -29,6 +29,7 @@ type Globals struct {
 	// Context
 	ctx   context.Context
 	agent llm.Agent
+	term  *Term
 }
 
 type Ollama struct {
@@ -67,6 +68,15 @@ func main() {
 	defer cancel()
 	cli.Globals.ctx = ctx
 
+	// Create a terminal
+	term, err := NewTerm(os.Stdout)
+	if err != nil {
+		cmd.FatalIfErrorf(err)
+		return
+	} else {
+		cli.Globals.term = term
+	}
+
 	// Client options
 	clientopts := []client.ClientOpt{}
 	if cli.Debug || cli.Verbose {

cmd/agent/term.go

@@ -0,0 +1,66 @@
+package main
+
+import (
+	"io"
+	"os"
+
+	// Packages
+	"golang.org/x/term"
+)
+
+type Term struct {
+	r  io.Reader
+	fd int
+	*term.Terminal
+}
+
+func NewTerm(r io.Reader) (*Term, error) {
+	t := new(Term)
+	t.r = r
+
+	// Set file descriptor
+	if osf, ok := r.(*os.File); ok {
+		t.fd = int(osf.Fd())
+		if term.IsTerminal(t.fd) {
+			t.Terminal = term.NewTerminal(osf, "")
+		}
+	}
+
+	// Return success
+	return t, nil
+}
+
+// Returns the width and height of the terminal, or (0,0)
+func (t *Term) Size() (int, int) {
+	if t.Terminal != nil {
+		if w, h, err := term.GetSize(t.fd); err == nil {
+			return w, h
+		}
+	}
+	// Unable to get the size
+	return 0, 0
+}
+
+func (t *Term) ReadLine(prompt string) (string, error) {
+	// Set terminal raw mode
+	if t.Terminal != nil {
+		state, err := term.MakeRaw(t.fd)
+		if err != nil {
+			return "", err
+		}
+		defer term.Restore(t.fd, state)
+	}
+
+	// Set the prompt
+	if t.Terminal != nil {
+		t.Terminal.SetPrompt(prompt)
+	}
+
+	// Read the line
+	if t.Terminal != nil {
+		return t.Terminal.ReadLine()
+	} else {
+		// Don't support non-terminal input yet
+		return "", io.EOF
+	}
+}

context.go

@@ -3,8 +3,17 @@ package llm
 //////////////////////////////////////////////////////////////////
 // TYPES
 
-// Context is fed to the agent to generate a response. Role can be
-// assistant, user, tool, tool_result, ...
+// Context is fed to the agent to generate a response
 type Context interface {
+	// Return the role, which can be assistant, user, tool, tool_result, ...
 	Role() string
+
+	// Return the text of the context
+	Text() string
+
+	// Append user prompt (and attachments) to a context
+	AppendUserPrompt(string, ...Opt) error
+
+	// Append the result of calling a tool to a context
+	AppendToolResult(string, ...Opt) error
 }

model.go

@@ -5,9 +5,6 @@ type Model interface {
 	// Return the name of the model
 	Name() string
 
-	// Create user prompt for a model
-	UserPrompt(string, ...Opt) Context
-
-	// Create the result of calling a tool for a model
-	ToolResult(id string, opts ...Opt) Context
+	// Return a context object, and set options
+	Context(...Opt) Context
 }

pkg/agent/agent.go

@@ -28,11 +28,10 @@ var _ llm.Agent = (*Agent)(nil)
 ///////////////////////////////////////////////////////////////////////////////
 // LIFECYCLE
 
-// Return a new agent, composed of agents and tools
+// Return a new agent, composed of  a series of agents and tools
 func New(opts ...llm.Opt) (*Agent, error) {
 	agent := new(Agent)
-	opt, err := apply(opts...)
-	if err != nil {
+	if opt, err := apply(opts...); err != nil {
 		return nil, err
 	} else {
 		agent.opt = opt

pkg/agent/generate.go

@@ -29,7 +29,7 @@ func (a *Agent) Generate(ctx context.Context, m llm.Model, context llm.Context,
 		return nil, err
 	}
 
-	log.Print("agent.Generate:", m, context, opts)
+	log.Print("agent.Generate =>", context, opts)
 
 	// Call Generate for the agent
 	return agent.Generate(ctx, m, context, opts...)

pkg/anthropic/context.go

@@ -0,0 +1,95 @@
+package anthropic
+
+import (
+	"encoding/json"
+
+	llm "github.com/mutablelogic/go-llm"
+)
+
+//////////////////////////////////////////////////////////////////
+// TYPES
+
+type session struct {
+	seq []*MessageMeta
+}
+
+var _ llm.Context = (*session)(nil)
+
+///////////////////////////////////////////////////////////////////////////////
+// LIFECYCLE
+
+func (*model) Context(...llm.Opt) llm.Context {
+	// TODO: Currently ignoring options
+	return &session{}
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// STRINGIFY
+
+func (session session) String() string {
+	var data []byte
+	var err error
+	if len(session.seq) == 1 {
+		data, err = json.MarshalIndent(session.seq[0], "", "  ")
+	} else {
+		data, err = json.MarshalIndent(session.seq, "", "  ")
+	}
+	if err != nil {
+		return err.Error()
+	}
+	return string(data)
+}
+
+//////////////////////////////////////////////////////////////////
+// PUBLIC METHODS
+
+// Return the role of the last message
+func (session *session) Role() string {
+	if len(session.seq) == 0 {
+		return ""
+	}
+	return session.seq[len(session.seq)-1].Role
+}
+
+// Return the text of the last message
+func (session *session) Text() string {
+	if len(session.seq) == 0 {
+		return ""
+	}
+	meta := session.seq[len(session.seq)-1]
+	data, err := json.MarshalIndent(meta.Content, "", "  ")
+	if err != nil {
+		return err.Error()
+	}
+	return string(data)
+}
+
+// Append user prompt (and attachments) to a context
+func (session *session) AppendUserPrompt(text string, opts ...llm.Opt) error {
+	// Apply attachments
+	opt, err := apply(opts...)
+	if err != nil {
+		return err
+	}
+
+	meta := MessageMeta{
+		Role:    "user",
+		Content: make([]*Content, 1, len(opt.data)+1),
+	}
+
+	// Append the text
+	meta.Content[0] = NewTextContent(text)
+
+	// Append any additional data
+	for _, data := range opt.data {
+		meta.Content = append(meta.Content, data)
+	}
+
+	// Return success
+	return nil
+}
+
+// Append the result of calling a tool to a context
+func (session *session) AppendToolResult(string, ...llm.Opt) error {
+	return llm.ErrNotImplemented
+}