whale-code 6.5.5 → 6.5.6

package/dist/server/providers/gemini.js

@@ -11,6 +11,7 @@
  * Phase 7.1: Also encapsulates thinking config, context management,
  * output token limits, and compaction config for Gemini models.
  */
+
 import { randomUUID } from "node:crypto";
 import { GoogleGenAI } from "@google/genai";
 import { sanitizeError } from "../../shared/agent-core.js";
@@ -20,120 +21,128 @@ import { jsonResponse, writeSSEHeaders, emitError, resolveProviderCredentials }
 // ============================================================================
 // CONSTANTS — Gemini-specific model config
 // ============================================================================
+
 const GEMINI_MAX_TOKENS = 65536;
 const DEFAULT_OUTPUT_TOKENS = 16384;
 const MODEL_MAX_OUTPUT_TOKENS = {
-    "gemini-3-pro-preview": 65536,
-    "gemini-3-flash-preview": 65536,
-    "gemini-2.5-pro": 65536,
-    "gemini-2.5-flash": 65536,
-    "gemini-2.5-flash-lite": 65536,
+  "gemini-3-pro-preview": 65536,
+  "gemini-3-flash-preview": 65536,
+  "gemini-2.5-pro": 65536,
+  "gemini-2.5-flash": 65536,
+  "gemini-2.5-flash-lite": 65536
 };
+
 // ============================================================================
 // MESSAGE CONVERSION
 // ============================================================================
+
 /** Convert Anthropic messages to Gemini Content format */
 function anthropicToGeminiMessages(messages) {
-    const raw = [];
-    // Track tool_use_id → name for tool_result conversion
-    const toolIdMap = new Map();
-    for (const msg of messages) {
-        const role = msg.role === "assistant" ? "model" : "user";
-        const parts = [];
-        if (typeof msg.content === "string") {
-            parts.push({ text: msg.content });
-        }
-        else if (Array.isArray(msg.content)) {
-            for (const block of msg.content) {
-                if (block.type === "text" && block.text) {
-                    parts.push({ text: block.text });
-                }
-                else if (block.type === "tool_use") {
-                    toolIdMap.set(block.id, block.name);
-                    parts.push({
-                        functionCall: { name: block.name, args: block.input || {} },
-                        // Preserve Gemini thought signature for function call round-trips
-                        ...(block.thought_signature ? { thoughtSignature: block.thought_signature } : {}),
-                    });
-                }
-                else if (block.type === "image" && block.source?.data) {
-                    parts.push({
-                        inlineData: {
-                            mimeType: block.source.media_type,
-                            data: block.source.data,
-                        },
-                    });
-                }
-                else if (block.type === "tool_result") {
-                    const toolName = toolIdMap.get(block.tool_use_id) || block.tool_use_id;
-                    let resultContent = "";
-                    if (typeof block.content === "string") {
-                        resultContent = block.content;
-                    }
-                    else if (Array.isArray(block.content)) {
-                        resultContent = block.content
-                            .filter((c) => c.type === "text")
-                            .map((c) => c.text)
-                            .join("\n");
-                    }
-                    parts.push({
-                        functionResponse: {
-                            name: toolName,
-                            response: { result: resultContent },
-                        },
-                    });
-                }
+  const raw = [];
+  // Track tool_use_id → name for tool_result conversion
+  const toolIdMap = new Map();
+  for (const msg of messages) {
+    const role = msg.role === "assistant" ? "model" : "user";
+    const parts = [];
+    if (typeof msg.content === "string") {
+      parts.push({
+        text: msg.content
+      });
+    } else if (Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        if (block.type === "text" && block.text) {
+          parts.push({
+            text: block.text
+          });
+        } else if (block.type === "tool_use") {
+          toolIdMap.set(block.id, block.name);
+          parts.push({
+            functionCall: {
+              name: block.name,
+              args: block.input || {}
+            },
+            // Preserve Gemini thought signature for function call round-trips
+            ...(block.thought_signature ? {
+              thoughtSignature: block.thought_signature
+            } : {})
+          });
+        } else if (block.type === "image" && block.source?.data) {
+          parts.push({
+            inlineData: {
+              mimeType: block.source.media_type,
+              data: block.source.data
             }
+          });
+        } else if (block.type === "tool_result") {
+          const toolName = toolIdMap.get(block.tool_use_id) || block.tool_use_id;
+          let resultContent = "";
+          if (typeof block.content === "string") {
+            resultContent = block.content;
+          } else if (Array.isArray(block.content)) {
+            resultContent = block.content.filter(c => c.type === "text").map(c => c.text).join("\n");
+          }
+          parts.push({
+            functionResponse: {
+              name: toolName,
+              response: {
+                result: resultContent
+              }
+            }
+          });
         }
-        if (parts.length > 0) {
-            raw.push({ role, parts });
-        }
+      }
     }
-    // Gemini requires strictly alternating user/model turns.
-    // After context compaction or multi-step tool use, consecutive same-role turns
-    // can appear — Gemini rejects these with INVALID_ARGUMENT.
-    // Fix: merge consecutive same-role turns by concatenating their parts.
-    const contents = [];
-    for (const turn of raw) {
-        const prev = contents[contents.length - 1];
-        if (prev && prev.role === turn.role) {
-            // Merge into the previous turn
-            prev.parts = [...(prev.parts || []), ...(turn.parts || [])];
-        }
-        else {
-            contents.push({ role: turn.role, parts: turn.parts });
-        }
+    if (parts.length > 0) {
+      raw.push({
+        role,
+        parts
+      });
+    }
+  }
+
+  // Gemini requires strictly alternating user/model turns.
+  // After context compaction or multi-step tool use, consecutive same-role turns
+  // can appear — Gemini rejects these with INVALID_ARGUMENT.
+  // Fix: merge consecutive same-role turns by concatenating their parts.
+  const contents = [];
+  for (const turn of raw) {
+    const prev = contents[contents.length - 1];
+    if (prev && prev.role === turn.role) {
+      // Merge into the previous turn
+      prev.parts = [...(prev.parts || []), ...(turn.parts || [])];
+    } else {
+      contents.push({
+        role: turn.role,
+        parts: turn.parts
+      });
     }
-    return contents;
+  }
+  return contents;
 }
+
 // ============================================================================
 // SCHEMA SANITIZATION
 // ============================================================================
+
 /** Gemini uses uppercase OpenAPI schema types, not lowercase JSON Schema types. */
 const GEMINI_TYPE_MAP = {
-    string: "STRING",
-    number: "NUMBER",
-    integer: "INTEGER",
-    boolean: "BOOLEAN",
-    array: "ARRAY",
-    object: "OBJECT",
+  string: "STRING",
+  number: "NUMBER",
+  integer: "INTEGER",
+  boolean: "BOOLEAN",
+  array: "ARRAY",
+  object: "OBJECT"
 };
+
 /**
  * Keys that are JSON Schema-only and not supported by Gemini's OpenAPI Schema.
  * IMPORTANT: Only strip keys that can't collide with property names in our tools.
  */
-const GEMINI_SCHEMA_ONLY_KEYS = new Set([
-    "$schema", "additionalProperties", "propertyNames",
-    "minProperties", "maxProperties",
-    "anyOf", "oneOf", "allOf", "not", "const",
-]);
+const GEMINI_SCHEMA_ONLY_KEYS = new Set(["$schema", "additionalProperties", "propertyNames", "minProperties", "maxProperties", "anyOf", "oneOf", "allOf", "not", "const"]);
+
 /** Keys to strip only from schema definition objects (objects with a "type" field) */
-const GEMINI_SCHEMA_VALIDATION_KEYS = new Set([
-    "exclusiveMinimum", "exclusiveMaximum",
-    "minItems", "maxItems", "minLength", "maxLength",
-    "minimum", "maximum", "pattern",
-    "default",
-]);
+const GEMINI_SCHEMA_VALIDATION_KEYS = new Set(["exclusiveMinimum", "exclusiveMaximum", "minItems", "maxItems", "minLength", "maxLength", "minimum", "maximum", "pattern", "default"]);
+
 /**
  * Sanitize JSON Schema → Gemini OpenAPI Schema:
  * - Convert type values to uppercase (string → STRING)
@@ -143,359 +152,480 @@ const GEMINI_SCHEMA_VALIDATION_KEYS = new Set([
  * - Filter required to only include defined properties
  */
 function sanitizeSchemaForGemini(schema) {
-    if (!schema || typeof schema !== "object")
-        return schema;
-    if (Array.isArray(schema))
-        return schema.map((s) => sanitizeSchemaForGemini(s));
-    const result = {};
-    const isSchemaNode = "type" in schema;
-    for (const [key, value] of Object.entries(schema)) {
-        // Always strip structural JSON Schema keys
-        if (GEMINI_SCHEMA_ONLY_KEYS.has(key))
-            continue;
-        // Strip validation keys only from schema nodes (not property name maps)
-        if (isSchemaNode && GEMINI_SCHEMA_VALIDATION_KEYS.has(key))
-            continue;
-        if (key === "type" && typeof value === "string") {
-            result[key] = GEMINI_TYPE_MAP[value] || value.toUpperCase();
-        }
-        else if (key === "enum" && Array.isArray(value)) {
-            result[key] = value.map((v) => String(v));
-        }
-        else if (key === "properties" && typeof value === "object" && value !== null && !Array.isArray(value)) {
-            // Properties map: keys are property names, values are schema definitions
-            const props = {};
-            for (const [propName, propSchema] of Object.entries(value)) {
-                props[propName] = sanitizeSchemaForGemini(propSchema);
-            }
-            result[key] = props;
-        }
-        else {
-            result[key] = sanitizeSchemaForGemini(value);
-        }
-    }
-    // Gemini requires array items to have a type
-    if (result.type === "ARRAY") {
-        if (!result.items || (typeof result.items === "object" && Object.keys(result.items).length === 0)) {
-            result.items = { type: "STRING" };
-        }
+  if (!schema || typeof schema !== "object") return schema;
+  if (Array.isArray(schema)) return schema.map(s => sanitizeSchemaForGemini(s));
+  const result = {};
+  const isSchemaNode = "type" in schema;
+  for (const [key, value] of Object.entries(schema)) {
+    // Always strip structural JSON Schema keys
+    if (GEMINI_SCHEMA_ONLY_KEYS.has(key)) continue;
+    // Strip validation keys only from schema nodes (not property name maps)
+    if (isSchemaNode && GEMINI_SCHEMA_VALIDATION_KEYS.has(key)) continue;
+    if (key === "type" && typeof value === "string") {
+      result[key] = GEMINI_TYPE_MAP[value] || value.toUpperCase();
+    } else if (key === "enum" && Array.isArray(value)) {
+      result[key] = value.map(v => String(v));
+    } else if (key === "properties" && typeof value === "object" && value !== null && !Array.isArray(value)) {
+      // Properties map: keys are property names, values are schema definitions
+      const props = {};
+      for (const [propName, propSchema] of Object.entries(value)) {
+        props[propName] = sanitizeSchemaForGemini(propSchema);
+      }
+      result[key] = props;
+    } else {
+      result[key] = sanitizeSchemaForGemini(value);
     }
-    // Gemini requires object types to have properties
-    if (result.type === "OBJECT" && !result.properties) {
-        result.properties = {};
+  }
+
+  // Gemini requires array items to have a type
+  if (result.type === "ARRAY") {
+    if (!result.items || typeof result.items === "object" && Object.keys(result.items).length === 0) {
+      result.items = {
+        type: "STRING"
+      };
     }
-    // Gemini only allows enum on STRING type — force type to STRING if enum is present
-    if (result.enum && Array.isArray(result.enum) && result.type && result.type !== "STRING") {
-        result.type = "STRING";
-    }
-    // Filter required to only include properties that actually exist
-    if (result.required && Array.isArray(result.required) && result.properties) {
-        const validProps = new Set(Object.keys(result.properties));
-        result.required = result.required.filter((r) => validProps.has(r));
-        if (result.required.length === 0)
-            delete result.required;
-    }
-    return result;
+  }
+
+  // Gemini requires object types to have properties
+  if (result.type === "OBJECT" && !result.properties) {
+    result.properties = {};
+  }
+
+  // Gemini only allows enum on STRING type — force type to STRING if enum is present
+  if (result.enum && Array.isArray(result.enum) && result.type && result.type !== "STRING") {
+    result.type = "STRING";
+  }
+
+  // Filter required to only include properties that actually exist
+  if (result.required && Array.isArray(result.required) && result.properties) {
+    const validProps = new Set(Object.keys(result.properties));
+    result.required = result.required.filter(r => validProps.has(r));
+    if (result.required.length === 0) delete result.required;
+  }
+  return result;
 }
 function anthropicToGeminiFunctions(tools) {
-    return tools.map((t) => ({
-        name: t.name,
-        description: typeof t.description === "string" ? t.description.slice(0, 4096) : "",
-        parameters: sanitizeSchemaForGemini(t.input_schema || {}),
-    }));
+  return tools.map(t => ({
+    name: t.name,
+    description: typeof t.description === "string" ? t.description.slice(0, 4096) : "",
+    parameters: sanitizeSchemaForGemini(t.input_schema || {})
+  }));
 }
+
 // ============================================================================
 // ADAPTER
 // ============================================================================
+
 export class GeminiAdapter {
-    name = "gemini";
-    async handleStream(res, config, corsHeaders) {
-        const { model, messages, system, tools, max_tokens, temperature, storeId, tool_choice } = config;
-        const creds = await resolveProviderCredentials("google", storeId);
-        if (!creds.google) {
-            jsonResponse(res, 422, { error: "Google AI credentials not configured. Add google_ai_api_key to platform_secrets." }, corsHeaders);
-            return;
-        }
-        const client = new GoogleGenAI({ apiKey: creds.google.apiKey });
-        // Extract system prompt text
-        let systemText = "";
-        if (typeof system === "string") {
-            systemText = system;
+  name = "gemini";
+  async handleStream(res, config, corsHeaders) {
+    const {
+      model,
+      messages,
+      system,
+      tools,
+      max_tokens,
+      temperature,
+      storeId,
+      tool_choice
+    } = config;
+    const creds = await resolveProviderCredentials("google", storeId);
+    if (!creds.google) {
+      jsonResponse(res, 422, {
+        error: "Google AI credentials not configured. Add google_ai_api_key to platform_secrets."
+      }, corsHeaders);
+      return;
+    }
+    const client = new GoogleGenAI({
+      apiKey: creds.google.apiKey
+    });
+
+    // Extract system prompt text
+    let systemText = "";
+    if (typeof system === "string") {
+      systemText = system;
+    } else if (Array.isArray(system)) {
+      systemText = system.map(s => s.text || "").join("\n");
+    }
+
+    // Build generation config
+    const genConfig = {
+      maxOutputTokens: max_tokens
+    };
+    if (temperature !== undefined) genConfig.temperature = temperature;
+
+    // Map tool_choice to Gemini functionCallingConfig
+    let geminiFunctionCallingConfig = {
+      mode: "AUTO"
+    };
+    let omitGeminiTools = false;
+    if (tool_choice) {
+      if (tool_choice === "auto") {
+        geminiFunctionCallingConfig = {
+          mode: "AUTO"
+        };
+      } else if (tool_choice === "any") {
+        geminiFunctionCallingConfig = {
+          mode: "ANY"
+        };
+      } else if (tool_choice === "none") {
+        geminiFunctionCallingConfig = {
+          mode: "NONE"
+        };
+        omitGeminiTools = true;
+      } else if (typeof tool_choice === "object" && tool_choice.type === "tool") {
+        geminiFunctionCallingConfig = {
+          mode: "ANY",
+          allowedFunctionNames: [tool_choice.name]
+        };
+      }
+    }
+
+    // Build request config for the new SDK — model is passed per-request
+    const requestConfig = {
+      model,
+      config: {
+        ...genConfig,
+        ...(systemText ? {
+          systemInstruction: systemText
+        } : {}),
+        ...(!omitGeminiTools && tools?.length ? {
+          tools: [{
+            functionDeclarations: anthropicToGeminiFunctions(tools)
+          }],
+          toolConfig: {
+            functionCallingConfig: geminiFunctionCallingConfig
+          }
+        } : {})
+      }
+    };
+    const genModel = client.models;
+
+    // Convert messages
+    const contents = anthropicToGeminiMessages(messages);
+
+    // Track tokens outside try so catch block can reference them
+    let totalOutputTokens = 0;
+    let totalInputTokens = 0;
+    let totalThinkingTokens = 0;
+    let totalCacheReadTokens = 0;
+
+    // Defer SSE headers until stream is successfully created
+    // so we can return proper HTTP errors if the initial API call fails.
+    let heartbeat;
+    try {
+      // Request with includeThoughts so we stream Gemini's thinking process
+      const streamResult = await genModel.generateContentStream({
+        ...requestConfig,
+        contents,
+        config: {
+          ...requestConfig.config,
+          thinkingConfig: {
+            includeThoughts: true
+          }
         }
-        else if (Array.isArray(system)) {
-            systemText = system.map((s) => s.text || "").join("\n");
+      });
+
+      // Stream created successfully — now safe to commit to SSE
+      writeSSEHeaders(res, corsHeaders);
+
+      // Heartbeat keeps the connection alive and helps detect dead clients
+      heartbeat = setInterval(() => {
+        if (!res.writableEnded) res.write(":ping\n\n");
+      }, 15_000);
+
+      // Emit Anthropic-format message_start
+      res.write(`data: ${JSON.stringify({
+        type: "message_start",
+        message: {
+          id: `msg_gemini_${randomUUID().slice(0, 8)}`,
+          type: "message",
+          role: "assistant",
+          content: [],
+          model,
+          stop_reason: null,
+          usage: {
+            input_tokens: 0,
+            output_tokens: 0
+          }
         }
-        // Build generation config
-        const genConfig = { maxOutputTokens: max_tokens };
-        if (temperature !== undefined)
-            genConfig.temperature = temperature;
-        // Map tool_choice to Gemini functionCallingConfig
-        let geminiFunctionCallingConfig = { mode: "AUTO" };
-        let omitGeminiTools = false;
-        if (tool_choice) {
-            if (tool_choice === "auto") {
-                geminiFunctionCallingConfig = { mode: "AUTO" };
-            }
-            else if (tool_choice === "any") {
-                geminiFunctionCallingConfig = { mode: "ANY" };
-            }
-            else if (tool_choice === "none") {
-                geminiFunctionCallingConfig = { mode: "NONE" };
-                omitGeminiTools = true;
-            }
-            else if (typeof tool_choice === "object" && tool_choice.type === "tool") {
-                geminiFunctionCallingConfig = { mode: "ANY", allowedFunctionNames: [tool_choice.name] };
-            }
+      })}\n\n`);
+      let blockIndex = 0;
+      let hasOpenTextBlock = false;
+      let hasOpenThinkingBlock = false;
+      let hasToolUse = false;
+      let hasEmittedContent = false;
+      const seenFunctionCalls = new Set();
+      for await (const chunk of streamResult) {
+        const candidates = chunk.candidates || [];
+        const usage = chunk.usageMetadata;
+        if (usage) {
+          totalOutputTokens = usage.candidatesTokenCount || usage.totalTokenCount || 0;
+          totalInputTokens = usage.promptTokenCount || 0;
+          totalThinkingTokens = usage.thoughtsTokenCount || 0;
+          if (usage.cachedContentTokenCount) {
+            totalCacheReadTokens = usage.cachedContentTokenCount;
+          }
         }
-        // Build request config for the new SDK — model is passed per-request
-        const requestConfig = {
-            model,
-            config: {
-                ...genConfig,
-                ...(systemText ? { systemInstruction: systemText } : {}),
-                ...(!omitGeminiTools && tools?.length ? {
-                    tools: [{ functionDeclarations: anthropicToGeminiFunctions(tools) }],
-                    toolConfig: { functionCallingConfig: geminiFunctionCallingConfig },
-                } : {}),
-            },
-        };
-        const genModel = client.models;
-        // Convert messages
-        const contents = anthropicToGeminiMessages(messages);
-        // Track tokens outside try so catch block can reference them
-        let totalOutputTokens = 0;
-        let totalInputTokens = 0;
-        let totalThinkingTokens = 0;
-        let totalCacheReadTokens = 0;
-        // Defer SSE headers until stream is successfully created
-        // so we can return proper HTTP errors if the initial API call fails.
-        let heartbeat;
-        try {
-            // Request with includeThoughts so we stream Gemini's thinking process
-            const streamResult = await genModel.generateContentStream({
-                ...requestConfig,
-                contents,
-                config: {
-                    ...requestConfig.config,
-                    thinkingConfig: { includeThoughts: true },
-                },
-            });
-            // Stream created successfully — now safe to commit to SSE
-            writeSSEHeaders(res, corsHeaders);
-            // Heartbeat keeps the connection alive and helps detect dead clients
-            heartbeat = setInterval(() => {
-                if (!res.writableEnded)
-                    res.write(":ping\n\n");
-            }, 15_000);
-            // Emit Anthropic-format message_start
-            res.write(`data: ${JSON.stringify({
-                type: "message_start",
-                message: {
-                    id: `msg_gemini_${randomUUID().slice(0, 8)}`,
-                    type: "message",
-                    role: "assistant",
-                    content: [],
-                    model,
-                    stop_reason: null,
-                    usage: { input_tokens: 0, output_tokens: 0 },
-                },
-            })}\n\n`);
-            let blockIndex = 0;
-            let hasOpenTextBlock = false;
-            let hasOpenThinkingBlock = false;
-            let hasToolUse = false;
-            let hasEmittedContent = false;
-            const seenFunctionCalls = new Set();
-            for await (const chunk of streamResult) {
-                const candidates = chunk.candidates || [];
-                const usage = chunk.usageMetadata;
-                if (usage) {
-                    totalOutputTokens = usage.candidatesTokenCount || usage.totalTokenCount || 0;
-                    totalInputTokens = usage.promptTokenCount || 0;
-                    totalThinkingTokens = usage.thoughtsTokenCount || 0;
-                    if (usage.cachedContentTokenCount) {
-                        totalCacheReadTokens = usage.cachedContentTokenCount;
-                    }
-                }
-                for (const candidate of candidates) {
-                    const allParts = candidate.content?.parts || [];
-                    for (const part of allParts) {
-                        const isThought = !!part.thought;
-                        // Thinking text delta
-                        if (isThought && part.text) {
-                            if (hasOpenTextBlock) {
-                                res.write(`data: ${JSON.stringify({ type: "content_block_stop", index: blockIndex })}\n\n`);
-                                blockIndex++;
-                                hasOpenTextBlock = false;
-                            }
-                            if (!hasOpenThinkingBlock) {
-                                res.write(`data: ${JSON.stringify({
-                                    type: "content_block_start",
-                                    index: blockIndex,
-                                    content_block: { type: "thinking", thinking: "" },
-                                })}\n\n`);
-                                hasOpenThinkingBlock = true;
-                                hasEmittedContent = true;
-                            }
-                            res.write(`data: ${JSON.stringify({
-                                type: "content_block_delta",
-                                index: blockIndex,
-                                delta: { type: "thinking_delta", thinking: part.text },
-                            })}\n\n`);
-                            continue;
-                        }
-                        // Response text delta
-                        if (part.text && !isThought) {
-                            if (hasOpenThinkingBlock) {
-                                res.write(`data: ${JSON.stringify({ type: "content_block_stop", index: blockIndex })}\n\n`);
-                                blockIndex++;
-                                hasOpenThinkingBlock = false;
-                            }
-                            if (!hasOpenTextBlock) {
-                                res.write(`data: ${JSON.stringify({
-                                    type: "content_block_start",
-                                    index: blockIndex,
-                                    content_block: { type: "text", text: "" },
-                                })}\n\n`);
-                                hasOpenTextBlock = true;
-                                hasEmittedContent = true;
-                            }
-                            res.write(`data: ${JSON.stringify({
-                                type: "content_block_delta",
-                                index: blockIndex,
-                                delta: { type: "text_delta", text: part.text },
-                            })}\n\n`);
-                            continue;
-                        }
-                        // Function call
-                        if (part.functionCall) {
-                            const fc = {
-                                name: part.functionCall.name || "",
-                                args: part.functionCall.args || {},
-                                thoughtSignature: part.thoughtSignature,
-                            };
-                            const fcKey = `${fc.name}:${JSON.stringify(fc.args)}`;
-                            if (seenFunctionCalls.has(fcKey))
-                                continue;
-                            seenFunctionCalls.add(fcKey);
-                            // Close any open thinking block
-                            if (hasOpenThinkingBlock) {
-                                res.write(`data: ${JSON.stringify({ type: "content_block_stop", index: blockIndex })}\n\n`);
-                                blockIndex++;
-                                hasOpenThinkingBlock = false;
-                            }
-                            // Close any open text block
-                            if (hasOpenTextBlock) {
-                                res.write(`data: ${JSON.stringify({ type: "content_block_stop", index: blockIndex })}\n\n`);
-                                blockIndex++;
-                                hasOpenTextBlock = false;
-                            }
-                            hasToolUse = true;
-                            hasEmittedContent = true;
-                            const toolUseId = `toolu_gemini_${randomUUID().slice(0, 12)}`;
-                            res.write(`data: ${JSON.stringify({
-                                type: "content_block_start",
-                                index: blockIndex,
-                                content_block: {
-                                    type: "tool_use",
-                                    id: toolUseId,
-                                    name: fc.name,
-                                    input: {},
-                                    // Preserve Gemini thought_signature — required for tool call round-trips with thinking
-                                    ...(fc.thoughtSignature ? { thought_signature: fc.thoughtSignature } : {}),
-                                },
-                            })}\n\n`);
-                            res.write(`data: ${JSON.stringify({
-                                type: "content_block_delta",
-                                index: blockIndex,
-                                delta: {
-                                    type: "input_json_delta",
-                                    partial_json: JSON.stringify(fc.args || {}),
-                                },
-                            })}\n\n`);
-                            res.write(`data: ${JSON.stringify({ type: "content_block_stop", index: blockIndex })}\n\n`);
-                            blockIndex++;
-                        }
-                    }
+        for (const candidate of candidates) {
+          const allParts = candidate.content?.parts || [];
+          for (const part of allParts) {
+            const isThought = !!part.thought;
+
+            // Thinking text delta
+            if (isThought && part.text) {
+              if (hasOpenTextBlock) {
+                res.write(`data: ${JSON.stringify({
+                  type: "content_block_stop",
+                  index: blockIndex
+                })}\n\n`);
+                blockIndex++;
+                hasOpenTextBlock = false;
+              }
+              if (!hasOpenThinkingBlock) {
+                res.write(`data: ${JSON.stringify({
+                  type: "content_block_start",
+                  index: blockIndex,
+                  content_block: {
+                    type: "thinking",
+                    thinking: ""
+                  }
+                })}\n\n`);
+                hasOpenThinkingBlock = true;
+                hasEmittedContent = true;
+              }
+              res.write(`data: ${JSON.stringify({
+                type: "content_block_delta",
+                index: blockIndex,
+                delta: {
+                  type: "thinking_delta",
+                  thinking: part.text
                 }
+              })}\n\n`);
+              continue;
             }
-            // Close any open blocks — no signature_delta for Gemini thinking
-            if (hasOpenThinkingBlock) {
-                res.write(`data: ${JSON.stringify({ type: "content_block_stop", index: blockIndex })}\n\n`);
-            }
-            if (hasOpenTextBlock) {
-                res.write(`data: ${JSON.stringify({ type: "content_block_stop", index: blockIndex })}\n\n`);
+
+            // Response text delta
+            if (part.text && !isThought) {
+              if (hasOpenThinkingBlock) {
+                res.write(`data: ${JSON.stringify({
+                  type: "content_block_stop",
+                  index: blockIndex
+                })}\n\n`);
+                blockIndex++;
+                hasOpenThinkingBlock = false;
+              }
+              if (!hasOpenTextBlock) {
+                res.write(`data: ${JSON.stringify({
+                  type: "content_block_start",
+                  index: blockIndex,
+                  content_block: {
+                    type: "text",
+                    text: ""
+                  }
+                })}\n\n`);
+                hasOpenTextBlock = true;
+                hasEmittedContent = true;
+              }
+              res.write(`data: ${JSON.stringify({
+                type: "content_block_delta",
+                index: blockIndex,
+                delta: {
+                  type: "text_delta",
+                  text: part.text
+                }
+              })}\n\n`);
+              continue;
             }
-            // Handle empty response — Gemini sometimes returns finishReason: STOP with no content
-            if (!hasEmittedContent) {
+
+            // Function call
+            if (part.functionCall) {
+              const fc = {
+                name: part.functionCall.name || "",
+                args: part.functionCall.args || {},
+                thoughtSignature: part.thoughtSignature
+              };
+              const fcKey = `${fc.name}:${JSON.stringify(fc.args)}`;
+              if (seenFunctionCalls.has(fcKey)) continue;
+              seenFunctionCalls.add(fcKey);
+
+              // Close any open thinking block
+              if (hasOpenThinkingBlock) {
                 res.write(`data: ${JSON.stringify({
-                    type: "content_block_start",
-                    index: 0,
-                    content_block: { type: "text", text: "" },
+                  type: "content_block_stop",
+                  index: blockIndex
                 })}\n\n`);
+                blockIndex++;
+                hasOpenThinkingBlock = false;
+              }
+              // Close any open text block
+              if (hasOpenTextBlock) {
                 res.write(`data: ${JSON.stringify({
-                    type: "content_block_delta",
-                    index: 0,
-                    delta: { type: "text_delta", text: "[Gemini returned an empty response. Please try again.]" },
+                  type: "content_block_stop",
+                  index: blockIndex
                 })}\n\n`);
-                res.write(`data: ${JSON.stringify({ type: "content_block_stop", index: 0 })}\n\n`);
+                blockIndex++;
+                hasOpenTextBlock = false;
+              }
+              hasToolUse = true;
+              hasEmittedContent = true;
+              const toolUseId = `toolu_gemini_${randomUUID().slice(0, 12)}`;
+              res.write(`data: ${JSON.stringify({
+                type: "content_block_start",
+                index: blockIndex,
+                content_block: {
+                  type: "tool_use",
+                  id: toolUseId,
+                  name: fc.name,
+                  input: {},
+                  // Preserve Gemini thought_signature — required for tool call round-trips with thinking
+                  ...(fc.thoughtSignature ? {
+                    thought_signature: fc.thoughtSignature
+                  } : {})
+                }
+              })}\n\n`);
+              res.write(`data: ${JSON.stringify({
+                type: "content_block_delta",
+                index: blockIndex,
+                delta: {
+                  type: "input_json_delta",
+                  partial_json: JSON.stringify(fc.args || {})
+                }
+              })}\n\n`);
+              res.write(`data: ${JSON.stringify({
+                type: "content_block_stop",
+                index: blockIndex
+              })}\n\n`);
+              blockIndex++;
             }
-            // Determine stop reason
-            const stopReason = hasToolUse ? "tool_use" : "end_turn";
-            // Emit message_delta with stop reason + full usage
-            res.write(`data: ${JSON.stringify({
-                type: "message_delta",
-                delta: { stop_reason: stopReason, stop_sequence: null },
-                usage: {
-                    input_tokens: totalInputTokens,
-                    output_tokens: totalOutputTokens,
-                    ...(totalThinkingTokens > 0 ? { thinking_tokens: totalThinkingTokens } : {}),
-                    ...(totalCacheReadTokens > 0 ? { cache_read_input_tokens: totalCacheReadTokens } : {}),
-                },
-            })}\n\n`);
-            // Emit message_stop
-            res.write(`data: ${JSON.stringify({ type: "message_stop" })}\n\n`);
-            res.write("data: [DONE]\n\n");
+          }
         }
-        catch (err) {
-            emitError(res, err, corsHeaders, sanitizeError, {
-                provider: "gemini",
-                inputTokens: totalInputTokens,
-                outputTokens: totalOutputTokens,
-                thinkingTokens: totalThinkingTokens,
-                cacheReadTokens: totalCacheReadTokens,
-            });
+      }
+
+      // Close any open blocks — no signature_delta for Gemini thinking
+      if (hasOpenThinkingBlock) {
+        res.write(`data: ${JSON.stringify({
+          type: "content_block_stop",
+          index: blockIndex
+        })}\n\n`);
+      }
+      if (hasOpenTextBlock) {
+        res.write(`data: ${JSON.stringify({
+          type: "content_block_stop",
+          index: blockIndex
+        })}\n\n`);
+      }
+
+      // Handle empty response — Gemini sometimes returns finishReason: STOP with no content
+      if (!hasEmittedContent) {
+        res.write(`data: ${JSON.stringify({
+          type: "content_block_start",
+          index: 0,
+          content_block: {
+            type: "text",
+            text: ""
+          }
+        })}\n\n`);
+        res.write(`data: ${JSON.stringify({
+          type: "content_block_delta",
+          index: 0,
+          delta: {
+            type: "text_delta",
+            text: "[Gemini returned an empty response. Please try again.]"
+          }
+        })}\n\n`);
+        res.write(`data: ${JSON.stringify({
+          type: "content_block_stop",
+          index: 0
+        })}\n\n`);
+      }
+
+      // Determine stop reason
+      const stopReason = hasToolUse ? "tool_use" : "end_turn";
+
+      // Emit message_delta with stop reason + full usage
+      res.write(`data: ${JSON.stringify({
+        type: "message_delta",
+        delta: {
+          stop_reason: stopReason,
+          stop_sequence: null
+        },
+        usage: {
+          input_tokens: totalInputTokens,
+          output_tokens: totalOutputTokens,
+          ...(totalThinkingTokens > 0 ? {
+            thinking_tokens: totalThinkingTokens
+          } : {}),
+          ...(totalCacheReadTokens > 0 ? {
+            cache_read_input_tokens: totalCacheReadTokens
+          } : {})
         }
-        finally {
-            if (heartbeat)
-                clearInterval(heartbeat);
-        }
-        res.end();
-    }
-    // ---- Provider-specific config methods ----
-    getThinkingConfig(_model, enabled) {
-        if (!enabled) {
-            return { thinking: { type: "disabled" }, beta: "" };
-        }
-        // Gemini models: thinking is always-on for 2.5+/3.x — signal pass-through
-        return { thinking: { type: "enabled" }, beta: "" };
-    }
-    getMaxOutputTokens(model, agentMax) {
-        const modelMax = MODEL_MAX_OUTPUT_TOKENS[model] ?? DEFAULT_OUTPUT_TOKENS;
-        if (agentMax)
-            return Math.min(agentMax, modelMax);
-        return Math.min(DEFAULT_OUTPUT_TOKENS, modelMax);
-    }
-    getContextManagement(_model) {
-        // Gemini doesn't use Anthropic betas or context management
-        return { betas: [], config: { edits: [] } };
-    }
-    getCompactionConfig(_model) {
-        return { triggerTokens: 700_000, totalBudget: 4_000_000, isNative: false };
+      })}\n\n`);
+
+      // Emit message_stop
+      res.write(`data: ${JSON.stringify({
+        type: "message_stop"
+      })}\n\n`);
+      res.write("data: [DONE]\n\n");
+    } catch (err) {
+      emitError(res, err, corsHeaders, sanitizeError, {
+        provider: "gemini",
+        inputTokens: totalInputTokens,
+        outputTokens: totalOutputTokens,
+        thinkingTokens: totalThinkingTokens,
+        cacheReadTokens: totalCacheReadTokens
+      });
+    } finally {
+      if (heartbeat) clearInterval(heartbeat);
     }
-    getCapabilities() {
-        return getCapabilities("gemini");
+    res.end();
+  }
+
+  // ---- Provider-specific config methods ----
+
+  getThinkingConfig(_model, enabled) {
+    if (!enabled) {
+      return {
+        thinking: {
+          type: "disabled"
+        },
+        beta: ""
+      };
     }
+    // Gemini models: thinking is always-on for 2.5+/3.x — signal pass-through
+    return {
+      thinking: {
+        type: "enabled"
+      },
+      beta: ""
+    };
+  }
+  getMaxOutputTokens(model, agentMax) {
+    const modelMax = MODEL_MAX_OUTPUT_TOKENS[model] ?? DEFAULT_OUTPUT_TOKENS;
+    if (agentMax) return Math.min(agentMax, modelMax);
+    return Math.min(DEFAULT_OUTPUT_TOKENS, modelMax);
+  }
+  getContextManagement(_model) {
+    // Gemini doesn't use Anthropic betas or context management
+    return {
+      betas: [],
+      config: {
+        edits: []
+      }
+    };
+  }
+  getCompactionConfig(_model) {
+    return {
+      triggerTokens: 700_000,
+      totalBudget: 4_000_000,
+      isNative: false
+    };
+  }
+  getCapabilities() {
+    return getCapabilities("gemini");
+  }
 }
+
 // Auto-register on import
 registerProvider("gemini", new GeminiAdapter());
+//# sourceMappingURL=gemini.js.map