Update gemini response translator

Co-Authored-By: Claude <noreply@anthropic.com>

internal/translator/gemini/openai/chat-completions/gemini_openai_response.go

@@ -140,31 +140,12 @@ func ConvertGeminiResponseToOpenAI(_ context.Context, _ string, originalRequestR
 			hasFunctionCall := false
 
 			// Handle Grounding (Google Search)
-			// If we have search entry point (HTML) or web search queries, we should display them.
-			// Ideally, we append this to the content so the user sees it.
 			if groundingMetadata.Exists() {
 				var groundingText strings.Builder
-
-				// 1. Search Entry Point (rendered HTML usually)
 				if rendered := groundingMetadata.Get("searchEntryPoint.renderedContent"); rendered.Exists() && rendered.String() != "" {
 					groundingText.WriteString("\n\n" + rendered.String())
 				}
-
-				// 2. Web Search Queries (if available) - optional, maybe verbose
-				// queries := groundingMetadata.Get("webSearchQueries")
-
-				// Append to content if we have grounding info
 				if groundingText.Len() > 0 {
-					// We need to find the text part to append to, or create one.
-					// If streaming, this might come in a separate chunk or the last chunk.
-					// For simplicity in streaming, we can emit a separate content chunk for grounding.
-
-					// However, we are inside a loop over candidates.
-					// Let's modify the template to include this in the content delta if possible.
-					// Or just append to the first text part found?
-					// Or emit a new delta?
-
-					// Safest: Emit a dedicated text delta for the grounding info.
 					groundingTemplate := template // clone
 					groundingTemplate, _ = sjson.Set(groundingTemplate, "choices.0.delta.content", groundingText.String())
 					groundingTemplate, _ = sjson.Set(groundingTemplate, "choices.0.delta.role", "assistant")
@@ -184,6 +165,18 @@ func ConvertGeminiResponseToOpenAI(_ context.Context, _ string, originalRequestR
 					if !inlineDataResult.Exists() {
 						inlineDataResult = partResult.Get("inline_data")
 					}
+					thoughtSignatureResult := partResult.Get("thoughtSignature")
+					if !thoughtSignatureResult.Exists() {
+						thoughtSignatureResult = partResult.Get("thought_signature")
+					}
+
+					hasThoughtSignature := thoughtSignatureResult.Exists() && thoughtSignatureResult.String() != ""
+					hasContentPayload := partTextResult.Exists() || functionCallResult.Exists() || inlineDataResult.Exists() || executableCodeResult.Exists() || codeExecutionResult.Exists()
+
+					// Skip pure thoughtSignature parts but keep any actual payload in the same part.
+					if hasThoughtSignature && !hasContentPayload {
+						continue
+					}
 
 					if partTextResult.Exists() {
 						text := partTextResult.String()
@@ -224,7 +217,6 @@ func ConvertGeminiResponseToOpenAI(_ context.Context, _ string, originalRequestR
 						hasFunctionCall = true
 						toolCallsResult := gjson.Get(template, "choices.0.delta.tool_calls")
 
-						// Retrieve the function index for this specific candidate.
 						functionCallIndex := p.FunctionIndex[candidateIndex]
 						p.FunctionIndex[candidateIndex]++
 
@@ -254,6 +246,209 @@ func ConvertGeminiResponseToOpenAI(_ context.Context, _ string, originalRequestR
 						template, _ = sjson.Set(template, "choices.0.delta.content", displayText)
 						template, _ = sjson.Set(template, "choices.0.delta.role", "assistant")
 
+					} else if inlineDataResult.Exists() {
+						data := inlineDataResult.Get("data").String()
+						if data != "" {
+							mimeType := inlineDataResult.Get("mimeType").String()
+							if mimeType == "" {
+								mimeType = inlineDataResult.Get("mime_type").String()
+							}
+							if mimeType == "" {
+								mimeType = "image/png"
+							}
+							imageURL := fmt.Sprintf("data:%s;base64,%s", mimeType, data)
+							imagesResult := gjson.Get(template, "choices.0.delta.images")
+							if !imagesResult.Exists() || !imagesResult.IsArray() {
+								template, _ = sjson.SetRaw(template, "choices.0.delta.images", `[]`)
+							}
+							imageIndex := len(gjson.Get(template, "choices.0.delta.images").Array())
+							imagePayload := `{"type":"image_url","image_url":{"url":""}}`
+							imagePayload, _ = sjson.Set(imagePayload, "index", imageIndex)
+							imagePayload, _ = sjson.Set(imagePayload, "image_url.url", imageURL)
+							template, _ = sjson.Set(template, "choices.0.delta.role", "assistant")
+							template, _ = sjson.SetRaw(template, "choices.0.delta.images.-1", imagePayload)
+						}
+					}
+				}
+			}
+
+			if hasFunctionCall {
+				template, _ = sjson.Set(template, "choices.0.finish_reason", "tool_calls")
+				template, _ = sjson.Set(template, "choices.0.native_finish_reason", "tool_calls")
+			}
+
+			responseStrings = append(responseStrings, template)
+			return true
+		})
+	} else {
+		// If there are no candidates (e.g., a pure usageMetadata chunk), return the usage chunk if present.
+		if gjson.GetBytes(rawJSON, "usageMetadata").Exists() && len(responseStrings) == 0 {
+			responseStrings = append(responseStrings, baseTemplate)
+		}
+	}
+
+	return responseStrings
+}
+
+// ConvertGeminiResponseToOpenAINonStream converts a non-streaming Gemini response to a non-streaming OpenAI response.
+// This function processes the complete Gemini response and transforms it into a single OpenAI-compatible
+// JSON response. It handles message content, tool calls, reasoning content, and usage metadata, combining all
+// the information into a single response that matches the OpenAI API format.
+//
+// Parameters:
+//   - ctx: The context for the request, used for cancellation and timeout handling
+//   - modelName: The name of the model being used for the response (unused in current implementation)
+//   - rawJSON: The raw JSON response from the Gemini API
+//   - param: A pointer to a parameter object for the conversion (unused in current implementation)
+//
+// Returns:
+//   - string: An OpenAI-compatible JSON response containing all message content and metadata
+func ConvertGeminiResponseToOpenAINonStream(_ context.Context, _ string, originalRequestRawJSON, requestRawJSON, rawJSON []byte, _ *any) string {
+	var unixTimestamp int64
+	// Initialize template with an empty choices array to support multiple candidates.
+	template := `{"id":"","object":"chat.completion","created":123456,"model":"model","choices":[]}`
+
+	if modelVersionResult := gjson.GetBytes(rawJSON, "modelVersion"); modelVersionResult.Exists() {
+		template, _ = sjson.Set(template, "model", modelVersionResult.String())
+	}
+
+	if createTimeResult := gjson.GetBytes(rawJSON, "createTime"); createTimeResult.Exists() {
+		t, err := time.Parse(time.RFC3339Nano, createTimeResult.String())
+		if err == nil {
+			unixTimestamp = t.Unix()
+		}
+		template, _ = sjson.Set(template, "created", unixTimestamp)
+	} else {
+		template, _ = sjson.Set(template, "created", unixTimestamp)
+	}
+
+	if responseIDResult := gjson.GetBytes(rawJSON, "responseId"); responseIDResult.Exists() {
+		template, _ = sjson.Set(template, "id", responseIDResult.String())
+	}
+
+	if usageResult := gjson.GetBytes(rawJSON, "usageMetadata"); usageResult.Exists() {
+		if candidatesTokenCountResult := usageResult.Get("candidatesTokenCount"); candidatesTokenCountResult.Exists() {
+			template, _ = sjson.Set(template, "usage.completion_tokens", candidatesTokenCountResult.Int())
+		}
+		if totalTokenCountResult := usageResult.Get("totalTokenCount"); totalTokenCountResult.Exists() {
+			template, _ = sjson.Set(template, "usage.total_tokens", totalTokenCountResult.Int())
+		}
+		promptTokenCount := usageResult.Get("promptTokenCount").Int()
+		thoughtsTokenCount := usageResult.Get("thoughtsTokenCount").Int()
+		cachedTokenCount := usageResult.Get("cachedContentTokenCount").Int()
+		template, _ = sjson.Set(template, "usage.prompt_tokens", promptTokenCount+thoughtsTokenCount)
+		if thoughtsTokenCount > 0 {
+			template, _ = sjson.Set(template, "usage.completion_tokens_details.reasoning_tokens", thoughtsTokenCount)
+		}
+		// Include cached token count if present (indicates prompt caching is working)
+		if cachedTokenCount > 0 {
+			var err error
+			template, err = sjson.Set(template, "usage.prompt_tokens_details.cached_tokens", cachedTokenCount)
+			if err != nil {
+				log.Warnf("gemini openai response: failed to set cached_tokens in non-streaming: %v", err)
+			}
+		}
+	}
+
+	// Process the main content part of the response for all candidates.
+	candidates := gjson.GetBytes(rawJSON, "candidates")
+	if candidates.IsArray() {
+		candidates.ForEach(func(_, candidate gjson.Result) bool {
+			// Construct a single Choice object.
+			choiceTemplate := `{"index":0,"message":{"role":"assistant","content":null,"reasoning_content":null,"tool_calls":null},"finish_reason":null,"native_finish_reason":null}`
+
+			// Set the index for this choice.
+			choiceTemplate, _ = sjson.Set(choiceTemplate, "index", candidate.Get("index").Int())
+
+			// Set finish reason.
+			if finishReasonResult := candidate.Get("finishReason"); finishReasonResult.Exists() {
+				choiceTemplate, _ = sjson.Set(choiceTemplate, "finish_reason", strings.ToLower(finishReasonResult.String()))
+				choiceTemplate, _ = sjson.Set(choiceTemplate, "native_finish_reason", strings.ToLower(finishReasonResult.String()))
+			}
+
+			// Handle Grounding (Google Search)
+			groundingMetadata := candidate.Get("groundingMetadata")
+			if groundingMetadata.Exists() {
+				var groundingText strings.Builder
+				if rendered := groundingMetadata.Get("searchEntryPoint.renderedContent"); rendered.Exists() && rendered.String() != "" {
+					groundingText.WriteString("\n\n" + rendered.String())
+				}
+				if groundingText.Len() > 0 {
+					oldVal := gjson.Get(choiceTemplate, "message.content").String()
+					choiceTemplate, _ = sjson.Set(choiceTemplate, "message.content", oldVal+groundingText.String())
+					choiceTemplate, _ = sjson.Set(choiceTemplate, "message.role", "assistant")
+				}
+			}
+
+			partsResult := candidate.Get("content.parts")
+			hasFunctionCall := false
+			if partsResult.IsArray() {
+				partsResults := partsResult.Array()
+				for i := 0; i < len(partsResults); i++ {
+					partResult := partsResults[i]
+					partTextResult := partResult.Get("text")
+					functionCallResult := partResult.Get("functionCall")
+					executableCodeResult := partResult.Get("executableCode")
+					codeExecutionResult := partResult.Get("codeExecutionResult")
+					inlineDataResult := partResult.Get("inlineData")
+					if !inlineDataResult.Exists() {
+						inlineDataResult = partResult.Get("inline_data")
+					}
+
+					if partTextResult.Exists() {
+						// Append text content, distinguishing between regular content and reasoning.
+						if partResult.Get("thought").Bool() {
+							oldVal := gjson.Get(choiceTemplate, "message.reasoning_content").String()
+							choiceTemplate, _ = sjson.Set(choiceTemplate, "message.reasoning_content", oldVal+partTextResult.String())
+						} else {
+							oldVal := gjson.Get(choiceTemplate, "message.content").String()
+							choiceTemplate, _ = sjson.Set(choiceTemplate, "message.content", oldVal+partTextResult.String())
+						}
+						choiceTemplate, _ = sjson.Set(choiceTemplate, "message.role", "assistant")
+					} else if functionCallResult.Exists() {
+						// Append function call content to the tool_calls array.
+						hasFunctionCall = true
+						toolCallsResult := gjson.Get(choiceTemplate, "message.tool_calls")
+						if !toolCallsResult.Exists() || !toolCallsResult.IsArray() {
+							choiceTemplate, _ = sjson.SetRaw(choiceTemplate, "message.tool_calls", `[]`)
+						}
+						functionCallItemTemplate := `{"id": "","type": "function","function": {"name": "","arguments": ""}}`
+						fcName := functionCallResult.Get("name").String()
+						functionCallItemTemplate, _ = sjson.Set(functionCallItemTemplate, "id", fmt.Sprintf("%s-%d-%d", fcName, time.Now().UnixNano(), atomic.AddUint64(&functionCallIDCounter, 1)))
+						functionCallItemTemplate, _ = sjson.Set(functionCallItemTemplate, "function.name", fcName)
+						if fcArgsResult := functionCallResult.Get("args"); fcArgsResult.Exists() {
+							functionCallItemTemplate, _ = sjson.Set(functionCallItemTemplate, "function.arguments", fcArgsResult.Raw)
+						}
+						choiceTemplate, _ = sjson.Set(choiceTemplate, "message.role", "assistant")
+						choiceTemplate, _ = sjson.SetRaw(choiceTemplate, "message.tool_calls.-1", functionCallItemTemplate)
+					} else if executableCodeResult.Exists() {
+						// Handle Gemini Code Execution (executableCode)
+						hasFunctionCall = true
+						toolCallsResult := gjson.Get(choiceTemplate, "message.tool_calls")
+						if !toolCallsResult.Exists() || !toolCallsResult.IsArray() {
+							choiceTemplate, _ = sjson.SetRaw(choiceTemplate, "message.tool_calls", `[]`)
+						}
+
+						code := executableCodeResult.Get("code").String()
+						codeArgs := fmt.Sprintf(`{"code": %q}`, code)
+
+						functionCallItemTemplate := `{"id": "","type": "function","function": {"name": "python","arguments": ""}}`
+						functionCallItemTemplate, _ = sjson.Set(functionCallItemTemplate, "id", fmt.Sprintf("call_code_%d_%d", time.Now().UnixNano(), atomic.AddUint64(&functionCallIDCounter, 1)))
+						functionCallItemTemplate, _ = sjson.SetRaw(functionCallItemTemplate, "function.arguments", codeArgs)
+
+						choiceTemplate, _ = sjson.Set(choiceTemplate, "message.role", "assistant")
+						choiceTemplate, _ = sjson.SetRaw(choiceTemplate, "message.tool_calls.-1", functionCallItemTemplate)
+
+					} else if codeExecutionResult.Exists() {
+						// Handle Gemini Code Execution Result
+						output := codeExecutionResult.Get("output").String()
+						outcome := codeExecutionResult.Get("outcome").String()
+						displayText := fmt.Sprintf("\n\n> **Code Execution (%s):**\n```\n%s\n```\n", outcome, output)
+
+						oldVal := gjson.Get(choiceTemplate, "message.content").String()
+						choiceTemplate, _ = sjson.Set(choiceTemplate, "message.content", oldVal+displayText)
+						choiceTemplate, _ = sjson.Set(choiceTemplate, "message.role", "assistant")
+
 					} else if inlineDataResult.Exists() {
 						data := inlineDataResult.Get("data").String()
 						if data != "" {