krisyotam/proxy

internal/translator/antigravity/claude/antigravity_claude_response.go+1−1

@@ -452,7 +452,7 @@ func ConvertAntigravityResponseToClaudeNonStream(_ context.Context, _ string, or · 451 unmodified lines
452	toolBlock, _ = sjson.Set(toolBlock, "id", fmt.Sprintf("tool_%d", toolIDCounter))	452	toolBlock, _ = sjson.Set(toolBlock, "id", fmt.Sprintf("tool_%d", toolIDCounter))
453	toolBlock, _ = sjson.Set(toolBlock, "name", name)	453	toolBlock, _ = sjson.Set(toolBlock, "name", name)
454		454
455	if args := functionCall.Get("args"); args.Exists() && args.Raw != "" && gjson.Valid(args.Raw) {	455	if args := functionCall.Get("args"); args.Exists() && args.Raw != "" && gjson.Valid(args.Raw) && args.IsObject() {
456	toolBlock, _ = sjson.SetRaw(toolBlock, "input", args.Raw)	456	toolBlock, _ = sjson.SetRaw(toolBlock, "input", args.Raw)
457	}	457	}
458		458

internal/translator/antigravity/gemini/antigravity_gemini_request.go+43−65

 import (
 	"bytes"
-	"encoding/json"
 	"fmt"
 	"github.com/router-for-me/CLIProxyAPI/v6/internal/translator/gemini/common"
 // FunctionCallGroup represents a group of function calls and their responses
 type FunctionCallGroup struct {
-	ModelContent    map[string]interface{}
-	FunctionCalls   []gjson.Result
 	ResponsesNeeded int
 }
-// parseFunctionResponse attempts to unmarshal a function response part.
+// parseFunctionResponseRaw attempts to normalize a function response part into a JSON object string.
-// Falls back to gjson extraction if standard json.Unmarshal fails.
+// Falls back to a minimal "functionResponse" object when parsing fails.
-func parseFunctionResponse(response gjson.Result) map[string]interface{} {
+func parseFunctionResponseRaw(response gjson.Result) string {
-	var responseMap map[string]interface{}
+	if response.IsObject() && gjson.Valid(response.Raw) {
-	err := json.Unmarshal([]byte(response.Raw), &responseMap)
+		return response.Raw
-	if err == nil {
-		return responseMap
 	}
-	log.Debugf("unmarshal function response failed, using fallback: %v", err)
+	log.Debugf("parse function response failed, using fallback")
 	funcResp := response.Get("functionResponse")
 	if funcResp.Exists() {
-		fr := map[string]interface{}{
+		fr := `{"functionResponse":{"name":"","response":{"result":""}}}`
-			"name": funcResp.Get("name").String(),
+		fr, _ = sjson.Set(fr, "functionResponse.name", funcResp.Get("name").String())
-			"response": map[string]interface{}{
+		fr, _ = sjson.Set(fr, "functionResponse.response.result", funcResp.Get("response").String())
-				"result": funcResp.Get("response").String(),
-			},
-		}
 		if id := funcResp.Get("id").String(); id != "" {
-			fr["id"] = id
+			fr, _ = sjson.Set(fr, "functionResponse.id", id)
 		}
-		return map[string]interface{}{"functionResponse": fr}
+		return fr
 	}
-	return map[string]interface{}{
+	fr := `{"functionResponse":{"name":"unknown","response":{"result":""}}}`
-		"functionResponse": map[string]interface{}{
+	fr, _ = sjson.Set(fr, "functionResponse.response.result", response.String())
-			"name":     "unknown",
+	return fr
-			"response": map[string]interface{}{"result": response.String()},
-		},
-	}
 }
 // fixCLIToolResponse performs sophisticated tool response format conversion and grouping.
 	}
 	// Initialize data structures for processing and grouping
-	var newContents []interface{}          // Final processed contents array
+	contentsWrapper := `{"contents":[]}`
 	var pendingGroups []*FunctionCallGroup // Groups awaiting completion with responses
 	var collectedResponses []gjson.Result  // Standalone responses to be matched
 					collectedResponses = collectedResponses[group.ResponsesNeeded:]
 					// Create merged function response content
-					var responseParts []interface{}
+					functionResponseContent := `{"parts":[],"role":"function"}`
 					for _, response := range groupResponses {
-						responseParts = append(responseParts, parseFunctionResponse(response))
+						partRaw := parseFunctionResponseRaw(response)
+						if partRaw != "" {
+							functionResponseContent, _ = sjson.SetRaw(functionResponseContent, "parts.-1", partRaw)
+						}
 					}
-					if len(responseParts) > 0 {
+					if gjson.Get(functionResponseContent, "parts.#").Int() > 0 {
-						functionResponseContent := map[string]interface{}{
+						contentsWrapper, _ = sjson.SetRaw(contentsWrapper, "contents.-1", functionResponseContent)
-							"parts": responseParts,
-							"role":  "function",
-						}
-						newContents = append(newContents, functionResponseContent)
 					}
 					// Remove this group as it's been satisfied
 		// If this is a model with function calls, create a new group
 		if role == "model" {
-			var functionCallsInThisModel []gjson.Result
+			functionCallsCount := 0
 			parts.ForEach(func(_, part gjson.Result) bool {
 				if part.Get("functionCall").Exists() {
-					functionCallsInThisModel = append(functionCallsInThisModel, part)
+					functionCallsCount++
 				}
 				return true
 			})
-			if len(functionCallsInThisModel) > 0 {
+			if functionCallsCount > 0 {
 				// Add the model content
-				var contentMap map[string]interface{}
+				if !value.IsObject() {
-				errUnmarshal := json.Unmarshal([]byte(value.Raw), &contentMap)
+					log.Warnf("failed to parse model content")
-				if errUnmarshal != nil {
-					log.Warnf("failed to unmarshal model content: %v\n", errUnmarshal)
 					return true
 				}
-				newContents = append(newContents, contentMap)
+				contentsWrapper, _ = sjson.SetRaw(contentsWrapper, "contents.-1", value.Raw)
 				// Create a new group for tracking responses
 				group := &FunctionCallGroup{
-					ModelContent:    contentMap,
+					ResponsesNeeded: functionCallsCount,
-					FunctionCalls:   functionCallsInThisModel,
-					ResponsesNeeded: len(functionCallsInThisModel),
 				}
 				pendingGroups = append(pendingGroups, group)
 			} else {
 				// Regular model content without function calls
-				var contentMap map[string]interface{}
+				if !value.IsObject() {
-				errUnmarshal := json.Unmarshal([]byte(value.Raw), &contentMap)
+					log.Warnf("failed to parse content")
-				if errUnmarshal != nil {
-					log.Warnf("failed to unmarshal content: %v\n", errUnmarshal)
 					return true
 				}
-				newContents = append(newContents, contentMap)
+				contentsWrapper, _ = sjson.SetRaw(contentsWrapper, "contents.-1", value.Raw)
 			}
 		} else {
 			// Non-model content (user, etc.)
-			var contentMap map[string]interface{}
+			if !value.IsObject() {
-			errUnmarshal := json.Unmarshal([]byte(value.Raw), &contentMap)
+				log.Warnf("failed to parse content")
-			if errUnmarshal != nil {
-				log.Warnf("failed to unmarshal content: %v\n", errUnmarshal)
 				return true
 			}
-			newContents = append(newContents, contentMap)
+			contentsWrapper, _ = sjson.SetRaw(contentsWrapper, "contents.-1", value.Raw)
 		}
 		return true
 			groupResponses := collectedResponses[:group.ResponsesNeeded]
 			collectedResponses = collectedResponses[group.ResponsesNeeded:]
-			var responseParts []interface{}
+			functionResponseContent := `{"parts":[],"role":"function"}`
 			for _, response := range groupResponses {
-				responseParts = append(responseParts, parseFunctionResponse(response))
+				partRaw := parseFunctionResponseRaw(response)
+				if partRaw != "" {
+					functionResponseContent, _ = sjson.SetRaw(functionResponseContent, "parts.-1", partRaw)
+				}
 			}
-			if len(responseParts) > 0 {
+			if gjson.Get(functionResponseContent, "parts.#").Int() > 0 {
-				functionResponseContent := map[string]interface{}{
+				contentsWrapper, _ = sjson.SetRaw(contentsWrapper, "contents.-1", functionResponseContent)
-					"parts": responseParts,
-					"role":  "function",
-				}
-				newContents = append(newContents, functionResponseContent)
 			}
 		}
 	}
 	// Update the original JSON with the new contents
 	result := input
-	newContentsJSON, _ := json.Marshal(newContents)
+	result, _ = sjson.SetRaw(result, "request.contents", gjson.Get(contentsWrapper, "contents").Raw)
-	result, _ = sjson.Set(result, "request.contents", json.RawMessage(newContentsJSON))
 	return result, nil
 }

internal/translator/antigravity/openai/chat-completions/antigravity_openai_request.go+2−2

@@ -319,7 +319,7 @@ func ConvertOpenAIRequestToAntigravity(modelName string, inputRawJSON []byte, _ · 318 unmodified lines
319	log.Warnf("Failed to set default schema type for tool '%s': %v", fn.Get("name").String(), errSet)	319	log.Warnf("Failed to set default schema type for tool '%s': %v", fn.Get("name").String(), errSet)
320	continue	320	continue
321	}	321	}
322	fnRaw, errSet = sjson.Set(fnRaw, "parametersJsonSchema.properties", map[string]interface{}{})	322	fnRaw, errSet = sjson.SetRaw(fnRaw, "parametersJsonSchema.properties", `{}`)
323	if errSet != nil {	323	if errSet != nil {
324	log.Warnf("Failed to set default schema properties for tool '%s': %v", fn.Get("name").String(), errSet)	324	log.Warnf("Failed to set default schema properties for tool '%s': %v", fn.Get("name").String(), errSet)
325	continue	325	continue
@@ -334,7 +334,7 @@ func ConvertOpenAIRequestToAntigravity(modelName string, inputRawJSON []byte, _ · 8 unmodified lines
334	log.Warnf("Failed to set default schema type for tool '%s': %v", fn.Get("name").String(), errSet)	334	log.Warnf("Failed to set default schema type for tool '%s': %v", fn.Get("name").String(), errSet)
335	continue	335	continue
336	}	336	}
337	fnRaw, errSet = sjson.Set(fnRaw, "parametersJsonSchema.properties", map[string]interface{}{})	337	fnRaw, errSet = sjson.SetRaw(fnRaw, "parametersJsonSchema.properties", `{}`)
338	if errSet != nil {	338	if errSet != nil {
339	log.Warnf("Failed to set default schema properties for tool '%s': %v", fn.Get("name").String(), errSet)	339	log.Warnf("Failed to set default schema properties for tool '%s': %v", fn.Get("name").String(), errSet)
340	continue	340	continue

internal/translator/antigravity/openai/chat-completions/antigravity_openai_response.go+3−11

 import (
 	"bytes"
 	"context"
-	"encoding/json"
 	"fmt"
 	"strings"
 	"sync/atomic"
 					mimeType = "image/png"
 				}
 				imageURL := fmt.Sprintf("data:%s;base64,%s", mimeType, data)
-				imagePayload, err := json.Marshal(map[string]any{
+				imagePayload := `{"image_url":{"url":""},"type":"image_url"}`
-					"type": "image_url",
+				imagePayload, _ = sjson.Set(imagePayload, "image_url.url", imageURL)
-					"image_url": map[string]string{
-						"url": imageURL,
-					},
-				})
-				if err != nil {
-					continue
-				}
 				imagesResult := gjson.Get(template, "choices.0.delta.images")
 				if !imagesResult.Exists() || !imagesResult.IsArray() {
 					template, _ = sjson.SetRaw(template, "choices.0.delta.images", `[]`)
 				}
 				template, _ = sjson.Set(template, "choices.0.delta.role", "assistant")
-				template, _ = sjson.SetRaw(template, "choices.0.delta.images.-1", string(imagePayload))
+				template, _ = sjson.SetRaw(template, "choices.0.delta.images.-1", imagePayload)
 			}
 		}
 	}

internal/translator/claude/gemini/claude_gemini_request.go+4−4

@@ -194,7 +194,7 @@ func ConvertGeminiRequestToClaude(modelName string, inputRawJSON []byte, stream · 193 unmodified lines
194	if name := fc.Get("name"); name.Exists() {	194	if name := fc.Get("name"); name.Exists() {
195	toolUse, _ = sjson.Set(toolUse, "name", name.String())	195	toolUse, _ = sjson.Set(toolUse, "name", name.String())
196	}	196	}
197	if args := fc.Get("args"); args.Exists() {	197	if args := fc.Get("args"); args.Exists() && args.IsObject() {
198	toolUse, _ = sjson.SetRaw(toolUse, "input", args.Raw)	198	toolUse, _ = sjson.SetRaw(toolUse, "input", args.Raw)
199	}	199	}
200	msg, _ = sjson.SetRaw(msg, "content.-1", toolUse)	200	msg, _ = sjson.SetRaw(msg, "content.-1", toolUse)
@@ -314,11 +314,11 @@ func ConvertGeminiRequestToClaude(modelName string, inputRawJSON []byte, stream · 113 unmodified lines
314	if mode := funcCalling.Get("mode"); mode.Exists() {	314	if mode := funcCalling.Get("mode"); mode.Exists() {
315	switch mode.String() {	315	switch mode.String() {
316	case "AUTO":	316	case "AUTO":
317	out, _ = sjson.Set(out, "tool_choice", map[string]interface{}{"type": "auto"})	317	out, _ = sjson.SetRaw(out, "tool_choice", `{"type":"auto"}`)
318	case "NONE":	318	case "NONE":
319	out, _ = sjson.Set(out, "tool_choice", map[string]interface{}{"type": "none"})	319	out, _ = sjson.SetRaw(out, "tool_choice", `{"type":"none"}`)
320	case "ANY":	320	case "ANY":
321	out, _ = sjson.Set(out, "tool_choice", map[string]interface{}{"type": "any"})	321	out, _ = sjson.SetRaw(out, "tool_choice", `{"type":"any"}`)
322	}	322	}
323	}	323	}
324	}	324	}

internal/translator/claude/gemini/claude_gemini_response.go+28−92

 	}
 }
-// convertArrayToJSON converts []interface{} to JSON array string
-func convertArrayToJSON(arr []interface{}) string {
-	result := "[]"
-	for _, item := range arr {
-		switch itemData := item.(type) {
-		case map[string]interface{}:
-			itemJSON := convertMapToJSON(itemData)
-			result, _ = sjson.SetRaw(result, "-1", itemJSON)
-		case string:
-			result, _ = sjson.Set(result, "-1", itemData)
-		case bool:
-			result, _ = sjson.Set(result, "-1", itemData)
-		case float64, int, int64:
-			result, _ = sjson.Set(result, "-1", itemData)
-		default:
-			result, _ = sjson.Set(result, "-1", itemData)
-		}
-	}
-	return result
-}
-// convertMapToJSON converts map[string]interface{} to JSON object string
-func convertMapToJSON(m map[string]interface{}) string {
-	result := "{}"
-	for key, value := range m {
-		switch val := value.(type) {
-		case map[string]interface{}:
-			nestedJSON := convertMapToJSON(val)
-			result, _ = sjson.SetRaw(result, key, nestedJSON)
-		case []interface{}:
-			arrayJSON := convertArrayToJSON(val)
-			result, _ = sjson.SetRaw(result, key, arrayJSON)
-		case string:
-			result, _ = sjson.Set(result, key, val)
-		case bool:
-			result, _ = sjson.Set(result, key, val)
-		case float64, int, int64:
-			result, _ = sjson.Set(result, key, val)
-		default:
-			result, _ = sjson.Set(result, key, val)
-		}
-	}
-	return result
-}
 // ConvertClaudeResponseToGeminiNonStream converts a non-streaming Claude Code response to a non-streaming Gemini response.
 // This function processes the complete Claude Code response and transforms it into a single Gemini-compatible
 // JSON response. It handles message content, tool calls, reasoning content, and usage metadata, combining all
 	}
 	// Process each streaming event and collect parts
-	var allParts []interface{}
+	var allParts []string
-	var finalUsage map[string]interface{}
+	var finalUsageJSON string
 	var responseID string
 	var createdAt int64
 					if text := delta.Get("text"); text.Exists() && text.String() != "" {
 						partJSON := `{"text":""}`
 						partJSON, _ = sjson.Set(partJSON, "text", text.String())
-						part := gjson.Parse(partJSON).Value().(map[string]interface{})
+						allParts = append(allParts, partJSON)
-						allParts = append(allParts, part)
 					}
 				case "thinking_delta":
 					// Process reasoning/thinking content
 					if text := delta.Get("thinking"); text.Exists() && text.String() != "" {
 						partJSON := `{"thought":true,"text":""}`
 						partJSON, _ = sjson.Set(partJSON, "text", text.String())
-						part := gjson.Parse(partJSON).Value().(map[string]interface{})
+						allParts = append(allParts, partJSON)
-						allParts = append(allParts, part)
 					}
 				case "input_json_delta":
 					// accumulate args partial_json for this index
 				if argsTrim != "" {
 					functionCallJSON, _ = sjson.SetRaw(functionCallJSON, "functionCall.args", argsTrim)
 				}
-				// Parse back to interface{} for allParts
+				allParts = append(allParts, functionCallJSON)
-				functionCall := gjson.Parse(functionCallJSON).Value().(map[string]interface{})
-				allParts = append(allParts, functionCall)
 				// cleanup used state for this index
 				if newParam.ToolUseArgs != nil {
 					delete(newParam.ToolUseArgs, idx)
 				// Set traffic type (required by Gemini API)
 				usageJSON, _ = sjson.Set(usageJSON, "trafficType", "PROVISIONED_THROUGHPUT")
-				// Convert to map[string]interface{} using gjson
+				finalUsageJSON = usageJSON
-				finalUsage = gjson.Parse(usageJSON).Value().(map[string]interface{})
 			}
 		}
 	}
 	// Set the consolidated parts array
 	if len(consolidatedParts) > 0 {
-		template, _ = sjson.SetRaw(template, "candidates.0.content.parts", convertToJSONString(consolidatedParts))
+		partsJSON := "[]"
+		for _, partJSON := range consolidatedParts {
+			partsJSON, _ = sjson.SetRaw(partsJSON, "-1", partJSON)
+		}
+		template, _ = sjson.SetRaw(template, "candidates.0.content.parts", partsJSON)
 	}
 	// Set usage metadata
-	if finalUsage != nil {
+	if finalUsageJSON != "" {
-		template, _ = sjson.SetRaw(template, "usageMetadata", convertToJSONString(finalUsage))
+		template, _ = sjson.SetRaw(template, "usageMetadata", finalUsageJSON)
 	}
 	return template
 // This function processes the parts array to combine adjacent text elements and thinking elements
 // into single consolidated parts, which results in a more readable and efficient response structure.
 // Tool calls and other non-text parts are preserved as separate elements.
-func consolidateParts(parts []interface{}) []interface{} {
+func consolidateParts(parts []string) []string {
 	if len(parts) == 0 {
 		return parts
 	}
-	var consolidated []interface{}
+	var consolidated []string
 	var currentTextPart strings.Builder
 	var currentThoughtPart strings.Builder
 	var hasText, hasThought bool
 		if hasText && currentTextPart.Len() > 0 {
 			textPartJSON := `{"text":""}`
 			textPartJSON, _ = sjson.Set(textPartJSON, "text", currentTextPart.String())
-			textPart := gjson.Parse(textPartJSON).Value().(map[string]interface{})
+			consolidated = append(consolidated, textPartJSON)
-			consolidated = append(consolidated, textPart)
 			currentTextPart.Reset()
 			hasText = false
 		}
 		if hasThought && currentThoughtPart.Len() > 0 {
 			thoughtPartJSON := `{"thought":true,"text":""}`
 			thoughtPartJSON, _ = sjson.Set(thoughtPartJSON, "text", currentThoughtPart.String())
-			thoughtPart := gjson.Parse(thoughtPartJSON).Value().(map[string]interface{})
+			consolidated = append(consolidated, thoughtPartJSON)
-			consolidated = append(consolidated, thoughtPart)
 			currentThoughtPart.Reset()
 			hasThought = false
 		}
 	}
-	for _, part := range parts {
+	for _, partJSON := range parts {
-		partMap, ok := part.(map[string]interface{})
+		part := gjson.Parse(partJSON)
-		if !ok {
+		if !part.Exists() || !part.IsObject() {
 			// Flush any pending parts and add this non-text part
 			flushText()
 			flushThought()
-			consolidated = append(consolidated, part)
+			consolidated = append(consolidated, partJSON)
 			continue
 		}
-		if thought, isThought := partMap["thought"]; isThought && thought == true {
+		thought := part.Get("thought")
+		if thought.Exists() && thought.Type == gjson.True {
 			// This is a thinking part - flush any pending text first
 			flushText() // Flush any pending text first
-			if text, hasTextContent := partMap["text"].(string); hasTextContent {
+			if text := part.Get("text"); text.Exists() && text.Type == gjson.String {
-				currentThoughtPart.WriteString(text)
+				currentThoughtPart.WriteString(text.String())
 				hasThought = true
 			}
-		} else if text, hasTextContent := partMap["text"].(string); hasTextContent {
+		} else if text := part.Get("text"); text.Exists() && text.Type == gjson.String {
 			// This is a regular text part - flush any pending thought first
 			flushThought() // Flush any pending thought first
-			currentTextPart.WriteString(text)
+			currentTextPart.WriteString(text.String())
 			hasText = true
 		} else {
 			// This is some other type of part (like function call) - flush both text and thought
 			flushText()
 			flushThought()
-			consolidated = append(consolidated, part)
+			consolidated = append(consolidated, partJSON)
 		}
 	}
 	return consolidated
 }
-// convertToJSONString converts interface{} to JSON string using sjson/gjson.
-// This function provides a consistent way to serialize different data types to JSON strings
-// for inclusion in the Gemini API response structure.
-func convertToJSONString(v interface{}) string {
-	switch val := v.(type) {
-	case []interface{}:
-		return convertArrayToJSON(val)
-	case map[string]interface{}:
-		return convertMapToJSON(val)
-	default:
-		// For simple types, create a temporary JSON and extract the value
-		temp := `{"temp":null}`
-		temp, _ = sjson.Set(temp, "temp", val)
-		return gjson.Get(temp, "temp").Raw
-	}
-}

internal/translator/claude/openai/chat-completions/claude_openai_request.go+44−96

 	"crypto/rand"
 	"crypto/sha256"
 	"encoding/hex"
-	"encoding/json"
 	"fmt"
 	"math/big"
 	"strings"
 	out, _ = sjson.Set(out, "stream", stream)
 	// Process messages and transform them to Claude Code format
-	var anthropicMessages []interface{}
-	var toolCallIDs []string // Track tool call IDs for matching with tool results
 	if messages := root.Get("messages"); messages.Exists() && messages.IsArray() {
 		messages.ForEach(func(_, message gjson.Result) bool {
 			role := message.Get("role").String()
 					role = "user"
 				}
-				msg := map[string]interface{}{
+				msg := `{"role":"","content":[]}`
-					"role":    role,
+				msg, _ = sjson.Set(msg, "role", role)
-					"content": []interface{}{},
-				}
 				// Handle content based on its type (string or array)
 				if contentResult.Exists() && contentResult.Type == gjson.String && contentResult.String() != "" {
-					// Simple text content conversion
+					part := `{"type":"text","text":""}`
-					msg["content"] = []interface{}{
+					part, _ = sjson.Set(part, "text", contentResult.String())
-						map[string]interface{}{
+					msg, _ = sjson.SetRaw(msg, "content.-1", part)
-							"type": "text",
-							"text": contentResult.String(),
-						},
-					}
 				} else if contentResult.Exists() && contentResult.IsArray() {
-					// Array of content parts processing
-					var contentParts []interface{}
 					contentResult.ForEach(func(_, part gjson.Result) bool {
 						partType := part.Get("type").String()
 						switch partType {
 						case "text":
-							// Text part conversion
+							textPart := `{"type":"text","text":""}`
-							contentParts = append(contentParts, map[string]interface{}{
+							textPart, _ = sjson.Set(textPart, "text", part.Get("text").String())
-								"type": "text",
+							msg, _ = sjson.SetRaw(msg, "content.-1", textPart)
-								"text": part.Get("text").String(),
-							})
 						case "image_url":
 							// Convert OpenAI image format to Claude Code format
 									mediaType := strings.TrimPrefix(mediaTypePart, "data:")
 									data := parts[1]
-									contentParts = append(contentParts, map[string]interface{}{
+									imagePart := `{"type":"image","source":{"type":"base64","media_type":"","data":""}}`
-										"type": "image",
+									imagePart, _ = sjson.Set(imagePart, "source.media_type", mediaType)
-										"source": map[string]interface{}{
+									imagePart, _ = sjson.Set(imagePart, "source.data", data)
-											"type":       "base64",
+									msg, _ = sjson.SetRaw(msg, "content.-1", imagePart)
-											"media_type": mediaType,
-											"data":       data,
-										},
-									})
 								}
 							}
 						}
 						return true
 					})
-					if len(contentParts) > 0 {
-						msg["content"] = contentParts
-					}
-				} else {
-					// Initialize empty content array for tool calls
-					msg["content"] = []interface{}{}
 				}
 				// Handle tool calls (for assistant messages)
 				if toolCalls := message.Get("tool_calls"); toolCalls.Exists() && toolCalls.IsArray() && role == "assistant" {
-					var contentParts []interface{}
-					// Add existing text content if any
-					if existingContent, ok := msg["content"].([]interface{}); ok {
-						contentParts = existingContent
-					}
 					toolCalls.ForEach(func(_, toolCall gjson.Result) bool {
 						if toolCall.Get("type").String() == "function" {
 							toolCallID := toolCall.Get("id").String()
 							if toolCallID == "" {
 								toolCallID = genToolCallID()
 							}
-							toolCallIDs = append(toolCallIDs, toolCallID)
 							function := toolCall.Get("function")
-							toolUse := map[string]interface{}{
+							toolUse := `{"type":"tool_use","id":"","name":"","input":{}}`
-								"type": "tool_use",
+							toolUse, _ = sjson.Set(toolUse, "id", toolCallID)
-								"id":   toolCallID,
+							toolUse, _ = sjson.Set(toolUse, "name", function.Get("name").String())
-								"name": function.Get("name").String(),
-							}
 							// Parse arguments for the tool call
 							if args := function.Get("arguments"); args.Exists() {
 								argsStr := args.String()
-								if argsStr != "" {
+								if argsStr != "" && gjson.Valid(argsStr) {
-									var argsMap map[string]interface{}
+									argsJSON := gjson.Parse(argsStr)
-									if err := json.Unmarshal([]byte(argsStr), &argsMap); err == nil {
+									if argsJSON.IsObject() {
-										toolUse["input"] = argsMap
+										toolUse, _ = sjson.SetRaw(toolUse, "input", argsJSON.Raw)
 									} else {
-										toolUse["input"] = map[string]interface{}{}
+										toolUse, _ = sjson.SetRaw(toolUse, "input", "{}")
 									}
 								} else {
-									toolUse["input"] = map[string]interface{}{}
+									toolUse, _ = sjson.SetRaw(toolUse, "input", "{}")
 								}
 							} else {
-								toolUse["input"] = map[string]interface{}{}
+								toolUse, _ = sjson.SetRaw(toolUse, "input", "{}")
 							}
-							contentParts = append(contentParts, toolUse)
+							msg, _ = sjson.SetRaw(msg, "content.-1", toolUse)
 						}
 						return true
 					})
-					msg["content"] = contentParts
 				}
-				anthropicMessages = append(anthropicMessages, msg)
+				out, _ = sjson.SetRaw(out, "messages.-1", msg)
 			case "tool":
 				// Handle tool result messages conversion
 				toolCallID := message.Get("tool_call_id").String()
 				content := message.Get("content").String()
-				// Create tool result message in Claude Code format
+				msg := `{"role":"user","content":[{"type":"tool_result","tool_use_id":"","content":""}]}`
-				msg := map[string]interface{}{
+				msg, _ = sjson.Set(msg, "content.0.tool_use_id", toolCallID)
-					"role": "user",
+				msg, _ = sjson.Set(msg, "content.0.content", content)
-					"content": []interface{}{
+				out, _ = sjson.SetRaw(out, "messages.-1", msg)
-						map[string]interface{}{
-							"type":        "tool_result",
-							"tool_use_id": toolCallID,
-							"content":     content,
-						},
-					},
-				}
-				anthropicMessages = append(anthropicMessages, msg)
 			}
 			return true
 		})
 	}
-	// Set messages in the output template
-	if len(anthropicMessages) > 0 {
-		messagesJSON, _ := json.Marshal(anthropicMessages)
-		out, _ = sjson.SetRaw(out, "messages", string(messagesJSON))
-	}
 	// Tools mapping: OpenAI tools -> Claude Code tools
 	if tools := root.Get("tools"); tools.Exists() && tools.IsArray() && len(tools.Array()) > 0 {
-		var anthropicTools []interface{}
+		hasAnthropicTools := false
 		tools.ForEach(func(_, tool gjson.Result) bool {
 			if tool.Get("type").String() == "function" {
 				function := tool.Get("function")
-				anthropicTool := map[string]interface{}{
+				anthropicTool := `{"name":"","description":""}`
-					"name":        function.Get("name").String(),
+				anthropicTool, _ = sjson.Set(anthropicTool, "name", function.Get("name").String())
-					"description": function.Get("description").String(),
+				anthropicTool, _ = sjson.Set(anthropicTool, "description", function.Get("description").String())
-				}
 				// Convert parameters schema for the tool
 				if parameters := function.Get("parameters"); parameters.Exists() {
-					anthropicTool["input_schema"] = parameters.Value()
+					anthropicTool, _ = sjson.SetRaw(anthropicTool, "input_schema", parameters.Raw)
-				} else if parameters = function.Get("parametersJsonSchema"); parameters.Exists() {
+				} else if parameters := function.Get("parametersJsonSchema"); parameters.Exists() {
-					anthropicTool["input_schema"] = parameters.Value()
+					anthropicTool, _ = sjson.SetRaw(anthropicTool, "input_schema", parameters.Raw)
 				}
-				anthropicTools = append(anthropicTools, anthropicTool)
+				out, _ = sjson.SetRaw(out, "tools.-1", anthropicTool)
+				hasAnthropicTools = true
 			}
 			return true
 		})
-		if len(anthropicTools) > 0 {
+		if !hasAnthropicTools {
-			toolsJSON, _ := json.Marshal(anthropicTools)
+			out, _ = sjson.Delete(out, "tools")
-			out, _ = sjson.SetRaw(out, "tools", string(toolsJSON))
 		}
 	}
 			case "none":
 				// Don't set tool_choice, Claude Code will not use tools
 			case "auto":
-				out, _ = sjson.Set(out, "tool_choice", map[string]interface{}{"type": "auto"})
+				out, _ = sjson.SetRaw(out, "tool_choice", `{"type":"auto"}`)
 			case "required":
-				out, _ = sjson.Set(out, "tool_choice", map[string]interface{}{"type": "any"})
+				out, _ = sjson.SetRaw(out, "tool_choice", `{"type":"any"}`)
 			}
 		case gjson.JSON:
 			// Specific tool choice mapping
 			if toolChoice.Get("type").String() == "function" {
 				functionName := toolChoice.Get("function.name").String()
-				out, _ = sjson.Set(out, "tool_choice", map[string]interface{}{
+				toolChoiceJSON := `{"type":"tool","name":""}`
-					"type": "tool",
+				toolChoiceJSON, _ = sjson.Set(toolChoiceJSON, "name", functionName)
-					"name": functionName,
+				out, _ = sjson.SetRaw(out, "tool_choice", toolChoiceJSON)
-				})
 			}
 		default:
 		}

internal/translator/claude/openai/chat-completions/claude_openai_response.go+46−62

@@ -8,7 +8,7 @@ package chat_completions · 7 unmodified lines
8	import (	8	import (
9	"bytes"	9	"bytes"
10	"context"	10	"context"
11	"encoding/json"	11	"fmt"
12	"strings"	12	"strings"
13	"time"	13	"time"
14		14
@@ -178,18 +178,11 @@ func ConvertClaudeResponseToOpenAI(_ context.Context, modelName string, original · 163 unmodified lines
178	if arguments == "" {	178	if arguments == "" {
179	arguments = "{}"	179	arguments = "{}"
180	}	180	}
181		181	template, _ = sjson.Set(template, "choices.0.delta.tool_calls.0.index", index)
182	toolCall := map[string]interface{}{	182	template, _ = sjson.Set(template, "choices.0.delta.tool_calls.0.id", accumulator.ID)
183	"index": index,	183	template, _ = sjson.Set(template, "choices.0.delta.tool_calls.0.type", "function")
184	"id": accumulator.ID,	184	template, _ = sjson.Set(template, "choices.0.delta.tool_calls.0.function.name", accumulator.Name)
185	"type": "function",	185	template, _ = sjson.Set(template, "choices.0.delta.tool_calls.0.function.arguments", arguments)
186	"function": map[string]interface{}{
187	"name": accumulator.Name,
188	"arguments": arguments,
189	},
190	}
191
192	template, _ = sjson.Set(template, "choices.0.delta.tool_calls", []interface{}{toolCall})
193		186
194	// Clean up the accumulator for this index	187	// Clean up the accumulator for this index
195	delete((param).(ConvertAnthropicResponseToOpenAIParams).ToolCallsAccumulator, index)	188	delete((param).(ConvertAnthropicResponseToOpenAIParams).ToolCallsAccumulator, index)
@@ -210,12 +203,11 @@ func ConvertClaudeResponseToOpenAI(_ context.Context, modelName string, original · 14 unmodified lines
210		203
211	// Handle usage information for token counts	204	// Handle usage information for token counts
212	if usage := root.Get("usage"); usage.Exists() {	205	if usage := root.Get("usage"); usage.Exists() {
213	usageObj := map[string]interface{}{	206	inputTokens := usage.Get("input_tokens").Int()
214	"prompt_tokens": usage.Get("input_tokens").Int(),	207	outputTokens := usage.Get("output_tokens").Int()
215	"completion_tokens": usage.Get("output_tokens").Int(),	208	template, _ = sjson.Set(template, "usage.prompt_tokens", inputTokens)
216	"total_tokens": usage.Get("input_tokens").Int() + usage.Get("output_tokens").Int(),	209	template, _ = sjson.Set(template, "usage.completion_tokens", outputTokens)
217	}	210	template, _ = sjson.Set(template, "usage.total_tokens", inputTokens+outputTokens)
218	template, _ = sjson.Set(template, "usage", usageObj)
219	}	211	}
220	return []string{template}	212	return []string{template}
221		213
@@ -230,14 +222,10 @@ func ConvertClaudeResponseToOpenAI(_ context.Context, modelName string, original · 8 unmodified lines
230	case "error":	222	case "error":
231	// Error event - format and return error response	223	// Error event - format and return error response
232	if errorData := root.Get("error"); errorData.Exists() {	224	if errorData := root.Get("error"); errorData.Exists() {
233	errorResponse := map[string]interface{}{	225	errorJSON := `{"error":{"message":"","type":""}}`
234	"error": map[string]interface{}{	226	errorJSON, _ = sjson.Set(errorJSON, "error.message", errorData.Get("message").String())
235	"message": errorData.Get("message").String(),	227	errorJSON, _ = sjson.Set(errorJSON, "error.type", errorData.Get("type").String())
236	"type": errorData.Get("type").String(),	228	return []string{errorJSON}
237	},
238	}
239	errorJSON, _ := json.Marshal(errorResponse)
240	return []string{string(errorJSON)}
241	}	229	}
242	return []string{}	230	return []string{}
243		231
@@ -298,10 +286,7 @@ func ConvertClaudeResponseToOpenAINonStream(_ context.Context, _ string, origina · 54 unmodified lines
298	var stopReason string	286	var stopReason string
299	var contentParts []string	287	var contentParts []string
300	var reasoningParts []string	288	var reasoningParts []string
301	// Use map to track tool calls by index for proper merging	289	toolCallsAccumulator := make(map[int]*ToolCallAccumulator)
302	toolCallsMap := make(map[int]map[string]interface{})
303	// Track tool call arguments accumulation
304	toolCallArgsMap := make(map[int]strings.Builder)
305		290
306	for _, chunk := range chunks {	291	for _, chunk := range chunks {
307	root := gjson.ParseBytes(chunk)	292	root := gjson.ParseBytes(chunk)
@@ -327,18 +312,12 @@ func ConvertClaudeResponseToOpenAINonStream(_ context.Context, _ string, origina · 19 unmodified lines
327	// Start of thinking/reasoning content - skip for now as it's handled in delta	312	// Start of thinking/reasoning content - skip for now as it's handled in delta
328	continue	313	continue
329	} else if blockType == "tool_use" {	314	} else if blockType == "tool_use" {
330	// Initialize tool call tracking for this index	315	// Initialize tool call accumulator for this index
331	index := int(root.Get("index").Int())	316	index := int(root.Get("index").Int())
332	toolCallsMap[index] = map[string]interface{}{	317	toolCallsAccumulator[index] = &ToolCallAccumulator{
333	"id": contentBlock.Get("id").String(),	318	ID: contentBlock.Get("id").String(),
334	"type": "function",	319	Name: contentBlock.Get("name").String(),
335	"function": map[string]interface{}{
336	"name": contentBlock.Get("name").String(),
337	"arguments": "",
338	},
339	}	320	}
340	// Initialize arguments builder for this tool call
341	toolCallArgsMap[index] = strings.Builder{}
342	}	321	}
343	}	322	}
344		323
@@ -361,9 +340,8 @@ func ConvertClaudeResponseToOpenAINonStream(_ context.Context, _ string, origina · 16 unmodified lines
361	// Accumulate tool call arguments	340	// Accumulate tool call arguments
362	if partialJSON := delta.Get("partial_json"); partialJSON.Exists() {	341	if partialJSON := delta.Get("partial_json"); partialJSON.Exists() {
363	index := int(root.Get("index").Int())	342	index := int(root.Get("index").Int())
364	if builder, exists := toolCallArgsMap[index]; exists {	343	if accumulator, exists := toolCallsAccumulator[index]; exists {
365	builder.WriteString(partialJSON.String())	344	accumulator.Arguments.WriteString(partialJSON.String())
366	toolCallArgsMap[index] = builder
367	}	345	}
368	}	346	}
369	}	347	}
@@ -372,14 +350,9 @@ func ConvertClaudeResponseToOpenAINonStream(_ context.Context, _ string, origina · 2 unmodified lines
372	case "content_block_stop":	350	case "content_block_stop":
373	// Finalize tool call arguments for this index when content block ends	351	// Finalize tool call arguments for this index when content block ends
374	index := int(root.Get("index").Int())	352	index := int(root.Get("index").Int())
375	if toolCall, exists := toolCallsMap[index]; exists {	353	if accumulator, exists := toolCallsAccumulator[index]; exists {
376	if builder, argsExists := toolCallArgsMap[index]; argsExists {	354	if accumulator.Arguments.Len() == 0 {
377	// Set the accumulated arguments for the tool call	355	accumulator.Arguments.WriteString("{}")
378	arguments := builder.String()
379	if arguments == "" {
380	arguments = "{}"
381	}
382	toolCall["function"].(map[string]interface{})["arguments"] = arguments
383	}	356	}
384	}	357	}
385		358
@@ -417,24 +390,35 @@ func ConvertClaudeResponseToOpenAINonStream(_ context.Context, _ string, origina · 31 unmodified lines
417	}	390	}
418		391
419	// Set tool calls if any were accumulated during processing	392	// Set tool calls if any were accumulated during processing
420	if len(toolCallsMap) > 0 {	393	if len(toolCallsAccumulator) > 0 {
421	// Convert tool calls map to array, preserving order by index	394	toolCallsCount := 0
422	var toolCallsArray []interface{}
423	// Find the maximum index to determine the range
424	maxIndex := -1	395	maxIndex := -1
425	for index := range toolCallsMap {	396	for index := range toolCallsAccumulator {
426	if index > maxIndex {	397	if index > maxIndex {
427	maxIndex = index	398	maxIndex = index
428	}	399	}
429	}	400	}
430	// Iterate through all possible indices up to maxIndex	401
431	for i := 0; i <= maxIndex; i++ {	402	for i := 0; i <= maxIndex; i++ {
432	if toolCall, exists := toolCallsMap[i]; exists {	403	accumulator, exists := toolCallsAccumulator[i]
433	toolCallsArray = append(toolCallsArray, toolCall)	404	if !exists {
		405	continue
434	}	406	}
		407
		408	arguments := accumulator.Arguments.String()
		409
		410	idPath := fmt.Sprintf("choices.0.message.tool_calls.%d.id", toolCallsCount)
		411	typePath := fmt.Sprintf("choices.0.message.tool_calls.%d.type", toolCallsCount)
		412	namePath := fmt.Sprintf("choices.0.message.tool_calls.%d.function.name", toolCallsCount)
		413	argumentsPath := fmt.Sprintf("choices.0.message.tool_calls.%d.function.arguments", toolCallsCount)
		414
		415	out, _ = sjson.Set(out, idPath, accumulator.ID)
		416	out, _ = sjson.Set(out, typePath, "function")
		417	out, _ = sjson.Set(out, namePath, accumulator.Name)
		418	out, _ = sjson.Set(out, argumentsPath, arguments)
		419	toolCallsCount++
435	}	420	}
436	if len(toolCallsArray) > 0 {	421	if toolCallsCount > 0 {
437	out, _ = sjson.Set(out, "choices.0.message.tool_calls", toolCallsArray)
438	out, _ = sjson.Set(out, "choices.0.finish_reason", "tool_calls")	422	out, _ = sjson.Set(out, "choices.0.finish_reason", "tool_calls")
439	} else {	423	} else {
440	out, _ = sjson.Set(out, "choices.0.finish_reason", mapAnthropicStopReasonToOpenAI(stopReason))	424	out, _ = sjson.Set(out, "choices.0.finish_reason", mapAnthropicStopReasonToOpenAI(stopReason))

internal/translator/claude/openai/responses/claude_openai-responses_request.go+9−4

 				toolUse, _ = sjson.Set(toolUse, "id", callID)
 				toolUse, _ = sjson.Set(toolUse, "name", name)
 				if argsStr != "" && gjson.Valid(argsStr) {
-					toolUse, _ = sjson.SetRaw(toolUse, "input", argsStr)
+					argsJSON := gjson.Parse(argsStr)
+					if argsJSON.IsObject() {
+						toolUse, _ = sjson.SetRaw(toolUse, "input", argsJSON.Raw)
+					}
 				}
 				asst := `{"role":"assistant","content":[]}`
 		case gjson.String:
 			switch toolChoice.String() {
 			case "auto":
-				out, _ = sjson.Set(out, "tool_choice", map[string]interface{}{"type": "auto"})
+				out, _ = sjson.SetRaw(out, "tool_choice", `{"type":"auto"}`)
 			case "none":
 				// Leave unset; implies no tools
 			case "required":
-				out, _ = sjson.Set(out, "tool_choice", map[string]interface{}{"type": "any"})
+				out, _ = sjson.SetRaw(out, "tool_choice", `{"type":"any"}`)
 			}
 		case gjson.JSON:
 			if toolChoice.Get("type").String() == "function" {
 				fn := toolChoice.Get("function.name").String()
-				out, _ = sjson.Set(out, "tool_choice", map[string]interface{}{"type": "tool", "name": fn})
+				toolChoiceJSON := `{"name":"","type":"tool"}`
+				toolChoiceJSON, _ = sjson.Set(toolChoiceJSON, "name", fn)
+				out, _ = sjson.SetRaw(out, "tool_choice", toolChoiceJSON)
 			}
 		default:

internal/translator/claude/openai/responses/claude_openai-responses_response.go+34−59

 		}
 		// Build response.output from aggregated state
-		var outputs []interface{}
+		outputsWrapper := `{"arr":[]}`
 		// reasoning item (if any)
 		if st.ReasoningBuf.Len() > 0 || st.ReasoningPartAdded {
-			r := map[string]interface{}{
+			item := `{"id":"","type":"reasoning","summary":[{"type":"summary_text","text":""}]}`
-				"id":      st.ReasoningItemID,
+			item, _ = sjson.Set(item, "id", st.ReasoningItemID)
-				"type":    "reasoning",
+			item, _ = sjson.Set(item, "summary.0.text", st.ReasoningBuf.String())
-				"summary": []interface{}{map[string]interface{}{"type": "summary_text", "text": st.ReasoningBuf.String()}},
+			outputsWrapper, _ = sjson.SetRaw(outputsWrapper, "arr.-1", item)
-			}
-			outputs = append(outputs, r)
 		}
 		// assistant message item (if any text)
 		if st.TextBuf.Len() > 0 || st.InTextBlock || st.CurrentMsgID != "" {
-			m := map[string]interface{}{
+			item := `{"id":"","type":"message","status":"completed","content":[{"type":"output_text","annotations":[],"logprobs":[],"text":""}],"role":"assistant"}`
-				"id":     st.CurrentMsgID,
+			item, _ = sjson.Set(item, "id", st.CurrentMsgID)
-				"type":   "message",
+			item, _ = sjson.Set(item, "content.0.text", st.TextBuf.String())
-				"status": "completed",
+			outputsWrapper, _ = sjson.SetRaw(outputsWrapper, "arr.-1", item)
-				"content": []interface{}{map[string]interface{}{
-					"type":        "output_text",
-					"annotations": []interface{}{},
-					"logprobs":    []interface{}{},
-					"text":        st.TextBuf.String(),
-				}},
-				"role": "assistant",
-			}
-			outputs = append(outputs, m)
 		}
 		// function_call items (in ascending index order for determinism)
 		if len(st.FuncArgsBuf) > 0 {
 				if callID == "" && st.CurrentFCID != "" {
 					callID = st.CurrentFCID
 				}
-				item := map[string]interface{}{
+				item := `{"id":"","type":"function_call","status":"completed","arguments":"","call_id":"","name":""}`
-					"id":        fmt.Sprintf("fc_%s", callID),
+				item, _ = sjson.Set(item, "id", fmt.Sprintf("fc_%s", callID))
-					"type":      "function_call",
+				item, _ = sjson.Set(item, "arguments", args)
-					"status":    "completed",
+				item, _ = sjson.Set(item, "call_id", callID)
-					"arguments": args,
+				item, _ = sjson.Set(item, "name", name)
-					"call_id":   callID,
+				outputsWrapper, _ = sjson.SetRaw(outputsWrapper, "arr.-1", item)
-					"name":      name,
-				}
-				outputs = append(outputs, item)
 			}
 		}
-		if len(outputs) > 0 {
+		if gjson.Get(outputsWrapper, "arr.#").Int() > 0 {
-			completed, _ = sjson.Set(completed, "response.output", outputs)
+			completed, _ = sjson.SetRaw(completed, "response.output", gjson.Get(outputsWrapper, "arr").Raw)
 		}
 		reasoningTokens := int64(0)
 	}
 	// Build output array
-	var outputs []interface{}
+	outputsWrapper := `{"arr":[]}`
 	if reasoningBuf.Len() > 0 {
-		outputs = append(outputs, map[string]interface{}{
+		item := `{"id":"","type":"reasoning","summary":[{"type":"summary_text","text":""}]}`
-			"id":      reasoningItemID,
+		item, _ = sjson.Set(item, "id", reasoningItemID)
-			"type":    "reasoning",
+		item, _ = sjson.Set(item, "summary.0.text", reasoningBuf.String())
-			"summary": []interface{}{map[string]interface{}{"type": "summary_text", "text": reasoningBuf.String()}},
+		outputsWrapper, _ = sjson.SetRaw(outputsWrapper, "arr.-1", item)
-		})
 	}
 	if currentMsgID != "" || textBuf.Len() > 0 {
-		outputs = append(outputs, map[string]interface{}{
+		item := `{"id":"","type":"message","status":"completed","content":[{"type":"output_text","annotations":[],"logprobs":[],"text":""}],"role":"assistant"}`
-			"id":     currentMsgID,
+		item, _ = sjson.Set(item, "id", currentMsgID)
-			"type":   "message",
+		item, _ = sjson.Set(item, "content.0.text", textBuf.String())
-			"status": "completed",
+		outputsWrapper, _ = sjson.SetRaw(outputsWrapper, "arr.-1", item)
-			"content": []interface{}{map[string]interface{}{
-				"type":        "output_text",
-				"annotations": []interface{}{},
-				"logprobs":    []interface{}{},
-				"text":        textBuf.String(),
-			}},
-			"role": "assistant",
-		})
 	}
 	if len(toolCalls) > 0 {
 		// Preserve index order
 			if args == "" {
 				args = "{}"
 			}
-			outputs = append(outputs, map[string]interface{}{
+			item := `{"id":"","type":"function_call","status":"completed","arguments":"","call_id":"","name":""}`
-				"id":        fmt.Sprintf("fc_%s", st.id),
+			item, _ = sjson.Set(item, "id", fmt.Sprintf("fc_%s", st.id))
-				"type":      "function_call",
+			item, _ = sjson.Set(item, "arguments", args)
-				"status":    "completed",
+			item, _ = sjson.Set(item, "call_id", st.id)
-				"arguments": args,
+			item, _ = sjson.Set(item, "name", st.name)
-				"call_id":   st.id,
+			outputsWrapper, _ = sjson.SetRaw(outputsWrapper, "arr.-1", item)
-				"name":      st.name,
-			})
 		}
 	}
-	if len(outputs) > 0 {
+	if gjson.Get(outputsWrapper, "arr.#").Int() > 0 {
-		out, _ = sjson.Set(out, "output", outputs)
+		out, _ = sjson.SetRaw(out, "output", gjson.Get(outputsWrapper, "arr").Raw)
 	}
 	// Usage

internal/translator/codex/claude/codex_claude_response.go+31−57

@@ -9,7 +9,6 @@ package claude · 8 unmodified lines
9	import (	9	import (
10	"bytes"	10	"bytes"
11	"context"	11	"context"
12	"encoding/json"
13	"fmt"	12	"fmt"
14	"strings"	13	"strings"
15		14
@@ -191,21 +190,12 @@ func ConvertCodexResponseToClaudeNonStream(_ context.Context, _ string, original · 175 unmodified lines
191	return ""	190	return ""
192	}	191	}
193		192
194	response := map[string]interface{}{	193	out := `{"id":"","type":"message","role":"assistant","model":"","content":[],"stop_reason":null,"stop_sequence":null,"usage":{"input_tokens":0,"output_tokens":0}}`
195	"id": responseData.Get("id").String(),	194	out, _ = sjson.Set(out, "id", responseData.Get("id").String())
196	"type": "message",	195	out, _ = sjson.Set(out, "model", responseData.Get("model").String())
197	"role": "assistant",	196	out, _ = sjson.Set(out, "usage.input_tokens", responseData.Get("usage.input_tokens").Int())
198	"model": responseData.Get("model").String(),	197	out, _ = sjson.Set(out, "usage.output_tokens", responseData.Get("usage.output_tokens").Int())
199	"content": []interface{}{},
200	"stop_reason": nil,
201	"stop_sequence": nil,
202	"usage": map[string]interface{}{
203	"input_tokens": responseData.Get("usage.input_tokens").Int(),
204	"output_tokens": responseData.Get("usage.output_tokens").Int(),
205	},
206	}
207		198
208	var contentBlocks []interface{}
209	hasToolCall := false	199	hasToolCall := false
210		200
211	if output := responseData.Get("output"); output.Exists() && output.IsArray() {	201	if output := responseData.Get("output"); output.Exists() && output.IsArray() {
@@ -244,10 +234,9 @@ func ConvertCodexResponseToClaudeNonStream(_ context.Context, _ string, original · 32 unmodified lines
244	}	234	}
245	}	235	}
246	if thinkingBuilder.Len() > 0 {	236	if thinkingBuilder.Len() > 0 {
247	contentBlocks = append(contentBlocks, map[string]interface{}{	237	block := `{"type":"thinking","thinking":""}`
248	"type": "thinking",	238	block, _ = sjson.Set(block, "thinking", thinkingBuilder.String())
249	"thinking": thinkingBuilder.String(),	239	out, _ = sjson.SetRaw(out, "content.-1", block)
250	})
251	}	240	}
252	case "message":	241	case "message":
253	if content := item.Get("content"); content.Exists() {	242	if content := item.Get("content"); content.Exists() {
@@ -256,10 +245,9 @@ func ConvertCodexResponseToClaudeNonStream(_ context.Context, _ string, original · 2 unmodified lines
256	if part.Get("type").String() == "output_text" {	245	if part.Get("type").String() == "output_text" {
257	text := part.Get("text").String()	246	text := part.Get("text").String()
258	if text != "" {	247	if text != "" {
259	contentBlocks = append(contentBlocks, map[string]interface{}{	248	block := `{"type":"text","text":""}`
260	"type": "text",	249	block, _ = sjson.Set(block, "text", text)
261	"text": text,	250	out, _ = sjson.SetRaw(out, "content.-1", block)
262	})
263	}	251	}
264	}	252	}
265	return true	253	return true
@@ -267,10 +255,9 @@ func ConvertCodexResponseToClaudeNonStream(_ context.Context, _ string, original · 1 unmodified line
267	} else {	255	} else {
268	text := content.String()	256	text := content.String()
269	if text != "" {	257	if text != "" {
270	contentBlocks = append(contentBlocks, map[string]interface{}{	258	block := `{"type":"text","text":""}`
271	"type": "text",	259	block, _ = sjson.Set(block, "text", text)
272	"text": text,	260	out, _ = sjson.SetRaw(out, "content.-1", block)
273	})
274	}	261	}
275	}	262	}
276	}	263	}
@@ -281,54 +268,41 @@ func ConvertCodexResponseToClaudeNonStream(_ context.Context, _ string, original · 4 unmodified lines
281	name = original	268	name = original
282	}	269	}
283		270
284	toolBlock := map[string]interface{}{	271	toolBlock := `{"type":"tool_use","id":"","name":"","input":{}}`
285	"type": "tool_use",	272	toolBlock, _ = sjson.Set(toolBlock, "id", item.Get("call_id").String())
286	"id": item.Get("call_id").String(),	273	toolBlock, _ = sjson.Set(toolBlock, "name", name)
287	"name": name,	274	inputRaw := "{}"
288	"input": map[string]interface{}{},	275	if argsStr := item.Get("arguments").String(); argsStr != "" && gjson.Valid(argsStr) {
289	}	276	argsJSON := gjson.Parse(argsStr)
290		277	if argsJSON.IsObject() {
291	if argsStr := item.Get("arguments").String(); argsStr != "" {	278	inputRaw = argsJSON.Raw
292	var args interface{}
293	if err := json.Unmarshal([]byte(argsStr), &args); err == nil {
294	toolBlock["input"] = args
295	}	279	}
296	}	280	}
297		281	toolBlock, _ = sjson.SetRaw(toolBlock, "input", inputRaw)
298	contentBlocks = append(contentBlocks, toolBlock)	282	out, _ = sjson.SetRaw(out, "content.-1", toolBlock)
299	}	283	}
300	return true	284	return true
301	})	285	})
302	}	286	}
303		287
304	if len(contentBlocks) > 0 {
305	response["content"] = contentBlocks
306	}
307
308	if stopReason := responseData.Get("stop_reason"); stopReason.Exists() && stopReason.String() != "" {	288	if stopReason := responseData.Get("stop_reason"); stopReason.Exists() && stopReason.String() != "" {
309	response["stop_reason"] = stopReason.String()	289	out, _ = sjson.Set(out, "stop_reason", stopReason.String())
310	} else if hasToolCall {	290	} else if hasToolCall {
311	response["stop_reason"] = "tool_use"	291	out, _ = sjson.Set(out, "stop_reason", "tool_use")
312	} else {	292	} else {
313	response["stop_reason"] = "end_turn"	293	out, _ = sjson.Set(out, "stop_reason", "end_turn")
314	}	294	}
315		295
316	if stopSequence := responseData.Get("stop_sequence"); stopSequence.Exists() && stopSequence.String() != "" {	296	if stopSequence := responseData.Get("stop_sequence"); stopSequence.Exists() && stopSequence.String() != "" {
317	response["stop_sequence"] = stopSequence.Value()	297	out, _ = sjson.SetRaw(out, "stop_sequence", stopSequence.Raw)
318	}	298	}
319		299
320	if responseData.Get("usage.input_tokens").Exists() \|\| responseData.Get("usage.output_tokens").Exists() {	300	if responseData.Get("usage.input_tokens").Exists() \|\| responseData.Get("usage.output_tokens").Exists() {
321	response["usage"] = map[string]interface{}{	301	out, _ = sjson.Set(out, "usage.input_tokens", responseData.Get("usage.input_tokens").Int())
322	"input_tokens": responseData.Get("usage.input_tokens").Int(),	302	out, _ = sjson.Set(out, "usage.output_tokens", responseData.Get("usage.output_tokens").Int())
323	"output_tokens": responseData.Get("usage.output_tokens").Int(),
324	}
325	}	303	}
326		304
327	responseJSON, err := json.Marshal(response)	305	return out
328	if err != nil {
329	return ""
330	}
331	return string(responseJSON)
332	}	306	}
333		307
334	// buildReverseMapFromClaudeOriginalShortToOriginal builds a map[short]original from original Claude request tools.	308	// buildReverseMapFromClaudeOriginalShortToOriginal builds a map[short]original from original Claude request tools.

internal/translator/codex/gemini/codex_gemini_response.go+24−49

 import (
 	"bytes"
 	"context"
-	"encoding/json"
 	"fmt"
 	"time"
 		}
 		// Process output content to build parts array
-		var parts []interface{}
 		hasToolCall := false
-		var pendingFunctionCalls []interface{}
+		var pendingFunctionCalls []string
 		flushPendingFunctionCalls := func() {
-			if len(pendingFunctionCalls) > 0 {
+			if len(pendingFunctionCalls) == 0 {
-				// Add all pending function calls as individual parts
+				return
-				// This maintains the original Gemini API format while ensuring consecutive calls are grouped together
+			}
-				for _, fc := range pendingFunctionCalls {
+			// Add all pending function calls as individual parts
-					parts = append(parts, fc)
+			// This maintains the original Gemini API format while ensuring consecutive calls are grouped together
-				}
+			for _, fc := range pendingFunctionCalls {
-				pendingFunctionCalls = nil
+				template, _ = sjson.SetRaw(template, "candidates.0.content.parts.-1", fc)
 			}
+			pendingFunctionCalls = nil
 		}
 		if output := responseData.Get("output"); output.Exists() && output.IsArray() {
 					// Add thinking content
 					if content := value.Get("content"); content.Exists() {
-						part := map[string]interface{}{
+						part := `{"text":"","thought":true}`
-							"thought": true,
+						part, _ = sjson.Set(part, "text", content.String())
-							"text":    content.String(),
+						template, _ = sjson.SetRaw(template, "candidates.0.content.parts.-1", part)
-						}
-						parts = append(parts, part)
 					}
 				case "message":
 						content.ForEach(func(_, contentItem gjson.Result) bool {
 							if contentItem.Get("type").String() == "output_text" {
 								if text := contentItem.Get("text"); text.Exists() {
-									part := map[string]interface{}{
+									part := `{"text":""}`
-										"text": text.String(),
+									part, _ = sjson.Set(part, "text", text.String())
-									}
+									template, _ = sjson.SetRaw(template, "candidates.0.content.parts.-1", part)
-									parts = append(parts, part)
 								}
 							}
 							return true
 				case "function_call":
 					// Collect function call for potential merging with consecutive ones
 					hasToolCall = true
-					functionCall := map[string]interface{}{
+					functionCall := `{"functionCall":{"args":{},"name":""}}`
-						"functionCall": map[string]interface{}{
+					{
-							"name": func() string {
+						n := value.Get("name").String()
-								n := value.Get("name").String()
+						rev := buildReverseMapFromGeminiOriginal(originalRequestRawJSON)
-								rev := buildReverseMapFromGeminiOriginal(originalRequestRawJSON)
+						if orig, ok := rev[n]; ok {
-								if orig, ok := rev[n]; ok {
+							n = orig
-									return orig
+						}
-								}
+						functionCall, _ = sjson.Set(functionCall, "functionCall.name", n)
-								return n
-							}(),
-							"args": map[string]interface{}{},
-						},
 					}
 					// Parse and set arguments
 					if argsStr := value.Get("arguments").String(); argsStr != "" {
 						argsResult := gjson.Parse(argsStr)
 						if argsResult.IsObject() {
-							var args map[string]interface{}
+							functionCall, _ = sjson.SetRaw(functionCall, "functionCall.args", argsStr)
-							if err := json.Unmarshal([]byte(argsStr), &args); err == nil {
-								functionCall["functionCall"].(map[string]interface{})["args"] = args
-							}
 						}
 					}
 			flushPendingFunctionCalls()
 		}
-		// Set the parts array
-		if len(parts) > 0 {
-			template, _ = sjson.SetRaw(template, "candidates.0.content.parts", mustMarshalJSON(parts))
-		}
 		// Set finish reason based on whether there were tool calls
 		if hasToolCall {
 			template, _ = sjson.Set(template, "candidates.0.finishReason", "STOP")
 	return rev
 }
-// mustMarshalJSON marshals a value to JSON, panicking on error.
-func mustMarshalJSON(v interface{}) string {
-	data, err := json.Marshal(v)
-	if err != nil {
-		return ""
-	}
-	return string(data)
-}
 func GeminiTokenCount(ctx context.Context, count int64) string {
 	return fmt.Sprintf(`{"totalTokens":%d,"promptTokensDetails":[{"modality":"TEXT","tokenCount":%d}]}`, count, count)
 }

internal/translator/gemini-cli/claude/gemini-cli_claude_request.go+78−83

@@ -7,10 +7,8 @@ package claude · 6 unmodified lines
7		7
8	import (	8	import (
9	"bytes"	9	"bytes"
10	"encoding/json"
11	"strings"	10	"strings"
12		11
13	client "github.com/router-for-me/CLIProxyAPI/v6/internal/interfaces"
14	"github.com/router-for-me/CLIProxyAPI/v6/internal/translator/gemini/common"	12	"github.com/router-for-me/CLIProxyAPI/v6/internal/translator/gemini/common"
15	"github.com/router-for-me/CLIProxyAPI/v6/internal/util"	13	"github.com/router-for-me/CLIProxyAPI/v6/internal/util"
16	"github.com/tidwall/gjson"	14	"github.com/tidwall/gjson"
@@ -41,92 +39,100 @@ func ConvertClaudeRequestToCLI(modelName string, inputRawJSON []byte, _ bool) [] · 24 unmodified lines
41	rawJSON := bytes.Clone(inputRawJSON)	39	rawJSON := bytes.Clone(inputRawJSON)
42	rawJSON = bytes.Replace(rawJSON, []byte(`"url":{"type":"string","format":"uri",`), []byte(`"url":{"type":"string",`), -1)	40	rawJSON = bytes.Replace(rawJSON, []byte(`"url":{"type":"string","format":"uri",`), []byte(`"url":{"type":"string",`), -1)
43		41
		42	// Build output Gemini CLI request JSON
		43	out := `{"model":"","request":{"contents":[]}}`
		44	out, _ = sjson.Set(out, "model", modelName)
		45
44	// system instruction	46	// system instruction
45	var systemInstruction *client.Content	47	if systemResult := gjson.GetBytes(rawJSON, "system"); systemResult.IsArray() {
46	systemResult := gjson.GetBytes(rawJSON, "system")	48	systemInstruction := `{"role":"user","parts":[]}`
47	if systemResult.IsArray() {	49	hasSystemParts := false
48	systemResults := systemResult.Array()	50	systemResult.ForEach(func(_, systemPromptResult gjson.Result) bool {
49	systemInstruction = &client.Content{Role: "user", Parts: []client.Part{}}	51	if systemPromptResult.Get("type").String() == "text" {
50	for i := 0; i < len(systemResults); i++ {	52	textResult := systemPromptResult.Get("text")
51	systemPromptResult := systemResults[i]	53	if textResult.Type == gjson.String {
52	systemTypePromptResult := systemPromptResult.Get("type")	54	part := `{"text":""}`
53	if systemTypePromptResult.Type == gjson.String && systemTypePromptResult.String() == "text" {	55	part, _ = sjson.Set(part, "text", textResult.String())
54	systemPrompt := systemPromptResult.Get("text").String()	56	systemInstruction, _ = sjson.SetRaw(systemInstruction, "parts.-1", part)
55	systemPart := client.Part{Text: systemPrompt}	57	hasSystemParts = true
56	systemInstruction.Parts = append(systemInstruction.Parts, systemPart)	58	}
57	}	59	}
58	}	60	return true
59	if len(systemInstruction.Parts) == 0 {	61	})
60	systemInstruction = nil	62	if hasSystemParts {
		63	out, _ = sjson.SetRaw(out, "request.systemInstruction", systemInstruction)
61	}	64	}
62	}	65	}
63		66
64	// contents	67	// contents
65	contents := make([]client.Content, 0)	68	if messagesResult := gjson.GetBytes(rawJSON, "messages"); messagesResult.IsArray() {
66	messagesResult := gjson.GetBytes(rawJSON, "messages")	69	messagesResult.ForEach(func(_, messageResult gjson.Result) bool {
67	if messagesResult.IsArray() {
68	messageResults := messagesResult.Array()
69	for i := 0; i < len(messageResults); i++ {
70	messageResult := messageResults[i]
71	roleResult := messageResult.Get("role")	70	roleResult := messageResult.Get("role")
72	if roleResult.Type != gjson.String {	71	if roleResult.Type != gjson.String {
73	continue	72	return true
74	}	73	}
75	role := roleResult.String()	74	role := roleResult.String()
76	if role == "assistant" {	75	if role == "assistant" {
77	role = "model"	76	role = "model"
78	}	77	}
79	clientContent := client.Content{Role: role, Parts: []client.Part{}}	78
		79	contentJSON := `{"role":"","parts":[]}`
		80	contentJSON, _ = sjson.Set(contentJSON, "role", role)
		81
80	contentsResult := messageResult.Get("content")	82	contentsResult := messageResult.Get("content")
81	if contentsResult.IsArray() {	83	if contentsResult.IsArray() {
82	contentResults := contentsResult.Array()	84	contentsResult.ForEach(func(_, contentResult gjson.Result) bool {
83	for j := 0; j < len(contentResults); j++ {	85	switch contentResult.Get("type").String() {
84	contentResult := contentResults[j]	86	case "text":
85	contentTypeResult := contentResult.Get("type")	87	part := `{"text":""}`
86	if contentTypeResult.Type == gjson.String && contentTypeResult.String() == "text" {	88	part, _ = sjson.Set(part, "text", contentResult.Get("text").String())
87	prompt := contentResult.Get("text").String()	89	contentJSON, _ = sjson.SetRaw(contentJSON, "parts.-1", part)
88	clientContent.Parts = append(clientContent.Parts, client.Part{Text: prompt})	90
89	} else if contentTypeResult.Type == gjson.String && contentTypeResult.String() == "tool_use" {	91	case "tool_use":
90	functionName := contentResult.Get("name").String()	92	functionName := contentResult.Get("name").String()
91	functionArgs := contentResult.Get("input").String()	93	functionArgs := contentResult.Get("input").String()
92	var args map[string]any	94	argsResult := gjson.Parse(functionArgs)
93	if err := json.Unmarshal([]byte(functionArgs), &args); err == nil {	95	if argsResult.IsObject() && gjson.Valid(functionArgs) {
94	clientContent.Parts = append(clientContent.Parts, client.Part{	96	part := `{"thoughtSignature":"","functionCall":{"name":"","args":{}}}`
95	FunctionCall: &client.FunctionCall{Name: functionName, Args: args},	97	part, _ = sjson.Set(part, "thoughtSignature", geminiCLIClaudeThoughtSignature)
96	ThoughtSignature: geminiCLIClaudeThoughtSignature,	98	part, _ = sjson.Set(part, "functionCall.name", functionName)
97	})	99	part, _ = sjson.SetRaw(part, "functionCall.args", functionArgs)
		100	contentJSON, _ = sjson.SetRaw(contentJSON, "parts.-1", part)
98	}	101	}
99	} else if contentTypeResult.Type == gjson.String && contentTypeResult.String() == "tool_result" {	102
		103	case "tool_result":
100	toolCallID := contentResult.Get("tool_use_id").String()	104	toolCallID := contentResult.Get("tool_use_id").String()
101	if toolCallID != "" {	105	if toolCallID == "" {
102	funcName := toolCallID	106	return true
103	toolCallIDs := strings.Split(toolCallID, "-")	107	}
104	if len(toolCallIDs) > 1 {	108	funcName := toolCallID
105	funcName = strings.Join(toolCallIDs[0:len(toolCallIDs)-1], "-")	109	toolCallIDs := strings.Split(toolCallID, "-")
106	}	110	if len(toolCallIDs) > 1 {
107	responseData := contentResult.Get("content").Raw	111	funcName = strings.Join(toolCallIDs[0:len(toolCallIDs)-1], "-")
108	functionResponse := client.FunctionResponse{Name: funcName, Response: map[string]interface{}{"result": responseData}}
109	clientContent.Parts = append(clientContent.Parts, client.Part{FunctionResponse: &functionResponse})
110	}	112	}
		113	responseData := contentResult.Get("content").Raw
		114	part := `{"functionResponse":{"name":"","response":{"result":""}}}`
		115	part, _ = sjson.Set(part, "functionResponse.name", funcName)
		116	part, _ = sjson.Set(part, "functionResponse.response.result", responseData)
		117	contentJSON, _ = sjson.SetRaw(contentJSON, "parts.-1", part)
111	}	118	}
112	}	119	return true
113	contents = append(contents, clientContent)	120	})
		121	out, _ = sjson.SetRaw(out, "request.contents.-1", contentJSON)
114	} else if contentsResult.Type == gjson.String {	122	} else if contentsResult.Type == gjson.String {
115	prompt := contentsResult.String()	123	part := `{"text":""}`
116	contents = append(contents, client.Content{Role: role, Parts: []client.Part{{Text: prompt}}})	124	part, _ = sjson.Set(part, "text", contentsResult.String())
		125	contentJSON, _ = sjson.SetRaw(contentJSON, "parts.-1", part)
		126	out, _ = sjson.SetRaw(out, "request.contents.-1", contentJSON)
117	}	127	}
118	}	128	return true
		129	})
119	}	130	}
120		131
121	// tools	132	// tools
122	var tools []client.ToolDeclaration	133	if toolsResult := gjson.GetBytes(rawJSON, "tools"); toolsResult.IsArray() {
123	toolsResult := gjson.GetBytes(rawJSON, "tools")	134	hasTools := false
124	if toolsResult.IsArray() {	135	toolsResult.ForEach(func(_, toolResult gjson.Result) bool {
125	tools = make([]client.ToolDeclaration, 1)
126	tools[0].FunctionDeclarations = make([]any, 0)
127	toolsResults := toolsResult.Array()
128	for i := 0; i < len(toolsResults); i++ {
129	toolResult := toolsResults[i]
130	inputSchemaResult := toolResult.Get("input_schema")	136	inputSchemaResult := toolResult.Get("input_schema")
131	if inputSchemaResult.Exists() && inputSchemaResult.IsObject() {	137	if inputSchemaResult.Exists() && inputSchemaResult.IsObject() {
132	inputSchema := inputSchemaResult.Raw	138	inputSchema := inputSchemaResult.Raw
@@ -136,30 +142,19 @@ func ConvertClaudeRequestToCLI(modelName string, inputRawJSON []byte, _ bool) [] · 3 unmodified lines
136	tool, _ = sjson.Delete(tool, "input_examples")	142	tool, _ = sjson.Delete(tool, "input_examples")
137	tool, _ = sjson.Delete(tool, "type")	143	tool, _ = sjson.Delete(tool, "type")
138	tool, _ = sjson.Delete(tool, "cache_control")	144	tool, _ = sjson.Delete(tool, "cache_control")
139	var toolDeclaration any	145	if gjson.Valid(tool) && gjson.Parse(tool).IsObject() {
140	if err := json.Unmarshal([]byte(tool), &toolDeclaration); err == nil {	146	if !hasTools {
141	tools[0].FunctionDeclarations = append(tools[0].FunctionDeclarations, toolDeclaration)	147	out, _ = sjson.SetRaw(out, "request.tools", `[{"functionDeclarations":[]}]`)
		148	hasTools = true
		149	}
		150	out, _ = sjson.SetRaw(out, "request.tools.0.functionDeclarations.-1", tool)
142	}	151	}
143	}	152	}
		153	return true
		154	})
		155	if !hasTools {
		156	out, _ = sjson.Delete(out, "request.tools")
144	}	157	}
145	} else {
146	tools = make([]client.ToolDeclaration, 0)
147	}
148
149	// Build output Gemini CLI request JSON
150	out := `{"model":"","request":{"contents":[]}}`
151	out, _ = sjson.Set(out, "model", modelName)
152	if systemInstruction != nil {
153	b, _ := json.Marshal(systemInstruction)
154	out, _ = sjson.SetRaw(out, "request.systemInstruction", string(b))
155	}
156	if len(contents) > 0 {
157	b, _ := json.Marshal(contents)
158	out, _ = sjson.SetRaw(out, "request.contents", string(b))
159	}
160	if len(tools) > 0 && len(tools[0].FunctionDeclarations) > 0 {
161	b, _ := json.Marshal(tools)
162	out, _ = sjson.SetRaw(out, "request.tools", string(b))
163	}	158	}
164		159
165	// Map Anthropic thinking -> Gemini thinkingBudget/include_thoughts when type==enabled	160	// Map Anthropic thinking -> Gemini thinkingBudget/include_thoughts when type==enabled

internal/translator/gemini-cli/claude/gemini-cli_claude_response.go+26−49

@@ -9,7 +9,6 @@ package claude · 8 unmodified lines
9	import (	9	import (
10	"bytes"	10	"bytes"
11	"context"	11	"context"
12	"encoding/json"
13	"fmt"	12	"fmt"
14	"strings"	13	"strings"
15	"sync/atomic"	14	"sync/atomic"
@@ -276,22 +275,16 @@ func ConvertGeminiCLIResponseToClaudeNonStream(_ context.Context, _ string, orig · 260 unmodified lines
276		275
277	root := gjson.ParseBytes(rawJSON)	276	root := gjson.ParseBytes(rawJSON)
278		277
279	response := map[string]interface{}{	278	out := `{"id":"","type":"message","role":"assistant","model":"","content":[],"stop_reason":null,"stop_sequence":null,"usage":{"input_tokens":0,"output_tokens":0}}`
280	"id": root.Get("response.responseId").String(),	279	out, _ = sjson.Set(out, "id", root.Get("response.responseId").String())
281	"type": "message",	280	out, _ = sjson.Set(out, "model", root.Get("response.modelVersion").String())
282	"role": "assistant",	281
283	"model": root.Get("response.modelVersion").String(),	282	inputTokens := root.Get("response.usageMetadata.promptTokenCount").Int()
284	"content": []interface{}{},	283	outputTokens := root.Get("response.usageMetadata.candidatesTokenCount").Int() + root.Get("response.usageMetadata.thoughtsTokenCount").Int()
285	"stop_reason": nil,	284	out, _ = sjson.Set(out, "usage.input_tokens", inputTokens)
286	"stop_sequence": nil,	285	out, _ = sjson.Set(out, "usage.output_tokens", outputTokens)
287	"usage": map[string]interface{}{
288	"input_tokens": root.Get("response.usageMetadata.promptTokenCount").Int(),
289	"output_tokens": root.Get("response.usageMetadata.candidatesTokenCount").Int() + root.Get("response.usageMetadata.thoughtsTokenCount").Int(),
290	},
291	}
292		286
293	parts := root.Get("response.candidates.0.content.parts")	287	parts := root.Get("response.candidates.0.content.parts")
294	var contentBlocks []interface{}
295	textBuilder := strings.Builder{}	288	textBuilder := strings.Builder{}
296	thinkingBuilder := strings.Builder{}	289	thinkingBuilder := strings.Builder{}
297	toolIDCounter := 0	290	toolIDCounter := 0
@@ -301,10 +294,9 @@ func ConvertGeminiCLIResponseToClaudeNonStream(_ context.Context, _ string, orig · 3 unmodified lines
301	if textBuilder.Len() == 0 {	294	if textBuilder.Len() == 0 {
302	return	295	return
303	}	296	}
304	contentBlocks = append(contentBlocks, map[string]interface{}{	297	block := `{"type":"text","text":""}`
305	"type": "text",	298	block, _ = sjson.Set(block, "text", textBuilder.String())
306	"text": textBuilder.String(),	299	out, _ = sjson.SetRaw(out, "content.-1", block)
307	})
308	textBuilder.Reset()	300	textBuilder.Reset()
309	}	301	}
310		302
@@ -312,10 +304,9 @@ func ConvertGeminiCLIResponseToClaudeNonStream(_ context.Context, _ string, orig · 1 unmodified line
312	if thinkingBuilder.Len() == 0 {	304	if thinkingBuilder.Len() == 0 {
313	return	305	return
314	}	306	}
315	contentBlocks = append(contentBlocks, map[string]interface{}{	307	block := `{"type":"thinking","thinking":""}`
316	"type": "thinking",	308	block, _ = sjson.Set(block, "thinking", thinkingBuilder.String())
317	"thinking": thinkingBuilder.String(),	309	out, _ = sjson.SetRaw(out, "content.-1", block)
318	})
319	thinkingBuilder.Reset()	310	thinkingBuilder.Reset()
320	}	311	}
321		312
@@ -339,21 +330,15 @@ func ConvertGeminiCLIResponseToClaudeNonStream(_ context.Context, _ string, orig · 17 unmodified lines
339		330
340	name := functionCall.Get("name").String()	331	name := functionCall.Get("name").String()
341	toolIDCounter++	332	toolIDCounter++
342	toolBlock := map[string]interface{}{	333	toolBlock := `{"type":"tool_use","id":"","name":"","input":{}}`
343	"type": "tool_use",	334	toolBlock, _ = sjson.Set(toolBlock, "id", fmt.Sprintf("tool_%d", toolIDCounter))
344	"id": fmt.Sprintf("tool_%d", toolIDCounter),	335	toolBlock, _ = sjson.Set(toolBlock, "name", name)
345	"name": name,	336	inputRaw := "{}"
346	"input": map[string]interface{}{},	337	if args := functionCall.Get("args"); args.Exists() && gjson.Valid(args.Raw) && args.IsObject() {
347	}	338	inputRaw = args.Raw
348
349	if args := functionCall.Get("args"); args.Exists() {
350	var parsed interface{}
351	if err := json.Unmarshal([]byte(args.Raw), &parsed); err == nil {
352	toolBlock["input"] = parsed
353	}
354	}	339	}
355		340	toolBlock, _ = sjson.SetRaw(toolBlock, "input", inputRaw)
356	contentBlocks = append(contentBlocks, toolBlock)	341	out, _ = sjson.SetRaw(out, "content.-1", toolBlock)
357	continue	342	continue
358	}	343	}
359	}	344	}
@@ -362,8 +347,6 @@ func ConvertGeminiCLIResponseToClaudeNonStream(_ context.Context, _ string, orig · 2 unmodified lines
362	flushThinking()	347	flushThinking()
363	flushText()	348	flushText()
364		349
365	response["content"] = contentBlocks
366
367	stopReason := "end_turn"	350	stopReason := "end_turn"
368	if hasToolCall {	351	if hasToolCall {
369	stopReason = "tool_use"	352	stopReason = "tool_use"
@@ -379,19 +362,13 @@ func ConvertGeminiCLIResponseToClaudeNonStream(_ context.Context, _ string, orig · 9 unmodified lines
379	}	362	}
380	}	363	}
381	}	364	}
382	response["stop_reason"] = stopReason	365	out, _ = sjson.Set(out, "stop_reason", stopReason)
383		366
384	if usage := response["usage"].(map[string]interface{}); usage["input_tokens"] == int64(0) && usage["output_tokens"] == int64(0) {	367	if inputTokens == int64(0) && outputTokens == int64(0) && !root.Get("response.usageMetadata").Exists() {
385	if usageMeta := root.Get("response.usageMetadata"); !usageMeta.Exists() {	368	out, _ = sjson.Delete(out, "usage")
386	delete(response, "usage")
387	}
388	}	369	}
389		370
390	encoded, err := json.Marshal(response)	371	return out
391	if err != nil {
392	return ""
393	}
394	return string(encoded)
395	}	372	}
396		373
397	func ClaudeTokenCount(ctx context.Context, count int64) string {	374	func ClaudeTokenCount(ctx context.Context, count int64) string {

internal/translator/gemini-cli/gemini/gemini-cli_gemini_request.go+27−51

 import (
 	"bytes"
-	"encoding/json"
 	"fmt"
 	"github.com/router-for-me/CLIProxyAPI/v6/internal/translator/gemini/common"
 // FunctionCallGroup represents a group of function calls and their responses
 type FunctionCallGroup struct {
-	ModelContent    map[string]interface{}
-	FunctionCalls   []gjson.Result
 	ResponsesNeeded int
 }
 	}
 	// Initialize data structures for processing and grouping
-	var newContents []interface{}          // Final processed contents array
+	contentsWrapper := `{"contents":[]}`
 	var pendingGroups []*FunctionCallGroup // Groups awaiting completion with responses
 	var collectedResponses []gjson.Result  // Standalone responses to be matched
 					collectedResponses = collectedResponses[group.ResponsesNeeded:]
 					// Create merged function response content
-					var responseParts []interface{}
+					functionResponseContent := `{"parts":[],"role":"function"}`
 					for _, response := range groupResponses {
-						var responseMap map[string]interface{}
+						if !response.IsObject() {
-						errUnmarshal := json.Unmarshal([]byte(response.Raw), &responseMap)
+							log.Warnf("failed to parse function response")
-						if errUnmarshal != nil {
-							log.Warnf("failed to unmarshal function response: %v\n", errUnmarshal)
 							continue
 						}
-						responseParts = append(responseParts, responseMap)
+						functionResponseContent, _ = sjson.SetRaw(functionResponseContent, "parts.-1", response.Raw)
 					}
-					if len(responseParts) > 0 {
+					if gjson.Get(functionResponseContent, "parts.#").Int() > 0 {
-						functionResponseContent := map[string]interface{}{
+						contentsWrapper, _ = sjson.SetRaw(contentsWrapper, "contents.-1", functionResponseContent)
-							"parts": responseParts,
-							"role":  "function",
-						}
-						newContents = append(newContents, functionResponseContent)
 					}
 					// Remove this group as it's been satisfied
 		// If this is a model with function calls, create a new group
 		if role == "model" {
-			var functionCallsInThisModel []gjson.Result
+			functionCallsCount := 0
 			parts.ForEach(func(_, part gjson.Result) bool {
 				if part.Get("functionCall").Exists() {
-					functionCallsInThisModel = append(functionCallsInThisModel, part)
+					functionCallsCount++
 				}
 				return true
 			})
-			if len(functionCallsInThisModel) > 0 {
+			if functionCallsCount > 0 {
 				// Add the model content
-				var contentMap map[string]interface{}
+				if !value.IsObject() {
-				errUnmarshal := json.Unmarshal([]byte(value.Raw), &contentMap)
+					log.Warnf("failed to parse model content")
-				if errUnmarshal != nil {
-					log.Warnf("failed to unmarshal model content: %v\n", errUnmarshal)
 					return true
 				}
-				newContents = append(newContents, contentMap)
+				contentsWrapper, _ = sjson.SetRaw(contentsWrapper, "contents.-1", value.Raw)
 				// Create a new group for tracking responses
 				group := &FunctionCallGroup{
-					ModelContent:    contentMap,
+					ResponsesNeeded: functionCallsCount,
-					FunctionCalls:   functionCallsInThisModel,
-					ResponsesNeeded: len(functionCallsInThisModel),
 				}
 				pendingGroups = append(pendingGroups, group)
 			} else {
 				// Regular model content without function calls
-				var contentMap map[string]interface{}
+				if !value.IsObject() {
-				errUnmarshal := json.Unmarshal([]byte(value.Raw), &contentMap)
+					log.Warnf("failed to parse content")
-				if errUnmarshal != nil {
-					log.Warnf("failed to unmarshal content: %v\n", errUnmarshal)
 					return true
 				}
-				newContents = append(newContents, contentMap)
+				contentsWrapper, _ = sjson.SetRaw(contentsWrapper, "contents.-1", value.Raw)
 			}
 		} else {
 			// Non-model content (user, etc.)
-			var contentMap map[string]interface{}
+			if !value.IsObject() {
-			errUnmarshal := json.Unmarshal([]byte(value.Raw), &contentMap)
+				log.Warnf("failed to parse content")
-			if errUnmarshal != nil {
-				log.Warnf("failed to unmarshal content: %v\n", errUnmarshal)
 				return true
 			}
-			newContents = append(newContents, contentMap)
+			contentsWrapper, _ = sjson.SetRaw(contentsWrapper, "contents.-1", value.Raw)
 		}
 		return true
 			groupResponses := collectedResponses[:group.ResponsesNeeded]
 			collectedResponses = collectedResponses[group.ResponsesNeeded:]
-			var responseParts []interface{}
+			functionResponseContent := `{"parts":[],"role":"function"}`
 			for _, response := range groupResponses {
-				var responseMap map[string]interface{}
+				if !response.IsObject() {
-				errUnmarshal := json.Unmarshal([]byte(response.Raw), &responseMap)
+					log.Warnf("failed to parse function response")
-				if errUnmarshal != nil {
-					log.Warnf("failed to unmarshal function response: %v\n", errUnmarshal)
 					continue
 				}
-				responseParts = append(responseParts, responseMap)
+				functionResponseContent, _ = sjson.SetRaw(functionResponseContent, "parts.-1", response.Raw)
 			}
-			if len(responseParts) > 0 {
+			if gjson.Get(functionResponseContent, "parts.#").Int() > 0 {
-				functionResponseContent := map[string]interface{}{
+				contentsWrapper, _ = sjson.SetRaw(contentsWrapper, "contents.-1", functionResponseContent)
-					"parts": responseParts,
-					"role":  "function",
-				}
-				newContents = append(newContents, functionResponseContent)
 			}
 		}
 	}
 	// Update the original JSON with the new contents
 	result := input
-	newContentsJSON, _ := json.Marshal(newContents)
+	result, _ = sjson.SetRaw(result, "request.contents", gjson.Get(contentsWrapper, "contents").Raw)
-	result, _ = sjson.Set(result, "request.contents", json.RawMessage(newContentsJSON))
 	return result, nil
 }

internal/translator/gemini-cli/openai/chat-completions/gemini-cli_openai_request.go+2−2

@@ -278,7 +278,7 @@ func ConvertOpenAIRequestToGeminiCLI(modelName string, inputRawJSON []byte, _ bo · 277 unmodified lines
278	log.Warnf("Failed to set default schema type for tool '%s': %v", fn.Get("name").String(), errSet)	278	log.Warnf("Failed to set default schema type for tool '%s': %v", fn.Get("name").String(), errSet)
279	continue	279	continue
280	}	280	}
281	fnRaw, errSet = sjson.Set(fnRaw, "parametersJsonSchema.properties", map[string]interface{}{})	281	fnRaw, errSet = sjson.SetRaw(fnRaw, "parametersJsonSchema.properties", `{}`)
282	if errSet != nil {	282	if errSet != nil {
283	log.Warnf("Failed to set default schema properties for tool '%s': %v", fn.Get("name").String(), errSet)	283	log.Warnf("Failed to set default schema properties for tool '%s': %v", fn.Get("name").String(), errSet)
284	continue	284	continue
@@ -293,7 +293,7 @@ func ConvertOpenAIRequestToGeminiCLI(modelName string, inputRawJSON []byte, _ bo · 8 unmodified lines
293	log.Warnf("Failed to set default schema type for tool '%s': %v", fn.Get("name").String(), errSet)	293	log.Warnf("Failed to set default schema type for tool '%s': %v", fn.Get("name").String(), errSet)
294	continue	294	continue
295	}	295	}
296	fnRaw, errSet = sjson.Set(fnRaw, "parametersJsonSchema.properties", map[string]interface{}{})	296	fnRaw, errSet = sjson.SetRaw(fnRaw, "parametersJsonSchema.properties", `{}`)
297	if errSet != nil {	297	if errSet != nil {
298	log.Warnf("Failed to set default schema properties for tool '%s': %v", fn.Get("name").String(), errSet)	298	log.Warnf("Failed to set default schema properties for tool '%s': %v", fn.Get("name").String(), errSet)
299	continue	299	continue

internal/translator/gemini-cli/openai/chat-completions/gemini-cli_openai_response.go+3−11

 import (
 	"bytes"
 	"context"
-	"encoding/json"
 	"fmt"
 	"strings"
 	"sync/atomic"
 					mimeType = "image/png"
 				}
 				imageURL := fmt.Sprintf("data:%s;base64,%s", mimeType, data)
-				imagePayload, err := json.Marshal(map[string]any{
+				imagePayload := `{"image_url":{"url":""},"type":"image_url"}`
-					"type": "image_url",
+				imagePayload, _ = sjson.Set(imagePayload, "image_url.url", imageURL)
-					"image_url": map[string]string{
-						"url": imageURL,
-					},
-				})
-				if err != nil {
-					continue
-				}
 				imagesResult := gjson.Get(template, "choices.0.delta.images")
 				if !imagesResult.Exists() || !imagesResult.IsArray() {
 					template, _ = sjson.SetRaw(template, "choices.0.delta.images", `[]`)
 				}
 				template, _ = sjson.Set(template, "choices.0.delta.role", "assistant")
-				template, _ = sjson.SetRaw(template, "choices.0.delta.images.-1", string(imagePayload))
+				template, _ = sjson.SetRaw(template, "choices.0.delta.images.-1", imagePayload)
 			}
 		}
 	}

internal/translator/gemini/claude/gemini_claude_request.go+78−83

@@ -7,10 +7,8 @@ package claude · 6 unmodified lines
7		7
8	import (	8	import (
9	"bytes"	9	"bytes"
10	"encoding/json"
11	"strings"	10	"strings"
12		11
13	client "github.com/router-for-me/CLIProxyAPI/v6/internal/interfaces"
14	"github.com/router-for-me/CLIProxyAPI/v6/internal/translator/gemini/common"	12	"github.com/router-for-me/CLIProxyAPI/v6/internal/translator/gemini/common"
15	"github.com/router-for-me/CLIProxyAPI/v6/internal/util"	13	"github.com/router-for-me/CLIProxyAPI/v6/internal/util"
16	"github.com/tidwall/gjson"	14	"github.com/tidwall/gjson"
@@ -34,92 +32,100 @@ func ConvertClaudeRequestToGemini(modelName string, inputRawJSON []byte, _ bool) · 17 unmodified lines
34	rawJSON := bytes.Clone(inputRawJSON)	32	rawJSON := bytes.Clone(inputRawJSON)
35	rawJSON = bytes.Replace(rawJSON, []byte(`"url":{"type":"string","format":"uri",`), []byte(`"url":{"type":"string",`), -1)	33	rawJSON = bytes.Replace(rawJSON, []byte(`"url":{"type":"string","format":"uri",`), []byte(`"url":{"type":"string",`), -1)
36		34
		35	// Build output Gemini CLI request JSON
		36	out := `{"contents":[]}`
		37	out, _ = sjson.Set(out, "model", modelName)
		38
37	// system instruction	39	// system instruction
38	var systemInstruction *client.Content	40	if systemResult := gjson.GetBytes(rawJSON, "system"); systemResult.IsArray() {
39	systemResult := gjson.GetBytes(rawJSON, "system")	41	systemInstruction := `{"role":"user","parts":[]}`
40	if systemResult.IsArray() {	42	hasSystemParts := false
41	systemResults := systemResult.Array()	43	systemResult.ForEach(func(_, systemPromptResult gjson.Result) bool {
42	systemInstruction = &client.Content{Role: "user", Parts: []client.Part{}}	44	if systemPromptResult.Get("type").String() == "text" {
43	for i := 0; i < len(systemResults); i++ {	45	textResult := systemPromptResult.Get("text")
44	systemPromptResult := systemResults[i]	46	if textResult.Type == gjson.String {
45	systemTypePromptResult := systemPromptResult.Get("type")	47	part := `{"text":""}`
46	if systemTypePromptResult.Type == gjson.String && systemTypePromptResult.String() == "text" {	48	part, _ = sjson.Set(part, "text", textResult.String())
47	systemPrompt := systemPromptResult.Get("text").String()	49	systemInstruction, _ = sjson.SetRaw(systemInstruction, "parts.-1", part)
48	systemPart := client.Part{Text: systemPrompt}	50	hasSystemParts = true
49	systemInstruction.Parts = append(systemInstruction.Parts, systemPart)	51	}
50	}	52	}
51	}	53	return true
52	if len(systemInstruction.Parts) == 0 {	54	})
53	systemInstruction = nil	55	if hasSystemParts {
		56	out, _ = sjson.SetRaw(out, "system_instruction", systemInstruction)
54	}	57	}
55	}	58	}
56		59
57	// contents	60	// contents
58	contents := make([]client.Content, 0)	61	if messagesResult := gjson.GetBytes(rawJSON, "messages"); messagesResult.IsArray() {
59	messagesResult := gjson.GetBytes(rawJSON, "messages")	62	messagesResult.ForEach(func(_, messageResult gjson.Result) bool {
60	if messagesResult.IsArray() {
61	messageResults := messagesResult.Array()
62	for i := 0; i < len(messageResults); i++ {
63	messageResult := messageResults[i]
64	roleResult := messageResult.Get("role")	63	roleResult := messageResult.Get("role")
65	if roleResult.Type != gjson.String {	64	if roleResult.Type != gjson.String {
66	continue	65	return true
67	}	66	}
68	role := roleResult.String()	67	role := roleResult.String()
69	if role == "assistant" {	68	if role == "assistant" {
70	role = "model"	69	role = "model"
71	}	70	}
72	clientContent := client.Content{Role: role, Parts: []client.Part{}}	71
		72	contentJSON := `{"role":"","parts":[]}`
		73	contentJSON, _ = sjson.Set(contentJSON, "role", role)
		74
73	contentsResult := messageResult.Get("content")	75	contentsResult := messageResult.Get("content")
74	if contentsResult.IsArray() {	76	if contentsResult.IsArray() {
75	contentResults := contentsResult.Array()	77	contentsResult.ForEach(func(_, contentResult gjson.Result) bool {
76	for j := 0; j < len(contentResults); j++ {	78	switch contentResult.Get("type").String() {
77	contentResult := contentResults[j]	79	case "text":
78	contentTypeResult := contentResult.Get("type")	80	part := `{"text":""}`
79	if contentTypeResult.Type == gjson.String && contentTypeResult.String() == "text" {	81	part, _ = sjson.Set(part, "text", contentResult.Get("text").String())
80	prompt := contentResult.Get("text").String()	82	contentJSON, _ = sjson.SetRaw(contentJSON, "parts.-1", part)
81	clientContent.Parts = append(clientContent.Parts, client.Part{Text: prompt})	83
82	} else if contentTypeResult.Type == gjson.String && contentTypeResult.String() == "tool_use" {	84	case "tool_use":
83	functionName := contentResult.Get("name").String()	85	functionName := contentResult.Get("name").String()
84	functionArgs := contentResult.Get("input").String()	86	functionArgs := contentResult.Get("input").String()
85	var args map[string]any	87	argsResult := gjson.Parse(functionArgs)
86	if err := json.Unmarshal([]byte(functionArgs), &args); err == nil {	88	if argsResult.IsObject() && gjson.Valid(functionArgs) {
87	clientContent.Parts = append(clientContent.Parts, client.Part{	89	part := `{"thoughtSignature":"","functionCall":{"name":"","args":{}}}`
88	FunctionCall: &client.FunctionCall{Name: functionName, Args: args},	90	part, _ = sjson.Set(part, "thoughtSignature", geminiClaudeThoughtSignature)
89	ThoughtSignature: geminiClaudeThoughtSignature,	91	part, _ = sjson.Set(part, "functionCall.name", functionName)
90	})	92	part, _ = sjson.SetRaw(part, "functionCall.args", functionArgs)
		93	contentJSON, _ = sjson.SetRaw(contentJSON, "parts.-1", part)
91	}	94	}
92	} else if contentTypeResult.Type == gjson.String && contentTypeResult.String() == "tool_result" {	95
		96	case "tool_result":
93	toolCallID := contentResult.Get("tool_use_id").String()	97	toolCallID := contentResult.Get("tool_use_id").String()
94	if toolCallID != "" {	98	if toolCallID == "" {
95	funcName := toolCallID	99	return true
96	toolCallIDs := strings.Split(toolCallID, "-")	100	}
97	if len(toolCallIDs) > 1 {	101	funcName := toolCallID
98	funcName = strings.Join(toolCallIDs[0:len(toolCallIDs)-1], "-")	102	toolCallIDs := strings.Split(toolCallID, "-")
99	}	103	if len(toolCallIDs) > 1 {
100	responseData := contentResult.Get("content").Raw	104	funcName = strings.Join(toolCallIDs[0:len(toolCallIDs)-1], "-")
101	functionResponse := client.FunctionResponse{Name: funcName, Response: map[string]interface{}{"result": responseData}}
102	clientContent.Parts = append(clientContent.Parts, client.Part{FunctionResponse: &functionResponse})
103	}	105	}
		106	responseData := contentResult.Get("content").Raw
		107	part := `{"functionResponse":{"name":"","response":{"result":""}}}`
		108	part, _ = sjson.Set(part, "functionResponse.name", funcName)
		109	part, _ = sjson.Set(part, "functionResponse.response.result", responseData)
		110	contentJSON, _ = sjson.SetRaw(contentJSON, "parts.-1", part)
104	}	111	}
105	}	112	return true
106	contents = append(contents, clientContent)	113	})
		114	out, _ = sjson.SetRaw(out, "contents.-1", contentJSON)
107	} else if contentsResult.Type == gjson.String {	115	} else if contentsResult.Type == gjson.String {
108	prompt := contentsResult.String()	116	part := `{"text":""}`
109	contents = append(contents, client.Content{Role: role, Parts: []client.Part{{Text: prompt}}})	117	part, _ = sjson.Set(part, "text", contentsResult.String())
		118	contentJSON, _ = sjson.SetRaw(contentJSON, "parts.-1", part)
		119	out, _ = sjson.SetRaw(out, "contents.-1", contentJSON)
110	}	120	}
111	}	121	return true
		122	})
112	}	123	}
113		124
114	// tools	125	// tools
115	var tools []client.ToolDeclaration	126	if toolsResult := gjson.GetBytes(rawJSON, "tools"); toolsResult.IsArray() {
116	toolsResult := gjson.GetBytes(rawJSON, "tools")	127	hasTools := false
117	if toolsResult.IsArray() {	128	toolsResult.ForEach(func(_, toolResult gjson.Result) bool {
118	tools = make([]client.ToolDeclaration, 1)
119	tools[0].FunctionDeclarations = make([]any, 0)
120	toolsResults := toolsResult.Array()
121	for i := 0; i < len(toolsResults); i++ {
122	toolResult := toolsResults[i]
123	inputSchemaResult := toolResult.Get("input_schema")	129	inputSchemaResult := toolResult.Get("input_schema")
124	if inputSchemaResult.Exists() && inputSchemaResult.IsObject() {	130	if inputSchemaResult.Exists() && inputSchemaResult.IsObject() {
125	inputSchema := inputSchemaResult.Raw	131	inputSchema := inputSchemaResult.Raw
@@ -129,30 +135,19 @@ func ConvertClaudeRequestToGemini(modelName string, inputRawJSON []byte, _ bool) · 3 unmodified lines
129	tool, _ = sjson.Delete(tool, "input_examples")	135	tool, _ = sjson.Delete(tool, "input_examples")
130	tool, _ = sjson.Delete(tool, "type")	136	tool, _ = sjson.Delete(tool, "type")
131	tool, _ = sjson.Delete(tool, "cache_control")	137	tool, _ = sjson.Delete(tool, "cache_control")
132	var toolDeclaration any	138	if gjson.Valid(tool) && gjson.Parse(tool).IsObject() {
133	if err := json.Unmarshal([]byte(tool), &toolDeclaration); err == nil {	139	if !hasTools {
134	tools[0].FunctionDeclarations = append(tools[0].FunctionDeclarations, toolDeclaration)	140	out, _ = sjson.SetRaw(out, "tools", `[{"functionDeclarations":[]}]`)
		141	hasTools = true
		142	}
		143	out, _ = sjson.SetRaw(out, "tools.0.functionDeclarations.-1", tool)
135	}	144	}
136	}	145	}
		146	return true
		147	})
		148	if !hasTools {
		149	out, _ = sjson.Delete(out, "tools")
137	}	150	}
138	} else {
139	tools = make([]client.ToolDeclaration, 0)
140	}
141
142	// Build output Gemini CLI request JSON
143	out := `{"contents":[]}`
144	out, _ = sjson.Set(out, "model", modelName)
145	if systemInstruction != nil {
146	b, _ := json.Marshal(systemInstruction)
147	out, _ = sjson.SetRaw(out, "system_instruction", string(b))
148	}
149	if len(contents) > 0 {
150	b, _ := json.Marshal(contents)
151	out, _ = sjson.SetRaw(out, "contents", string(b))
152	}
153	if len(tools) > 0 && len(tools[0].FunctionDeclarations) > 0 {
154	b, _ := json.Marshal(tools)
155	out, _ = sjson.SetRaw(out, "tools", string(b))
156	}	151	}
157		152
158	// Map Anthropic thinking -> Gemini thinkingBudget/include_thoughts when enabled	153	// Map Anthropic thinking -> Gemini thinkingBudget/include_thoughts when enabled

internal/translator/gemini/claude/gemini_claude_response.go+26−49

@@ -9,7 +9,6 @@ package claude · 8 unmodified lines
9	import (	9	import (
10	"bytes"	10	"bytes"
11	"context"	11	"context"
12	"encoding/json"
13	"fmt"	12	"fmt"
14	"strings"	13	"strings"
15	"sync/atomic"	14	"sync/atomic"
@@ -282,22 +281,16 @@ func ConvertGeminiResponseToClaudeNonStream(_ context.Context, _ string, origina · 266 unmodified lines
282		281
283	root := gjson.ParseBytes(rawJSON)	282	root := gjson.ParseBytes(rawJSON)
284		283
285	response := map[string]interface{}{	284	out := `{"id":"","type":"message","role":"assistant","model":"","content":[],"stop_reason":null,"stop_sequence":null,"usage":{"input_tokens":0,"output_tokens":0}}`
286	"id": root.Get("responseId").String(),	285	out, _ = sjson.Set(out, "id", root.Get("responseId").String())
287	"type": "message",	286	out, _ = sjson.Set(out, "model", root.Get("modelVersion").String())
288	"role": "assistant",	287
289	"model": root.Get("modelVersion").String(),	288	inputTokens := root.Get("usageMetadata.promptTokenCount").Int()
290	"content": []interface{}{},	289	outputTokens := root.Get("usageMetadata.candidatesTokenCount").Int() + root.Get("usageMetadata.thoughtsTokenCount").Int()
291	"stop_reason": nil,	290	out, _ = sjson.Set(out, "usage.input_tokens", inputTokens)
292	"stop_sequence": nil,	291	out, _ = sjson.Set(out, "usage.output_tokens", outputTokens)
293	"usage": map[string]interface{}{
294	"input_tokens": root.Get("usageMetadata.promptTokenCount").Int(),
295	"output_tokens": root.Get("usageMetadata.candidatesTokenCount").Int() + root.Get("usageMetadata.thoughtsTokenCount").Int(),
296	},
297	}
298		292
299	parts := root.Get("candidates.0.content.parts")	293	parts := root.Get("candidates.0.content.parts")
300	var contentBlocks []interface{}
301	textBuilder := strings.Builder{}	294	textBuilder := strings.Builder{}
302	thinkingBuilder := strings.Builder{}	295	thinkingBuilder := strings.Builder{}
303	toolIDCounter := 0	296	toolIDCounter := 0
@@ -307,10 +300,9 @@ func ConvertGeminiResponseToClaudeNonStream(_ context.Context, _ string, origina · 3 unmodified lines
307	if textBuilder.Len() == 0 {	300	if textBuilder.Len() == 0 {
308	return	301	return
309	}	302	}
310	contentBlocks = append(contentBlocks, map[string]interface{}{	303	block := `{"type":"text","text":""}`
311	"type": "text",	304	block, _ = sjson.Set(block, "text", textBuilder.String())
312	"text": textBuilder.String(),	305	out, _ = sjson.SetRaw(out, "content.-1", block)
313	})
314	textBuilder.Reset()	306	textBuilder.Reset()
315	}	307	}
316		308
@@ -318,10 +310,9 @@ func ConvertGeminiResponseToClaudeNonStream(_ context.Context, _ string, origina · 1 unmodified line
318	if thinkingBuilder.Len() == 0 {	310	if thinkingBuilder.Len() == 0 {
319	return	311	return
320	}	312	}
321	contentBlocks = append(contentBlocks, map[string]interface{}{	313	block := `{"type":"thinking","thinking":""}`
322	"type": "thinking",	314	block, _ = sjson.Set(block, "thinking", thinkingBuilder.String())
323	"thinking": thinkingBuilder.String(),	315	out, _ = sjson.SetRaw(out, "content.-1", block)
324	})
325	thinkingBuilder.Reset()	316	thinkingBuilder.Reset()
326	}	317	}
327		318
@@ -345,21 +336,15 @@ func ConvertGeminiResponseToClaudeNonStream(_ context.Context, _ string, origina · 17 unmodified lines
345		336
346	name := functionCall.Get("name").String()	337	name := functionCall.Get("name").String()
347	toolIDCounter++	338	toolIDCounter++
348	toolBlock := map[string]interface{}{	339	toolBlock := `{"type":"tool_use","id":"","name":"","input":{}}`
349	"type": "tool_use",	340	toolBlock, _ = sjson.Set(toolBlock, "id", fmt.Sprintf("tool_%d", toolIDCounter))
350	"id": fmt.Sprintf("tool_%d", toolIDCounter),	341	toolBlock, _ = sjson.Set(toolBlock, "name", name)
351	"name": name,	342	inputRaw := "{}"
352	"input": map[string]interface{}{},	343	if args := functionCall.Get("args"); args.Exists() && gjson.Valid(args.Raw) && args.IsObject() {
353	}	344	inputRaw = args.Raw
354
355	if args := functionCall.Get("args"); args.Exists() {
356	var parsed interface{}
357	if err := json.Unmarshal([]byte(args.Raw), &parsed); err == nil {
358	toolBlock["input"] = parsed
359	}
360	}	345	}
361		346	toolBlock, _ = sjson.SetRaw(toolBlock, "input", inputRaw)
362	contentBlocks = append(contentBlocks, toolBlock)	347	out, _ = sjson.SetRaw(out, "content.-1", toolBlock)
363	continue	348	continue
364	}	349	}
365	}	350	}
@@ -368,8 +353,6 @@ func ConvertGeminiResponseToClaudeNonStream(_ context.Context, _ string, origina · 2 unmodified lines
368	flushThinking()	353	flushThinking()
369	flushText()	354	flushText()
370		355
371	response["content"] = contentBlocks
372
373	stopReason := "end_turn"	356	stopReason := "end_turn"
374	if hasToolCall {	357	if hasToolCall {
375	stopReason = "tool_use"	358	stopReason = "tool_use"
@@ -385,19 +368,13 @@ func ConvertGeminiResponseToClaudeNonStream(_ context.Context, _ string, origina · 9 unmodified lines
385	}	368	}
386	}	369	}
387	}	370	}
388	response["stop_reason"] = stopReason	371	out, _ = sjson.Set(out, "stop_reason", stopReason)
389		372
390	if usage := response["usage"].(map[string]interface{}); usage["input_tokens"] == int64(0) && usage["output_tokens"] == int64(0) {	373	if inputTokens == int64(0) && outputTokens == int64(0) && !root.Get("usageMetadata").Exists() {
391	if usageMeta := root.Get("usageMetadata"); !usageMeta.Exists() {	374	out, _ = sjson.Delete(out, "usage")
392	delete(response, "usage")
393	}
394	}	375	}
395		376
396	encoded, err := json.Marshal(response)	377	return out
397	if err != nil {
398	return ""
399	}
400	return string(encoded)
401	}	378	}
402		379
403	func ClaudeTokenCount(ctx context.Context, count int64) string {	380	func ClaudeTokenCount(ctx context.Context, count int64) string {

internal/translator/gemini/openai/chat-completions/gemini_openai_request.go+2−2

@@ -320,7 +320,7 @@ func ConvertOpenAIRequestToGemini(modelName string, inputRawJSON []byte, _ bool) · 319 unmodified lines
320	log.Warnf("Failed to set default schema type for tool '%s': %v", fn.Get("name").String(), errSet)	320	log.Warnf("Failed to set default schema type for tool '%s': %v", fn.Get("name").String(), errSet)
321	continue	321	continue
322	}	322	}
323	fnRaw, errSet = sjson.Set(fnRaw, "parametersJsonSchema.properties", map[string]interface{}{})	323	fnRaw, errSet = sjson.SetRaw(fnRaw, "parametersJsonSchema.properties", `{}`)
324	if errSet != nil {	324	if errSet != nil {
325	log.Warnf("Failed to set default schema properties for tool '%s': %v", fn.Get("name").String(), errSet)	325	log.Warnf("Failed to set default schema properties for tool '%s': %v", fn.Get("name").String(), errSet)
326	continue	326	continue
@@ -335,7 +335,7 @@ func ConvertOpenAIRequestToGemini(modelName string, inputRawJSON []byte, _ bool) · 8 unmodified lines
335	log.Warnf("Failed to set default schema type for tool '%s': %v", fn.Get("name").String(), errSet)	335	log.Warnf("Failed to set default schema type for tool '%s': %v", fn.Get("name").String(), errSet)
336	continue	336	continue
337	}	337	}
338	fnRaw, errSet = sjson.Set(fnRaw, "parametersJsonSchema.properties", map[string]interface{}{})	338	fnRaw, errSet = sjson.SetRaw(fnRaw, "parametersJsonSchema.properties", `{}`)
339	if errSet != nil {	339	if errSet != nil {
340	log.Warnf("Failed to set default schema properties for tool '%s': %v", fn.Get("name").String(), errSet)	340	log.Warnf("Failed to set default schema properties for tool '%s': %v", fn.Get("name").String(), errSet)
341	continue	341	continue

internal/translator/gemini/openai/chat-completions/gemini_openai_response.go+6−21

 import (
 	"bytes"
 	"context"
-	"encoding/json"
 	"fmt"
 	"strings"
 	"sync/atomic"
 					mimeType = "image/png"
 				}
 				imageURL := fmt.Sprintf("data:%s;base64,%s", mimeType, data)
-				imagePayload, err := json.Marshal(map[string]any{
+				imagePayload := `{"image_url":{"url":""},"type":"image_url"}`
-					"type": "image_url",
+				imagePayload, _ = sjson.Set(imagePayload, "image_url.url", imageURL)
-					"image_url": map[string]string{
-						"url": imageURL,
-					},
-				})
-				if err != nil {
-					continue
-				}
 				imagesResult := gjson.Get(template, "choices.0.delta.images")
 				if !imagesResult.Exists() || !imagesResult.IsArray() {
 					template, _ = sjson.SetRaw(template, "choices.0.delta.images", `[]`)
 				}
 				template, _ = sjson.Set(template, "choices.0.delta.role", "assistant")
-				template, _ = sjson.SetRaw(template, "choices.0.delta.images.-1", string(imagePayload))
+				template, _ = sjson.SetRaw(template, "choices.0.delta.images.-1", imagePayload)
 			}
 		}
 	}
 					mimeType = "image/png"
 				}
 				imageURL := fmt.Sprintf("data:%s;base64,%s", mimeType, data)
-				imagePayload, err := json.Marshal(map[string]any{
+				imagePayload := `{"image_url":{"url":""},"type":"image_url"}`
-					"type": "image_url",
+				imagePayload, _ = sjson.Set(imagePayload, "image_url.url", imageURL)
-					"image_url": map[string]string{
-						"url": imageURL,
-					},
-				})
-				if err != nil {
-					continue
-				}
 				imagesResult := gjson.Get(template, "choices.0.message.images")
 				if !imagesResult.Exists() || !imagesResult.IsArray() {
 					template, _ = sjson.SetRaw(template, "choices.0.message.images", `[]`)
 				}
 				template, _ = sjson.Set(template, "choices.0.message.role", "assistant")
-				template, _ = sjson.SetRaw(template, "choices.0.message.images.-1", string(imagePayload))
+				template, _ = sjson.SetRaw(template, "choices.0.message.images.-1", imagePayload)
 			}
 		}
 	}

internal/translator/gemini/openai/responses/gemini_openai-responses_response.go+53−72

 		}
 		// Compose outputs in encountered order: reasoning, message, function_calls
-		var outputs []interface{}
+		outputsWrapper := `{"arr":[]}`
 		if st.ReasoningOpened {
-			outputs = append(outputs, map[string]interface{}{
+			item := `{"id":"","type":"reasoning","summary":[{"type":"summary_text","text":""}]}`
-				"id":      st.ReasoningItemID,
+			item, _ = sjson.Set(item, "id", st.ReasoningItemID)
-				"type":    "reasoning",
+			item, _ = sjson.Set(item, "summary.0.text", st.ReasoningBuf.String())
-				"summary": []interface{}{map[string]interface{}{"type": "summary_text", "text": st.ReasoningBuf.String()}},
+			outputsWrapper, _ = sjson.SetRaw(outputsWrapper, "arr.-1", item)
-			})
 		}
 		if st.MsgOpened {
-			outputs = append(outputs, map[string]interface{}{
+			item := `{"id":"","type":"message","status":"completed","content":[{"type":"output_text","annotations":[],"logprobs":[],"text":""}],"role":"assistant"}`
-				"id":     st.CurrentMsgID,
+			item, _ = sjson.Set(item, "id", st.CurrentMsgID)
-				"type":   "message",
+			item, _ = sjson.Set(item, "content.0.text", st.TextBuf.String())
-				"status": "completed",
+			outputsWrapper, _ = sjson.SetRaw(outputsWrapper, "arr.-1", item)
-				"content": []interface{}{map[string]interface{}{
-					"type":        "output_text",
-					"annotations": []interface{}{},
-					"logprobs":    []interface{}{},
-					"text":        st.TextBuf.String(),
-				}},
-				"role": "assistant",
-			})
 		}
 		if len(st.FuncArgsBuf) > 0 {
 			idxs := make([]int, 0, len(st.FuncArgsBuf))
 				if b := st.FuncArgsBuf[idx]; b != nil {
 					args = b.String()
 				}
-				outputs = append(outputs, map[string]interface{}{
+				item := `{"id":"","type":"function_call","status":"completed","arguments":"","call_id":"","name":""}`
-					"id":        fmt.Sprintf("fc_%s", st.FuncCallIDs[idx]),
+				item, _ = sjson.Set(item, "id", fmt.Sprintf("fc_%s", st.FuncCallIDs[idx]))
-					"type":      "function_call",
+				item, _ = sjson.Set(item, "arguments", args)
-					"status":    "completed",
+				item, _ = sjson.Set(item, "call_id", st.FuncCallIDs[idx])
-					"arguments": args,
+				item, _ = sjson.Set(item, "name", st.FuncNames[idx])
-					"call_id":   st.FuncCallIDs[idx],
+				outputsWrapper, _ = sjson.SetRaw(outputsWrapper, "arr.-1", item)
-					"name":      st.FuncNames[idx],
-				})
 			}
 		}
-		if len(outputs) > 0 {
+		if gjson.Get(outputsWrapper, "arr.#").Int() > 0 {
-			completed, _ = sjson.Set(completed, "response.output", outputs)
+			completed, _ = sjson.SetRaw(completed, "response.output", gjson.Get(outputsWrapper, "arr").Raw)
 		}
 		// usage mapping
 	}
 	// Build outputs from candidates[0].content.parts
-	var outputs []interface{}
 	var reasoningText strings.Builder
 	var reasoningEncrypted string
 	var messageText strings.Builder
 	var haveMessage bool
+	haveOutput := false
+	ensureOutput := func() {
+		if haveOutput {
+			return
+		}
+		resp, _ = sjson.SetRaw(resp, "output", "[]")
+		haveOutput = true
+	}
+	appendOutput := func(itemJSON string) {
+		ensureOutput()
+		resp, _ = sjson.SetRaw(resp, "output.-1", itemJSON)
+	}
 	if parts := root.Get("candidates.0.content.parts"); parts.Exists() && parts.IsArray() {
 		parts.ForEach(func(_, p gjson.Result) bool {
 			if p.Get("thought").Bool() {
 				name := fc.Get("name").String()
 				args := fc.Get("args")
 				callID := fmt.Sprintf("call_%x_%d", time.Now().UnixNano(), atomic.AddUint64(&funcCallIDCounter, 1))
-				outputs = append(outputs, map[string]interface{}{
+				itemJSON := `{"id":"","type":"function_call","status":"completed","arguments":"","call_id":"","name":""}`
-					"id":     fmt.Sprintf("fc_%s", callID),
+				itemJSON, _ = sjson.Set(itemJSON, "id", fmt.Sprintf("fc_%s", callID))
-					"type":   "function_call",
+				itemJSON, _ = sjson.Set(itemJSON, "call_id", callID)
-					"status": "completed",
+				itemJSON, _ = sjson.Set(itemJSON, "name", name)
-					"arguments": func() string {
+				argsStr := ""
-						if args.Exists() {
+				if args.Exists() {
-							return args.Raw
+					argsStr = args.Raw
-						}
+				}
-						return ""
+				itemJSON, _ = sjson.Set(itemJSON, "arguments", argsStr)
-					}(),
+				appendOutput(itemJSON)
-					"call_id": callID,
-					"name":    name,
-				})
 				return true
 			}
 			return true
 	// Reasoning output item
 	if reasoningText.Len() > 0 || reasoningEncrypted != "" {
 		rid := strings.TrimPrefix(id, "resp_")
-		item := map[string]interface{}{
+		itemJSON := `{"id":"","type":"reasoning","encrypted_content":""}`
-			"id":                fmt.Sprintf("rs_%s", rid),
+		itemJSON, _ = sjson.Set(itemJSON, "id", fmt.Sprintf("rs_%s", rid))
-			"type":              "reasoning",
+		itemJSON, _ = sjson.Set(itemJSON, "encrypted_content", reasoningEncrypted)
-			"encrypted_content": reasoningEncrypted,
-		}
-		var summaries []interface{}
 		if reasoningText.Len() > 0 {
-			summaries = append(summaries, map[string]interface{}{
+			summaryJSON := `{"type":"summary_text","text":""}`
-				"type": "summary_text",
+			summaryJSON, _ = sjson.Set(summaryJSON, "text", reasoningText.String())
-				"text": reasoningText.String(),
+			itemJSON, _ = sjson.SetRaw(itemJSON, "summary", "[]")
-			})
+			itemJSON, _ = sjson.SetRaw(itemJSON, "summary.-1", summaryJSON)
-		}
-		if summaries != nil {
-			item["summary"] = summaries
 		}
-		outputs = append(outputs, item)
+		appendOutput(itemJSON)
 	}
 	// Assistant message output item
 	if haveMessage {
-		outputs = append(outputs, map[string]interface{}{
+		itemJSON := `{"id":"","type":"message","status":"completed","content":[{"type":"output_text","annotations":[],"logprobs":[],"text":""}],"role":"assistant"}`
-			"id":     fmt.Sprintf("msg_%s_0", strings.TrimPrefix(id, "resp_")),
+		itemJSON, _ = sjson.Set(itemJSON, "id", fmt.Sprintf("msg_%s_0", strings.TrimPrefix(id, "resp_")))
-			"type":   "message",
+		itemJSON, _ = sjson.Set(itemJSON, "content.0.text", messageText.String())
-			"status": "completed",
+		appendOutput(itemJSON)
-			"content": []interface{}{map[string]interface{}{
-				"type":        "output_text",
-				"annotations": []interface{}{},
-				"logprobs":    []interface{}{},
-				"text":        messageText.String(),
-			}},
-			"role": "assistant",
-		})
-	}
-	if len(outputs) > 0 {
-		resp, _ = sjson.Set(resp, "output", outputs)
 	}
 	// usage mapping

internal/translator/openai/claude/openai_claude_request.go+2−8

 import (
 	"bytes"
-	"encoding/json"
 	"strings"
 	"github.com/router-for-me/CLIProxyAPI/v6/internal/util"
 						// Convert input to arguments JSON string
 						if input := part.Get("input"); input.Exists() {
-							if inputJSON, err := json.Marshal(input.Value()); err == nil {
+							toolCallJSON, _ = sjson.Set(toolCallJSON, "function.arguments", input.Raw)
-								toolCallJSON, _ = sjson.Set(toolCallJSON, "function.arguments", string(inputJSON))
-							} else {
-								toolCallJSON, _ = sjson.Set(toolCallJSON, "function.arguments", "{}")
-							}
 						} else {
 							toolCallJSON, _ = sjson.Set(toolCallJSON, "function.arguments", "{}")
 						}
 				// Emit tool calls in a separate assistant message
 				if role == "assistant" && len(toolCalls) > 0 {
 					toolCallMsgJSON := `{"role":"assistant","tool_calls":[]}`
-					toolCallsJSON, _ := json.Marshal(toolCalls)
+					toolCallMsgJSON, _ = sjson.Set(toolCallMsgJSON, "tool_calls", toolCalls)
-					toolCallMsgJSON, _ = sjson.SetRaw(toolCallMsgJSON, "tool_calls", string(toolCallsJSON))
 					messagesJSON, _ = sjson.Set(messagesJSON, "-1", gjson.Parse(toolCallMsgJSON).Value())
 				}

internal/translator/openai/claude/openai_claude_response.go+136−307

@@ -8,7 +8,6 @@ package claude · 7 unmodified lines
8	import (	8	import (
9	"bytes"	9	"bytes"
10	"context"	10	"context"
11	"encoding/json"
12	"fmt"	11	"fmt"
13	"strings"	12	"strings"
14		13
@@ -133,24 +132,10 @@ func convertOpenAIStreamingChunkToAnthropic(rawJSON []byte, param *ConvertOpenAI · 118 unmodified lines
133	if delta := root.Get("choices.0.delta"); delta.Exists() {	132	if delta := root.Get("choices.0.delta"); delta.Exists() {
134	if !param.MessageStarted {	133	if !param.MessageStarted {
135	// Send message_start event	134	// Send message_start event
136	messageStart := map[string]interface{}{	135	messageStartJSON := `{"type":"message_start","message":{"id":"","type":"message","role":"assistant","model":"","content":[],"stop_reason":null,"stop_sequence":null,"usage":{"input_tokens":0,"output_tokens":0}}}`
137	"type": "message_start",	136	messageStartJSON, _ = sjson.Set(messageStartJSON, "message.id", param.MessageID)
138	"message": map[string]interface{}{	137	messageStartJSON, _ = sjson.Set(messageStartJSON, "message.model", param.Model)
139	"id": param.MessageID,	138	results = append(results, "event: message_start\ndata: "+messageStartJSON+"\n\n")
140	"type": "message",
141	"role": "assistant",
142	"model": param.Model,
143	"content": []interface{}{},
144	"stop_reason": nil,
145	"stop_sequence": nil,
146	"usage": map[string]interface{}{
147	"input_tokens": 0,
148	"output_tokens": 0,
149	},
150	},
151	}
152	messageStartJSON, _ := json.Marshal(messageStart)
153	results = append(results, "event: message_start\ndata: "+string(messageStartJSON)+"\n\n")
154	param.MessageStarted = true	139	param.MessageStarted = true
155		140
156	// Don't send content_block_start for text here - wait for actual content	141	// Don't send content_block_start for text here - wait for actual content
@@ -168,29 +153,16 @@ func convertOpenAIStreamingChunkToAnthropic(rawJSON []byte, param *ConvertOpenAI · 11 unmodified lines
168	param.ThinkingContentBlockIndex = param.NextContentBlockIndex	153	param.ThinkingContentBlockIndex = param.NextContentBlockIndex
169	param.NextContentBlockIndex++	154	param.NextContentBlockIndex++
170	}	155	}
171	contentBlockStart := map[string]interface{}{	156	contentBlockStartJSON := `{"type":"content_block_start","index":0,"content_block":{"type":"thinking","thinking":""}}`
172	"type": "content_block_start",	157	contentBlockStartJSON, _ = sjson.Set(contentBlockStartJSON, "index", param.ThinkingContentBlockIndex)
173	"index": param.ThinkingContentBlockIndex,	158	results = append(results, "event: content_block_start\ndata: "+contentBlockStartJSON+"\n\n")
174	"content_block": map[string]interface{}{
175	"type": "thinking",
176	"thinking": "",
177	},
178	}
179	contentBlockStartJSON, _ := json.Marshal(contentBlockStart)
180	results = append(results, "event: content_block_start\ndata: "+string(contentBlockStartJSON)+"\n\n")
181	param.ThinkingContentBlockStarted = true	159	param.ThinkingContentBlockStarted = true
182	}	160	}
183		161
184	thinkingDelta := map[string]interface{}{	162	thinkingDeltaJSON := `{"type":"content_block_delta","index":0,"delta":{"type":"thinking_delta","thinking":""}}`
185	"type": "content_block_delta",	163	thinkingDeltaJSON, _ = sjson.Set(thinkingDeltaJSON, "index", param.ThinkingContentBlockIndex)
186	"index": param.ThinkingContentBlockIndex,	164	thinkingDeltaJSON, _ = sjson.Set(thinkingDeltaJSON, "delta.thinking", reasoningText)
187	"delta": map[string]interface{}{	165	results = append(results, "event: content_block_delta\ndata: "+thinkingDeltaJSON+"\n\n")
188	"type": "thinking_delta",
189	"thinking": reasoningText,
190	},
191	}
192	thinkingDeltaJSON, _ := json.Marshal(thinkingDelta)
193	results = append(results, "event: content_block_delta\ndata: "+string(thinkingDeltaJSON)+"\n\n")
194	}	166	}
195	}	167	}
196		168
@@ -203,29 +175,16 @@ func convertOpenAIStreamingChunkToAnthropic(rawJSON []byte, param *ConvertOpenAI · 6 unmodified lines
203	param.TextContentBlockIndex = param.NextContentBlockIndex	175	param.TextContentBlockIndex = param.NextContentBlockIndex
204	param.NextContentBlockIndex++	176	param.NextContentBlockIndex++
205	}	177	}
206	contentBlockStart := map[string]interface{}{	178	contentBlockStartJSON := `{"type":"content_block_start","index":0,"content_block":{"type":"text","text":""}}`
207	"type": "content_block_start",	179	contentBlockStartJSON, _ = sjson.Set(contentBlockStartJSON, "index", param.TextContentBlockIndex)
208	"index": param.TextContentBlockIndex,	180	results = append(results, "event: content_block_start\ndata: "+contentBlockStartJSON+"\n\n")
209	"content_block": map[string]interface{}{
210	"type": "text",
211	"text": "",
212	},
213	}
214	contentBlockStartJSON, _ := json.Marshal(contentBlockStart)
215	results = append(results, "event: content_block_start\ndata: "+string(contentBlockStartJSON)+"\n\n")
216	param.TextContentBlockStarted = true	181	param.TextContentBlockStarted = true
217	}	182	}
218		183
219	contentDelta := map[string]interface{}{	184	contentDeltaJSON := `{"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":""}}`
220	"type": "content_block_delta",	185	contentDeltaJSON, _ = sjson.Set(contentDeltaJSON, "index", param.TextContentBlockIndex)
221	"index": param.TextContentBlockIndex,	186	contentDeltaJSON, _ = sjson.Set(contentDeltaJSON, "delta.text", content.String())
222	"delta": map[string]interface{}{	187	results = append(results, "event: content_block_delta\ndata: "+contentDeltaJSON+"\n\n")
223	"type": "text_delta",
224	"text": content.String(),
225	},
226	}
227	contentDeltaJSON, _ := json.Marshal(contentDelta)
228	results = append(results, "event: content_block_delta\ndata: "+string(contentDeltaJSON)+"\n\n")
229		188
230	// Accumulate content	189	// Accumulate content
231	param.ContentAccumulator.WriteString(content.String())	190	param.ContentAccumulator.WriteString(content.String())
@@ -263,18 +222,11 @@ func convertOpenAIStreamingChunkToAnthropic(rawJSON []byte, param *ConvertOpenAI · 31 unmodified lines
263	stopTextContentBlock(param, &results)	222	stopTextContentBlock(param, &results)
264		223
265	// Send content_block_start for tool_use	224	// Send content_block_start for tool_use
266	contentBlockStart := map[string]interface{}{	225	contentBlockStartJSON := `{"type":"content_block_start","index":0,"content_block":{"type":"tool_use","id":"","name":"","input":{}}}`
267	"type": "content_block_start",	226	contentBlockStartJSON, _ = sjson.Set(contentBlockStartJSON, "index", blockIndex)
268	"index": blockIndex,	227	contentBlockStartJSON, _ = sjson.Set(contentBlockStartJSON, "content_block.id", accumulator.ID)
269	"content_block": map[string]interface{}{	228	contentBlockStartJSON, _ = sjson.Set(contentBlockStartJSON, "content_block.name", accumulator.Name)
270	"type": "tool_use",	229	results = append(results, "event: content_block_start\ndata: "+contentBlockStartJSON+"\n\n")
271	"id": accumulator.ID,
272	"name": accumulator.Name,
273	"input": map[string]interface{}{},
274	},
275	}
276	contentBlockStartJSON, _ := json.Marshal(contentBlockStart)
277	results = append(results, "event: content_block_start\ndata: "+string(contentBlockStartJSON)+"\n\n")
278	}	230	}
279		231
280	// Handle function arguments	232	// Handle function arguments
@@ -298,12 +250,9 @@ func convertOpenAIStreamingChunkToAnthropic(rawJSON []byte, param *ConvertOpenAI · 17 unmodified lines
298		250
299	// Send content_block_stop for thinking content if needed	251	// Send content_block_stop for thinking content if needed
300	if param.ThinkingContentBlockStarted {	252	if param.ThinkingContentBlockStarted {
301	contentBlockStop := map[string]interface{}{	253	contentBlockStopJSON := `{"type":"content_block_stop","index":0}`
302	"type": "content_block_stop",	254	contentBlockStopJSON, _ = sjson.Set(contentBlockStopJSON, "index", param.ThinkingContentBlockIndex)
303	"index": param.ThinkingContentBlockIndex,	255	results = append(results, "event: content_block_stop\ndata: "+contentBlockStopJSON+"\n\n")
304	}
305	contentBlockStopJSON, _ := json.Marshal(contentBlockStop)
306	results = append(results, "event: content_block_stop\ndata: "+string(contentBlockStopJSON)+"\n\n")
307	param.ThinkingContentBlockStarted = false	256	param.ThinkingContentBlockStarted = false
308	param.ThinkingContentBlockIndex = -1	257	param.ThinkingContentBlockIndex = -1
309	}	258	}
@@ -319,24 +268,15 @@ func convertOpenAIStreamingChunkToAnthropic(rawJSON []byte, param *ConvertOpenAI · 9 unmodified lines
319		268
320	// Send complete input_json_delta with all accumulated arguments	269	// Send complete input_json_delta with all accumulated arguments
321	if accumulator.Arguments.Len() > 0 {	270	if accumulator.Arguments.Len() > 0 {
322	inputDelta := map[string]interface{}{	271	inputDeltaJSON := `{"type":"content_block_delta","index":0,"delta":{"type":"input_json_delta","partial_json":""}}`
323	"type": "content_block_delta",	272	inputDeltaJSON, _ = sjson.Set(inputDeltaJSON, "index", blockIndex)
324	"index": blockIndex,	273	inputDeltaJSON, _ = sjson.Set(inputDeltaJSON, "delta.partial_json", util.FixJSON(accumulator.Arguments.String()))
325	"delta": map[string]interface{}{	274	results = append(results, "event: content_block_delta\ndata: "+inputDeltaJSON+"\n\n")
326	"type": "input_json_delta",
327	"partial_json": util.FixJSON(accumulator.Arguments.String()),
328	},
329	}
330	inputDeltaJSON, _ := json.Marshal(inputDelta)
331	results = append(results, "event: content_block_delta\ndata: "+string(inputDeltaJSON)+"\n\n")
332	}	275	}
333		276
334	contentBlockStop := map[string]interface{}{	277	contentBlockStopJSON := `{"type":"content_block_stop","index":0}`
335	"type": "content_block_stop",	278	contentBlockStopJSON, _ = sjson.Set(contentBlockStopJSON, "index", blockIndex)
336	"index": blockIndex,	279	results = append(results, "event: content_block_stop\ndata: "+contentBlockStopJSON+"\n\n")
337	}
338	contentBlockStopJSON, _ := json.Marshal(contentBlockStop)
339	results = append(results, "event: content_block_stop\ndata: "+string(contentBlockStopJSON)+"\n\n")
340	delete(param.ToolCallBlockIndexes, index)	280	delete(param.ToolCallBlockIndexes, index)
341	}	281	}
342	param.ContentBlocksStopped = true	282	param.ContentBlocksStopped = true
@@ -361,20 +301,11 @@ func convertOpenAIStreamingChunkToAnthropic(rawJSON []byte, param *ConvertOpenAI · 18 unmodified lines
361	}	301	}
362	}	302	}
363	// Send message_delta with usage	303	// Send message_delta with usage
364	messageDelta := map[string]interface{}{	304	messageDeltaJSON := `{"type":"message_delta","delta":{"stop_reason":"","stop_sequence":null},"usage":{"input_tokens":0,"output_tokens":0}}`
365	"type": "message_delta",	305	messageDeltaJSON, _ = sjson.Set(messageDeltaJSON, "delta.stop_reason", mapOpenAIFinishReasonToAnthropic(param.FinishReason))
366	"delta": map[string]interface{}{	306	messageDeltaJSON, _ = sjson.Set(messageDeltaJSON, "usage.input_tokens", inputTokens)
367	"stop_reason": mapOpenAIFinishReasonToAnthropic(param.FinishReason),	307	messageDeltaJSON, _ = sjson.Set(messageDeltaJSON, "usage.output_tokens", outputTokens)
368	"stop_sequence": nil,	308	results = append(results, "event: message_delta\ndata: "+messageDeltaJSON+"\n\n")
369	},
370	"usage": map[string]interface{}{
371	"input_tokens": inputTokens,
372	"output_tokens": outputTokens,
373	},
374	}
375
376	messageDeltaJSON, _ := json.Marshal(messageDelta)
377	results = append(results, "event: message_delta\ndata: "+string(messageDeltaJSON)+"\n\n")
378	param.MessageDeltaSent = true	309	param.MessageDeltaSent = true
379		310
380	emitMessageStopIfNeeded(param, &results)	311	emitMessageStopIfNeeded(param, &results)
@@ -390,12 +321,9 @@ func convertOpenAIDoneToAnthropic(param *ConvertOpenAIResponseToAnthropicParams) · 9 unmodified lines
390		321
391	// Ensure all content blocks are stopped before final events	322	// Ensure all content blocks are stopped before final events
392	if param.ThinkingContentBlockStarted {	323	if param.ThinkingContentBlockStarted {
393	contentBlockStop := map[string]interface{}{	324	contentBlockStopJSON := `{"type":"content_block_stop","index":0}`
394	"type": "content_block_stop",	325	contentBlockStopJSON, _ = sjson.Set(contentBlockStopJSON, "index", param.ThinkingContentBlockIndex)
395	"index": param.ThinkingContentBlockIndex,	326	results = append(results, "event: content_block_stop\ndata: "+contentBlockStopJSON+"\n\n")
396	}
397	contentBlockStopJSON, _ := json.Marshal(contentBlockStop)
398	results = append(results, "event: content_block_stop\ndata: "+string(contentBlockStopJSON)+"\n\n")
399	param.ThinkingContentBlockStarted = false	327	param.ThinkingContentBlockStarted = false
400	param.ThinkingContentBlockIndex = -1	328	param.ThinkingContentBlockIndex = -1
401	}	329	}
@@ -408,24 +336,15 @@ func convertOpenAIDoneToAnthropic(param *ConvertOpenAIResponseToAnthropicParams) · 6 unmodified lines
408	blockIndex := param.toolContentBlockIndex(index)	336	blockIndex := param.toolContentBlockIndex(index)
409		337
410	if accumulator.Arguments.Len() > 0 {	338	if accumulator.Arguments.Len() > 0 {
411	inputDelta := map[string]interface{}{	339	inputDeltaJSON := `{"type":"content_block_delta","index":0,"delta":{"type":"input_json_delta","partial_json":""}}`
412	"type": "content_block_delta",	340	inputDeltaJSON, _ = sjson.Set(inputDeltaJSON, "index", blockIndex)
413	"index": blockIndex,	341	inputDeltaJSON, _ = sjson.Set(inputDeltaJSON, "delta.partial_json", util.FixJSON(accumulator.Arguments.String()))
414	"delta": map[string]interface{}{	342	results = append(results, "event: content_block_delta\ndata: "+inputDeltaJSON+"\n\n")
415	"type": "input_json_delta",
416	"partial_json": util.FixJSON(accumulator.Arguments.String()),
417	},
418	}
419	inputDeltaJSON, _ := json.Marshal(inputDelta)
420	results = append(results, "event: content_block_delta\ndata: "+string(inputDeltaJSON)+"\n\n")
421	}	343	}
422		344
423	contentBlockStop := map[string]interface{}{	345	contentBlockStopJSON := `{"type":"content_block_stop","index":0}`
424	"type": "content_block_stop",	346	contentBlockStopJSON, _ = sjson.Set(contentBlockStopJSON, "index", blockIndex)
425	"index": blockIndex,	347	results = append(results, "event: content_block_stop\ndata: "+contentBlockStopJSON+"\n\n")
426	}
427	contentBlockStopJSON, _ := json.Marshal(contentBlockStop)
428	results = append(results, "event: content_block_stop\ndata: "+string(contentBlockStopJSON)+"\n\n")
429	delete(param.ToolCallBlockIndexes, index)	348	delete(param.ToolCallBlockIndexes, index)
430	}	349	}
431	param.ContentBlocksStopped = true	350	param.ContentBlocksStopped = true
@@ -433,16 +352,9 @@ func convertOpenAIDoneToAnthropic(param *ConvertOpenAIResponseToAnthropicParams) · 1 unmodified line
433		352
434	// If we haven't sent message_delta yet (no usage info was received), send it now	353	// If we haven't sent message_delta yet (no usage info was received), send it now
435	if param.FinishReason != "" && !param.MessageDeltaSent {	354	if param.FinishReason != "" && !param.MessageDeltaSent {
436	messageDelta := map[string]interface{}{	355	messageDeltaJSON := `{"type":"message_delta","delta":{"stop_reason":"","stop_sequence":null}}`
437	"type": "message_delta",	356	messageDeltaJSON, _ = sjson.Set(messageDeltaJSON, "delta.stop_reason", mapOpenAIFinishReasonToAnthropic(param.FinishReason))
438	"delta": map[string]interface{}{	357	results = append(results, "event: message_delta\ndata: "+messageDeltaJSON+"\n\n")
439	"stop_reason": mapOpenAIFinishReasonToAnthropic(param.FinishReason),
440	"stop_sequence": nil,
441	},
442	}
443
444	messageDeltaJSON, _ := json.Marshal(messageDelta)
445	results = append(results, "event: message_delta\ndata: "+string(messageDeltaJSON)+"\n\n")
446	param.MessageDeltaSent = true	358	param.MessageDeltaSent = true
447	}	359	}
448		360
@@ -455,105 +367,73 @@ func convertOpenAIDoneToAnthropic(param *ConvertOpenAIResponseToAnthropicParams) · 6 unmodified lines
455	func convertOpenAINonStreamingToAnthropic(rawJSON []byte) []string {	367	func convertOpenAINonStreamingToAnthropic(rawJSON []byte) []string {
456	root := gjson.ParseBytes(rawJSON)	368	root := gjson.ParseBytes(rawJSON)
457		369
458	// Build Anthropic response	370	out := `{"id":"","type":"message","role":"assistant","model":"","content":[],"stop_reason":null,"stop_sequence":null,"usage":{"input_tokens":0,"output_tokens":0}}`
459	response := map[string]interface{}{	371	out, _ = sjson.Set(out, "id", root.Get("id").String())
460	"id": root.Get("id").String(),	372	out, _ = sjson.Set(out, "model", root.Get("model").String())
461	"type": "message",
462	"role": "assistant",
463	"model": root.Get("model").String(),
464	"content": []interface{}{},
465	"stop_reason": nil,
466	"stop_sequence": nil,
467	"usage": map[string]interface{}{
468	"input_tokens": 0,
469	"output_tokens": 0,
470	},
471	}
472		373
473	// Process message content and tool calls	374	// Process message content and tool calls
474	var contentBlocks []interface{}	375	if choices := root.Get("choices"); choices.Exists() && choices.IsArray() && len(choices.Array()) > 0 {
475
476	if choices := root.Get("choices"); choices.Exists() && choices.IsArray() {
477	choice := choices.Array()[0] // Take first choice	376	choice := choices.Array()[0] // Take first choice
478	reasoningNode := choice.Get("message.reasoning_content")
479	allReasoning := collectOpenAIReasoningTexts(reasoningNode)
480		377
481	for _, reasoningText := range allReasoning {	378	reasoningNode := choice.Get("message.reasoning_content")
		379	for _, reasoningText := range collectOpenAIReasoningTexts(reasoningNode) {
482	if reasoningText == "" {	380	if reasoningText == "" {
483	continue	381	continue
484	}	382	}
485	contentBlocks = append(contentBlocks, map[string]interface{}{	383	block := `{"type":"thinking","thinking":""}`
486	"type": "thinking",	384	block, _ = sjson.Set(block, "thinking", reasoningText)
487	"thinking": reasoningText,	385	out, _ = sjson.SetRaw(out, "content.-1", block)
488	})
489	}	386	}
490		387
491	// Handle text content	388	// Handle text content
492	if content := choice.Get("message.content"); content.Exists() && content.String() != "" {	389	if content := choice.Get("message.content"); content.Exists() && content.String() != "" {
493	textBlock := map[string]interface{}{	390	block := `{"type":"text","text":""}`
494	"type": "text",	391	block, _ = sjson.Set(block, "text", content.String())
495	"text": content.String(),	392	out, _ = sjson.SetRaw(out, "content.-1", block)
496	}
497	contentBlocks = append(contentBlocks, textBlock)
498	}	393	}
499		394
500	// Handle tool calls	395	// Handle tool calls
501	if toolCalls := choice.Get("message.tool_calls"); toolCalls.Exists() && toolCalls.IsArray() {	396	if toolCalls := choice.Get("message.tool_calls"); toolCalls.Exists() && toolCalls.IsArray() {
502	toolCalls.ForEach(func(_, toolCall gjson.Result) bool {	397	toolCalls.ForEach(func(_, toolCall gjson.Result) bool {
503	toolUseBlock := map[string]interface{}{	398	toolUseBlock := `{"type":"tool_use","id":"","name":"","input":{}}`
504	"type": "tool_use",	399	toolUseBlock, _ = sjson.Set(toolUseBlock, "id", toolCall.Get("id").String())
505	"id": toolCall.Get("id").String(),	400	toolUseBlock, _ = sjson.Set(toolUseBlock, "name", toolCall.Get("function.name").String())
506	"name": toolCall.Get("function.name").String(),	401
507	}	402	argsStr := util.FixJSON(toolCall.Get("function.arguments").String())
508		403	if argsStr != "" && gjson.Valid(argsStr) {
509	// Parse arguments	404	argsJSON := gjson.Parse(argsStr)
510	argsStr := toolCall.Get("function.arguments").String()	405	if argsJSON.IsObject() {
511	argsStr = util.FixJSON(argsStr)	406	toolUseBlock, _ = sjson.SetRaw(toolUseBlock, "input", argsJSON.Raw)
512	if argsStr != "" {
513	var args interface{}
514	if err := json.Unmarshal([]byte(argsStr), &args); err == nil {
515	toolUseBlock["input"] = args
516	} else {	407	} else {
517	toolUseBlock["input"] = map[string]interface{}{}	408	toolUseBlock, _ = sjson.SetRaw(toolUseBlock, "input", "{}")
518	}	409	}
519	} else {	410	} else {
520	toolUseBlock["input"] = map[string]interface{}{}	411	toolUseBlock, _ = sjson.SetRaw(toolUseBlock, "input", "{}")
521	}	412	}
522		413
523	contentBlocks = append(contentBlocks, toolUseBlock)	414	out, _ = sjson.SetRaw(out, "content.-1", toolUseBlock)
524	return true	415	return true
525	})	416	})
526	}	417	}
527		418
528	// Set stop reason	419	// Set stop reason
529	if finishReason := choice.Get("finish_reason"); finishReason.Exists() {	420	if finishReason := choice.Get("finish_reason"); finishReason.Exists() {
530	response["stop_reason"] = mapOpenAIFinishReasonToAnthropic(finishReason.String())	421	out, _ = sjson.Set(out, "stop_reason", mapOpenAIFinishReasonToAnthropic(finishReason.String()))
531	}	422	}
532	}	423	}
533		424
534	response["content"] = contentBlocks
535
536	// Set usage information	425	// Set usage information
537	if usage := root.Get("usage"); usage.Exists() {	426	if usage := root.Get("usage"); usage.Exists() {
538	response["usage"] = map[string]interface{}{	427	out, _ = sjson.Set(out, "usage.input_tokens", usage.Get("prompt_tokens").Int())
539	"input_tokens": usage.Get("prompt_tokens").Int(),	428	out, _ = sjson.Set(out, "usage.output_tokens", usage.Get("completion_tokens").Int())
540	"output_tokens": usage.Get("completion_tokens").Int(),	429	reasoningTokens := int64(0)
541	"reasoning_tokens": func() int64 {	430	if v := usage.Get("completion_tokens_details.reasoning_tokens"); v.Exists() {
542	if v := usage.Get("completion_tokens_details.reasoning_tokens"); v.Exists() {	431	reasoningTokens = v.Int()
543	return v.Int()
544	}
545	return 0
546	}(),
547	}
548	} else {
549	response["usage"] = map[string]interface{}{
550	"input_tokens": 0,
551	"output_tokens": 0,
552	}	432	}
		433	out, _ = sjson.Set(out, "usage.reasoning_tokens", reasoningTokens)
553	}	434	}
554		435
555	responseJSON, _ := json.Marshal(response)	436	return []string{out}
556	return []string{string(responseJSON)}
557	}	437	}
558		438
559	// mapOpenAIFinishReasonToAnthropic maps OpenAI finish reasons to Anthropic equivalents	439	// mapOpenAIFinishReasonToAnthropic maps OpenAI finish reasons to Anthropic equivalents
@@ -620,12 +500,9 @@ func stopThinkingContentBlock(param *ConvertOpenAIResponseToAnthropicParams, res · 60 unmodified lines
620	if !param.ThinkingContentBlockStarted {	500	if !param.ThinkingContentBlockStarted {
621	return	501	return
622	}	502	}
623	contentBlockStop := map[string]interface{}{	503	contentBlockStopJSON := `{"type":"content_block_stop","index":0}`
624	"type": "content_block_stop",	504	contentBlockStopJSON, _ = sjson.Set(contentBlockStopJSON, "index", param.ThinkingContentBlockIndex)
625	"index": param.ThinkingContentBlockIndex,	505	results = append(results, "event: content_block_stop\ndata: "+contentBlockStopJSON+"\n\n")
626	}
627	contentBlockStopJSON, _ := json.Marshal(contentBlockStop)
628	results = append(results, "event: content_block_stop\ndata: "+string(contentBlockStopJSON)+"\n\n")
629	param.ThinkingContentBlockStarted = false	506	param.ThinkingContentBlockStarted = false
630	param.ThinkingContentBlockIndex = -1	507	param.ThinkingContentBlockIndex = -1
631	}	508	}
@@ -642,12 +519,9 @@ func stopTextContentBlock(param *ConvertOpenAIResponseToAnthropicParams, results · 10 unmodified lines
642	if !param.TextContentBlockStarted {	519	if !param.TextContentBlockStarted {
643	return	520	return
644	}	521	}
645	contentBlockStop := map[string]interface{}{	522	contentBlockStopJSON := `{"type":"content_block_stop","index":0}`
646	"type": "content_block_stop",	523	contentBlockStopJSON, _ = sjson.Set(contentBlockStopJSON, "index", param.TextContentBlockIndex)
647	"index": param.TextContentBlockIndex,	524	results = append(results, "event: content_block_stop\ndata: "+contentBlockStopJSON+"\n\n")
648	}
649	contentBlockStopJSON, _ := json.Marshal(contentBlockStop)
650	results = append(results, "event: content_block_stop\ndata: "+string(contentBlockStopJSON)+"\n\n")
651	param.TextContentBlockStarted = false	525	param.TextContentBlockStarted = false
652	param.TextContentBlockIndex = -1	526	param.TextContentBlockIndex = -1
653	}	527	}
@@ -667,29 +541,19 @@ func ConvertOpenAIResponseToClaudeNonStream(_ context.Context, _ string, origina · 13 unmodified lines
667	_ = requestRawJSON	541	_ = requestRawJSON
668		542
669	root := gjson.ParseBytes(rawJSON)	543	root := gjson.ParseBytes(rawJSON)
		544	out := `{"id":"","type":"message","role":"assistant","model":"","content":[],"stop_reason":null,"stop_sequence":null,"usage":{"input_tokens":0,"output_tokens":0}}`
		545	out, _ = sjson.Set(out, "id", root.Get("id").String())
		546	out, _ = sjson.Set(out, "model", root.Get("model").String())
670		547
671	response := map[string]interface{}{
672	"id": root.Get("id").String(),
673	"type": "message",
674	"role": "assistant",
675	"model": root.Get("model").String(),
676	"content": []interface{}{},
677	"stop_reason": nil,
678	"stop_sequence": nil,
679	"usage": map[string]interface{}{
680	"input_tokens": 0,
681	"output_tokens": 0,
682	},
683	}
684
685	contentBlocks := make([]interface{}, 0)
686	hasToolCall := false	548	hasToolCall := false
		549	stopReasonSet := false
687		550
688	if choices := root.Get("choices"); choices.Exists() && choices.IsArray() && len(choices.Array()) > 0 {	551	if choices := root.Get("choices"); choices.Exists() && choices.IsArray() && len(choices.Array()) > 0 {
689	choice := choices.Array()[0]	552	choice := choices.Array()[0]
690		553
691	if finishReason := choice.Get("finish_reason"); finishReason.Exists() {	554	if finishReason := choice.Get("finish_reason"); finishReason.Exists() {
692	response["stop_reason"] = mapOpenAIFinishReasonToAnthropic(finishReason.String())	555	out, _ = sjson.Set(out, "stop_reason", mapOpenAIFinishReasonToAnthropic(finishReason.String()))
		556	stopReasonSet = true
693	}	557	}
694		558
695	if message := choice.Get("message"); message.Exists() {	559	if message := choice.Get("message"); message.Exists() {
@@ -702,10 +566,9 @@ func ConvertOpenAIResponseToClaudeNonStream(_ context.Context, _ string, origina · 6 unmodified lines
702	if textBuilder.Len() == 0 {	566	if textBuilder.Len() == 0 {
703	return	567	return
704	}	568	}
705	contentBlocks = append(contentBlocks, map[string]interface{}{	569	block := `{"type":"text","text":""}`
706	"type": "text",	570	block, _ = sjson.Set(block, "text", textBuilder.String())
707	"text": textBuilder.String(),	571	out, _ = sjson.SetRaw(out, "content.-1", block)
708	})
709	textBuilder.Reset()	572	textBuilder.Reset()
710	}	573	}
711		574
@@ -713,16 +576,14 @@ func ConvertOpenAIResponseToClaudeNonStream(_ context.Context, _ string, origina · 1 unmodified line
713	if thinkingBuilder.Len() == 0 {	576	if thinkingBuilder.Len() == 0 {
714	return	577	return
715	}	578	}
716	contentBlocks = append(contentBlocks, map[string]interface{}{	579	block := `{"type":"thinking","thinking":""}`
717	"type": "thinking",	580	block, _ = sjson.Set(block, "thinking", thinkingBuilder.String())
718	"thinking": thinkingBuilder.String(),	581	out, _ = sjson.SetRaw(out, "content.-1", block)
719	})
720	thinkingBuilder.Reset()	582	thinkingBuilder.Reset()
721	}	583	}
722		584
723	for _, item := range contentResult.Array() {	585	for _, item := range contentResult.Array() {
724	typeStr := item.Get("type").String()	586	switch item.Get("type").String() {
725	switch typeStr {
726	case "text":	587	case "text":
727	flushThinking()	588	flushThinking()
728	textBuilder.WriteString(item.Get("text").String())	589	textBuilder.WriteString(item.Get("text").String())
@@ -733,25 +594,23 @@ func ConvertOpenAIResponseToClaudeNonStream(_ context.Context, _ string, origina · 4 unmodified lines
733	if toolCalls.IsArray() {	594	if toolCalls.IsArray() {
734	toolCalls.ForEach(func(_, tc gjson.Result) bool {	595	toolCalls.ForEach(func(_, tc gjson.Result) bool {
735	hasToolCall = true	596	hasToolCall = true
736	toolUse := map[string]interface{}{	597	toolUse := `{"type":"tool_use","id":"","name":"","input":{}}`
737	"type": "tool_use",	598	toolUse, _ = sjson.Set(toolUse, "id", tc.Get("id").String())
738	"id": tc.Get("id").String(),	599	toolUse, _ = sjson.Set(toolUse, "name", tc.Get("function.name").String())
739	"name": tc.Get("function.name").String(),
740	}
741		600
742	argsStr := util.FixJSON(tc.Get("function.arguments").String())	601	argsStr := util.FixJSON(tc.Get("function.arguments").String())
743	if argsStr != "" {	602	if argsStr != "" && gjson.Valid(argsStr) {
744	var parsed interface{}	603	argsJSON := gjson.Parse(argsStr)
745	if err := json.Unmarshal([]byte(argsStr), &parsed); err == nil {	604	if argsJSON.IsObject() {
746	toolUse["input"] = parsed	605	toolUse, _ = sjson.SetRaw(toolUse, "input", argsJSON.Raw)
747	} else {	606	} else {
748	toolUse["input"] = map[string]interface{}{}	607	toolUse, _ = sjson.SetRaw(toolUse, "input", "{}")
749	}	608	}
750	} else {	609	} else {
751	toolUse["input"] = map[string]interface{}{}	610	toolUse, _ = sjson.SetRaw(toolUse, "input", "{}")
752	}	611	}
753		612
754	contentBlocks = append(contentBlocks, toolUse)	613	out, _ = sjson.SetRaw(out, "content.-1", toolUse)
755	return true	614	return true
756	})	615	})
757	}	616	}
@@ -771,10 +630,9 @@ func ConvertOpenAIResponseToClaudeNonStream(_ context.Context, _ string, origina · 13 unmodified lines
771	} else if contentResult.Type == gjson.String {	630	} else if contentResult.Type == gjson.String {
772	textContent := contentResult.String()	631	textContent := contentResult.String()
773	if textContent != "" {	632	if textContent != "" {
774	contentBlocks = append(contentBlocks, map[string]interface{}{	633	block := `{"type":"text","text":""}`
775	"type": "text",	634	block, _ = sjson.Set(block, "text", textContent)
776	"text": textContent,	635	out, _ = sjson.SetRaw(out, "content.-1", block)
777	})
778	}	636	}
779	}	637	}
780	}	638	}
@@ -784,81 +642,52 @@ func ConvertOpenAIResponseToClaudeNonStream(_ context.Context, _ string, origina · 3 unmodified lines
784	if reasoningText == "" {	642	if reasoningText == "" {
785	continue	643	continue
786	}	644	}
787	contentBlocks = append(contentBlocks, map[string]interface{}{	645	block := `{"type":"thinking","thinking":""}`
788	"type": "thinking",	646	block, _ = sjson.Set(block, "thinking", reasoningText)
789	"thinking": reasoningText,	647	out, _ = sjson.SetRaw(out, "content.-1", block)
790	})
791	}	648	}
792	}	649	}
793		650
794	if toolCalls := message.Get("tool_calls"); toolCalls.Exists() && toolCalls.IsArray() {	651	if toolCalls := message.Get("tool_calls"); toolCalls.Exists() && toolCalls.IsArray() {
795	toolCalls.ForEach(func(_, toolCall gjson.Result) bool {	652	toolCalls.ForEach(func(_, toolCall gjson.Result) bool {
796	hasToolCall = true	653	hasToolCall = true
797	toolUseBlock := map[string]interface{}{	654	toolUseBlock := `{"type":"tool_use","id":"","name":"","input":{}}`
798	"type": "tool_use",	655	toolUseBlock, _ = sjson.Set(toolUseBlock, "id", toolCall.Get("id").String())
799	"id": toolCall.Get("id").String(),	656	toolUseBlock, _ = sjson.Set(toolUseBlock, "name", toolCall.Get("function.name").String())
800	"name": toolCall.Get("function.name").String(),	657
801	}	658	argsStr := util.FixJSON(toolCall.Get("function.arguments").String())
802		659	if argsStr != "" && gjson.Valid(argsStr) {
803	argsStr := toolCall.Get("function.arguments").String()	660	argsJSON := gjson.Parse(argsStr)
804	argsStr = util.FixJSON(argsStr)	661	if argsJSON.IsObject() {
805	if argsStr != "" {	662	toolUseBlock, _ = sjson.SetRaw(toolUseBlock, "input", argsJSON.Raw)
806	var args interface{}
807	if err := json.Unmarshal([]byte(argsStr), &args); err == nil {
808	toolUseBlock["input"] = args
809	} else {	663	} else {
810	toolUseBlock["input"] = map[string]interface{}{}	664	toolUseBlock, _ = sjson.SetRaw(toolUseBlock, "input", "{}")
811	}	665	}
812	} else {	666	} else {
813	toolUseBlock["input"] = map[string]interface{}{}	667	toolUseBlock, _ = sjson.SetRaw(toolUseBlock, "input", "{}")
814	}	668	}
815		669
816	contentBlocks = append(contentBlocks, toolUseBlock)	670	out, _ = sjson.SetRaw(out, "content.-1", toolUseBlock)
817	return true	671	return true
818	})	672	})
819	}	673	}
820	}	674	}
821	}	675	}
822		676
823	response["content"] = contentBlocks
824
825	if respUsage := root.Get("usage"); respUsage.Exists() {	677	if respUsage := root.Get("usage"); respUsage.Exists() {
826	usageJSON := `{}`	678	out, _ = sjson.Set(out, "usage.input_tokens", respUsage.Get("prompt_tokens").Int())
827	usageJSON, _ = sjson.Set(usageJSON, "input_tokens", respUsage.Get("prompt_tokens").Int())	679	out, _ = sjson.Set(out, "usage.output_tokens", respUsage.Get("completion_tokens").Int())
828	usageJSON, _ = sjson.Set(usageJSON, "output_tokens", respUsage.Get("completion_tokens").Int())
829	parsedUsage := gjson.Parse(usageJSON).Value().(map[string]interface{})
830	response["usage"] = parsedUsage
831	} else {
832	response["usage"] = `{"input_tokens":0,"output_tokens":0}`
833	}	680	}
834		681
835	if response["stop_reason"] == nil {	682	if !stopReasonSet {
836	if hasToolCall {	683	if hasToolCall {
837	response["stop_reason"] = "tool_use"	684	out, _ = sjson.Set(out, "stop_reason", "tool_use")
838	} else {	685	} else {
839	response["stop_reason"] = "end_turn"	686	out, _ = sjson.Set(out, "stop_reason", "end_turn")
840	}	687	}
841	}	688	}
842		689
843	if !hasToolCall {	690	return out
844	if toolBlocks := response["content"].([]interface{}); len(toolBlocks) > 0 {
845	for _, block := range toolBlocks {
846	if m, ok := block.(map[string]interface{}); ok && m["type"] == "tool_use" {
847	hasToolCall = true
848	break
849	}
850	}
851	}
852	if hasToolCall {
853	response["stop_reason"] = "tool_use"
854	}
855	}
856
857	responseJSON, err := json.Marshal(response)
858	if err != nil {
859	return ""
860	}
861	return string(responseJSON)
862	}	691	}
863		692
864	func ClaudeTokenCount(ctx context.Context, count int64) string {	693	func ClaudeTokenCount(ctx context.Context, count int64) string {

internal/translator/openai/gemini/openai_gemini_request.go+53−202

 import (
 	"bytes"
 	"crypto/rand"
-	"encoding/json"
 	"fmt"
 	"math/big"
 	"strings"
 	out, _ = sjson.Set(out, "stream", stream)
 	// Process contents (Gemini messages) -> OpenAI messages
-	var openAIMessages []interface{}
 	var toolCallIDs []string // Track tool call IDs for matching with tool results
 	// System instruction -> OpenAI system message
 	}
 	if systemInstruction.Exists() {
 		parts := systemInstruction.Get("parts")
-		msg := map[string]interface{}{
+		msg := `{"role":"system","content":[]}`
-			"role":    "system",
+		hasContent := false
-			"content": []interface{}{},
-		}
-		var aggregatedParts []interface{}
 		if parts.Exists() && parts.IsArray() {
 			parts.ForEach(func(_, part gjson.Result) bool {
 				// Handle text parts
 				if text := part.Get("text"); text.Exists() {
-					formattedText := text.String()
+					contentPart := `{"type":"text","text":""}`
-					aggregatedParts = append(aggregatedParts, map[string]interface{}{
+					contentPart, _ = sjson.Set(contentPart, "text", text.String())
-						"type": "text",
+					msg, _ = sjson.SetRaw(msg, "content.-1", contentPart)
-						"text": formattedText,
+					hasContent = true
-					})
 				}
 				// Handle inline data (e.g., images)
 					data := inlineData.Get("data").String()
 					imageURL := fmt.Sprintf("data:%s;base64,%s", mimeType, data)
-					aggregatedParts = append(aggregatedParts, map[string]interface{}{
+					contentPart := `{"type":"image_url","image_url":{"url":""}}`
-						"type": "image_url",
+					contentPart, _ = sjson.Set(contentPart, "image_url.url", imageURL)
-						"image_url": map[string]interface{}{
+					msg, _ = sjson.SetRaw(msg, "content.-1", contentPart)
-							"url": imageURL,
+					hasContent = true
-						},
-					})
 				}
 				return true
 			})
 		}
-		if len(aggregatedParts) > 0 {
+		if hasContent {
-			msg["content"] = aggregatedParts
+			out, _ = sjson.SetRaw(out, "messages.-1", msg)
-			openAIMessages = append(openAIMessages, msg)
 		}
 	}
 				role = "assistant"
 			}
-			// Create OpenAI message
+			msg := `{"role":"","content":""}`
-			msg := map[string]interface{}{
+			msg, _ = sjson.Set(msg, "role", role)
-				"role":    role,
-				"content": "",
-			}
 			var textBuilder strings.Builder
-			var aggregatedParts []interface{}
+			contentWrapper := `{"arr":[]}`
+			contentPartsCount := 0
 			onlyTextContent := true
-			var toolCalls []interface{}
+			toolCallsWrapper := `{"arr":[]}`
+			toolCallsCount := 0
 			if parts.Exists() && parts.IsArray() {
 				parts.ForEach(func(_, part gjson.Result) bool {
 					if text := part.Get("text"); text.Exists() {
 						formattedText := text.String()
 						textBuilder.WriteString(formattedText)
-						aggregatedParts = append(aggregatedParts, map[string]interface{}{
+						contentPart := `{"type":"text","text":""}`
-							"type": "text",
+						contentPart, _ = sjson.Set(contentPart, "text", formattedText)
-							"text": formattedText,
+						contentWrapper, _ = sjson.SetRaw(contentWrapper, "arr.-1", contentPart)
-						})
+						contentPartsCount++
 					}
 					// Handle inline data (e.g., images)
 						data := inlineData.Get("data").String()
 						imageURL := fmt.Sprintf("data:%s;base64,%s", mimeType, data)
-						aggregatedParts = append(aggregatedParts, map[string]interface{}{
+						contentPart := `{"type":"image_url","image_url":{"url":""}}`
-							"type": "image_url",
+						contentPart, _ = sjson.Set(contentPart, "image_url.url", imageURL)
-							"image_url": map[string]interface{}{
+						contentWrapper, _ = sjson.SetRaw(contentWrapper, "arr.-1", contentPart)
-								"url": imageURL,
+						contentPartsCount++
-							},
-						})
 					}
 					// Handle function calls (Gemini) -> tool calls (OpenAI)
 						toolCallID := genToolCallID()
 						toolCallIDs = append(toolCallIDs, toolCallID)
-						toolCall := map[string]interface{}{
+						toolCall := `{"id":"","type":"function","function":{"name":"","arguments":""}}`
-							"id":   toolCallID,
+						toolCall, _ = sjson.Set(toolCall, "id", toolCallID)
-							"type": "function",
+						toolCall, _ = sjson.Set(toolCall, "function.name", functionCall.Get("name").String())
-							"function": map[string]interface{}{
-								"name": functionCall.Get("name").String(),
-							},
-						}
 						// Convert args to arguments JSON string
 						if args := functionCall.Get("args"); args.Exists() {
-							argsJSON, _ := json.Marshal(args.Value())
+							toolCall, _ = sjson.Set(toolCall, "function.arguments", args.Raw)
-							toolCall["function"].(map[string]interface{})["arguments"] = string(argsJSON)
 						} else {
-							toolCall["function"].(map[string]interface{})["arguments"] = "{}"
+							toolCall, _ = sjson.Set(toolCall, "function.arguments", "{}")
 						}
-						toolCalls = append(toolCalls, toolCall)
+						toolCallsWrapper, _ = sjson.SetRaw(toolCallsWrapper, "arr.-1", toolCall)
+						toolCallsCount++
 					}
 					// Handle function responses (Gemini) -> tool role messages (OpenAI)
 					if functionResponse := part.Get("functionResponse"); functionResponse.Exists() {
 						// Create tool message for function response
-						toolMsg := map[string]interface{}{
+						toolMsg := `{"role":"tool","tool_call_id":"","content":""}`
-							"role":         "tool",
-							"tool_call_id": "", // Will be set based on context
-							"content":      "",
-						}
 						// Convert response.content to JSON string
 						if response := functionResponse.Get("response"); response.Exists() {
-							if content = response.Get("content"); content.Exists() {
+							if contentField := response.Get("content"); contentField.Exists() {
-								// Use the content field from the response
+								toolMsg, _ = sjson.Set(toolMsg, "content", contentField.Raw)
-								contentJSON, _ := json.Marshal(content.Value())
-								toolMsg["content"] = string(contentJSON)
 							} else {
-								// Fallback to entire response
+								toolMsg, _ = sjson.Set(toolMsg, "content", response.Raw)
-								responseJSON, _ := json.Marshal(response.Value())
-								toolMsg["content"] = string(responseJSON)
 							}
 						}
 						if len(toolCallIDs) > 0 {
 							// Use the last tool call ID (simple matching by function name)
 							// In a real implementation, you might want more sophisticated matching
-							toolMsg["tool_call_id"] = toolCallIDs[len(toolCallIDs)-1]
+							toolMsg, _ = sjson.Set(toolMsg, "tool_call_id", toolCallIDs[len(toolCallIDs)-1])
 						} else {
 							// Generate a tool call ID if none available
-							toolMsg["tool_call_id"] = genToolCallID()
+							toolMsg, _ = sjson.Set(toolMsg, "tool_call_id", genToolCallID())
 						}
-						openAIMessages = append(openAIMessages, toolMsg)
+						out, _ = sjson.SetRaw(out, "messages.-1", toolMsg)
 					}
 					return true
 			}
 			// Set content
-			if len(aggregatedParts) > 0 {
+			if contentPartsCount > 0 {
 				if onlyTextContent {
-					msg["content"] = textBuilder.String()
+					msg, _ = sjson.Set(msg, "content", textBuilder.String())
 				} else {
-					msg["content"] = aggregatedParts
+					msg, _ = sjson.SetRaw(msg, "content", gjson.Get(contentWrapper, "arr").Raw)
 				}
 			}
 			// Set tool calls if any
-			if len(toolCalls) > 0 {
+			if toolCallsCount > 0 {
-				msg["tool_calls"] = toolCalls
+				msg, _ = sjson.SetRaw(msg, "tool_calls", gjson.Get(toolCallsWrapper, "arr").Raw)
 			}
-			openAIMessages = append(openAIMessages, msg)
+			out, _ = sjson.SetRaw(out, "messages.-1", msg)
-			// switch role {
-			// case "user", "model":
-			// 	// Convert role: model -> assistant
-			// 	if role == "model" {
-			// 		role = "assistant"
-			// 	}
-			//
-			// 	// Create OpenAI message
-			// 	msg := map[string]interface{}{
-			// 		"role":    role,
-			// 		"content": "",
-			// 	}
-			//
-			// 	var contentParts []string
-			// 	var toolCalls []interface{}
-			//
-			// 	if parts.Exists() && parts.IsArray() {
-			// 		parts.ForEach(func(_, part gjson.Result) bool {
-			// 			// Handle text parts
-			// 			if text := part.Get("text"); text.Exists() {
-			// 				contentParts = append(contentParts, text.String())
-			// 			}
-			//
-			// 			// Handle function calls (Gemini) -> tool calls (OpenAI)
-			// 			if functionCall := part.Get("functionCall"); functionCall.Exists() {
-			// 				toolCallID := genToolCallID()
-			// 				toolCallIDs = append(toolCallIDs, toolCallID)
-			//
-			// 				toolCall := map[string]interface{}{
-			// 					"id":   toolCallID,
-			// 					"type": "function",
-			// 					"function": map[string]interface{}{
-			// 						"name": functionCall.Get("name").String(),
-			// 					},
-			// 				}
-			//
-			// 				// Convert args to arguments JSON string
-			// 				if args := functionCall.Get("args"); args.Exists() {
-			// 					argsJSON, _ := json.Marshal(args.Value())
-			// 					toolCall["function"].(map[string]interface{})["arguments"] = string(argsJSON)
-			// 				} else {
-			// 					toolCall["function"].(map[string]interface{})["arguments"] = "{}"
-			// 				}
-			//
-			// 				toolCalls = append(toolCalls, toolCall)
-			// 			}
-			//
-			// 			return true
-			// 		})
-			// 	}
-			//
-			// 	// Set content
-			// 	if len(contentParts) > 0 {
-			// 		msg["content"] = strings.Join(contentParts, "")
-			// 	}
-			//
-			// 	// Set tool calls if any
-			// 	if len(toolCalls) > 0 {
-			// 		msg["tool_calls"] = toolCalls
-			// 	}
-			//
-			// 	openAIMessages = append(openAIMessages, msg)
-			//
-			// case "function":
-			// 	// Handle Gemini function role -> OpenAI tool role
-			// 	if parts.Exists() && parts.IsArray() {
-			// 		parts.ForEach(func(_, part gjson.Result) bool {
-			// 			// Handle function responses (Gemini) -> tool role messages (OpenAI)
-			// 			if functionResponse := part.Get("functionResponse"); functionResponse.Exists() {
-			// 				// Create tool message for function response
-			// 				toolMsg := map[string]interface{}{
-			// 					"role":         "tool",
-			// 					"tool_call_id": "", // Will be set based on context
-			// 					"content":      "",
-			// 				}
-			//
-			// 				// Convert response.content to JSON string
-			// 				if response := functionResponse.Get("response"); response.Exists() {
-			// 					if content = response.Get("content"); content.Exists() {
-			// 						// Use the content field from the response
-			// 						contentJSON, _ := json.Marshal(content.Value())
-			// 						toolMsg["content"] = string(contentJSON)
-			// 					} else {
-			// 						// Fallback to entire response
-			// 						responseJSON, _ := json.Marshal(response.Value())
-			// 						toolMsg["content"] = string(responseJSON)
-			// 					}
-			// 				}
-			//
-			// 				// Try to match with previous tool call ID
-			// 				_ = functionResponse.Get("name").String() // functionName not used for now
-			// 				if len(toolCallIDs) > 0 {
-			// 					// Use the last tool call ID (simple matching by function name)
-			// 					// In a real implementation, you might want more sophisticated matching
-			// 					toolMsg["tool_call_id"] = toolCallIDs[len(toolCallIDs)-1]
-			// 				} else {
-			// 					// Generate a tool call ID if none available
-			// 					toolMsg["tool_call_id"] = genToolCallID()
-			// 				}
-			//
-			// 				openAIMessages = append(openAIMessages, toolMsg)
-			// 			}
-			//
-			// 			return true
-			// 		})
-			// 	}
-			// }
 			return true
 		})
 	}
-	// Set messages
-	if len(openAIMessages) > 0 {
-		messagesJSON, _ := json.Marshal(openAIMessages)
-		out, _ = sjson.SetRaw(out, "messages", string(messagesJSON))
-	}
 	// Tools mapping: Gemini tools -> OpenAI tools
 	if tools := root.Get("tools"); tools.Exists() && tools.IsArray() {
-		var openAITools []interface{}
 		tools.ForEach(func(_, tool gjson.Result) bool {
 			if functionDeclarations := tool.Get("functionDeclarations"); functionDeclarations.Exists() && functionDeclarations.IsArray() {
 				functionDeclarations.ForEach(func(_, funcDecl gjson.Result) bool {
-					openAITool := map[string]interface{}{
+					openAITool := `{"type":"function","function":{"name":"","description":""}}`
-						"type": "function",
+					openAITool, _ = sjson.Set(openAITool, "function.name", funcDecl.Get("name").String())
-						"function": map[string]interface{}{
+					openAITool, _ = sjson.Set(openAITool, "function.description", funcDecl.Get("description").String())
-							"name":        funcDecl.Get("name").String(),
-							"description": funcDecl.Get("description").String(),
-						},
-					}
 					// Convert parameters schema
 					if parameters := funcDecl.Get("parameters"); parameters.Exists() {
-						openAITool["function"].(map[string]interface{})["parameters"] = parameters.Value()
+						openAITool, _ = sjson.SetRaw(openAITool, "function.parameters", parameters.Raw)
-					} else if parameters = funcDecl.Get("parametersJsonSchema"); parameters.Exists() {
+					} else if parameters := funcDecl.Get("parametersJsonSchema"); parameters.Exists() {
-						openAITool["function"].(map[string]interface{})["parameters"] = parameters.Value()
+						openAITool, _ = sjson.SetRaw(openAITool, "function.parameters", parameters.Raw)
 					}
-					openAITools = append(openAITools, openAITool)
+					out, _ = sjson.SetRaw(out, "tools.-1", openAITool)
 					return true
 				})
 			}
 			return true
 		})
-		if len(openAITools) > 0 {
-			toolsJSON, _ := json.Marshal(openAITools)
-			out, _ = sjson.SetRaw(out, "tools", string(toolsJSON))
-		}
 	}
 	// Tool choice mapping (Gemini doesn't have direct equivalent, but we can handle it)

internal/translator/openai/gemini/openai_gemini_response.go+68−107

@@ -8,7 +8,6 @@ package gemini · 7 unmodified lines
8	import (	8	import (
9	"bytes"	9	"bytes"
10	"context"	10	"context"
11	"encoding/json"
12	"fmt"	11	"fmt"
13	"strconv"	12	"strconv"
14	"strings"	13	"strings"
@@ -84,15 +83,12 @@ func ConvertOpenAIResponseToGemini(_ context.Context, _ string, originalRequestR · 69 unmodified lines
84	template, _ = sjson.Set(template, "model", model.String())	83	template, _ = sjson.Set(template, "model", model.String())
85	}	84	}
86		85
87	usageObj := map[string]interface{}{	86	template, _ = sjson.Set(template, "usageMetadata.promptTokenCount", usage.Get("prompt_tokens").Int())
88	"promptTokenCount": usage.Get("prompt_tokens").Int(),	87	template, _ = sjson.Set(template, "usageMetadata.candidatesTokenCount", usage.Get("completion_tokens").Int())
89	"candidatesTokenCount": usage.Get("completion_tokens").Int(),	88	template, _ = sjson.Set(template, "usageMetadata.totalTokenCount", usage.Get("total_tokens").Int())
90	"totalTokenCount": usage.Get("total_tokens").Int(),
91	}
92	if reasoningTokens := reasoningTokensFromUsage(usage); reasoningTokens > 0 {	89	if reasoningTokens := reasoningTokensFromUsage(usage); reasoningTokens > 0 {
93	usageObj["thoughtsTokenCount"] = reasoningTokens	90	template, _ = sjson.Set(template, "usageMetadata.thoughtsTokenCount", reasoningTokens)
94	}	91	}
95	template, _ = sjson.Set(template, "usageMetadata", usageObj)
96	return []string{template}	92	return []string{template}
97	}	93	}
98	return []string{}	94	return []string{}
@@ -133,13 +129,8 @@ func ConvertOpenAIResponseToGemini(_ context.Context, _ string, originalRequestR · 34 unmodified lines
133	continue	129	continue
134	}	130	}
135	reasoningTemplate := baseTemplate	131	reasoningTemplate := baseTemplate
136	parts := []interface{}{	132	reasoningTemplate, _ = sjson.Set(reasoningTemplate, "candidates.0.content.parts.0.thought", true)
137	map[string]interface{}{	133	reasoningTemplate, _ = sjson.Set(reasoningTemplate, "candidates.0.content.parts.0.text", reasoningText)
138	"thought": true,
139	"text": reasoningText,
140	},
141	}
142	reasoningTemplate, _ = sjson.Set(reasoningTemplate, "candidates.0.content.parts", parts)
143	chunkOutputs = append(chunkOutputs, reasoningTemplate)	134	chunkOutputs = append(chunkOutputs, reasoningTemplate)
144	}	135	}
145	}	136	}
@@ -150,13 +141,8 @@ func ConvertOpenAIResponseToGemini(_ context.Context, _ string, originalRequestR · 4 unmodified lines
150	(param).(ConvertOpenAIResponseToGeminiParams).ContentAccumulator.WriteString(contentText)	141	(param).(ConvertOpenAIResponseToGeminiParams).ContentAccumulator.WriteString(contentText)
151		142
152	// Create text part for this delta	143	// Create text part for this delta
153	parts := []interface{}{
154	map[string]interface{}{
155	"text": contentText,
156	},
157	}
158	contentTemplate := baseTemplate	144	contentTemplate := baseTemplate
159	contentTemplate, _ = sjson.Set(contentTemplate, "candidates.0.content.parts", parts)	145	contentTemplate, _ = sjson.Set(contentTemplate, "candidates.0.content.parts.0.text", contentText)
160	chunkOutputs = append(chunkOutputs, contentTemplate)	146	chunkOutputs = append(chunkOutputs, contentTemplate)
161	}	147	}
162		148
@@ -225,24 +211,13 @@ func ConvertOpenAIResponseToGemini(_ context.Context, _ string, originalRequestR · 62 unmodified lines
225		211
226	// If we have accumulated tool calls, output them now	212	// If we have accumulated tool calls, output them now
227	if len((param).(ConvertOpenAIResponseToGeminiParams).ToolCallsAccumulator) > 0 {	213	if len((param).(ConvertOpenAIResponseToGeminiParams).ToolCallsAccumulator) > 0 {
228	var parts []interface{}	214	partIndex := 0
229	for _, accumulator := range (param).(ConvertOpenAIResponseToGeminiParams).ToolCallsAccumulator {	215	for _, accumulator := range (param).(ConvertOpenAIResponseToGeminiParams).ToolCallsAccumulator {
230	argsStr := accumulator.Arguments.String()	216	namePath := fmt.Sprintf("candidates.0.content.parts.%d.functionCall.name", partIndex)
231	var argsMap map[string]interface{}	217	argsPath := fmt.Sprintf("candidates.0.content.parts.%d.functionCall.args", partIndex)
232		218	template, _ = sjson.Set(template, namePath, accumulator.Name)
233	argsMap = parseArgsToMap(argsStr)	219	template, _ = sjson.SetRaw(template, argsPath, parseArgsToObjectRaw(accumulator.Arguments.String()))
234		220	partIndex++
235	functionCallPart := map[string]interface{}{
236	"functionCall": map[string]interface{}{
237	"name": accumulator.Name,
238	"args": argsMap,
239	},
240	}
241	parts = append(parts, functionCallPart)
242	}
243
244	if len(parts) > 0 {
245	template, _ = sjson.Set(template, "candidates.0.content.parts", parts)
246	}	221	}
247		222
248	// Clear accumulators	223	// Clear accumulators
@@ -255,15 +230,12 @@ func ConvertOpenAIResponseToGemini(_ context.Context, _ string, originalRequestR · 6 unmodified lines
255		230
256	// Handle usage information	231	// Handle usage information
257	if usage := root.Get("usage"); usage.Exists() {	232	if usage := root.Get("usage"); usage.Exists() {
258	usageObj := map[string]interface{}{	233	template, _ = sjson.Set(template, "usageMetadata.promptTokenCount", usage.Get("prompt_tokens").Int())
259	"promptTokenCount": usage.Get("prompt_tokens").Int(),	234	template, _ = sjson.Set(template, "usageMetadata.candidatesTokenCount", usage.Get("completion_tokens").Int())
260	"candidatesTokenCount": usage.Get("completion_tokens").Int(),	235	template, _ = sjson.Set(template, "usageMetadata.totalTokenCount", usage.Get("total_tokens").Int())
261	"totalTokenCount": usage.Get("total_tokens").Int(),
262	}
263	if reasoningTokens := reasoningTokensFromUsage(usage); reasoningTokens > 0 {	236	if reasoningTokens := reasoningTokensFromUsage(usage); reasoningTokens > 0 {
264	usageObj["thoughtsTokenCount"] = reasoningTokens	237	template, _ = sjson.Set(template, "usageMetadata.thoughtsTokenCount", reasoningTokens)
265	}	238	}
266	template, _ = sjson.Set(template, "usageMetadata", usageObj)
267	results = append(results, template)	239	results = append(results, template)
268	return true	240	return true
269	}	241	}
@@ -291,46 +263,54 @@ func mapOpenAIFinishReasonToGemini(openAIReason string) string { · 21 unmodified lines
291	}	263	}
292	}	264	}
293		265
294	// parseArgsToMap safely parses a JSON string of function arguments into a map.	266	// parseArgsToObjectRaw safely parses a JSON string of function arguments into an object JSON string.
295	// It returns an empty map if the input is empty or cannot be parsed as a JSON object.	267	// It returns "{}" if the input is empty or cannot be parsed as a JSON object.
296	func parseArgsToMap(argsStr string) map[string]interface{} {	268	func parseArgsToObjectRaw(argsStr string) string {
297	trimmed := strings.TrimSpace(argsStr)	269	trimmed := strings.TrimSpace(argsStr)
298	if trimmed == "" \|\| trimmed == "{}" {	270	if trimmed == "" \|\| trimmed == "{}" {
299	return map[string]interface{}{}	271	return "{}"
300	}	272	}
301		273
302	// First try strict JSON	274	// First try strict JSON
303	var out map[string]interface{}	275	if gjson.Valid(trimmed) {
304	if errUnmarshal := json.Unmarshal([]byte(trimmed), &out); errUnmarshal == nil {	276	strict := gjson.Parse(trimmed)
305	return out	277	if strict.IsObject() {
		278	return strict.Raw
		279	}
306	}	280	}
307		281
308	// Tolerant parse: handle streams where values are barewords (e.g., 北京, celsius)	282	// Tolerant parse: handle streams where values are barewords (e.g., 北京, celsius)
309	tolerant := tolerantParseJSONMap(trimmed)	283	tolerant := tolerantParseJSONObjectRaw(trimmed)
310	if len(tolerant) > 0 {	284	if tolerant != "{}" {
311	return tolerant	285	return tolerant
312	}	286	}
313		287
314	// Fallback: return empty object when parsing fails	288	// Fallback: return empty object when parsing fails
315	return map[string]interface{}{}	289	return "{}"
316	}	290	}
317		291
318	// tolerantParseJSONMap attempts to parse a JSON-like object string into a map, tolerating	292	func escapeSjsonPathKey(key string) string {
		293	key = strings.ReplaceAll(key, `\`, `\\`)
		294	key = strings.ReplaceAll(key, `.`, `\.`)
		295	return key
		296	}
		297
		298	// tolerantParseJSONObjectRaw attempts to parse a JSON-like object string into a JSON object string, tolerating
319	// bareword values (unquoted strings) commonly seen during streamed tool calls.	299	// bareword values (unquoted strings) commonly seen during streamed tool calls.
320	// Example input: {"location": 北京, "unit": celsius}	300	// Example input: {"location": 北京, "unit": celsius}
321	func tolerantParseJSONMap(s string) map[string]interface{} {	301	func tolerantParseJSONObjectRaw(s string) string {
322	// Ensure we operate within the outermost braces if present	302	// Ensure we operate within the outermost braces if present
323	start := strings.Index(s, "{")	303	start := strings.Index(s, "{")
324	end := strings.LastIndex(s, "}")	304	end := strings.LastIndex(s, "}")
325	if start == -1 \|\| end == -1 \|\| start >= end {	305	if start == -1 \|\| end == -1 \|\| start >= end {
326	return map[string]interface{}{}	306	return "{}"
327	}	307	}
328	content := s[start+1 : end]	308	content := s[start+1 : end]
329		309
330	runes := []rune(content)	310	runes := []rune(content)
331	n := len(runes)	311	n := len(runes)
332	i := 0	312	i := 0
333	result := make(map[string]interface{})	313	result := "{}"
334		314
335	for i < n {	315	for i < n {
336	// Skip whitespace and commas	316	// Skip whitespace and commas
@@ -356,6 +336,7 @@ func tolerantParseJSONMap(s string) map[string]interface{} { · 19 unmodified lines
356	break	336	break
357	}	337	}
358	keyName := jsonStringTokenToRawString(keyToken)	338	keyName := jsonStringTokenToRawString(keyToken)
		339	sjsonKey := escapeSjsonPathKey(keyName)
359	i = nextIdx	340	i = nextIdx
360		341
361	// Skip whitespace	342	// Skip whitespace
@@ -375,17 +356,16 @@ func tolerantParseJSONMap(s string) map[string]interface{} { · 13 unmodified lines
375	}	356	}
376		357
377	// Parse value (string, number, object/array, bareword)	358	// Parse value (string, number, object/array, bareword)
378	var value interface{}
379	switch runes[i] {	359	switch runes[i] {
380	case '"':	360	case '"':
381	// JSON string	361	// JSON string
382	valToken, ni := parseJSONStringRunes(runes, i)	362	valToken, ni := parseJSONStringRunes(runes, i)
383	if ni == -1 {	363	if ni == -1 {
384	// Malformed; treat as empty string	364	// Malformed; treat as empty string
385	value = ""	365	result, _ = sjson.Set(result, sjsonKey, "")
386	i = n	366	i = n
387	} else {	367	} else {
388	value = jsonStringTokenToRawString(valToken)	368	result, _ = sjson.Set(result, sjsonKey, jsonStringTokenToRawString(valToken))
389	i = ni	369	i = ni
390	}	370	}
391	case '{', '[':	371	case '{', '[':
@@ -394,11 +374,10 @@ func tolerantParseJSONMap(s string) map[string]interface{} { · 2 unmodified lines
394	if ni == -1 {	374	if ni == -1 {
395	i = n	375	i = n
396	} else {	376	} else {
397	var anyVal interface{}	377	if gjson.Valid(seg) {
398	if errUnmarshal := json.Unmarshal([]byte(seg), &anyVal); errUnmarshal == nil {	378	result, _ = sjson.SetRaw(result, sjsonKey, seg)
399	value = anyVal
400	} else {	379	} else {
401	value = seg	380	result, _ = sjson.Set(result, sjsonKey, seg)
402	}	381	}
403	i = ni	382	i = ni
404	}	383	}
@@ -411,21 +390,19 @@ func tolerantParseJSONMap(s string) map[string]interface{} { · 6 unmodified lines
411	token := strings.TrimSpace(string(runes[i:j]))	390	token := strings.TrimSpace(string(runes[i:j]))
412	// Interpret common JSON atoms and numbers; otherwise treat as string	391	// Interpret common JSON atoms and numbers; otherwise treat as string
413	if token == "true" {	392	if token == "true" {
414	value = true	393	result, _ = sjson.Set(result, sjsonKey, true)
415	} else if token == "false" {	394	} else if token == "false" {
416	value = false	395	result, _ = sjson.Set(result, sjsonKey, false)
417	} else if token == "null" {	396	} else if token == "null" {
418	value = nil	397	result, _ = sjson.Set(result, sjsonKey, nil)
419	} else if numVal, ok := tryParseNumber(token); ok {	398	} else if numVal, ok := tryParseNumber(token); ok {
420	value = numVal	399	result, _ = sjson.Set(result, sjsonKey, numVal)
421	} else {	400	} else {
422	value = token	401	result, _ = sjson.Set(result, sjsonKey, token)
423	}	402	}
424	i = j	403	i = j
425	}	404	}
426		405
427	result[keyName] = value
428
429	// Skip trailing whitespace and optional comma before next pair	406	// Skip trailing whitespace and optional comma before next pair
430	for i < n && (runes[i] == ' ' \|\| runes[i] == '\n' \|\| runes[i] == '\r' \|\| runes[i] == '\t') {	407	for i < n && (runes[i] == ' ' \|\| runes[i] == '\n' \|\| runes[i] == '\r' \|\| runes[i] == '\t') {
431	i++	408	i++
@@ -463,9 +440,9 @@ func parseJSONStringRunes(runes []rune, start int) (string, int) { · 31 unmodified lines
463		440
464	// jsonStringTokenToRawString converts a JSON string token (including quotes) to a raw Go string value.	441	// jsonStringTokenToRawString converts a JSON string token (including quotes) to a raw Go string value.
465	func jsonStringTokenToRawString(token string) string {	442	func jsonStringTokenToRawString(token string) string {
466	var s string	443	r := gjson.Parse(token)
467	if errUnmarshal := json.Unmarshal([]byte(token), &s); errUnmarshal == nil {	444	if r.Type == gjson.String {
468	return s	445	return r.String()
469	}	446	}
470	// Fallback: strip surrounding quotes if present	447	// Fallback: strip surrounding quotes if present
471	if len(token) >= 2 && token[0] == '"' && token[len(token)-1] == '"' {	448	if len(token) >= 2 && token[0] == '"' && token[len(token)-1] == '"' {
@@ -579,7 +556,7 @@ func ConvertOpenAIResponseToGeminiNonStream(_ context.Context, _ string, origina · 107 unmodified lines
579	}	556	}
580	}	557	}
581		558
582	var parts []interface{}	559	partIndex := 0
583		560
584	// Handle reasoning content before visible text	561	// Handle reasoning content before visible text
585	if reasoning := message.Get("reasoning_content"); reasoning.Exists() {	562	if reasoning := message.Get("reasoning_content"); reasoning.Exists() {
@@ -587,18 +564,16 @@ func ConvertOpenAIResponseToGeminiNonStream(_ context.Context, _ string, origina · 1 unmodified line
587	if reasoningText == "" {	564	if reasoningText == "" {
588	continue	565	continue
589	}	566	}
590	parts = append(parts, map[string]interface{}{	567	out, _ = sjson.Set(out, fmt.Sprintf("candidates.0.content.parts.%d.thought", partIndex), true)
591	"thought": true,	568	out, _ = sjson.Set(out, fmt.Sprintf("candidates.0.content.parts.%d.text", partIndex), reasoningText)
592	"text": reasoningText,	569	partIndex++
593	})
594	}	570	}
595	}	571	}
596		572
597	// Handle content first	573	// Handle content first
598	if content := message.Get("content"); content.Exists() && content.String() != "" {	574	if content := message.Get("content"); content.Exists() && content.String() != "" {
599	parts = append(parts, map[string]interface{}{	575	out, _ = sjson.Set(out, fmt.Sprintf("candidates.0.content.parts.%d.text", partIndex), content.String())
600	"text": content.String(),	576	partIndex++
601	})
602	}	577	}
603		578
604	// Handle tool calls	579	// Handle tool calls
@@ -609,27 +584,16 @@ func ConvertOpenAIResponseToGeminiNonStream(_ context.Context, _ string, origina · 4 unmodified lines
609	functionName := function.Get("name").String()	584	functionName := function.Get("name").String()
610	functionArgs := function.Get("arguments").String()	585	functionArgs := function.Get("arguments").String()
611		586
612	// Parse arguments	587	namePath := fmt.Sprintf("candidates.0.content.parts.%d.functionCall.name", partIndex)
613	var argsMap map[string]interface{}	588	argsPath := fmt.Sprintf("candidates.0.content.parts.%d.functionCall.args", partIndex)
614	argsMap = parseArgsToMap(functionArgs)	589	out, _ = sjson.Set(out, namePath, functionName)
615		590	out, _ = sjson.SetRaw(out, argsPath, parseArgsToObjectRaw(functionArgs))
616	functionCallPart := map[string]interface{}{	591	partIndex++
617	"functionCall": map[string]interface{}{
618	"name": functionName,
619	"args": argsMap,
620	},
621	}
622	parts = append(parts, functionCallPart)
623	}	592	}
624	return true	593	return true
625	})	594	})
626	}	595	}
627		596
628	// Set parts
629	if len(parts) > 0 {
630	out, _ = sjson.Set(out, "candidates.0.content.parts", parts)
631	}
632
633	// Handle finish reason	597	// Handle finish reason
634	if finishReason := choice.Get("finish_reason"); finishReason.Exists() {	598	if finishReason := choice.Get("finish_reason"); finishReason.Exists() {
635	geminiFinishReason := mapOpenAIFinishReasonToGemini(finishReason.String())	599	geminiFinishReason := mapOpenAIFinishReasonToGemini(finishReason.String())
@@ -645,15 +609,12 @@ func ConvertOpenAIResponseToGeminiNonStream(_ context.Context, _ string, origina · 9 unmodified lines
645		609
646	// Handle usage information	610	// Handle usage information
647	if usage := root.Get("usage"); usage.Exists() {	611	if usage := root.Get("usage"); usage.Exists() {
648	usageObj := map[string]interface{}{	612	out, _ = sjson.Set(out, "usageMetadata.promptTokenCount", usage.Get("prompt_tokens").Int())
649	"promptTokenCount": usage.Get("prompt_tokens").Int(),	613	out, _ = sjson.Set(out, "usageMetadata.candidatesTokenCount", usage.Get("completion_tokens").Int())
650	"candidatesTokenCount": usage.Get("completion_tokens").Int(),	614	out, _ = sjson.Set(out, "usageMetadata.totalTokenCount", usage.Get("total_tokens").Int())
651	"totalTokenCount": usage.Get("total_tokens").Int(),
652	}
653	if reasoningTokens := reasoningTokensFromUsage(usage); reasoningTokens > 0 {	615	if reasoningTokens := reasoningTokensFromUsage(usage); reasoningTokens > 0 {
654	usageObj["thoughtsTokenCount"] = reasoningTokens	616	out, _ = sjson.Set(out, "usageMetadata.thoughtsTokenCount", reasoningTokens)
655	}	617	}
656	out, _ = sjson.Set(out, "usageMetadata", usageObj)
657	}	618	}
658		619
659	return out	620	return out

internal/translator/openai/openai/responses/openai_openai-responses_response.go+35−66

 					}
 				}
 				// Build response.output using aggregated buffers
-				var outputs []interface{}
+				outputsWrapper := `{"arr":[]}`
 				if st.ReasoningBuf.Len() > 0 {
-					outputs = append(outputs, map[string]interface{}{
+					item := `{"id":"","type":"reasoning","summary":[{"type":"summary_text","text":""}]}`
-						"id":   st.ReasoningID,
+					item, _ = sjson.Set(item, "id", st.ReasoningID)
-						"type": "reasoning",
+					item, _ = sjson.Set(item, "summary.0.text", st.ReasoningBuf.String())
-						"summary": []interface{}{map[string]interface{}{
+					outputsWrapper, _ = sjson.SetRaw(outputsWrapper, "arr.-1", item)
-							"type": "summary_text",
-							"text": st.ReasoningBuf.String(),
-						}},
-					})
 				}
 				// Append message items in ascending index order
 				if len(st.MsgItemAdded) > 0 {
 						if b := st.MsgTextBuf[i]; b != nil {
 							txt = b.String()
 						}
-						outputs = append(outputs, map[string]interface{}{
+						item := `{"id":"","type":"message","status":"completed","content":[{"type":"output_text","annotations":[],"logprobs":[],"text":""}],"role":"assistant"}`
-							"id":     fmt.Sprintf("msg_%s_%d", st.ResponseID, i),
+						item, _ = sjson.Set(item, "id", fmt.Sprintf("msg_%s_%d", st.ResponseID, i))
-							"type":   "message",
+						item, _ = sjson.Set(item, "content.0.text", txt)
-							"status": "completed",
+						outputsWrapper, _ = sjson.SetRaw(outputsWrapper, "arr.-1", item)
-							"content": []interface{}{map[string]interface{}{
-								"type":        "output_text",
-								"annotations": []interface{}{},
-								"logprobs":    []interface{}{},
-								"text":        txt,
-							}},
-							"role": "assistant",
-						})
 					}
 				}
 				if len(st.FuncArgsBuf) > 0 {
 						}
 						callID := st.FuncCallIDs[i]
 						name := st.FuncNames[i]
-						outputs = append(outputs, map[string]interface{}{
+						item := `{"id":"","type":"function_call","status":"completed","arguments":"","call_id":"","name":""}`
-							"id":        fmt.Sprintf("fc_%s", callID),
+						item, _ = sjson.Set(item, "id", fmt.Sprintf("fc_%s", callID))
-							"type":      "function_call",
+						item, _ = sjson.Set(item, "arguments", args)
-							"status":    "completed",
+						item, _ = sjson.Set(item, "call_id", callID)
-							"arguments": args,
+						item, _ = sjson.Set(item, "name", name)
-							"call_id":   callID,
+						outputsWrapper, _ = sjson.SetRaw(outputsWrapper, "arr.-1", item)
-							"name":      name,
-						})
 					}
 				}
-				if len(outputs) > 0 {
+				if gjson.Get(outputsWrapper, "arr.#").Int() > 0 {
-					completed, _ = sjson.Set(completed, "response.output", outputs)
+					completed, _ = sjson.SetRaw(completed, "response.output", gjson.Get(outputsWrapper, "arr").Raw)
 				}
 				if st.UsageSeen {
 					completed, _ = sjson.Set(completed, "response.usage.input_tokens", st.PromptTokens)
 	}
 	// Build output list from choices[...]
-	var outputs []interface{}
+	outputsWrapper := `{"arr":[]}`
 	// Detect and capture reasoning content if present
 	rcText := gjson.GetBytes(rawJSON, "choices.0.message.reasoning_content").String()
 	includeReasoning := rcText != ""
 		if strings.HasPrefix(rid, "resp_") {
 			rid = strings.TrimPrefix(rid, "resp_")
 		}
-		reasoningItem := map[string]interface{}{
-			"id":                fmt.Sprintf("rs_%s", rid),
-			"type":              "reasoning",
-			"encrypted_content": "",
-		}
 		// Prefer summary_text from reasoning_content; encrypted_content is optional
-		var summaries []interface{}
+		reasoningItem := `{"id":"","type":"reasoning","encrypted_content":"","summary":[]}`
+		reasoningItem, _ = sjson.Set(reasoningItem, "id", fmt.Sprintf("rs_%s", rid))
 		if rcText != "" {
-			summaries = append(summaries, map[string]interface{}{
+			reasoningItem, _ = sjson.Set(reasoningItem, "summary.0.type", "summary_text")
-				"type": "summary_text",
+			reasoningItem, _ = sjson.Set(reasoningItem, "summary.0.text", rcText)
-				"text": rcText,
-			})
 		}
-		reasoningItem["summary"] = summaries
+		outputsWrapper, _ = sjson.SetRaw(outputsWrapper, "arr.-1", reasoningItem)
-		outputs = append(outputs, reasoningItem)
 	}
 	if choices := root.Get("choices"); choices.Exists() && choices.IsArray() {
 			if msg.Exists() {
 				// Text message part
 				if c := msg.Get("content"); c.Exists() && c.String() != "" {
-					outputs = append(outputs, map[string]interface{}{
+					item := `{"id":"","type":"message","status":"completed","content":[{"type":"output_text","annotations":[],"logprobs":[],"text":""}],"role":"assistant"}`
-						"id":     fmt.Sprintf("msg_%s_%d", id, int(choice.Get("index").Int())),
+					item, _ = sjson.Set(item, "id", fmt.Sprintf("msg_%s_%d", id, int(choice.Get("index").Int())))
-						"type":   "message",
+					item, _ = sjson.Set(item, "content.0.text", c.String())
-						"status": "completed",
+					outputsWrapper, _ = sjson.SetRaw(outputsWrapper, "arr.-1", item)
-						"content": []interface{}{map[string]interface{}{
-							"type":        "output_text",
-							"annotations": []interface{}{},
-							"logprobs":    []interface{}{},
-							"text":        c.String(),
-						}},
-						"role": "assistant",
-					})
 				}
 				// Function/tool calls
 						callID := tc.Get("id").String()
 						name := tc.Get("function.name").String()
 						args := tc.Get("function.arguments").String()
-						outputs = append(outputs, map[string]interface{}{
+						item := `{"id":"","type":"function_call","status":"completed","arguments":"","call_id":"","name":""}`
-							"id":        fmt.Sprintf("fc_%s", callID),
+						item, _ = sjson.Set(item, "id", fmt.Sprintf("fc_%s", callID))
-							"type":      "function_call",
+						item, _ = sjson.Set(item, "arguments", args)
-							"status":    "completed",
+						item, _ = sjson.Set(item, "call_id", callID)
-							"arguments": args,
+						item, _ = sjson.Set(item, "name", name)
-							"call_id":   callID,
+						outputsWrapper, _ = sjson.SetRaw(outputsWrapper, "arr.-1", item)
-							"name":      name,
-						})
 						return true
 					})
 				}
 			return true
 		})
 	}
-	if len(outputs) > 0 {
+	if gjson.Get(outputsWrapper, "arr.#").Int() > 0 {
-		resp, _ = sjson.Set(resp, "output", outputs)
+		resp, _ = sjson.SetRaw(resp, "output", gjson.Get(outputsWrapper, "arr").Raw)
 	}
 	// usage mapping