Updates for anthropic

Author: djthorpe

cmd/agent/chat.go

@@ -40,7 +40,9 @@ func (cmd *ChatCmd) Run(globals *Globals) error {
 		opts := []llm.Opt{}
 		if !cmd.NoStream {
 			opts = append(opts, llm.WithStream(func(cc llm.ContextContent) {
-				fmt.Println("STREAM", cc)
+				if text := cc.Text(); text != "" {
+					fmt.Println(text)
+				}
 			}))
 		}
 		if cmd.System != "" {
@@ -80,13 +82,13 @@ func (cmd *ChatCmd) Run(globals *Globals) error {
 					break
 				}
 				if session.Text() != "" {
-					fmt.Println("Calling", session.Text())
+					globals.term.Println(session.Text())
 				} else {
 					var names []string
 					for _, call := range calls {
 						names = append(names, call.Name())
 					}
-					fmt.Println("Calling", strings.Join(names, ", "))
+					globals.term.Println("Calling", strings.Join(names, ", "))
 				}
 				if results, err := globals.toolkit.Run(ctx, calls...); err != nil {
 					return err
@@ -96,7 +98,7 @@ func (cmd *ChatCmd) Run(globals *Globals) error {
 			}
 
 			// Print the response
-			fmt.Println("SESSION", session.Text())
+			globals.term.Println("\n" + session.Text() + "\n")
 		}
 	})
 }

cmd/agent/term.go

@@ -1,11 +1,14 @@
 package main
 
 import (
+	"fmt"
 	"io"
 	"os"
 
 	// Packages
-	"golang.org/x/term"
+	format "github.com/MichaelMure/go-term-text"
+	color "github.com/fatih/color"
+	term "golang.org/x/term"
 )
 
 type Term struct {
@@ -41,6 +44,15 @@ func (t *Term) Size() (int, int) {
 	return 0, 0
 }
 
+func (t *Term) Println(v ...any) {
+	text := fmt.Sprint(v...)
+	w, _ := t.Size()
+	if w > 0 {
+		text, _ = format.Wrap(text, w)
+	}
+	fmt.Fprintln(os.Stdout, text)
+}
+
 func (t *Term) ReadLine(prompt string) (string, error) {
 	// Set terminal raw mode
 	if t.Terminal != nil {
@@ -51,8 +63,9 @@ func (t *Term) ReadLine(prompt string) (string, error) {
 		defer term.Restore(t.fd, state)
 	}
 
-	// Set the prompt
+	// Set the prompt with color
 	if t.Terminal != nil {
+		prompt = color.New(color.Bold).Sprint(prompt)
 		t.Terminal.SetPrompt(prompt)
 	}
 

pkg/anthropic/message.go

@@ -22,7 +22,7 @@ type Content struct {
 	Type string `json:"type"` // image, document, text, tool_use
 	ContentText
 	ContentAttachment
-	ContentTool
+	*ContentTool
 	ContentToolResult
 	CacheControl *cachecontrol `json:"cache_control,omitempty"` // ephemeral
 }
@@ -34,7 +34,7 @@ type ContentText struct {
 type ContentTool struct {
 	Id        string         `json:"id,omitempty"`           // tool id
 	Name      string         `json:"name,omitempty"`         // tool name
-	Input     map[string]any `json:"input,omitempty"`        // tool input
+	Input     map[string]any `json:"input"`                  // tool input
 	InputJson string         `json:"partial_json,omitempty"` // partial json input (for streaming)
 }
 
@@ -107,6 +107,22 @@ func (m MessageMeta) String() string {
 ///////////////////////////////////////////////////////////////////////////////
 // PRIVATE METHODS
 
+func (m MessageMeta) Text() string {
+	if len(m.Content) == 0 {
+		return ""
+	}
+	var text []string
+	for _, content := range m.Content {
+		if content.Type == "text" {
+			text = append(text, content.ContentText.Text)
+		}
+	}
+	return strings.Join(text, "\n")
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// PRIVATE METHODS
+
 var (
 	supportedAttachments = map[string]string{
 		"image/jpeg":      "image",

pkg/anthropic/messages.go

@@ -48,8 +48,6 @@ func (r Response) String() string {
 
 type reqMessages struct {
 	Model         string         `json:"model"`
-	Messages      []*MessageMeta `json:"messages"`
-	Tools         []llm.Tool     `json:"tools,omitempty"`
 	MaxTokens     uint           `json:"max_tokens,omitempty"`
 	Metadata      *optmetadata   `json:"metadata,omitempty"`
 	StopSequences []string       `json:"stop_sequences,omitempty"`
@@ -58,6 +56,8 @@ type reqMessages struct {
 	Temperature   float64        `json:"temperature,omitempty"`
 	TopK          uint64         `json:"top_k,omitempty"`
 	TopP          float64        `json:"top_p,omitempty"`
+	Messages      []*MessageMeta `json:"messages"`
+	Tools         []llm.Tool     `json:"tools,omitempty"`
 }
 
 func (anthropic *Client) Messages(ctx context.Context, context llm.Context, opts ...llm.Opt) (*Response, error) {
@@ -231,11 +231,7 @@ func (response Response) Role() string {
 }
 
 func (response Response) Text() string {
-	data, err := json.MarshalIndent(response.MessageMeta.Content, "", "  ")
-	if err != nil {
-		return err.Error()
-	}
-	return string(data)
+	return response.MessageMeta.Text()
 }
 
 func (response Response) ToolCalls() []llm.ToolCall {

pkg/anthropic/session.go

@@ -82,11 +82,7 @@ func (session *session) Text() string {
 		return ""
 	}
 	meta := session.seq[len(session.seq)-1]
-	data, err := json.MarshalIndent(meta.Content, "", "  ")
-	if err != nil {
-		return err.Error()
-	}
-	return string(data)
+	return meta.Text()
 }
 
 // Return the current session tool calls, or empty if no tool calls were made

pkg/newsapi/agent.go

@@ -10,32 +10,14 @@ import (
 )
 
 ///////////////////////////////////////////////////////////////////////////////
-// TYPES
+// HEADLINES
 
 type headlines struct {
 	*Client `json:"-"`
-	// CountryCode string `json:"country_code,omitempty" help:"The two-letter countrycode to return headlines for. Leave empty for worldwide headlines."`
-}
-
-type search struct {
-	*Client `json:"-"`
-	Query   string `json:"query" help:"A phrase used to search for news headlines." required:"true"`
-}
-
-type category struct {
-	*Client  `json:"-"`
-	Category string `json:"category" enum:"business, entertainment, health, science, sports, technology" help:"business, entertainment, health, science, sports, technology" required:"true"`
 }
 
 var _ llm.Tool = (*headlines)(nil)
 
-var (
-	categories = []string{"business", "entertainment", "health", "science", "sports", "technology"}
-)
-
-///////////////////////////////////////////////////////////////////////////////
-// HEADLINES
-
 func (headlines) Name() string {
 	return "news_headlines"
 }
@@ -51,6 +33,13 @@ func (headlines *headlines) Run(ctx context.Context) (any, error) {
 ///////////////////////////////////////////////////////////////////////////////
 // SEARCH
 
+type search struct {
+	*Client `json:"-"`
+	Query   string `json:"query" help:"A phrase used to search for news headlines." required:"true"`
+}
+
+var _ llm.Tool = (*search)(nil)
+
 func (search) Name() string {
 	return "news_search"
 }
@@ -63,13 +52,24 @@ func (search *search) Run(ctx context.Context) (any, error) {
 	if search.Query == "" {
 		return nil, nil
 	}
-	fmt.Printf("search for %q\n", search.Query)
+	fmt.Printf("  => Search for %q\n", search.Query)
 	return search.Articles(OptQuery(search.Query), OptLimit(10))
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CATEGORY
 
+type category struct {
+	*Client  `json:"-"`
+	Category string `json:"category" enum:"business, entertainment, health, science, sports, technology" help:"business, entertainment, health, science, sports, technology" required:"true"`
+}
+
+var _ llm.Tool = (*category)(nil)
+
+var (
+	categories = []string{"business", "entertainment", "health", "science", "sports", "technology"}
+)
+
 func (category) Name() string {
 	return "news_headlines_category"
 }
@@ -80,158 +80,9 @@ func (category) Description() string {
 
 func (category *category) Run(ctx context.Context) (any, error) {
 	if !slices.Contains(categories, category.Category) {
-		fmt.Printf("search for %q\n", category.Category)
+		fmt.Printf("  => Search for %q\n", category.Category)
 		return category.Articles(OptQuery(category.Category), OptLimit(10))
 	}
-	fmt.Printf("category for %q\n", category.Category)
+	fmt.Printf("  => Headlines for %q\n", category.Category)
 	return category.Headlines(OptCategory(category.Category), OptLimit(10))
 }
-
-/*
-// Return all the agent tools for the weatherapi
-func (c *Client) Tools() []agent.Tool {
-	return []agent.Tool{
-		&tool{
-			name:        "current_headlines",
-			description: "Return the current news headlines",
-			run:         c.agentCurrentHeadlines,
-		}, &tool{
-			name:        "current_headlines_country",
-			description: "Return the current news headlines for a country",
-			run:         c.agentCountryHeadlines,
-			params: []agent.ToolParameter{
-				{
-					Name:        "countrycode",
-					Description: "The two-letter country code to return headlines for",
-					Required:    true,
-				},
-			},
-		}, &tool{
-			name:        "current_headlines_category",
-			description: "Return the current news headlines for a business, entertainment, health, science, sports or technology",
-			run:         c.agentCategoryHeadlines,
-			params: []agent.ToolParameter{
-				{
-					Name:        "category",
-					Description: "business, entertainment, health, science, sports, technology",
-					Required:    true,
-				},
-			},
-		}, &tool{
-			name:        "search_news",
-			description: "Return the news headlines with a search query",
-			run:         c.agentSearchNews,
-			params: []agent.ToolParameter{
-				{
-					Name:        "query",
-					Description: "A phrase used to search for news headlines",
-					Required:    true,
-				},
-			},
-		},
-	}
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// PRIVATE METHODS - TOOL
-
-func (*tool) Provider() string {
-	return "newsapi"
-}
-
-func (t *tool) Name() string {
-	return t.name
-}
-
-func (t *tool) Description() string {
-	return t.description
-}
-
-func (t *tool) Params() []agent.ToolParameter {
-	return t.params
-}
-
-func (t *tool) Run(ctx context.Context, call *agent.ToolCall) (*agent.ToolResult, error) {
-	return t.run(ctx, call)
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// PRIVATE METHODS - TOOL
-
-// Return the current general headlines
-func (c *Client) agentCurrentHeadlines(_ context.Context, call *agent.ToolCall) (*agent.ToolResult, error) {
-	response, err := c.Headlines(OptCategory("general"), OptLimit(5))
-	if err != nil {
-		return nil, err
-	}
-	return &agent.ToolResult{
-		Id: call.Id,
-		Result: map[string]any{
-			"type":      "text",
-			"headlines": response,
-		},
-	}, nil
-}
-
-// Return the headlines for a specific country
-func (c *Client) agentCountryHeadlines(_ context.Context, call *agent.ToolCall) (*agent.ToolResult, error) {
-	country, err := call.String("countrycode")
-	if err != nil {
-		return nil, err
-	}
-	country = strings.ToLower(country)
-	response, err := c.Headlines(OptCountry(country), OptLimit(5))
-	if err != nil {
-		return nil, err
-	}
-	return &agent.ToolResult{
-		Id: call.Id,
-		Result: map[string]any{
-			"type":      "text",
-			"country":   country,
-			"headlines": response,
-		},
-	}, nil
-}
-
-// Return the headlines for a specific category
-func (c *Client) agentCategoryHeadlines(_ context.Context, call *agent.ToolCall) (*agent.ToolResult, error) {
-	category, err := call.String("category")
-	if err != nil {
-		return nil, err
-	}
-	category = strings.ToLower(category)
-	response, err := c.Headlines(OptCategory(category), OptLimit(5))
-	if err != nil {
-		return nil, err
-	}
-	return &agent.ToolResult{
-		Id: call.Id,
-		Result: map[string]any{
-			"type":      "text",
-			"category":  category,
-			"headlines": response,
-		},
-	}, nil
-}
-
-// Return the headlines for a specific query
-func (c *Client) agentSearchNews(_ context.Context, call *agent.ToolCall) (*agent.ToolResult, error) {
-	query, err := call.String("query")
-	if err != nil {
-		return nil, err
-	}
-	response, err := c.Articles(OptQuery(query), OptLimit(5))
-	if err != nil {
-		return nil, err
-	}
-	return &agent.ToolResult{
-		Id: call.Id,
-		Result: map[string]any{
-			"type":      "text",
-			"query":     query,
-			"headlines": response,
-		},
-	}, nil
-}
-*/