feat: add custom tool type support in Google AI tests and enhance parameter conversion

Author: asdek

llms/googleai/googleai.go

@@ -505,30 +505,49 @@ func convertTools(tools []llms.Tool) ([]*genai.Tool, error) {
 	}}, nil
 }
 
-func convertMaps(i any) any {
+func convertMaps(i any) (any, error) {
+	var err error
 	switch v := i.(type) {
 	case map[any]any:
 		m := make(map[string]any)
 		for key, val := range v {
 			sKey, ok := key.(string)
 			if !ok {
-				return v
+				return v, nil
+			}
+			m[sKey], err = convertMaps(val)
+			if err != nil {
+				return nil, err
 			}
-			m[sKey] = convertMaps(val)
 		}
-		return m
+		return m, nil
 	case []any:
 		s := make([]any, len(v))
 		for idx, val := range v {
-			s[idx] = convertMaps(val)
+			s[idx], err = convertMaps(val)
+			if err != nil {
+				s[idx] = val
+			}
 		}
-		return s
+		return s, nil
+	default:
+		d, err := json.Marshal(i)
+		if err != nil {
+			return i, err
+		}
+		var m any
+		if err := json.Unmarshal(d, &m); err != nil {
+			return i, err
+		}
+		return m, nil
 	}
-	return i
 }
 
 func convertToSchema(e any, topLevel bool) (*genai.Schema, error) {
-	e = convertMaps(e)
+	e, err := convertMaps(e)
+	if err != nil {
+		return nil, err
+	}
 	schema := &genai.Schema{}
 
 	eMap, ok := e.(map[string]any)

llms/googleai/googleai_test.go

@@ -2,6 +2,7 @@ package googleai
 
 import (
 	"context"
+	"encoding/json"
 	"net/http"
 	"os"
 	"strings"
@@ -296,6 +297,84 @@ func TestGoogleAIWithTools(t *testing.T) {
 		assert.NotEmpty(t, toolCall.ID, "ToolCall ID should not be empty")
 		assert.Equal(t, "getWeather", toolCall.FunctionCall.Name)
 		assert.Contains(t, toolCall.FunctionCall.Arguments, "New York")
+	} else {
+		t.Fail()
+	}
+}
+
+func TestGoogleAIWithToolsCustomType(t *testing.T) {
+	llm := newHTTPRRClient(t)
+
+	type toolCallArgs struct {
+		Location string `json:"location"`
+	}
+
+	type property struct {
+		Type        string `json:"type"`
+		Description string `json:"description"`
+	}
+
+	type properties struct {
+		Location property `json:"location"`
+	}
+
+	type parameters struct {
+		Type       string     `json:"type"`
+		Properties properties `json:"properties"`
+		Required   []string   `json:"required"`
+	}
+
+	tools := []llms.Tool{
+		{
+			Type: "function",
+			Function: &llms.FunctionDefinition{
+				Name:        "getWeather",
+				Description: "Get the weather for a location",
+				Parameters: parameters{
+					Type: "object",
+					Properties: properties{
+						Location: property{
+							Type:        "string",
+							Description: "The location to get weather for",
+						},
+					},
+					Required: []string{"location"},
+				},
+			},
+		},
+	}
+
+	content := []llms.MessageContent{
+		{
+			Role: llms.ChatMessageTypeHuman,
+			Parts: []llms.ContentPart{
+				llms.TextPart("What's the weather in New York?"),
+			},
+		},
+	}
+
+	resp, err := llm.GenerateContent(
+		t.Context(),
+		content,
+		llms.WithTools(tools),
+	)
+
+	require.NoError(t, err)
+	require.NotNil(t, resp)
+	assert.NotEmpty(t, resp.Choices)
+
+	// Check if tool call was made
+	if len(resp.Choices[0].ToolCalls) > 0 {
+		toolCall := resp.Choices[0].ToolCalls[0]
+		assert.NotEmpty(t, toolCall.ID, "ToolCall ID should not be empty")
+		assert.Equal(t, "getWeather", toolCall.FunctionCall.Name)
+		assert.Contains(t, toolCall.FunctionCall.Arguments, "New York")
+		var args toolCallArgs
+		err := json.Unmarshal([]byte(toolCall.FunctionCall.Arguments), &args)
+		require.NoError(t, err)
+		assert.Equal(t, "New York", args.Location)
+	} else {
+		t.Fail()
 	}
 }
 

llms/googleai/testdata/TestGoogleAIWithToolsCustomType.httprr

@@ -397,7 +397,13 @@ func convertTools(tools []llms.Tool) ([]*genai.Tool, error) {
 		// extract properties to populate the schema.
 		params, ok := tool.Function.Parameters.(map[string]any)
 		if !ok {
-			return nil, fmt.Errorf("tool [%d]: unsupported type %T of Parameters", i, tool.Function.Parameters)
+			paramsData, err := json.Marshal(tool.Function.Parameters)
+			if err != nil {
+				return nil, fmt.Errorf("tool [%d]: failed to marshal parameters: %w", i, err)
+			}
+			if err := json.Unmarshal(paramsData, &params); err != nil {
+				return nil, fmt.Errorf("tool [%d]: failed to unmarshal parameters: %w", i, err)
+			}
 		}
 
 		schema := &genai.Schema{}