n9router 0.4.44 → 0.4.45

package/app/open-sse/translator/{helpers/openaiHelper.js → formats/openai.js}

@@ -1,8 +1,8 @@
 // OpenAI helper functions for translator
+import { ROLE, OPENAI_BLOCK, CLAUDE_BLOCK, VALID_OPENAI_CONTENT_TYPES, VALID_OPENAI_MESSAGE_TYPES } from "../schema/index.js";
 
-// Valid OpenAI content block types
-export const VALID_OPENAI_CONTENT_TYPES = ["text", "image_url", "image", "input_audio", "audio_url"];
-export const VALID_OPENAI_MESSAGE_TYPES = ["text", "image_url", "image", "tool_calls", "tool_result"];
+// Re-export valid-type lists (moved to schema/blocks.js) to keep existing importers working.
+export { VALID_OPENAI_CONTENT_TYPES, VALID_OPENAI_MESSAGE_TYPES };
 
 function normalizeOpenAIContent(content) {
   if (content.length === 0) return "";
@@ -14,48 +14,52 @@ function normalizeOpenAIContent(content) {
 
 // Filter messages to OpenAI standard format
 // Remove: thinking, redacted_thinking, signature, and other non-OpenAI blocks
-export function filterToOpenAIFormat(body) {
+// opts.preserveCacheControl: keep cache_control on content blocks (e.g. for DashScope/alicode)
+export function filterToOpenAIFormat(body, opts = {}) {
   if (!body.messages || !Array.isArray(body.messages)) return body;
-  
+  const keepCache = !!opts.preserveCacheControl;
+
+  function stripBlock(block) {
+    const { signature, cache_control, ...rest } = block;
+    return keepCache && cache_control ? { ...rest, cache_control } : rest;
+  }
+
   body.messages = body.messages.map(msg => {
     // Normalize developer role to system (many providers don't support developer)
-    if (msg.role === "developer") msg = { ...msg, role: "system" };
-    
+    if (msg.role === ROLE.DEVELOPER) msg = { ...msg, role: ROLE.SYSTEM };
+
     // Keep tool messages as-is (OpenAI format)
-    if (msg.role === "tool") return msg;
-    
+    if (msg.role === ROLE.TOOL) return msg;
+
     // Keep assistant messages with tool_calls as-is
-    if (msg.role === "assistant" && msg.tool_calls) return msg;
-    
+    if (msg.role === ROLE.ASSISTANT && msg.tool_calls) return msg;
+
     // Handle string content
     if (typeof msg.content === "string") return msg;
-    
+
     // Handle array content
     if (Array.isArray(msg.content)) {
       const filteredContent = [];
-      
+
       for (const block of msg.content) {
         // Skip thinking blocks
-        if (block.type === "thinking" || block.type === "redacted_thinking") continue;
-        
+        if (block.type === CLAUDE_BLOCK.THINKING || block.type === CLAUDE_BLOCK.REDACTED_THINKING) continue;
+
         // Only keep valid OpenAI content types
         if (VALID_OPENAI_CONTENT_TYPES.includes(block.type)) {
-          // Remove signature field if exists
-          const { signature, cache_control, ...cleanBlock } = block;
-          filteredContent.push(cleanBlock);
-        } else if (block.type === "tool_use") {
+          filteredContent.push(stripBlock(block));
+        } else if (block.type === CLAUDE_BLOCK.TOOL_USE) {
           // Convert tool_use to tool_calls format (handled separately)
           continue;
-        } else if (block.type === "tool_result") {
+        } else if (block.type === CLAUDE_BLOCK.TOOL_RESULT) {
           // Keep tool_result but clean it
-          const { signature, cache_control, ...cleanBlock } = block;
-          filteredContent.push(cleanBlock);
+          filteredContent.push(stripBlock(block));
         }
       }
       
       // If all content was filtered, add empty text
       if (filteredContent.length === 0) {
-        filteredContent.push({ type: "text", text: "" });
+        filteredContent.push({ type: OPENAI_BLOCK.TEXT, text: "" });
       }
       
       return { ...msg, content: normalizeOpenAIContent(filteredContent) };
@@ -67,15 +71,15 @@ export function filterToOpenAIFormat(body) {
   // Filter out messages with only empty text (but NEVER filter tool messages)
   body.messages = body.messages.filter(msg => {
     // Always keep tool messages
-    if (msg.role === "tool") return true;
+    if (msg.role === ROLE.TOOL) return true;
     // Always keep assistant messages with tool_calls
-    if (msg.role === "assistant" && msg.tool_calls) return true;
+    if (msg.role === ROLE.ASSISTANT && msg.tool_calls) return true;
     
     if (typeof msg.content === "string") return msg.content.trim() !== "";
     if (Array.isArray(msg.content)) {
       return msg.content.some(b => 
-        (b.type === "text" && b.text?.trim()) ||
-        b.type !== "text"
+        (b.type === OPENAI_BLOCK.TEXT && b.text?.trim()) ||
+        b.type !== OPENAI_BLOCK.TEXT
       );
     }
     return true;
@@ -90,12 +94,12 @@ export function filterToOpenAIFormat(body) {
   if (body.tools && Array.isArray(body.tools) && body.tools.length > 0) {
     body.tools = body.tools.map(tool => {
       // Already OpenAI format
-      if (tool.type === "function" && tool.function) return tool;
+      if (tool.type === OPENAI_BLOCK.FUNCTION && tool.function) return tool;
       
       // Claude format: {name, description, input_schema}
       if (tool.name && (tool.input_schema || tool.description)) {
         return {
-          type: "function",
+          type: OPENAI_BLOCK.FUNCTION,
           function: {
             name: tool.name,
             description: String(tool.description || ""),
@@ -107,7 +111,7 @@ export function filterToOpenAIFormat(body) {
       // Gemini format: {functionDeclarations: [{name, description, parameters}]}
       if (tool.functionDeclarations && Array.isArray(tool.functionDeclarations)) {
         return tool.functionDeclarations.map(fn => ({
-          type: "function",
+          type: OPENAI_BLOCK.FUNCTION,
           function: {
             name: fn.name,
             description: String(fn.description || ""),
@@ -129,7 +133,7 @@ export function filterToOpenAIFormat(body) {
     } else if (choice.type === "any") {
       body.tool_choice = "required";
     } else if (choice.type === "tool" && choice.name) {
-      body.tool_choice = { type: "function", function: { name: choice.name } };
+      body.tool_choice = { type: OPENAI_BLOCK.FUNCTION, function: { name: choice.name } };
     }
   }
 

package/app/open-sse/translator/{helpers/responsesApiHelper.js → formats/responsesApi.js}

@@ -1,3 +1,5 @@
+import { ROLE, OPENAI_BLOCK, RESPONSES_ITEM } from "../schema/index.js";
+
 /**
  * Normalize Responses API input to array format.
  * Accepts string or array, returns array of message items.
@@ -9,12 +11,12 @@
 export function normalizeResponsesInput(input) {
   if (typeof input === "string") {
     const text = input.trim() === "" ? "..." : input;
-    return [{ type: "message", role: "user", content: [{ type: "input_text", text }] }];
+    return [{ type: RESPONSES_ITEM.MESSAGE, role: ROLE.USER, content: [{ type: RESPONSES_ITEM.INPUT_TEXT, text }] }];
   }
   if (Array.isArray(input)) {
     // Empty input[] would produce messages:[] which all providers reject (#389)
     if (input.length === 0) {
-      return [{ type: "message", role: "user", content: [{ type: "input_text", text: "..." }] }];
+      return [{ type: RESPONSES_ITEM.MESSAGE, role: ROLE.USER, content: [{ type: RESPONSES_ITEM.INPUT_TEXT, text: "..." }] }];
     }
     return input;
   }
@@ -34,7 +36,7 @@ export function convertResponsesApiFormat(body) {
 
   // Convert instructions to system message
   if (body.instructions) {
-    result.messages.push({ role: "system", content: body.instructions });
+    result.messages.push({ role: ROLE.SYSTEM, content: body.instructions });
   }
 
   // Group items by conversation turn
@@ -48,9 +50,9 @@ export function convertResponsesApiFormat(body) {
   for (const item of inputItems) {
     // Determine item type - Droid CLI sends role-based items without 'type' field
     // Fallback: if no type but has role property, treat as message
-    const itemType = item.type || (item.role ? "message" : null);
+    const itemType = item.type || (item.role ? RESPONSES_ITEM.MESSAGE : null);
 
-    if (itemType === "message") {
+    if (itemType === RESPONSES_ITEM.MESSAGE) {
       // Flush any pending assistant message with tool calls
       if (currentAssistantMsg) {
         result.messages.push(currentAssistantMsg);
@@ -67,22 +69,22 @@ export function convertResponsesApiFormat(body) {
       // Convert content: input_text → text, output_text → text, input_image → image_url
       const content = Array.isArray(item.content)
         ? item.content.map(c => {
-          if (c.type === "input_text") return { type: "text", text: c.text };
-          if (c.type === "output_text") return { type: "text", text: c.text };
-          if (c.type === "input_image") {
+          if (c.type === RESPONSES_ITEM.INPUT_TEXT) return { type: OPENAI_BLOCK.TEXT, text: c.text };
+          if (c.type === RESPONSES_ITEM.OUTPUT_TEXT) return { type: OPENAI_BLOCK.TEXT, text: c.text };
+          if (c.type === RESPONSES_ITEM.INPUT_IMAGE) {
             const url = c.image_url || c.file_id || "";
-            return { type: "image_url", image_url: { url, detail: c.detail || "auto" } };
+            return { type: OPENAI_BLOCK.IMAGE_URL, image_url: { url, detail: c.detail || "auto" } };
           }
           return c;
         })
         : item.content;
       result.messages.push({ role: item.role, content });
     }
-    else if (itemType === "function_call") {
+    else if (itemType === RESPONSES_ITEM.FUNCTION_CALL) {
       // Start or append to assistant message with tool_calls
       if (!currentAssistantMsg) {
         currentAssistantMsg = {
-          role: "assistant",
+          role: ROLE.ASSISTANT,
           content: null,
           tool_calls: []
         };
@@ -91,14 +93,14 @@ export function convertResponsesApiFormat(body) {
       if (!item.name || typeof item.name !== "string" || item.name.trim() === "") continue;
       currentAssistantMsg.tool_calls.push({
         id: item.call_id,
-        type: "function",
+        type: OPENAI_BLOCK.FUNCTION,
         function: {
           name: item.name,
           arguments: item.arguments
         }
       });
     }
-    else if (itemType === "function_call_output") {
+    else if (itemType === RESPONSES_ITEM.FUNCTION_CALL_OUTPUT) {
       // Flush assistant message first if exists
       if (currentAssistantMsg) {
         result.messages.push(currentAssistantMsg);
@@ -106,12 +108,12 @@ export function convertResponsesApiFormat(body) {
       }
       // Add tool result
       pendingToolResults.push({
-        role: "tool",
+        role: ROLE.TOOL,
         tool_call_id: item.call_id,
         content: typeof item.output === "string" ? item.output : JSON.stringify(item.output)
       });
     }
-    else if (itemType === "reasoning") {
+    else if (itemType === RESPONSES_ITEM.REASONING) {
       // Skip reasoning items - they are for display only
       continue;
     }

package/app/open-sse/translator/index.js

@@ -1,20 +1,24 @@
 import { FORMATS } from "./formats.js";
-import { ensureToolCallIds, fixMissingToolResponses } from "./helpers/toolCallHelper.js";
-import { prepareClaudeRequest } from "./helpers/claudeHelper.js";
+import { ensureToolCallIds, fixMissingToolResponses } from "./concerns/toolCall.js";
+import { prepareClaudeRequest } from "./formats/claude.js";
 import { cloakClaudeTools } from "../utils/claudeCloaking.js";
-import { filterToOpenAIFormat } from "./helpers/openaiHelper.js";
+import { filterToOpenAIFormat } from "./formats/openai.js";
 import { normalizeThinkingConfig } from "../services/provider.js";
+import { applyThinking, captureThinking } from "./concerns/thinkingUnified.js";
+import { captureSessionId } from "../utils/sessionManager.js";
 import { AntigravityExecutor } from "../executors/antigravity.js";
+import { PROVIDERS } from "../providers/index.js";
 
-// Registry for translators
-const requestRegistry = new Map();
-const responseRegistry = new Map();
-
-// Track initialization state
-let initialized = false;
+// Registry for translators. Lazy-init guards against circular-import order:
+// translator modules call register() (side-effect) before this module's body runs.
+// var (not let): hoisted as undefined so register() can run during circular import (no TDZ).
+var requestRegistry;
+var responseRegistry;
 
 // Register translator
 export function register(from, to, requestFn, responseFn) {
+  requestRegistry ??= new Map();
+  responseRegistry ??= new Map();
   const key = `${from}:${to}`;
   if (requestFn) {
     requestRegistry.set(key, requestFn);
@@ -24,35 +28,8 @@ export function register(from, to, requestFn, responseFn) {
   }
 }
 
-// Lazy load translators (called once on first use)
-function ensureInitialized() {
-  if (initialized) return;
-  initialized = true;
-
-  // Request translators - sync require pattern for bundler
-  require("./request/claude-to-openai.js");
-  require("./request/openai-to-claude.js");
-  require("./request/gemini-to-openai.js");
-  require("./request/openai-to-gemini.js");
-  require("./request/openai-to-vertex.js");
-  require("./request/antigravity-to-openai.js");
-  require("./request/openai-responses.js");
-  require("./request/openai-to-kiro.js");
-  require("./request/openai-to-cursor.js");
-  require("./request/openai-to-ollama.js");
-  require("./request/openai-to-commandcode.js");
-
-  // Response translators
-  require("./response/claude-to-openai.js");
-  require("./response/openai-to-claude.js");
-  require("./response/gemini-to-openai.js");
-  require("./response/openai-to-antigravity.js");
-  require("./response/openai-responses.js");
-  require("./response/kiro-to-openai.js");
-  require("./response/cursor-to-openai.js");
-  require("./response/ollama-to-openai.js");
-  require("./response/commandcode-to-openai.js");
-}
+// No-op: translators self-register via the static imports at the bottom of this file.
+function ensureInitialized() {}
 
 // Strip specific content types from messages (explicit opt-in via strip[] in PROVIDER_MODELS)
 function stripContentTypes(body, stripList = []) {
@@ -88,42 +65,64 @@ export function translateRequest(sourceFormat, targetFormat, model, body, stream
   // Fix missing tool responses (insert empty tool_result if needed)
   fixMissingToolResponses(result);
 
+  // Capture thinking intent from the original (pre-translation) body, before any
+  // format conversion strips/renames the fields. Applied after translation.
+  const thinkingIntent = captureThinking(result);
+
+  // Capture session id from the original body (envelope still intact, e.g. antigravity request.sessionId)
+  const clientSessionId = captureSessionId(result, credentials, connectionId, targetFormat);
+  // Expose to downstream translators (gemini-cli/antigravity envelopes) that run after envelope is stripped
+  if (credentials) credentials._clientSessionId = clientSessionId;
+
   // If same format, skip translation steps
   if (sourceFormat !== targetFormat) {
-    // Step 1: source -> openai (if source is not openai)
-    if (sourceFormat !== FORMATS.OPENAI) {
-      const toOpenAI = requestRegistry.get(`${sourceFormat}:${FORMATS.OPENAI}`);
-      if (toOpenAI) {
-        result = toOpenAI(model, result, stream, credentials);
-        // Log OpenAI intermediate format
-        reqLogger?.logOpenAIRequest?.(result);
+    // Direct route: if a translator is registered for this exact source:target
+    // pair, use it instead of pivoting through OpenAI. This is lossless for
+    // pairs like claude:kiro (avoids the claude->openai->kiro double-hop).
+    const directFn = requestRegistry.get(`${sourceFormat}:${targetFormat}`);
+    if (directFn) {
+      result = directFn(model, result, stream, credentials);
+    } else {
+      // Step 1: source -> openai (if source is not openai)
+      if (sourceFormat !== FORMATS.OPENAI) {
+        const toOpenAI = requestRegistry.get(`${sourceFormat}:${FORMATS.OPENAI}`);
+        if (toOpenAI) {
+          result = toOpenAI(model, result, stream, credentials);
+          // Log OpenAI intermediate format
+          reqLogger?.logOpenAIRequest?.(result);
+        }
       }
-    }
 
-    // Step 2: openai -> target (if target is not openai)
-    if (targetFormat !== FORMATS.OPENAI) {
-      const fromOpenAI = requestRegistry.get(`${FORMATS.OPENAI}:${targetFormat}`);
-      if (fromOpenAI) {
-        result = fromOpenAI(model, result, stream, credentials);
+      // Step 2: openai -> target (if target is not openai)
+      if (targetFormat !== FORMATS.OPENAI) {
+        const fromOpenAI = requestRegistry.get(`${FORMATS.OPENAI}:${targetFormat}`);
+        if (fromOpenAI) {
+          result = fromOpenAI(model, result, stream, credentials);
+        }
       }
     }
   }
 
+  // Normalize thinking to the target provider-native format (config-driven, capability-aware)
+  applyThinking(targetFormat, model, result, provider, thinkingIntent);
+
   // Always normalize to clean OpenAI format when target is OpenAI
   // This handles hybrid requests (e.g., OpenAI messages + Claude tools)
   if (targetFormat === FORMATS.OPENAI) {
-    result = filterToOpenAIFormat(result);
+    result = filterToOpenAIFormat(result, {
+      preserveCacheControl: !!PROVIDERS[provider]?.quirks?.preserveCacheControl,
+    });
   }
 
   // Final step: prepare request for Claude format endpoints
   if (targetFormat === FORMATS.CLAUDE) {
     const apiKey = credentials?.accessToken || credentials?.apiKey || null;
-    result = prepareClaudeRequest(result, provider, apiKey, connectionId);
+    result = prepareClaudeRequest(result, provider, apiKey, connectionId, credentials?.rawHeaders, clientSessionId);
   }
 
   // Claude cloaking: rename client tools with _cc suffix (anti-ban)
-  // Only for claude provider (not anthropic-compatible-*) with OAuth token
-  if (provider === "claude") {
+  // quirk: only providers flagged cloakToolsOnOAuth, and only with an OAuth token
+  if (PROVIDERS[provider]?.quirks?.cloakToolsOnOAuth) {
     const apiKey = credentials?.accessToken || credentials?.apiKey || null;
     if (apiKey?.includes("sk-ant-oat")) {
       const { body: cloakedBody, toolNameMap } = cloakClaudeTools(result);
@@ -157,6 +156,16 @@ export function translateResponse(targetFormat, sourceFormat, chunk, state) {
   let results = [chunk];
   let openaiResults = null; // Store OpenAI intermediate results
 
+  // Direct route: if a response translator is registered for this exact
+  // target:source pair, use it instead of pivoting through OpenAI. Mirrors the
+  // request-side direct route (e.g. kiro:claude — KiroExecutor already emits
+  // OpenAI-shaped chunks, so this converts them straight to Claude SSE).
+  const directFn = responseRegistry.get(`${targetFormat}:${sourceFormat}`);
+  if (directFn) {
+    const converted = directFn(chunk, state);
+    return converted ? (Array.isArray(converted) ? converted : [converted]) : [];
+  }
+
   // Step 1: target -> openai (if target is not openai)
   if (targetFormat !== FORMATS.OPENAI) {
     const toOpenAI = responseRegistry.get(`${targetFormat}:${FORMATS.OPENAI}`);
@@ -245,7 +254,31 @@ export function initState(sourceFormat) {
   return base;
 }
 
-// Initialize all translators (kept for backward compatibility)
+// Kept for backward compatibility; translators are already registered at import time.
 export function initTranslators() {
   ensureInitialized();
 }
+
+// Static side-effect imports: each module calls register() at load (works in ESM + bundler).
+import "./request/claude-to-openai.js";
+import "./request/openai-to-claude.js";
+import "./request/gemini-to-openai.js";
+import "./request/openai-to-gemini.js";
+import "./request/openai-to-vertex.js";
+import "./request/antigravity-to-openai.js";
+import "./request/openai-responses.js";
+import "./request/openai-to-kiro.js";
+import "./request/openai-to-cursor.js";
+import "./request/openai-to-ollama.js";
+import "./request/openai-to-commandcode.js";
+import "./request/claude-to-kiro.js";
+import "./response/claude-to-openai.js";
+import "./response/openai-to-claude.js";
+import "./response/gemini-to-openai.js";
+import "./response/openai-to-antigravity.js";
+import "./response/openai-responses.js";
+import "./response/kiro-to-openai.js";
+import "./response/cursor-to-openai.js";
+import "./response/ollama-to-openai.js";
+import "./response/commandcode-to-openai.js";
+import "./response/kiro-to-claude.js";

package/app/open-sse/translator/request/antigravity-to-openai.js

@@ -1,6 +1,10 @@
 import { register } from "../index.js";
 import { FORMATS } from "../formats.js";
-import { adjustMaxTokens } from "../helpers/maxTokensHelper.js";
+import { adjustMaxTokens } from "../formats/maxTokens.js";
+import { encodeDataUri } from "../concerns/image.js";
+import { ROLE, GEMINI_ROLE, OPENAI_BLOCK } from "../schema/index.js";
+import { budgetToEffort } from "../concerns/thinking.js";
+import { collapseTextParts } from "../concerns/message.js";
 
 // Convert Antigravity request to OpenAI format
 // Antigravity body: { project, model, userAgent, requestType, requestId, request: { contents, systemInstruction, tools, toolConfig, generationConfig, sessionId } }
@@ -31,16 +35,8 @@ export function antigravityToOpenAIRequest(model, body, stream) {
 
     // Thinking config → reasoning_effort
     if (config.thinkingConfig) {
-      const budget = config.thinkingConfig.thinkingBudget || 0;
-      if (budget > 0) {
-        if (budget <= 2048) {
-          result.reasoning_effort = "low";
-        } else if (budget <= 16384) {
-          result.reasoning_effort = "medium";
-        } else {
-          result.reasoning_effort = "high";
-        }
-      }
+      const effort = budgetToEffort(config.thinkingConfig.thinkingBudget || 0);
+      if (effort) result.reasoning_effort = effort;
     }
   }
 
@@ -48,7 +44,7 @@ export function antigravityToOpenAIRequest(model, body, stream) {
   if (req.systemInstruction) {
     const systemText = extractText(req.systemInstruction);
     if (systemText) {
-      result.messages.push({ role: "system", content: systemText });
+      result.messages.push({ role: ROLE.SYSTEM, content: systemText });
     }
   }
 
@@ -73,7 +69,7 @@ export function antigravityToOpenAIRequest(model, body, stream) {
       if (tool.functionDeclarations) {
         for (const func of tool.functionDeclarations) {
           result.tools.push({
-            type: "function",
+            type: OPENAI_BLOCK.FUNCTION,
             function: {
               name: func.name,
               description: func.description || "",
@@ -163,7 +159,7 @@ function coerceStringifiedSchemaValues(schema) {
 // Convert Antigravity content to OpenAI message
 // Handles: text, thought, thoughtSignature, functionCall, functionResponse, inlineData
 function convertContent(content) {
-  const role = content.role === "model" ? "assistant" : content.role === "user" ? "user" : content.role;
+  const role = content.role === GEMINI_ROLE.MODEL ? ROLE.ASSISTANT : content.role === GEMINI_ROLE.USER ? ROLE.USER : content.role;
 
   if (!content.parts || !Array.isArray(content.parts)) {
     return null;
@@ -183,21 +179,23 @@ function convertContent(content) {
 
     // Text with thoughtSignature = regular text after thinking
     if (part.thoughtSignature && part.text !== undefined) {
-      textParts.push({ type: "text", text: part.text });
+      if (part.text) {
+        textParts.push({ type: OPENAI_BLOCK.TEXT, text: part.text });
+      }
       continue;
     }
 
     // Regular text
-    if (part.text !== undefined) {
-      textParts.push({ type: "text", text: part.text });
+    if (part.text !== undefined && part.text !== "") {
+      textParts.push({ type: OPENAI_BLOCK.TEXT, text: part.text });
     }
 
     // Inline data (images)
     if (part.inlineData) {
       textParts.push({
-        type: "image_url",
+        type: OPENAI_BLOCK.IMAGE_URL,
         image_url: {
-          url: `data:${part.inlineData.mimeType};base64,${part.inlineData.data}`
+          url: encodeDataUri(part.inlineData.mimeType, part.inlineData.data)
         }
       });
     }
@@ -205,8 +203,9 @@ function convertContent(content) {
     // Function call
     if (part.functionCall) {
       toolCalls.push({
-        id: part.functionCall.id || `call_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
-        type: "function",
+        // Deterministic id from name so the matching functionResponse pairs correctly.
+        id: part.functionCall.id || `call_${part.functionCall.name}`,
+        type: OPENAI_BLOCK.FUNCTION,
         function: {
           name: part.functionCall.name,
           arguments: JSON.stringify(part.functionCall.args || {})
@@ -217,23 +216,37 @@ function convertContent(content) {
     // Function response → collect all, each becomes a separate tool message
     if (part.functionResponse) {
       toolResults.push({
-        role: "tool",
-        tool_call_id: part.functionResponse.id || part.functionResponse.name,
+        role: ROLE.TOOL,
+        tool_call_id: part.functionResponse.id || `call_${part.functionResponse.name}`,
         content: JSON.stringify(part.functionResponse.response?.result || part.functionResponse.response || {})
       });
     }
   }
 
-  // Content with only functionResponses → return array of tool messages
+  // Content with functionResponses — return array of tool result messages,
+  // plus an assistant message for any co-located tool calls / text.
   if (toolResults.length > 0) {
+    if (toolCalls.length > 0 || textParts.length > 0 || reasoningContent) {
+      const assistantMsg = { role: ROLE.ASSISTANT };
+      if (textParts.length > 0) {
+        assistantMsg.content = collapseTextParts(textParts);
+      }
+      if (reasoningContent) {
+        assistantMsg.reasoning_content = reasoningContent;
+      }
+      if (toolCalls.length > 0) {
+        assistantMsg.tool_calls = toolCalls;
+      }
+      return [...toolResults, assistantMsg];
+    }
     return toolResults;
   }
 
   // Assistant with tool calls
   if (toolCalls.length > 0) {
-    const msg = { role: "assistant" };
+    const msg = { role: ROLE.ASSISTANT };
     if (textParts.length > 0) {
-      msg.content = textParts.length === 1 && textParts[0].type === "text" ? textParts[0].text : textParts;
+      msg.content = collapseTextParts(textParts);
     }
     if (reasoningContent) {
       msg.reasoning_content = reasoningContent;
@@ -246,7 +259,7 @@ function convertContent(content) {
   if (textParts.length > 0 || reasoningContent) {
     const msg = { role };
     if (textParts.length > 0) {
-      msg.content = textParts.length === 1 && textParts[0].type === "text" ? textParts[0].text : textParts;
+      msg.content = collapseTextParts(textParts);
     }
     if (reasoningContent) {
       msg.reasoning_content = reasoningContent;