Added news and ip address

Author: djthorpe

cmd/agent/main.go

@@ -11,6 +11,7 @@ import (
 	kong "github.com/alecthomas/kong"
 	client "github.com/mutablelogic/go-client"
 	agent "github.com/mutablelogic/go-client/pkg/agent"
+	"github.com/mutablelogic/go-client/pkg/ipify"
 	"github.com/mutablelogic/go-client/pkg/newsapi"
 	ollama "github.com/mutablelogic/go-client/pkg/ollama"
 	openai "github.com/mutablelogic/go-client/pkg/openai"
@@ -95,6 +96,10 @@ func main() {
 		cmd.FatalIfErrorf(err)
 		cli.Globals.tools = append(cli.Globals.tools, news.Tools()...)
 	}
+	// Add ipify
+	ipify, err := ipify.New(clientOpts(&cli)...)
+	cmd.FatalIfErrorf(err)
+	cli.Globals.tools = append(cli.Globals.tools, ipify.Tools()...)
 
 	// Create a context
 	ctx, cancel := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)

pkg/agent/tool.go

@@ -3,6 +3,7 @@ package agent
 import (
 	"context"
 	"encoding/json"
+	"fmt"
 	"strconv"
 
 	// Namespace imports
@@ -68,11 +69,20 @@ func (t *ToolResult) Role() string {
 	return "tool"
 }
 
+// Return parameter as a string
+func (t *ToolCall) String(name string) (string, error) {
+	v, ok := t.Args[name]
+	if !ok {
+		return "", ErrBadParameter.Withf("%q not found", name)
+	}
+	return fmt.Sprint(v), nil
+}
+
 // Return parameter as an integer
 func (t *ToolCall) Int(name string) (int, error) {
 	v, ok := t.Args[name]
 	if !ok {
-		return 0, ErrBadParameter.Withf("'%s' not found", name)
+		return 0, ErrBadParameter.Withf("%q not found", name)
 	}
 	switch v := v.(type) {
 	case int:

pkg/ipify/agent.go

@@ -4,33 +4,73 @@ import (
 	"context"
 
 	// Packages
-	schema "github.com/mutablelogic/go-client/pkg/openai/schema"
-
-	// Namespace imports
-	. "github.com/djthorpe/go-errors"
+	agent "github.com/mutablelogic/go-client/pkg/agent"
 )
 
 ///////////////////////////////////////////////////////////////////////////////
 // TYPES
 
+type tool struct {
+	name        string
+	description string
+	params      []agent.ToolParameter
+	run         func(context.Context, *agent.ToolCall) (*agent.ToolResult, error)
+}
+
+// Ensure tool satisfies the agent.Tool interface
+var _ agent.Tool = (*tool)(nil)
+
 ///////////////////////////////////////////////////////////////////////////////
 // PUBLIC METHODS
 
-// Return the tools available
-func (c *Client) Tools() []*schema.Tool {
-	if get_ip_address, err := schema.NewToolEx("get_ip_address", "Get the current IP address.", nil); err != nil {
-		panic(err)
-	} else {
-		return []*schema.Tool{get_ip_address}
+// Return all the agent tools for the weatherapi
+func (c *Client) Tools() []agent.Tool {
+	return []agent.Tool{
+		&tool{
+			name:        "get_ip_address",
+			description: "Return your IP address",
+			run:         c.agentGetAddress,
+		},
 	}
 }
 
-// Run a tool and return the result
-func (c *Client) Run(ctx context.Context, name string, _ any) (any, error) {
-	switch name {
-	case "get_ip_address":
-		return c.Get()
-	default:
-		return nil, ErrInternalAppError.With(name)
+///////////////////////////////////////////////////////////////////////////////
+// PRIVATE METHODS - TOOL
+
+func (*tool) Provider() string {
+	return "ipify"
+}
+
+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) agentGetAddress(_ context.Context, call *agent.ToolCall) (*agent.ToolResult, error) {
+	response, err := c.Get()
+	if err != nil {
+		return nil, err
 	}
+	return &agent.ToolResult{
+		Id: call.Id,
+		Result: map[string]any{
+			"type":       "text",
+			"ip_address": response,
+		},
+	}, nil
 }

pkg/ipify/agent_test.go

@@ -2,6 +2,7 @@ package newsapi
 
 import (
 	"context"
+	"strings"
 
 	// Packages
 	agent "github.com/mutablelogic/go-client/pkg/agent"
@@ -30,6 +31,39 @@ func (c *Client) Tools() []agent.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,
+				},
+			},
 		},
 	}
 }
@@ -60,7 +94,7 @@ func (t *tool) Run(ctx context.Context, call *agent.ToolCall) (*agent.ToolResult
 ///////////////////////////////////////////////////////////////////////////////
 // PRIVATE METHODS - TOOL
 
-// Return the current weather
+// Return the current general headlines
 func (c *Client) agentCurrentHeadlines(_ context.Context, call *agent.ToolCall) (*agent.ToolResult, error) {
 	response, err := c.Headlines(OptCategory("general"))
 	if err != nil {
@@ -74,3 +108,65 @@ func (c *Client) agentCurrentHeadlines(_ context.Context, call *agent.ToolCall)
 		},
 	}, 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))
+	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
+}

pkg/newsapi/agent.go

@@ -89,7 +89,14 @@ func NewToolResult(id string, result map[string]any) *Message {
 	var message Message
 	message.Role = "tool"
 	message.ToolCallId = id
-	message.Content = []any{result}
+
+	data, err := json.Marshal(result)
+	if err != nil {
+		return nil
+	} else {
+		message.Content = string(data)
+	}
+
 	return &message
 }