zevairouter 1.0.0

package/open-sse/translator/helpers/openaiHelper.js

@@ -0,0 +1,130 @@
+// OpenAI helper functions for translator
+
+// 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"];
+
+// Filter messages to OpenAI standard format
+// Remove: thinking, redacted_thinking, signature, and other non-OpenAI blocks
+export function filterToOpenAIFormat(body) {
+  if (!body.messages || !Array.isArray(body.messages)) return body;
+  
+  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" };
+    
+    // Keep tool messages as-is (OpenAI format)
+    if (msg.role === "tool") return msg;
+    
+    // Keep assistant messages with tool_calls as-is
+    if (msg.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;
+        
+        // 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") {
+          // Convert tool_use to tool_calls format (handled separately)
+          continue;
+        } else if (block.type === "tool_result") {
+          // Keep tool_result but clean it
+          const { signature, cache_control, ...cleanBlock } = block;
+          filteredContent.push(cleanBlock);
+        }
+      }
+      
+      // If all content was filtered, add empty text
+      if (filteredContent.length === 0) {
+        filteredContent.push({ type: "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 === "tool") return true;
+    // Always keep assistant messages with tool_calls
+    if (msg.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"
+      );
+    }
+    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 === "function" && tool.function) return tool;
+      
+      // Claude format: {name, description, input_schema}
+      if (tool.name && (tool.input_schema || tool.description)) {
+        return {
+          type: "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: "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: "function", function: { name: choice.name } };
+    }
+  }
+
+  return body;
+}
+

package/open-sse/translator/helpers/responsesApiHelper.js

@@ -0,0 +1,139 @@
+/**
+ * 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: "message", role: "user", content: [{ type: "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 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: "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 ? "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;
+      result.messages.push({ role: item.role, content });
+    }
+    else if (itemType === "function_call") {
+      // Start or append to assistant message with tool_calls
+      if (!currentAssistantMsg) {
+        currentAssistantMsg = {
+          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: "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;
+      }
+      // Add tool result
+      pendingToolResults.push({
+        role: "tool",
+        tool_call_id: item.call_id,
+        content: typeof item.output === "string" ? item.output : JSON.stringify(item.output)
+      });
+    }
+    else if (itemType === "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;
+}

package/open-sse/translator/helpers/toolCallHelper.js

@@ -0,0 +1,148 @@
+// Tool call helper functions for translator
+
+// Anthropic tool_use.id must match: ^[a-zA-Z0-9_-]+$
+const TOOL_ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
+
+// Generate deterministic tool call ID from position + tool name (cache-friendly)
+export function generateToolCallId(msgIndex = 0, tcIndex = 0, toolName = "") {
+  const name = toolName ? `_${toolName.replace(/[^a-zA-Z0-9_-]/g, "")}` : "";
+  return `call_msg${msgIndex}_tc${tcIndex}${name}`;
+}
+
+// Sanitize ID to match Anthropic pattern: keep only alphanumeric, underscore, hyphen
+function sanitizeToolId(id) {
+  if (!id || typeof id !== "string") return null;
+  const sanitized = id.replace(/[^a-zA-Z0-9_-]/g, "");
+  return sanitized.length > 0 ? sanitized : null;
+}
+
+// Ensure all tool_calls have valid id field and arguments is string (some providers require it)
+export function ensureToolCallIds(body) {
+  if (!body.messages || !Array.isArray(body.messages)) return body;
+
+  for (let i = 0; i < body.messages.length; i++) {
+    const msg = body.messages[i];
+    if (msg.role === "assistant" && msg.tool_calls && Array.isArray(msg.tool_calls)) {
+      for (let j = 0; j < msg.tool_calls.length; j++) {
+        const tc = msg.tool_calls[j];
+        // Validate or regenerate ID for Anthropic compatibility
+        if (!tc.id || !TOOL_ID_PATTERN.test(tc.id)) {
+          const sanitized = sanitizeToolId(tc.id);
+          tc.id = sanitized || generateToolCallId(i, j, tc.function?.name);
+        }
+        if (!tc.type) {
+          tc.type = "function";
+        }
+        // Ensure arguments is JSON string, not object
+        if (tc.function?.arguments && typeof tc.function.arguments !== "string") {
+          tc.function.arguments = JSON.stringify(tc.function.arguments);
+        }
+      }
+    }
+
+    // Validate tool_call_id in tool messages (role: "tool")
+    if (msg.role === "tool" && msg.tool_call_id && !TOOL_ID_PATTERN.test(msg.tool_call_id)) {
+      const sanitized = sanitizeToolId(msg.tool_call_id);
+      msg.tool_call_id = sanitized || generateToolCallId(i, 0);
+    }
+
+    // Also validate tool_use blocks in content (Claude format)
+    if (Array.isArray(msg.content)) {
+      for (let k = 0; k < msg.content.length; k++) {
+        const block = msg.content[k];
+        if (block.type === "tool_use" && block.id && !TOOL_ID_PATTERN.test(block.id)) {
+          const sanitized = sanitizeToolId(block.id);
+          block.id = sanitized || generateToolCallId(i, k, block.name);
+        }
+        // Validate tool_use_id in tool_result blocks
+        if (block.type === "tool_result" && block.tool_use_id && !TOOL_ID_PATTERN.test(block.tool_use_id)) {
+          const sanitized = sanitizeToolId(block.tool_use_id);
+          block.tool_use_id = sanitized || generateToolCallId(i, k);
+        }
+      }
+    }
+  }
+
+  return body;
+}
+
+// Get tool_call ids from assistant message (OpenAI format: tool_calls, Claude format: tool_use in content)
+export function getToolCallIds(msg) {
+  if (msg.role !== "assistant") return [];
+
+  const ids = [];
+
+  // OpenAI format: tool_calls array
+  if (msg.tool_calls && Array.isArray(msg.tool_calls)) {
+    for (const tc of msg.tool_calls) {
+      if (tc.id) ids.push(tc.id);
+    }
+  }
+
+  // Claude format: tool_use blocks in content
+  if (Array.isArray(msg.content)) {
+    for (const block of msg.content) {
+      if (block.type === "tool_use" && block.id) {
+        ids.push(block.id);
+      }
+    }
+  }
+
+  return ids;
+}
+
+// Check if user message has tool_result for given ids (OpenAI format: role=tool, Claude format: tool_result in content)
+export function hasToolResults(msg, toolCallIds) {
+  if (!msg || !toolCallIds.length) return false;
+
+  // OpenAI format: role = "tool" with tool_call_id
+  if (msg.role === "tool" && msg.tool_call_id) {
+    return toolCallIds.includes(msg.tool_call_id);
+  }
+
+  // Claude format: tool_result blocks in user message content
+  if (msg.role === "user" && Array.isArray(msg.content)) {
+    for (const block of msg.content) {
+      if (block.type === "tool_result" && toolCallIds.includes(block.tool_use_id)) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+// Fix missing tool responses - insert empty tool_result if assistant has tool_use but next message has no tool_result
+export function fixMissingToolResponses(body) {
+  if (!body.messages || !Array.isArray(body.messages)) return body;
+
+  const newMessages = [];
+
+  for (let i = 0; i < body.messages.length; i++) {
+    const msg = body.messages[i];
+    const nextMsg = body.messages[i + 1];
+
+    newMessages.push(msg);
+
+    // Check if this is assistant with tool_calls/tool_use
+    const toolCallIds = getToolCallIds(msg);
+    if (toolCallIds.length === 0) continue;
+
+    // Check if next message has tool_result
+    if (nextMsg && !hasToolResults(nextMsg, toolCallIds)) {
+      // Insert tool responses for each tool_call
+      for (const id of toolCallIds) {
+        // OpenAI format: role = "tool"
+        newMessages.push({
+          role: "tool",
+          tool_call_id: id,
+          content: ""
+        });
+      }
+    }
+  }
+
+  body.messages = newMessages;
+  return body;
+}
+

package/open-sse/translator/index.js

@@ -0,0 +1,251 @@
+import { FORMATS } from "./formats.js";
+import { ensureToolCallIds, fixMissingToolResponses } from "./helpers/toolCallHelper.js";
+import { prepareClaudeRequest } from "./helpers/claudeHelper.js";
+import { cloakClaudeTools } from "../utils/claudeCloaking.js";
+import { filterToOpenAIFormat } from "./helpers/openaiHelper.js";
+import { normalizeThinkingConfig } from "../services/provider.js";
+import { AntigravityExecutor } from "../executors/antigravity.js";
+
+// Registry for translators
+const requestRegistry = new Map();
+const responseRegistry = new Map();
+
+// Track initialization state
+let initialized = false;
+
+// Register translator
+export function register(from, to, requestFn, responseFn) {
+  const key = `${from}:${to}`;
+  if (requestFn) {
+    requestRegistry.set(key, requestFn);
+  }
+  if (responseFn) {
+    responseRegistry.set(key, 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");
+}
+
+// Strip specific content types from messages (explicit opt-in via strip[] in PROVIDER_MODELS)
+function stripContentTypes(body, stripList = []) {
+  if (!stripList.length || !body.messages || !Array.isArray(body.messages)) return;
+  const imageTypes = new Set(["image_url", "image"]);
+  const audioTypes = new Set(["audio_url", "input_audio"]);
+  const shouldStrip = (type) => {
+    if (imageTypes.has(type)) return stripList.includes("image");
+    if (audioTypes.has(type)) return stripList.includes("audio");
+    return false;
+  };
+  for (const msg of body.messages) {
+    if (!Array.isArray(msg.content)) continue;
+    msg.content = msg.content.filter(part => !shouldStrip(part.type));
+    if (msg.content.length === 0) msg.content = "";
+  }
+}
+
+// Translate request: source -> openai -> target
+export function translateRequest(sourceFormat, targetFormat, model, body, stream = true, credentials = null, provider = null, reqLogger = null, stripList = [], connectionId = null, clientTool = null) {
+  ensureInitialized();
+  let result = body;
+
+  // Strip explicit content types (opt-in via strip[] in PROVIDER_MODELS entry)
+  stripContentTypes(result, stripList);
+
+  // Normalize thinking config: remove if lastMessage is not user
+  normalizeThinkingConfig(result);
+
+  // Always ensure tool_calls have id (some providers require it)
+  ensureToolCallIds(result);
+  
+  // Fix missing tool responses (insert empty tool_result if needed)
+  fixMissingToolResponses(result);
+
+  // 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);
+      }
+    }
+
+    // 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);
+      }
+    }
+  }
+
+  // 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);
+  }
+
+  // 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);
+  }
+
+  // Claude cloaking: rename client tools with _cc suffix (anti-ban)
+  // Only for claude provider (not anthropic-compatible-*) with OAuth token
+  if (provider === "claude") {
+    const apiKey = credentials?.accessToken || credentials?.apiKey || null;
+    if (apiKey?.includes("sk-ant-oat")) {
+      const { body: cloakedBody, toolNameMap } = cloakClaudeTools(result);
+      result = cloakedBody;
+      if (toolNameMap?.size > 0) {
+        result._toolNameMap = toolNameMap;
+      }
+    }
+  }
+
+  // Antigravity cloaking disabled
+  // if (provider === FORMATS.ANTIGRAVITY && body.userAgent !== FORMATS.ANTIGRAVITY) {
+  //   const { cloakedBody, toolNameMap } = AntigravityExecutor.cloakTools(result);
+  //   result = cloakedBody;
+  //   if (toolNameMap?.size > 0) {
+  //     result._toolNameMap = toolNameMap;
+  //   }
+  // }
+
+  return result;
+}
+
+// Translate response chunk: target -> openai -> source
+export function translateResponse(targetFormat, sourceFormat, chunk, state) {
+  ensureInitialized();
+  // If same format, return as-is
+  if (sourceFormat === targetFormat) {
+    return [chunk];
+  }
+
+  let results = [chunk];
+  let openaiResults = null; // Store OpenAI intermediate results
+
+  // Step 1: target -> openai (if target is not openai)
+  if (targetFormat !== FORMATS.OPENAI) {
+    const toOpenAI = responseRegistry.get(`${targetFormat}:${FORMATS.OPENAI}`);
+    if (toOpenAI) {
+      results = [];
+      const converted = toOpenAI(chunk, state);
+      if (converted) {
+        results = Array.isArray(converted) ? converted : [converted];
+        openaiResults = results; // Store OpenAI intermediate
+      }
+    }
+  }
+
+  // Step 2: openai -> source (if source is not openai)
+  if (sourceFormat !== FORMATS.OPENAI) {
+    const fromOpenAI = responseRegistry.get(`${FORMATS.OPENAI}:${sourceFormat}`);
+    if (fromOpenAI) {
+      const finalResults = [];
+      for (const r of results) {
+        const converted = fromOpenAI(r, state);
+        if (converted) {
+          finalResults.push(...(Array.isArray(converted) ? converted : [converted]));
+        }
+      }
+      results = finalResults;
+    }
+  }
+
+  // Attach OpenAI intermediate results for logging
+  if (openaiResults && sourceFormat !== FORMATS.OPENAI && targetFormat !== FORMATS.OPENAI) {
+    results._openaiIntermediate = openaiResults;
+  }
+
+  return results;
+}
+
+// Check if translation needed
+export function needsTranslation(sourceFormat, targetFormat) {
+  return sourceFormat !== targetFormat;
+}
+
+// Initialize state for streaming response based on format
+export function initState(sourceFormat) {
+  // Base state for all formats
+  const base = {
+    messageId: null,
+    model: null,
+    textBlockStarted: false,
+    thinkingBlockStarted: false,
+    inThinkingBlock: false,
+    currentBlockIndex: null,
+    toolCalls: new Map(),
+    finishReason: null,
+    finishReasonSent: false,
+    usage: null,
+    contentBlockIndex: -1
+  };
+
+  // Add openai-responses specific fields
+  if (sourceFormat === FORMATS.OPENAI_RESPONSES) {
+    return {
+      ...base,
+      seq: 0,
+      responseId: `resp_${Date.now()}`,
+      created: Math.floor(Date.now() / 1000),
+      started: false,
+      msgTextBuf: {},
+      msgItemAdded: {},
+      msgContentAdded: {},
+      msgItemDone: {},
+      reasoningId: "",
+      reasoningIndex: -1,
+      reasoningBuf: "",
+      reasoningPartAdded: false,
+      reasoningDone: false,
+      inThinking: false,
+      funcArgsBuf: {},
+      funcNames: {},
+      funcCallIds: {},
+      funcArgsDone: {},
+      funcItemDone: {},
+      completedSent: false
+    };
+  }
+
+  return base;
+}
+
+// Initialize all translators (kept for backward compatibility)
+export function initTranslators() {
+  ensureInitialized();
+}