Merge branch 'dev' for v0.3.5 release

Author: run-bigpig

internal/adk/openai/convert.go

@@ -474,6 +474,17 @@ func convertChatCompletionResponse(resp *openai.ChatCompletionResponse) (*model.
 		}
 	}
 
+	// 兼容旧版 function_call 字段
+	if choice.Message.FunctionCall != nil && choice.Message.FunctionCall.Name != "" {
+		content.Parts = append(content.Parts, &genai.Part{
+			FunctionCall: &genai.FunctionCall{
+				ID:   "legacy_function_call",
+				Name: choice.Message.FunctionCall.Name,
+				Args: parseJSONArgs(choice.Message.FunctionCall.Arguments),
+			},
+		})
+	}
+
 	// 处理 usage
 	var usageMetadata *genai.GenerateContentResponseUsageMetadata
 	if resp.Usage.TotalTokens > 0 {

internal/adk/openai/model.go

@@ -2,11 +2,12 @@ package openai
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
 	"iter"
-	"slices"
+	"strings"
 
 	"github.com/sashabaranov/go-openai"
 	"google.golang.org/adk/model"
@@ -124,7 +125,7 @@ func (o *OpenAIModel) processStream(stream *openai.ChatCompletionStream, yield f
 	}
 	var finishReason genai.FinishReason
 	var usageMetadata *genai.GenerateContentResponseUsageMetadata
-	toolCallsMap := make(map[int]*toolCallBuilder)
+	toolCalls := newChatStreamToolCallAggregator()
 	var textContent string
 	var thoughtContent string
 	thinkParser := newThinkTagStreamParser()
@@ -186,24 +187,8 @@ func (o *OpenAIModel) processStream(stream *openai.ChatCompletionStream, yield f
 		}
 
 		// 处理标准工具调用
-		for _, toolCall := range choice.Delta.ToolCalls {
-			idx := 0
-			if toolCall.Index != nil {
-				idx = *toolCall.Index
-			}
-
-			if _, exists := toolCallsMap[idx]; !exists {
-				toolCallsMap[idx] = &toolCallBuilder{}
-			}
-
-			builder := toolCallsMap[idx]
-			if toolCall.ID != "" {
-				builder.id = toolCall.ID
-			}
-			if toolCall.Function.Name != "" {
-				builder.name = toolCall.Function.Name
-			}
-			builder.args += toolCall.Function.Arguments
+		for pos, toolCall := range choice.Delta.ToolCalls {
+			toolCalls.AddDelta(pos, toolCall)
 		}
 
 		if choice.FinishReason != "" {
@@ -248,19 +233,18 @@ func (o *OpenAIModel) processStream(stream *openai.ChatCompletionStream, yield f
 	}
 
 	// 聚合标准工具调用
-	if len(toolCallsMap) > 0 {
-		indices := sortedKeys(toolCallsMap)
-		for _, idx := range indices {
-			builder := toolCallsMap[idx]
-			part := &genai.Part{
-				FunctionCall: &genai.FunctionCall{
-					ID:   builder.id,
-					Name: builder.name,
-					Args: parseJSONArgs(builder.args),
-				},
-			}
-			aggregatedContent.Parts = append(aggregatedContent.Parts, part)
+	for _, builder := range toolCalls.OrderedBuilders() {
+		if builder == nil {
+			continue
+		}
+		part := &genai.Part{
+			FunctionCall: &genai.FunctionCall{
+				ID:   builder.id,
+				Name: builder.name,
+				Args: parseJSONArgs(builder.args),
+			},
 		}
+		aggregatedContent.Parts = append(aggregatedContent.Parts, part)
 	}
 
 	if streamErr != nil {
@@ -285,12 +269,133 @@ type toolCallBuilder struct {
 	args string
 }
 
-// sortedKeys 返回排序后的 map keys
-func sortedKeys(m map[int]*toolCallBuilder) []int {
-	keys := make([]int, 0, len(m))
-	for k := range m {
-		keys = append(keys, k)
+// chatStreamToolCallAggregator 聚合兼容 OpenAI 的流式工具调用。
+// 一些兼容接口不会稳定返回 index，这里优先按 index / id 归并，
+// 都缺失时再按当前位置兜底，并在检测到新 JSON 对象时自动切分。
+type chatStreamToolCallAggregator struct {
+	builders      map[string]*toolCallBuilder
+	order         []string
+	indexKeys     map[int]string
+	idKeys        map[string]string
+	fallbackKeys  map[int]string
+	nextSynthetic int
+}
+
+func newChatStreamToolCallAggregator() *chatStreamToolCallAggregator {
+	return &chatStreamToolCallAggregator{
+		builders:     make(map[string]*toolCallBuilder),
+		indexKeys:    make(map[int]string),
+		idKeys:       make(map[string]string),
+		fallbackKeys: make(map[int]string),
+	}
+}
+
+func (a *chatStreamToolCallAggregator) AddDelta(pos int, toolCall openai.ToolCall) {
+	key := a.lookupKey(pos, toolCall)
+	if builder := a.builders[key]; shouldRotateToolCallBuilder(builder, toolCall) {
+		key = a.newSyntheticKey()
+	}
+
+	a.bindAliases(pos, toolCall, key)
+	builder := a.ensureBuilder(key)
+	if toolCall.ID != "" {
+		builder.id = toolCall.ID
+	}
+	if toolCall.Function.Name != "" {
+		builder.name = toolCall.Function.Name
+	}
+	if toolCall.Function.Arguments != "" {
+		builder.args += toolCall.Function.Arguments
+	}
+}
+
+func (a *chatStreamToolCallAggregator) OrderedBuilders() []*toolCallBuilder {
+	builders := make([]*toolCallBuilder, 0, len(a.order))
+	for _, key := range a.order {
+		builders = append(builders, a.builders[key])
+	}
+	return builders
+}
+
+func (a *chatStreamToolCallAggregator) lookupKey(pos int, toolCall openai.ToolCall) string {
+	if toolCall.Index != nil {
+		if key, ok := a.indexKeys[*toolCall.Index]; ok {
+			return key
+		}
+	}
+	if toolCall.ID != "" {
+		if key, ok := a.idKeys[toolCall.ID]; ok {
+			return key
+		}
+	}
+	if key, ok := a.fallbackKeys[pos]; ok {
+		return key
+	}
+	if toolCall.Index != nil {
+		return fmt.Sprintf("idx:%d", *toolCall.Index)
+	}
+	if toolCall.ID != "" {
+		return fmt.Sprintf("id:%s", toolCall.ID)
+	}
+	return a.newSyntheticKey()
+}
+
+func (a *chatStreamToolCallAggregator) bindAliases(pos int, toolCall openai.ToolCall, key string) {
+	if toolCall.Index != nil {
+		a.indexKeys[*toolCall.Index] = key
+	}
+	if toolCall.ID != "" {
+		a.idKeys[toolCall.ID] = key
+	}
+	if toolCall.Index == nil {
+		a.fallbackKeys[pos] = key
+	}
+}
+
+func (a *chatStreamToolCallAggregator) ensureBuilder(key string) *toolCallBuilder {
+	if builder, ok := a.builders[key]; ok {
+		return builder
+	}
+	builder := &toolCallBuilder{}
+	a.builders[key] = builder
+	a.order = append(a.order, key)
+	return builder
+}
+
+func (a *chatStreamToolCallAggregator) newSyntheticKey() string {
+	key := fmt.Sprintf("anon:%d", a.nextSynthetic)
+	a.nextSynthetic++
+	return key
+}
+
+func shouldRotateToolCallBuilder(builder *toolCallBuilder, toolCall openai.ToolCall) bool {
+	if builder == nil {
+		return false
+	}
+	if toolCall.ID != "" && builder.id != "" && toolCall.ID != builder.id {
+		return true
+	}
+	if toolCall.Function.Name != "" && builder.name != "" && toolCall.Function.Name != builder.name {
+		return true
+	}
+
+	if !isCompleteJSONObject(builder.args) {
+		return false
+	}
+
+	if toolCall.Function.Arguments != "" {
+		return true
+	}
+	if toolCall.ID != "" && builder.id == "" {
+		return true
+	}
+	return false
+}
+
+func isCompleteJSONObject(s string) bool {
+	trimmed := strings.TrimSpace(s)
+	if trimmed == "" {
+		return false
 	}
-	slices.Sort(keys)
-	return keys
+	return json.Valid([]byte(trimmed))
 }

internal/adk/openai/responses_convert.go

@@ -70,7 +70,10 @@ func toResponsesRequest(req *model.LLMRequest, modelName string, noSystemRole bo
 
 	// 转换工具定义
 	if len(req.Config.Tools) > 0 {
-		apiReq.Tools = convertResponsesTools(req.Config.Tools)
+		apiReq.Tools, err = convertResponsesTools(req.Config.Tools)
+		if err != nil {
+			return CreateResponseRequest{}, err
+		}
 	}
 
 	// 应用生成参数
@@ -144,7 +147,6 @@ func toResponsesInputItem(content *genai.Content) ([]ResponsesInputItem, error)
 			}
 			toolCallItems = append(toolCallItems, ResponsesInputItem{
 				Type:      "function_call",
-				ID:        part.FunctionCall.ID,
 				CallID:    part.FunctionCall.ID,
 				Name:      part.FunctionCall.Name,
 				Arguments: string(argsJSON),
@@ -182,7 +184,7 @@ func convertRoleForResponses(role string) string {
 }
 
 // convertResponsesTools 转换工具定义为 Responses API 扁平化格式
-func convertResponsesTools(genaiTools []*genai.Tool) []ResponsesTool {
+func convertResponsesTools(genaiTools []*genai.Tool) ([]ResponsesTool, error) {
 	var tools []ResponsesTool
 	for _, genaiTool := range genaiTools {
 		if genaiTool == nil {
@@ -193,6 +195,10 @@ func convertResponsesTools(genaiTools []*genai.Tool) []ResponsesTool {
 			if params == nil {
 				params = funcDecl.Parameters
 			}
+			params, err := normalizeResponsesToolSchema(params)
+			if err != nil {
+				return nil, fmt.Errorf("normalize responses tool schema %s: %w", funcDecl.Name, err)
+			}
 			tools = append(tools, ResponsesTool{
 				Type:        "function",
 				Name:        funcDecl.Name,
@@ -201,7 +207,95 @@ func convertResponsesTools(genaiTools []*genai.Tool) []ResponsesTool {
 			})
 		}
 	}
-	return tools
+	return tools, nil
+}
+
+func normalizeResponsesToolSchema(schema any) (any, error) {
+	if schema == nil {
+		return defaultResponsesToolSchema(), nil
+	}
+
+	raw, err := json.Marshal(schema)
+	if err != nil {
+		return nil, fmt.Errorf("marshal schema: %w", err)
+	}
+	if string(raw) == "null" {
+		return defaultResponsesToolSchema(), nil
+	}
+
+	var normalized any
+	if err := json.Unmarshal(raw, &normalized); err != nil {
+		return nil, fmt.Errorf("unmarshal schema: %w", err)
+	}
+	if normalized == nil {
+		return defaultResponsesToolSchema(), nil
+	}
+
+	normalizeResponsesSchemaNode(normalized)
+	if root, ok := normalized.(map[string]any); ok {
+		ensureResponsesObjectSchema(root)
+	}
+
+	return normalized, nil
+}
+
+func defaultResponsesToolSchema() map[string]any {
+	return map[string]any{
+		"type":                 "object",
+		"properties":           map[string]any{},
+		"additionalProperties": false,
+	}
+}
+
+func normalizeResponsesSchemaNode(node any) {
+	switch typed := node.(type) {
+	case map[string]any:
+		ensureResponsesObjectSchema(typed)
+		for key, value := range typed {
+			if key == "additionalProperties" {
+				if schemaMap, ok := value.(map[string]any); ok && isAlwaysFalseSchema(schemaMap) {
+					typed[key] = false
+					continue
+				}
+			}
+			normalizeResponsesSchemaNode(value)
+		}
+	case []any:
+		for _, item := range typed {
+			normalizeResponsesSchemaNode(item)
+		}
+	}
+}
+
+func ensureResponsesObjectSchema(schema map[string]any) {
+	if !isObjectSchemaType(schema["type"]) {
+		return
+	}
+	if props, ok := schema["properties"]; !ok || props == nil {
+		schema["properties"] = map[string]any{}
+	}
+}
+
+func isObjectSchemaType(schemaType any) bool {
+	switch typed := schemaType.(type) {
+	case string:
+		return typed == "object"
+	case []any:
+		for _, item := range typed {
+			if item == "object" {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func isAlwaysFalseSchema(schema map[string]any) bool {
+	if len(schema) != 1 {
+		return false
+	}
+	notSchema, ok := schema["not"].(map[string]any)
+	return ok && len(notSchema) == 0
 }
 
 // convertResponsesResponse 将 Responses API 响应转换为 ADK LLMResponse