zevairouter 1.0.152 → 1.0.154

package/open-sse/translator/request/claude-to-openai.js

@@ -123,6 +123,8 @@ function convertClaudeMessage(msg) {
     const parts = [];
     const toolCalls = [];
     const toolResults = [];
+    const toolResultImages = [];
+    const reasoningParts = [];
 
     for (const block of msg.content) {
       switch (block.type) {
@@ -131,16 +133,20 @@ function convertClaudeMessage(msg) {
           break;
 
         case "image":
-          if (block.source?.type === "base64") {
-            parts.push({
-              type: "image_url",
-              image_url: {
-                url: `data:${block.source.media_type};base64,${block.source.data}`
-              }
-            });
+          {
+            const image = convertClaudeImage(block.source);
+            if (image) parts.push(image);
           }
           break;
 
+        case "thinking":
+          if (block.thinking) reasoningParts.push(block.thinking);
+          break;
+
+        case "redacted_thinking":
+          if (block.data) reasoningParts.push(block.data);
+          break;
+
         case "tool_use":
           toolCalls.push({
             id: block.id,
@@ -153,17 +159,30 @@ function convertClaudeMessage(msg) {
           break;
 
         case "tool_result":
+          {
           let resultContent = "";
           if (typeof block.content === "string") {
             resultContent = block.content;
           } else if (Array.isArray(block.content)) {
-            resultContent = block.content
+            const textContent = block.content
               .filter(c => c.type === "text")
               .map(c => c.text)
-              .join("\n") || JSON.stringify(block.content);
+              .join("\n");
+            const images = block.content
+              .filter(c => c.type === "image")
+              .map(c => convertClaudeImage(c.source))
+              .filter(Boolean);
+            toolResultImages.push(...images);
+            resultContent = textContent || (images.length > 0
+              ? "Tool returned image attachment(s) in the following user message."
+              : JSON.stringify(block.content));
           } else if (block.content) {
             resultContent = JSON.stringify(block.content);
           }
+
+          if (block.is_error) {
+            resultContent = `Tool result error (is_error=true):\n${resultContent}`;
+          }
           
           toolResults.push({
             role: "tool",
@@ -171,38 +190,44 @@ function convertClaudeMessage(msg) {
             content: resultContent
           });
           break;
+          }
       }
     }
 
-    // If has tool results, return array of tool messages
+    const reasoningContent = reasoningParts.join("\n");
+
+    // Tool results must remain tool messages, while their image attachments use
+    // a following user message because OpenAI tool messages only accept text.
     if (toolResults.length > 0) {
-      if (parts.length > 0) {
-        const textContent = parts.length === 1 && parts[0].type === "text" 
-          ? parts[0].text 
-          : parts;
-        return [...toolResults, { role: "user", content: textContent }];
+      const followupParts = [...parts, ...toolResultImages];
+      const convertedMessages = [...toolResults];
+      if (followupParts.length > 0) {
+        const content = followupParts.length === 1 && followupParts[0].type === "text"
+          ? followupParts[0].text
+          : followupParts;
+        convertedMessages.push({ role: "user", content });
+      }
+      if (toolCalls.length > 0) {
+        convertedMessages.push(buildAssistantToolCallMessage(toolCalls, [], reasoningContent));
       }
-      return toolResults;
+      return convertedMessages;
     }
 
     // If has tool calls, return assistant message with tool_calls
     if (toolCalls.length > 0) {
-      const result = { role: "assistant" };
-      if (parts.length > 0) {
-        result.content = parts.length === 1 && parts[0].type === "text" 
-          ? parts[0].text 
-          : parts;
-      }
-      result.tool_calls = toolCalls;
-      return result;
+      return buildAssistantToolCallMessage(toolCalls, parts, reasoningContent);
     }
 
     // Return content
-    if (parts.length > 0) {
-      return {
+    if (parts.length > 0 || reasoningContent) {
+      const result = {
         role,
-        content: parts.length === 1 && parts[0].type === "text" ? parts[0].text : parts
+        ...(parts.length > 0 && {
+          content: parts.length === 1 && parts[0].type === "text" ? parts[0].text : parts
+        })
       };
+      if (role === "assistant" && reasoningContent) result.reasoning_content = reasoningContent;
+      return result;
     }
     
     // Empty content array
@@ -214,6 +239,28 @@ function convertClaudeMessage(msg) {
   return null;
 }
 
+function convertClaudeImage(source) {
+  if (source?.type === "base64" && source.data) {
+    return {
+      type: "image_url",
+      image_url: { url: `data:${source.media_type || "image/png"};base64,${source.data}` }
+    };
+  }
+  if (source?.type === "url" && /^https?:\/\//.test(source.url || "")) {
+    return { type: "image_url", image_url: { url: source.url } };
+  }
+  return null;
+}
+
+function buildAssistantToolCallMessage(toolCalls, parts, reasoningContent) {
+  const result = { role: "assistant", tool_calls: toolCalls };
+  if (parts.length > 0) {
+    result.content = parts.length === 1 && parts[0].type === "text" ? parts[0].text : parts;
+  }
+  if (reasoningContent) result.reasoning_content = reasoningContent;
+  return result;
+}
+
 // Convert tool choice
 function convertToolChoice(choice) {
   if (!choice) return "auto";
@@ -229,4 +276,3 @@ function convertToolChoice(choice) {
 
 // Register
 register(FORMATS.CLAUDE, FORMATS.OPENAI, claudeToOpenAIRequest, null);
-

package/open-sse/translator/request/openai-responses.js

@@ -6,7 +6,7 @@
  */
 import { register } from "../index.js";
 import { FORMATS } from "../formats.js";
-import { normalizeResponsesInput } from "../helpers/responsesApiHelper.js";
+import { convertResponsesApiFormat } from "../helpers/responsesApiHelper.js";
 
 // Responses API enforces max 64 chars on call_id (#393)
 const MAX_CALL_ID_LEN = 64;
@@ -16,174 +16,7 @@ const clampCallId = (id) => (typeof id === "string" && id.length > MAX_CALL_ID_L
  * Convert OpenAI Responses API request to OpenAI Chat Completions format
  */
 export function openaiResponsesToOpenAIRequest(model, body, stream, credentials) {
-  if (!body.input) return body;
-
-  const result = { ...body };
-  result.messages = [];
-
-  // Convert instructions to system message
-  if (body.instructions) {
-    result.messages.push({ role: "system", content: body.instructions });
-  }
-
-  // Group items by conversation turn
-  let currentAssistantMsg = null;
-  let pendingToolResults = [];
-  let pendingReasoning = "";
-
-  const inputItems = normalizeResponsesInput(body.input);
-  if (!inputItems) return body;
-
-  // Extract reasoning text from summary[].text or encrypted_content fallback
-  const extractReasoningText = (item) => {
-    if (Array.isArray(item.summary)) {
-      const txt = item.summary.map(s => s?.text || "").filter(Boolean).join("\n");
-      if (txt) return txt;
-    }
-    if (Array.isArray(item.content)) {
-      const txt = item.content.map(c => c?.text || "").filter(Boolean).join("\n");
-      if (txt) return txt;
-    }
-    return "";
-  };
-
-  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);
-
-    if (itemType === "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 === "input_text") return { type: "text", text: c.text };
-          if (c.type === "output_text") return { type: "text", text: c.text };
-          if (c.type === "input_image") {
-            const url = c.image_url || c.file_id || "";
-            return { type: "image_url", image_url: { url, detail: c.detail || "auto" } };
-          }
-          return c;
-        })
-        : item.content;
-      const msg = { role: item.role, content };
-      // Attach buffered reasoning to assistant turn (required by xiaomi-mimo thinking mode)
-      if (item.role === "assistant" && pendingReasoning) {
-        msg.reasoning_content = pendingReasoning;
-      }
-      pendingReasoning = "";
-      result.messages.push(msg);
-    }
-    else if (itemType === "function_call") {
-      // Start or append to assistant message with tool_calls
-      if (!currentAssistantMsg) {
-        currentAssistantMsg = {
-          role: "assistant",
-          content: null,
-          tool_calls: []
-        };
-        if (pendingReasoning) {
-          currentAssistantMsg.reasoning_content = pendingReasoning;
-          pendingReasoning = "";
-        }
-      }
-      // Skip items with empty/missing name — Codex/OpenAI 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: "function",
-        function: {
-          name: item.name,
-          arguments: item.arguments
-        }
-      });
-    }
-    else if (itemType === "function_call_output") {
-      // Flush assistant message first if exists
-      if (currentAssistantMsg) {
-        result.messages.push(currentAssistantMsg);
-        currentAssistantMsg = null;
-      }
-      // Flush any pending tool results first
-      if (pendingToolResults.length > 0) {
-        for (const tr of pendingToolResults) {
-          result.messages.push(tr);
-        }
-        pendingToolResults = [];
-      }
-      // Add tool result immediately
-      result.messages.push({
-        role: "tool",
-        tool_call_id: item.call_id,
-        content: typeof item.output === "string" ? item.output : JSON.stringify(item.output)
-      });
-    }
-    else if (itemType === "reasoning") {
-      // Buffer reasoning text; attached to next assistant message/function_call
-      const txt = extractReasoningText(item);
-      if (txt) pendingReasoning = pendingReasoning ? `${pendingReasoning}\n${txt}` : txt;
-      continue;
-    }
-  }
-
-  // Flush remaining
-  if (currentAssistantMsg) {
-    result.messages.push(currentAssistantMsg);
-  }
-  if (pendingToolResults.length > 0) {
-    for (const tr of pendingToolResults) {
-      result.messages.push(tr);
-    }
-  }
-
-  // Convert tools format.
-  // Responses API supports "hosted" tools (e.g. { type: "request_user_input" }) that carry no
-  // explicit `name` field and cannot be represented as Chat Completions function declarations.
-  // Filter them out to avoid sending nameless functionDeclarations to downstream providers
-  // such as Gemini, which strictly validates function names.
-  if (body.tools && Array.isArray(body.tools)) {
-    result.tools = body.tools
-      .map(tool => {
-        // Already in Chat Completions format: { type: "function", function: { name, ... } }
-        if (tool.function) return tool;
-        // Responses API function tool: { type: "function", name, description, parameters }
-        // Only convert when a non-empty name is present; skip hosted tools without one.
-        const name = tool.name;
-        if (!name || typeof name !== "string" || name.trim() === "") return null;
-        return {
-          type: "function",
-          function: {
-            name,
-            description: String(tool.description || ""),
-            parameters: normalizeToolParameters(tool.parameters),
-            strict: tool.strict
-          }
-        };
-      })
-      .filter(Boolean);
-  }
-
-  // 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;
+  return convertResponsesApiFormat(body);
 }
 
 /**
@@ -200,27 +33,27 @@ function normalizeToolParameters(params) {
  */
 export function openaiToOpenAIResponsesRequest(model, body, stream, credentials) {
   // Body already in Responses API format (e.g. Cursor CLI calling /chat/completions with input[])
-  if (body.input) return { ...body, model, stream: true };
+  if (body && typeof body === "object" && "input" in body) {
+    return { ...body, model, stream: stream === true };
+  }
 
   const result = {
     model,
     input: [],
-    stream: true,
+    stream: stream === true,
     store: false
   };
 
-  // Extract system message as instructions
-  let hasSystemMessage = false;
+  // Responses has one instruction field, so preserve every system/developer
+  // message in order instead of silently keeping only the first one.
+  const instructionParts = [];
   const messages = body.messages || [];
 
   for (const msg of messages) {
-    if (msg.role === "system") {
-      // Use first system message as instructions
-      if (!hasSystemMessage) {
-        result.instructions = typeof msg.content === "string" ? msg.content : "";
-        hasSystemMessage = true;
-      }
-      continue; // Skip system messages in input
+    if (msg.role === "system" || msg.role === "developer") {
+      const text = extractInstructionText(msg.content);
+      if (text) instructionParts.push(text);
+      continue;
     }
 
     // Convert user/assistant messages to input items
@@ -263,8 +96,8 @@ export function openaiToOpenAIResponsesRequest(model, body, stream, credentials)
         result.input.push({
           type: "function_call",
           call_id: clampCallId(tc.id),
-          name: tc.function?.name || "_unknown",
-          arguments: tc.function?.arguments || "{}"
+          name: normalizeFunctionName(tc.function?.name),
+          arguments: serializeValue(tc.function?.arguments, "{}")
         });
       }
     }
@@ -275,7 +108,7 @@ export function openaiToOpenAIResponsesRequest(model, body, stream, credentials)
         ? msg.content
         : Array.isArray(msg.content)
           ? msg.content.map(c => c.text || JSON.stringify(c)).join("")
-          : JSON.stringify(msg.content);
+          : serializeValue(msg.content, "");
       result.input.push({
         type: "function_call_output",
         call_id: clampCallId(msg.tool_call_id),
@@ -284,18 +117,16 @@ export function openaiToOpenAIResponsesRequest(model, body, stream, credentials)
     }
   }
 
-  // If no system message, leave instructions empty (will be filled by executor)
-  if (!hasSystemMessage) {
-    result.instructions = "";
-  }
+  // Leave an empty value for the executor's provider-specific default.
+  result.instructions = instructionParts.join("\n\n");
 
   // Convert tools format
   if (body.tools && Array.isArray(body.tools)) {
     result.tools = body.tools.map(tool => {
-      if (tool.type === "function") {
+      if (tool.type === "function" && tool.function) {
         return {
           type: "function",
-          name: tool.function.name,
+          name: normalizeFunctionName(tool.function.name),
           description: String(tool.function.description || ""),
           parameters: normalizeToolParameters(tool.function.parameters),
           strict: tool.function.strict
@@ -307,12 +138,75 @@ export function openaiToOpenAIResponsesRequest(model, body, stream, credentials)
 
   // Pass through other relevant fields
   if (body.temperature !== undefined) result.temperature = body.temperature;
-  if (body.max_tokens !== undefined) result.max_tokens = body.max_tokens;
   if (body.top_p !== undefined) result.top_p = body.top_p;
+  const maxOutputTokens = body.max_output_tokens ?? body.max_completion_tokens ?? body.max_tokens;
+  if (maxOutputTokens !== undefined) result.max_output_tokens = maxOutputTokens;
+  if (body.reasoning && typeof body.reasoning === "object") {
+    result.reasoning = { ...body.reasoning };
+  } else if (typeof body.reasoning_effort === "string") {
+    result.reasoning = { effort: body.reasoning_effort };
+  }
+  const textFormat = chatResponseFormatToResponses(body.response_format);
+  if (textFormat) result.text = { format: textFormat };
+  if (body.tool_choice !== undefined) result.tool_choice = chatToolChoiceToResponses(body.tool_choice);
+  if (body.parallel_tool_calls !== undefined) result.parallel_tool_calls = body.parallel_tool_calls;
 
   return result;
 }
 
+function extractInstructionText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .map((part) => {
+      if (typeof part === "string") return part;
+      if (typeof part?.text === "string") return part.text;
+      if (typeof part?.content === "string") return part.content;
+      return "";
+    })
+    .filter(Boolean)
+    .join("\n");
+}
+
+function normalizeFunctionName(name) {
+  return typeof name === "string" && name.trim() ? name.trim() : "_unknown";
+}
+
+function serializeValue(value, fallback) {
+  if (typeof value === "string") return value;
+  if (value === undefined) return fallback;
+  try {
+    const serialized = JSON.stringify(value);
+    return serialized === undefined ? fallback : serialized;
+  } catch {
+    return String(value);
+  }
+}
+
+function chatResponseFormatToResponses(format) {
+  if (!format || typeof format !== "object") return null;
+  if (format.type !== "json_schema") return { ...format };
+
+  const schema = format.json_schema;
+  if (!schema || typeof schema !== "object") return null;
+  return {
+    type: "json_schema",
+    ...(schema.name !== undefined && { name: schema.name }),
+    ...(schema.description !== undefined && { description: schema.description }),
+    ...(schema.schema !== undefined && { schema: schema.schema }),
+    ...(schema.strict !== undefined && { strict: schema.strict }),
+  };
+}
+
+function chatToolChoiceToResponses(choice) {
+  if (!choice || typeof choice !== "object") return choice;
+  const name = choice.function?.name;
+  if (choice.type === "function" && typeof name === "string" && name.trim()) {
+    return { type: "function", name: name.trim() };
+  }
+  return choice;
+}
+
 // Register both directions
 register(FORMATS.OPENAI_RESPONSES, FORMATS.OPENAI, openaiResponsesToOpenAIRequest, null);
 register(FORMATS.OPENAI, FORMATS.OPENAI_RESPONSES, openaiToOpenAIResponsesRequest, null);

package/open-sse/translator/request/openai-to-claude.js

@@ -8,7 +8,7 @@ import { adjustMaxTokens } from "../helpers/maxTokensHelper.js";
 const CLAUDE_OAUTH_TOOL_PREFIX = "";
 
 // Convert OpenAI request to Claude format
-export function openaiToClaudeRequest(model, body, stream) {
+export function openaiToClaudeRequest(model, body, stream, _credentials = null, provider = null) {
   // Tool name mapping for Claude OAuth (capitalizedName → originalName)
   const toolNameMap = new Map();
   const result = {
@@ -120,18 +120,20 @@ Respond ONLY with the JSON object, no other text.`);
     }
   }
 
-  // System with Claude Code prompt and cache_control
-  const claudeCodePrompt = { type: "text", text: CLAUDE_SYSTEM_PROMPT };
-
+  // The Claude Code identity prompt is required by the official integration,
+  // but it must not pollute requests sent to unrelated Claude-compatible APIs.
+  const systemBlocks = [];
+  if (provider === null || provider === "claude") {
+    systemBlocks.push({ type: "text", text: CLAUDE_SYSTEM_PROMPT });
+  }
   if (systemParts.length > 0) {
-    const systemText = systemParts.join("\n");
-    result.system = [
-      claudeCodePrompt,
-      { type: "text", text: systemText, cache_control: { type: "ephemeral", ttl: "1h" } }
-    ];
-  } else {
-    result.system = [claudeCodePrompt];
+    systemBlocks.push({
+      type: "text",
+      text: systemParts.join("\n"),
+      cache_control: { type: "ephemeral", ttl: "1h" }
+    });
   }
+  if (systemBlocks.length > 0) result.system = systemBlocks;
 
   // Tools - convert from OpenAI format to Claude format with prefix for OAuth
   if (body.tools && Array.isArray(body.tools)) {
@@ -211,10 +213,17 @@ function getContentBlocksFromMessage(msg, toolNameMap = new Map()) {
   const blocks = [];
 
   if (msg.role === "tool") {
+    let content = msg.content;
+    let isError = msg.is_error === true;
+    if (typeof content === "string" && content.startsWith("Tool result error (is_error=true):")) {
+      isError = true;
+      content = content.replace(/^Tool result error \(is_error=true\):\n?/, "");
+    }
     blocks.push({
       type: "tool_result",
       tool_use_id: msg.tool_call_id,
-      content: msg.content
+      content,
+      ...(isError && { is_error: true })
     });
   } else if (msg.role === "user") {
     if (typeof msg.content === "string") {
@@ -248,6 +257,16 @@ function getContentBlocksFromMessage(msg, toolNameMap = new Map()) {
           }
         } else if (part.type === "image" && part.source) {
           blocks.push({ type: "image", source: part.source });
+        } else if (part.type === "input_audio" && part.input_audio?.data) {
+          const format = String(part.input_audio.format || "wav").toLowerCase();
+          blocks.push({
+            type: "audio",
+            source: {
+              type: "base64",
+              media_type: format === "mp3" ? "audio/mpeg" : `audio/${format}`,
+              data: part.input_audio.data
+            }
+          });
         }
       }
     }
@@ -263,6 +282,9 @@ function getContentBlocksFromMessage(msg, toolNameMap = new Map()) {
           // Include thinking block but strip cache_control (not allowed on thinking blocks)
           const { cache_control, ...thinkingBlock } = part;
           blocks.push(thinkingBlock);
+        } else if (part.type === "redacted_thinking") {
+          const { cache_control, ...thinkingBlock } = part;
+          blocks.push(thinkingBlock);
         }
       }
     } else if (msg.content) {
@@ -272,6 +294,10 @@ function getContentBlocksFromMessage(msg, toolNameMap = new Map()) {
       }
     }
 
+    if (typeof msg.reasoning_content === "string" && msg.reasoning_content) {
+      blocks.unshift({ type: "thinking", thinking: msg.reasoning_content });
+    }
+
     if (msg.tool_calls && Array.isArray(msg.tool_calls)) {
       for (const tc of msg.tool_calls) {
         if (tc.type === "function") {
@@ -303,7 +329,8 @@ function convertOpenAIToolChoice(choice) {
   // OpenAI string forms: "auto" | "none" | "required"
   if (typeof choice === "string") {
     if (choice === "required") return { type: "any" };
-    return { type: "auto" }; // "auto", "none", or anything unexpected
+    if (choice === "none") return { type: "none" };
+    return { type: "auto" }; // "auto" or anything unexpected
   }
 
   if (typeof choice === "object") {
@@ -398,4 +425,3 @@ export { openaiToClaudeRequestForAntigravity };
 
 // Register
 register(FORMATS.OPENAI, FORMATS.CLAUDE, openaiToClaudeRequest, null);
-

package/open-sse/translator/request/openai-to-commandcode.js

@@ -38,8 +38,16 @@ function toContentBlocks(content) {
       } else if (part && typeof part === "object") {
         if (part.type === "text" && typeof part.text === "string") {
           blocks.push({ type: "text", text: part.text });
-        } else if (part.type === "image_url" || part.type === "image") {
-          blocks.push({ type: "text", text: "[image omitted]" });
+        } else if (part.type === "image_url") {
+          const image = typeof part.image_url === "string" ? part.image_url : part.image_url?.url;
+          if (image) blocks.push({ type: "image", image });
+        } else if (part.type === "image" && part.source) {
+          if (part.source.type === "base64" && part.source.data) {
+            const mediaType = part.source.media_type || "image/png";
+            blocks.push({ type: "image", image: `data:${mediaType};base64,${part.source.data}` });
+          } else if (part.source.type === "url" && part.source.url) {
+            blocks.push({ type: "image", image: part.source.url });
+          }
         } else if (typeof part.text === "string") {
           blocks.push({ type: "text", text: part.text });
         }
@@ -53,7 +61,7 @@ function toContentBlocks(content) {
 function safeParseJson(s) {
   if (s == null) return {};
   if (typeof s !== "string") return s;
-  try { return JSON.parse(s); } catch { return {}; }
+  try { return JSON.parse(s); } catch { return { _raw: s }; }
 }
 
 function convertMessages(messages = []) {