@fudrouter/fsrouter 0.6.63 → 0.6.64

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

@@ -1,380 +0,0 @@
-// 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

@@ -1,34 +0,0 @@
-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

@@ -1,134 +0,0 @@
-// 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

@@ -1,141 +0,0 @@
-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;
-}