Added streamable messages

Author: djthorpe

pkg/anthropic/message.go

@@ -82,6 +82,7 @@ type Usage struct {
 type Delta struct {
 	Type string `json:"type"`
 	Text string `json:"text,omitempty"`
+	Json string `json:"partial_json,omitempty"`
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -136,6 +137,14 @@ func (c *Client) Messages(ctx context.Context, messages []*schema.Message, opt .
 	return response.Content, nil
 }
 
+///////////////////////////////////////////////////////////////////////////////
+// STRINGIFY
+
+func (d Delta) String() string {
+	data, _ := json.MarshalIndent(d, "", "  ")
+	return string(data)
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // UNMARSHAL TEXT STREAM
 
@@ -182,6 +191,7 @@ func (m *respMessage) decodeTextStream(r io.Reader) error {
 				// TODO: Set input_tokens from stream.Usage.InputTokens
 			case "message_stop":
 				if m.delta != nil {
+					// Callback with nil to indicate end of message
 					m.delta(nil)
 				}
 			case "content_block_start":
@@ -192,11 +202,13 @@ func (m *respMessage) decodeTextStream(r io.Reader) error {
 				case stream.Delta.Type == "text_delta" && content.Type == "text":
 					// Append text
 					content.Text += stream.Delta.Text
+				case stream.Delta.Type == "input_json_delta":
+					// Append partial_json
+					content.Text += stream.Delta.Json
 				}
 			case "content_block_stop":
 				// Append content
 				m.Content = append(m.Content, content)
-
 				// Reset content
 				content = schema.Content{}
 			case "message_delta":

pkg/anthropic/message_test.go

@@ -3,6 +3,7 @@ package anthropic_test
 import (
 	"context"
 	"os"
+	"reflect"
 	"testing"
 
 	opts "github.com/mutablelogic/go-client"
@@ -44,10 +45,29 @@ func Test_message_003(t *testing.T) {
 
 	// Create the weather tool
 	weather := schema.NewTool("weather", "Get the weather for a location")
-	weather.AddParameter("location", "The location to get the weather for", true)
+	assert.NoError(weather.Add("location", "The location to get the weather for", true, reflect.TypeOf("")))
 
 	// Request -> Response
 	content, err := client.Messages(context.Background(), []*schema.Message{msg}, anthropic.OptTool(weather))
 	assert.NoError(err)
 	t.Log(content)
 }
+
+func Test_message_004(t *testing.T) {
+	assert := assert.New(t)
+	client, err := anthropic.New(GetApiKey(t), opts.OptTrace(os.Stderr, true), opts.OptHeader("Anthropic-Beta", "tools-2024-04-04"))
+	assert.NoError(err)
+	assert.NotNil(client)
+	msg := schema.NewMessage("user", "What is the weather today in Berlin, Germany")
+
+	// Create the weather tool
+	weather := schema.NewTool("weather", "Get the weather for a location")
+	assert.NoError(weather.Add("location", "The location to get the weather for", true, reflect.TypeOf("")))
+
+	// Request -> Response
+	content, err := client.Messages(context.Background(), []*schema.Message{msg}, anthropic.OptTool(weather), anthropic.OptStream(func(v *anthropic.Delta) {
+		t.Log(v)
+	}))
+	assert.NoError(err)
+	t.Log(content)
+}

pkg/openai/schema/tool.go

@@ -2,9 +2,12 @@ package schema
 
 import (
 	"encoding/json"
+	"fmt"
+	"reflect"
 
 	// Namespace imports
 	. "github.com/djthorpe/go-errors"
+	"github.com/djthorpe/go-tablewriter/pkg/meta"
 )
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -21,7 +24,7 @@ type Tool struct {
 type toolParameters struct {
 	Type       string                   `json:"type,omitempty"`
 	Properties map[string]toolParameter `json:"properties,omitempty"`
-	Required   []string                 `json:"required"`
+	Required   []string                 `json:"required,omitempty"`
 }
 
 // Tool function call parameter
@@ -32,6 +35,19 @@ type toolParameter struct {
 	Description string   `json:"description"`
 }
 
+///////////////////////////////////////////////////////////////////////////////
+// GLOBALS
+
+const (
+	tagParameter = "json"
+)
+
+var (
+	typeString = reflect.TypeOf("")
+	typeBool   = reflect.TypeOf(true)
+	typeInt    = reflect.TypeOf(int(0))
+)
+
 ///////////////////////////////////////////////////////////////////////////////
 // LIFECYCLE
 
@@ -46,6 +62,29 @@ func NewTool(name, description string) *Tool {
 	}
 }
 
+func NewToolEx(name, description string, parameters any) (*Tool, error) {
+	t := NewTool(name, description)
+	if parameters == nil {
+		return t, nil
+	}
+
+	// Get tool metadata
+	meta, err := meta.New(parameters, tagParameter)
+	if err != nil {
+		return nil, err
+	}
+
+	// Iterate over fields, and add parameters
+	for _, field := range meta.Fields() {
+		if err := t.Add(field.Name(), field.Tag("description"), !field.Is("omitempty"), field.Type()); err != nil {
+			return nil, fmt.Errorf("field %q: %w", field.Name(), err)
+		}
+	}
+
+	// Return the tool
+	return t, nil
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // STRINGIFY
 
@@ -57,22 +96,42 @@ func (t Tool) String() string {
 ///////////////////////////////////////////////////////////////////////////////
 // PUBLIC METHODS
 
-func (t *Tool) AddParameter(name, description string, required bool) error {
+func (tool *Tool) Add(name, description string, required bool, t reflect.Type) error {
 	if name == "" {
 		return ErrBadParameter.With("missing name")
 	}
-	if _, exists := t.Parameters.Properties[name]; exists {
+	if _, exists := tool.Parameters.Properties[name]; exists {
 		return ErrDuplicateEntry.With(name)
 	}
-	t.Parameters.Properties[name] = toolParameter{
+	typ, err := typeOf(t)
+	if err != nil {
+		return err
+	}
+	tool.Parameters.Properties[name] = toolParameter{
 		Name:        name,
-		Type:        "string",
+		Type:        typ,
 		Description: description,
 	}
 	if required {
-		t.Parameters.Required = append(t.Parameters.Required, name)
+		tool.Parameters.Required = append(tool.Parameters.Required, name)
 	}
 
 	// Return success
 	return nil
 }
+
+///////////////////////////////////////////////////////////////////////////////
+// PRIVATE METHODS
+
+func typeOf(v reflect.Type) (string, error) {
+	switch v {
+	case typeString:
+		return "string", nil
+	case typeBool:
+		return "boolean", nil
+	case typeInt:
+		return "integer", nil
+	default:
+		return "", ErrBadParameter.Withf("unsupported type %q", v)
+	}
+}

pkg/openai/schema/tool_test.go

@@ -1,6 +1,7 @@
 package schema_test
 
 import (
+	"reflect"
 	"testing"
 
 	"github.com/mutablelogic/go-client/pkg/openai/schema"
@@ -11,6 +12,16 @@ func Test_tool_001(t *testing.T) {
 	assert := assert.New(t)
 	tool := schema.NewTool("get_stock_price", "Get the current stock price for a given ticker symbol.")
 	assert.NotNil(tool)
-	assert.NoError(tool.AddParameter("ticker", "The stock ticker symbol, e.g. AAPL for Apple Inc.", true))
+	assert.NoError(tool.Add("ticker", "The stock ticker symbol, e.g. AAPL for Apple Inc.", true, reflect.TypeOf("")))
+	t.Log(tool)
+}
+
+func Test_tool_002(t *testing.T) {
+	assert := assert.New(t)
+	tool, err := schema.NewToolEx("get_stock_price", "Get the current stock price for a given ticker symbol.", struct {
+		Ticker string `json:"ticker,omitempty" description:"The stock ticker symbol, e.g. AAPL for Apple Inc."`
+	}{})
+	assert.NoError(err)
+	assert.NotNil(tool)
 	t.Log(tool)
 }

transport.go

@@ -8,6 +8,7 @@ import (
 	"io"
 	"mime"
 	"net/http"
+	"strings"
 	"time"
 
 	// Packages
@@ -101,15 +102,15 @@ func (transport *logtransport) RoundTrip(req *http.Request) (*http.Response, err
 		resp.Body = io.NopCloser(bytes.NewReader(body))
 		defer resp.Body.Close()
 
-		switch contentType {
-		case ContentTypeJson:
+		switch {
+		case contentType == ContentTypeJson:
 			dst := &bytes.Buffer{}
 			if err := json.Indent(dst, body, "    ", "  "); err != nil {
 				fmt.Fprintf(transport.w, "  <= %q\n", string(body))
 			} else {
 				fmt.Fprintf(transport.w, "  <= %v\n", dst.String())
 			}
-		case ContentTypeTextPlain:
+		case strings.HasPrefix(contentType, "text/"):
 			fmt.Fprintf(transport.w, "  <= %q\n", string(body))
 		default:
 			fmt.Fprintf(transport.w, "  <= (not displaying response of type %q)\n", contentType)