@fudrouter/fsrouter 0.6.61 → 0.6.63

package/open-sse/translator/formats/gemini.js

@@ -0,0 +1,380 @@
+// Gemini helper functions for translator
+
+import { safeParseJSON } from "../concerns/json.js";
+import { OPENAI_BLOCK } from "../schema/index.js";
+
+// Unsupported JSON Schema constraints that should be removed for Antigravity
+export const UNSUPPORTED_SCHEMA_CONSTRAINTS = [
+  // Basic constraints (not supported by Gemini API)
+  "minLength", "maxLength", "exclusiveMinimum", "exclusiveMaximum",
+  "minItems", "maxItems", "format",
+  // Claude rejects these in VALIDATED mode
+  "default", "examples",
+  // JSON Schema meta keywords
+  "$schema", "$defs", "definitions", "const", "$ref", "$comment",
+  // Annotation keywords (rejected by Gemini/Antigravity - e.g. MCP tool schemas set these)
+  "deprecated", "readOnly", "writeOnly",
+  // Object validation keywords (not supported)
+  "additionalProperties", "propertyNames", "patternProperties", "enumDescriptions",
+  // Complex schema keywords (handled by flattenAnyOfOneOf/mergeAllOf)
+  "anyOf", "oneOf", "allOf", "not",
+  // Dependency keywords (not supported)
+  "dependencies", "dependentSchemas", "dependentRequired",
+  // Other unsupported keywords
+  "title", "optional", "deprecated", "if", "then", "else", "contentMediaType", "contentEncoding",
+  // UI/Styling properties (from Cursor tools - NOT JSON Schema standard)
+  "cornerRadius", "fillColor", "fontFamily", "fontSize", "fontWeight",
+  "gap", "padding", "strokeColor", "strokeThickness", "textColor"
+];
+
+// Default safety settings
+export const DEFAULT_SAFETY_SETTINGS = [
+  { category: "HARM_CATEGORY_HATE_SPEECH", threshold: "OFF" },
+  { category: "HARM_CATEGORY_DANGEROUS_CONTENT", threshold: "OFF" },
+  { category: "HARM_CATEGORY_SEXUALLY_EXPLICIT", threshold: "OFF" },
+  { category: "HARM_CATEGORY_HARASSMENT", threshold: "OFF" },
+  { category: "HARM_CATEGORY_CIVIC_INTEGRITY", threshold: "OFF" }
+];
+
+// Convert OpenAI content to Gemini parts
+export function convertOpenAIContentToParts(content) {
+  const parts = [];
+
+  if (typeof content === "string") {
+    parts.push({ text: content });
+  } else if (Array.isArray(content)) {
+    for (const item of content) {
+      if (item.type === OPENAI_BLOCK.TEXT) {
+        parts.push({ text: item.text });
+      } else if (item.type === OPENAI_BLOCK.IMAGE_URL && item.image_url?.url?.startsWith("data:")) {
+        const url = item.image_url.url;
+        const commaIndex = url.indexOf(",");
+        if (commaIndex !== -1) {
+          const mimePart = url.substring(5, commaIndex); // skip "data:"
+          const data = url.substring(commaIndex + 1);
+          const mimeType = mimePart.split(";")[0];
+
+          parts.push({
+            inlineData: { mime_type: mimeType, data: data }
+          });
+        }
+      } else if (item.type === OPENAI_BLOCK.IMAGE_URL && item.image_url?.url && (item.image_url.url.startsWith("http://") || item.image_url.url.startsWith("https://"))) {
+        parts.push({
+          fileData: { fileUri: item.image_url.url, mimeType: "image/*" }
+        });
+      } else if (item.type === OPENAI_BLOCK.INPUT_AUDIO && item.input_audio?.data) {
+        const format = item.input_audio.format || "wav";
+        const mimeType = format === "mp3" ? "audio/mpeg" : `audio/${format}`;
+        parts.push({
+          inlineData: { mime_type: mimeType, data: item.input_audio.data }
+        });
+      } else if (item.type === OPENAI_BLOCK.AUDIO_URL && item.audio_url?.url?.startsWith("data:")) {
+        const url = item.audio_url.url;
+        const commaIndex = url.indexOf(",");
+        if (commaIndex !== -1) {
+          const mimePart = url.substring(5, commaIndex);
+          const data = url.substring(commaIndex + 1);
+          const mimeType = mimePart.split(";")[0];
+          parts.push({
+            inlineData: { mime_type: mimeType, data: data }
+          });
+        }
+      } else if (item.type === OPENAI_BLOCK.FILE && item.file?.file_data?.startsWith("data:")) {
+        const url = item.file.file_data;
+        const commaIndex = url.indexOf(",");
+        if (commaIndex !== -1) {
+          const mimeType = url.substring(5, commaIndex).split(";")[0];
+          const data = url.substring(commaIndex + 1);
+          parts.push({ inlineData: { mime_type: mimeType, data: data } });
+        }
+      }
+    }
+  }
+
+  return parts;
+}
+
+// Extract text content from OpenAI content
+export function extractTextContent(content, separator = "") {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.filter(c => c.type === OPENAI_BLOCK.TEXT).map(c => c.text).join(separator);
+  }
+  return "";
+}
+
+// Try parse JSON safely (null fallback on parse error; re-export keeps legacy API)
+export function tryParseJSON(str) {
+  return safeParseJSON(str, null);
+}
+
+// Generate request ID
+export function generateRequestId() {
+  return `agent-${crypto.randomUUID()}`;
+}
+
+// Generate session ID (binary-compatible format: UUID + timestamp)
+export function generateSessionId() {
+  return crypto.randomUUID() + Date.now().toString();
+}
+
+// Generate project ID
+export function generateProjectId() {
+  const adjectives = ["useful", "bright", "swift", "calm", "bold"];
+  const nouns = ["fuze", "wave", "spark", "flow", "core"];
+  const adj = adjectives[Math.floor(Math.random() * adjectives.length)];
+  const noun = nouns[Math.floor(Math.random() * nouns.length)];
+  return `${adj}-${noun}-${crypto.randomUUID().slice(0, 5)}`;
+}
+
+// Helper: Remove unsupported keywords recursively from object/array
+// Also strips all vendor extension fields (x- prefixed) not supported by Gemini
+function removeUnsupportedKeywords(obj, keywords) {
+  if (!obj || typeof obj !== "object") return;
+
+  if (Array.isArray(obj)) {
+    for (const item of obj) {
+      removeUnsupportedKeywords(item, keywords);
+    }
+    return;
+  }
+
+  for (const key of Object.keys(obj)) {
+    if (keywords.includes(key) || key.startsWith("x-")) {
+      delete obj[key];
+      continue;
+    }
+
+    const value = obj[key];
+    if (value && typeof value === "object") {
+      removeUnsupportedKeywords(value, keywords);
+    }
+  }
+}
+
+// Convert const to enum
+function convertConstToEnum(obj) {
+  if (!obj || typeof obj !== "object") return;
+
+  if (obj.const !== undefined && !obj.enum) {
+    obj.enum = [obj.const];
+    delete obj.const;
+  }
+
+  for (const value of Object.values(obj)) {
+    if (value && typeof value === "object") {
+      convertConstToEnum(value);
+    }
+  }
+}
+
+// Convert enum values to strings (Gemini requires string enum values + explicit type:"string")
+function convertEnumValuesToStrings(obj) {
+  if (!obj || typeof obj !== "object") return;
+
+  if (obj.enum && Array.isArray(obj.enum)) {
+    obj.enum = obj.enum.map(v => String(v));
+    // Gemini API requires type:"string" when enum is present — without it returns 400
+    if (!obj.type) {
+      obj.type = "string";
+    }
+  }
+
+  for (const value of Object.values(obj)) {
+    if (value && typeof value === "object") {
+      convertEnumValuesToStrings(value);
+    }
+  }
+}
+
+// Merge allOf schemas
+function mergeAllOf(obj) {
+  if (!obj || typeof obj !== "object") return;
+
+  if (obj.allOf && Array.isArray(obj.allOf)) {
+    const merged = {};
+
+    for (const item of obj.allOf) {
+      if (item.properties) {
+        if (!merged.properties) merged.properties = {};
+        Object.assign(merged.properties, item.properties);
+      }
+      if (item.required && Array.isArray(item.required)) {
+        if (!merged.required) merged.required = [];
+        for (const req of item.required) {
+          if (!merged.required.includes(req)) {
+            merged.required.push(req);
+          }
+        }
+      }
+    }
+
+    delete obj.allOf;
+    if (merged.properties) obj.properties = { ...obj.properties, ...merged.properties };
+    if (merged.required) obj.required = [...(obj.required || []), ...merged.required];
+  }
+
+  for (const value of Object.values(obj)) {
+    if (value && typeof value === "object") {
+      mergeAllOf(value);
+    }
+  }
+}
+
+// Select best schema from anyOf/oneOf
+function selectBest(items) {
+  let bestIdx = 0;
+  let bestScore = -1;
+
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    let score = 0;
+    const type = item.type;
+
+    if (type === "object" || item.properties) {
+      score = 3;
+    } else if (type === "array" || item.items) {
+      score = 2;
+    } else if (type && type !== "null") {
+      score = 1;
+    }
+
+    if (score > bestScore) {
+      bestScore = score;
+      bestIdx = i;
+    }
+  }
+
+  return bestIdx;
+}
+
+// Flatten anyOf/oneOf
+function flattenAnyOfOneOf(obj) {
+  if (!obj || typeof obj !== "object") return;
+
+  if (obj.anyOf && Array.isArray(obj.anyOf) && obj.anyOf.length > 0) {
+    const nonNullSchemas = obj.anyOf.filter(s => s && s.type !== "null");
+    if (nonNullSchemas.length > 0) {
+      const bestIdx = selectBest(nonNullSchemas);
+      const selected = nonNullSchemas[bestIdx];
+      delete obj.anyOf;
+      Object.assign(obj, selected);
+    }
+  }
+
+  if (obj.oneOf && Array.isArray(obj.oneOf) && obj.oneOf.length > 0) {
+    const nonNullSchemas = obj.oneOf.filter(s => s && s.type !== "null");
+    if (nonNullSchemas.length > 0) {
+      const bestIdx = selectBest(nonNullSchemas);
+      const selected = nonNullSchemas[bestIdx];
+      delete obj.oneOf;
+      Object.assign(obj, selected);
+    }
+  }
+
+  for (const value of Object.values(obj)) {
+    if (value && typeof value === "object") {
+      flattenAnyOfOneOf(value);
+    }
+  }
+}
+
+// Flatten type arrays
+function flattenTypeArrays(obj) {
+  if (!obj || typeof obj !== "object") return;
+
+  if (obj.type && Array.isArray(obj.type)) {
+    const nonNullTypes = obj.type.filter(t => t !== "null");
+    obj.type = nonNullTypes.length > 0 ? nonNullTypes[0] : "string";
+  }
+
+  for (const value of Object.values(obj)) {
+    if (value && typeof value === "object") {
+      flattenTypeArrays(value);
+    }
+  }
+}
+
+// Infer missing type=object when properties exist (Gemini requires explicit type)
+function ensureObjectType(obj) {
+  if (!obj || typeof obj !== "object") return;
+  if (obj.properties && !obj.type) obj.type = "object";
+  for (const v of Object.values(obj)) if (v && typeof v === "object") ensureObjectType(v);
+}
+
+// Clean JSON Schema for Antigravity API compatibility - removes unsupported keywords recursively
+export function cleanJSONSchemaForAntigravity(schema) {
+  if (!schema || typeof schema !== "object") return schema;
+
+  // Mutate directly (schema is only used once per request)
+  let cleaned = schema;
+
+  // Phase 1: Convert and prepare
+  convertConstToEnum(cleaned);
+  convertEnumValuesToStrings(cleaned);
+
+  // Phase 2: Flatten complex structures
+  mergeAllOf(cleaned);
+  flattenAnyOfOneOf(cleaned);
+  flattenTypeArrays(cleaned);
+
+  // Phase 2.5: Infer missing type=object when properties exist (Gemini requirement)
+  ensureObjectType(cleaned);
+
+  // Phase 3: Remove all unsupported keywords at ALL levels (including inside arrays)
+  removeUnsupportedKeywords(cleaned, UNSUPPORTED_SCHEMA_CONSTRAINTS);
+
+  // Phase 4: Cleanup required fields recursively
+  function cleanupRequired(obj) {
+    if (!obj || typeof obj !== "object") return;
+
+    if (obj.required && Array.isArray(obj.required) && obj.properties) {
+      const validRequired = obj.required.filter(field =>
+        Object.prototype.hasOwnProperty.call(obj.properties, field)
+      );
+      if (validRequired.length === 0) {
+        delete obj.required;
+      } else {
+        obj.required = validRequired;
+      }
+    }
+
+    // Recurse into nested objects
+    for (const value of Object.values(obj)) {
+      if (value && typeof value === "object") {
+        cleanupRequired(value);
+      }
+    }
+  }
+
+  cleanupRequired(cleaned);
+
+  // Phase 5: Add placeholder for empty object schemas (Antigravity requirement)
+  function addPlaceholders(obj) {
+    if (!obj || typeof obj !== "object") return;
+
+    if (obj.type === "object") {
+      if (!obj.properties || Object.keys(obj.properties).length === 0) {
+        obj.properties = {
+          reason: {
+            type: "string",
+            description: "Brief explanation of why you are calling this tool"
+          }
+        };
+        obj.required = ["reason"];
+      }
+    }
+
+    // Recurse into nested objects
+    for (const value of Object.values(obj)) {
+      if (value && typeof value === "object") {
+        addPlaceholders(value);
+      }
+    }
+  }
+
+  addPlaceholders(cleaned);
+
+  return cleaned;
+}
+

package/open-sse/translator/formats/maxTokens.js

@@ -0,0 +1,34 @@
+import { DEFAULT_MAX_TOKENS, DEFAULT_MIN_TOKENS } from "../../config/runtimeConfig.js";
+
+/**
+ * Adjust max_tokens based on request context
+ * @param {object} body - Request body
+ * @param {number} [ceiling=DEFAULT_MAX_TOKENS] - Upper bound for max_tokens.
+ *   Callers with model context (e.g. openai-to-claude) pass the model's real
+ *   maxOutput so high-output models (Opus 4.8 = 128000) aren't pre-clamped to
+ *   the conservative 64000 default before the model-aware step sees them.
+ * @returns {number} Adjusted max_tokens
+ */
+export function adjustMaxTokens(body, ceiling = DEFAULT_MAX_TOKENS) {
+  let maxTokens = body.max_tokens || DEFAULT_MAX_TOKENS;
+
+  // Auto-increase for tool calling to prevent truncated arguments (min never above max)
+  if (body.tools && Array.isArray(body.tools) && body.tools.length > 0) {
+    if (maxTokens < DEFAULT_MIN_TOKENS) {
+      maxTokens = DEFAULT_MIN_TOKENS;
+    }
+  }
+
+  // Ensure max_tokens > thinking.budget_tokens (Claude API requirement)
+  // Claude API requires strictly greater, so add buffer instead of using the
+  // ceiling which could equal budget_tokens when budget_tokens >= ceiling
+  if (body.thinking?.budget_tokens && maxTokens <= body.thinking.budget_tokens) {
+    maxTokens = body.thinking.budget_tokens + 1024;
+  }
+
+  // Never exceed the ceiling
+  if (maxTokens > ceiling) maxTokens = ceiling;
+
+  return maxTokens;
+}
+

package/open-sse/translator/formats/openai.js

@@ -0,0 +1,134 @@
+// OpenAI helper functions for translator
+import { ROLE, OPENAI_BLOCK, CLAUDE_BLOCK, VALID_OPENAI_CONTENT_TYPES, VALID_OPENAI_MESSAGE_TYPES } from "../schema/index.js";
+
+// Re-export valid-type lists (moved to schema/blocks.js) to keep existing importers working.
+export { VALID_OPENAI_CONTENT_TYPES, VALID_OPENAI_MESSAGE_TYPES };
+
+// Filter messages to OpenAI standard format
+// Remove: thinking, redacted_thinking, signature, and other non-OpenAI blocks
+// 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 === ROLE.DEVELOPER) msg = { ...msg, role: ROLE.SYSTEM };
+
+    // Keep tool messages as-is (OpenAI format)
+    if (msg.role === ROLE.TOOL) return msg;
+
+    // Keep assistant messages with tool_calls as-is
+    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 === CLAUDE_BLOCK.THINKING || block.type === CLAUDE_BLOCK.REDACTED_THINKING) continue;
+
+        // Only keep valid OpenAI content types
+        if (VALID_OPENAI_CONTENT_TYPES.includes(block.type)) {
+          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 === CLAUDE_BLOCK.TOOL_RESULT) {
+          // Keep tool_result but clean it
+          filteredContent.push(stripBlock(block));
+        }
+      }
+      
+      // If all content was filtered, add empty text
+      if (filteredContent.length === 0) {
+        filteredContent.push({ type: OPENAI_BLOCK.TEXT, text: "" });
+      }
+      
+      return { ...msg, content: filteredContent };
+    }
+    
+    return msg;
+  });
+  
+  // 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 === ROLE.TOOL) return true;
+    // Always keep assistant messages with tool_calls
+    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 === OPENAI_BLOCK.TEXT && b.text?.trim()) ||
+        b.type !== OPENAI_BLOCK.TEXT
+      );
+    }
+    return true;
+  });
+
+  // Remove empty tools array (some providers like QWEN reject it)
+  if (body.tools && Array.isArray(body.tools) && body.tools.length === 0) {
+    delete body.tools;
+  }
+
+  // Normalize tools to OpenAI format (from Claude, Gemini, etc.)
+  if (body.tools && Array.isArray(body.tools) && body.tools.length > 0) {
+    body.tools = body.tools.map(tool => {
+      // Already OpenAI format
+      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: OPENAI_BLOCK.FUNCTION,
+          function: {
+            name: tool.name,
+            description: String(tool.description || ""),
+            parameters: tool.input_schema || { type: "object", properties: {} }
+          }
+        };
+      }
+      
+      // Gemini format: {functionDeclarations: [{name, description, parameters}]}
+      if (tool.functionDeclarations && Array.isArray(tool.functionDeclarations)) {
+        return tool.functionDeclarations.map(fn => ({
+          type: OPENAI_BLOCK.FUNCTION,
+          function: {
+            name: fn.name,
+            description: String(fn.description || ""),
+            parameters: fn.parameters || { type: "object", properties: {} }
+          }
+        }));
+      }
+      
+      return tool;
+    }).flat();
+  }
+
+  // Normalize tool_choice to OpenAI format
+  if (body.tool_choice && typeof body.tool_choice === "object") {
+    const choice = body.tool_choice;
+    // Claude format: {type: "auto|any|tool", name?: "..."}
+    if (choice.type === "auto") {
+      body.tool_choice = "auto";
+    } else if (choice.type === "any") {
+      body.tool_choice = "required";
+    } else if (choice.type === "tool" && choice.name) {
+      body.tool_choice = { type: OPENAI_BLOCK.FUNCTION, function: { name: choice.name } };
+    }
+  }
+
+  return body;
+}
+

package/open-sse/translator/formats/responsesApi.js

@@ -0,0 +1,141 @@
+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.
+ * An empty array is treated like an empty string — providers require at least one user
+ * message, so we inject a placeholder rather than forwarding an empty messages[].
+ * @param {string|Array} input - raw input from Responses API body
+ * @returns {Array|null} normalized array or null if invalid
+ */
+export function normalizeResponsesInput(input) {
+  if (typeof input === "string") {
+    const text = input.trim() === "" ? "..." : input;
+    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: RESPONSES_ITEM.MESSAGE, role: ROLE.USER, content: [{ type: RESPONSES_ITEM.INPUT_TEXT, text: "..." }] }];
+    }
+    return input;
+  }
+  return null;
+}
+
+/**
+ * Convert OpenAI Responses API format to standard chat completions format
+ * Responses API uses: { input: [...], instructions: "..." }
+ * Chat API uses: { messages: [...] }
+ */
+export function convertResponsesApiFormat(body) {
+  if (!body.input) return body;
+
+  const result = { ...body };
+  result.messages = [];
+
+  // Convert instructions to system message
+  if (body.instructions) {
+    result.messages.push({ role: ROLE.SYSTEM, content: body.instructions });
+  }
+
+  // Group items by conversation turn
+  let currentAssistantMsg = null;
+  let pendingToolCalls = [];
+  let pendingToolResults = [];
+
+  const inputItems = normalizeResponsesInput(body.input);
+  if (!inputItems) return 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 ? RESPONSES_ITEM.MESSAGE : null);
+
+    if (itemType === RESPONSES_ITEM.MESSAGE) {
+      // Flush any pending assistant message with tool calls
+      if (currentAssistantMsg) {
+        result.messages.push(currentAssistantMsg);
+        currentAssistantMsg = null;
+      }
+      // Flush pending tool results
+      if (pendingToolResults.length > 0) {
+        for (const tr of pendingToolResults) {
+          result.messages.push(tr);
+        }
+        pendingToolResults = [];
+      }
+
+      // 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 === 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: 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 === RESPONSES_ITEM.FUNCTION_CALL) {
+      // Start or append to assistant message with tool_calls
+      if (!currentAssistantMsg) {
+        currentAssistantMsg = {
+          role: ROLE.ASSISTANT,
+          content: null,
+          tool_calls: []
+        };
+      }
+      // Skip items with empty/missing name — upstream APIs reject nameless tool calls (#444)
+      if (!item.name || typeof item.name !== "string" || item.name.trim() === "") continue;
+      currentAssistantMsg.tool_calls.push({
+        id: item.call_id,
+        type: OPENAI_BLOCK.FUNCTION,
+        function: {
+          name: item.name,
+          arguments: item.arguments
+        }
+      });
+    }
+    else if (itemType === RESPONSES_ITEM.FUNCTION_CALL_OUTPUT) {
+      // Flush assistant message first if exists
+      if (currentAssistantMsg) {
+        result.messages.push(currentAssistantMsg);
+        currentAssistantMsg = null;
+      }
+      // Add tool result
+      pendingToolResults.push({
+        role: ROLE.TOOL,
+        tool_call_id: item.call_id,
+        content: typeof item.output === "string" ? item.output : JSON.stringify(item.output)
+      });
+    }
+    else if (itemType === RESPONSES_ITEM.REASONING) {
+      // Skip reasoning items - they are for display only
+      continue;
+    }
+  }
+
+  // Flush remaining
+  if (currentAssistantMsg) {
+    result.messages.push(currentAssistantMsg);
+  }
+  if (pendingToolResults.length > 0) {
+    for (const tr of pendingToolResults) {
+      result.messages.push(tr);
+    }
+  }
+
+  // Cleanup Responses API specific fields
+  delete result.input;
+  delete result.instructions;
+  delete result.include;
+  delete result.prompt_cache_key;
+  delete result.store;
+  delete result.reasoning;
+
+  return result;
+}