zevairouter 1.0.154 → 1.0.155

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

@@ -1,278 +0,0 @@
-import { register } from "../index.js";
-import { FORMATS } from "../formats.js";
-import { adjustMaxTokens } from "../helpers/maxTokensHelper.js";
-
-// Convert Claude request to OpenAI format
-export function claudeToOpenAIRequest(model, body, stream) {
-  const result = {
-    model: model,
-    messages: [],
-    stream: stream
-  };
-
-  // Max tokens
-  if (body.max_tokens) {
-    result.max_tokens = adjustMaxTokens(body);
-  }
-
-  // Temperature
-  if (body.temperature !== undefined) {
-    result.temperature = body.temperature;
-  }
-
-  // System message
-  if (body.system) {
-    const systemContent = Array.isArray(body.system)
-      ? body.system.map(s => s.text || "").join("\n")
-      : body.system;
-    
-    if (systemContent) {
-      result.messages.push({
-        role: "system",
-        content: systemContent
-      });
-    }
-  }
-
-  // Convert messages
-  if (body.messages && Array.isArray(body.messages)) {
-    for (let i = 0; i < body.messages.length; i++) {
-      const msg = body.messages[i];
-      const converted = convertClaudeMessage(msg);
-      if (converted) {
-        // Handle array of messages (multiple tool results)
-        if (Array.isArray(converted)) {
-          result.messages.push(...converted);
-        } else {
-          result.messages.push(converted);
-        }
-      }
-    }
-  }
-
-  // Fix missing tool responses - OpenAI requires every tool_call to have a response
-  fixMissingToolResponses(result.messages);
-
-  // Tools
-  if (body.tools && Array.isArray(body.tools)) {
-    result.tools = body.tools.map(tool => ({
-      type: "function",
-      function: {
-        name: tool.name,
-        description: String(tool.description || ""),
-        parameters: tool.input_schema || { type: "object", properties: {} }
-      }
-    }));
-  }
-
-  // Tool choice
-  if (body.tool_choice) {
-    result.tool_choice = convertToolChoice(body.tool_choice);
-  }
-
-  return result;
-}
-
-// Fix missing tool responses - add empty responses for tool_calls without responses
-function fixMissingToolResponses(messages) {
-  for (let i = 0; i < messages.length; i++) {
-    const msg = messages[i];
-    if (msg.role === "assistant" && msg.tool_calls && msg.tool_calls.length > 0) {
-      const toolCallIds = msg.tool_calls.map(tc => tc.id);
-      
-      // Collect all tool response IDs that IMMEDIATELY follow this assistant message
-      const respondedIds = new Set();
-      let insertPosition = i + 1;
-      for (let j = i + 1; j < messages.length; j++) {
-        const nextMsg = messages[j];
-        if (nextMsg.role === "tool" && nextMsg.tool_call_id) {
-          respondedIds.add(nextMsg.tool_call_id);
-          insertPosition = j + 1;
-        } else {
-          break;
-        }
-      }
-      
-      // Find missing responses and insert them
-      const missingIds = toolCallIds.filter(id => !respondedIds.has(id));
-      
-      if (missingIds.length > 0) {
-        const missingResponses = missingIds.map(id => ({
-          role: "tool",
-          tool_call_id: id,
-          content: "[No response received]"
-        }));
-        messages.splice(insertPosition, 0, ...missingResponses);
-        i = insertPosition + missingResponses.length - 1;
-      }
-    }
-  }
-}
-
-// Convert single Claude message - returns single message or array of messages
-function convertClaudeMessage(msg) {
-  const role = msg.role === "user" || msg.role === "tool" ? "user" : "assistant";
-  
-  // Simple string content
-  if (typeof msg.content === "string") {
-    return { role, content: msg.content };
-  }
-
-  // Array content
-  if (Array.isArray(msg.content)) {
-    const parts = [];
-    const toolCalls = [];
-    const toolResults = [];
-    const toolResultImages = [];
-    const reasoningParts = [];
-
-    for (const block of msg.content) {
-      switch (block.type) {
-        case "text":
-          parts.push({ type: "text", text: block.text });
-          break;
-
-        case "image":
-          {
-            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,
-            type: "function",
-            function: {
-              name: block.name,
-              arguments: JSON.stringify(block.input || {})
-            }
-          });
-          break;
-
-        case "tool_result":
-          {
-          let resultContent = "";
-          if (typeof block.content === "string") {
-            resultContent = block.content;
-          } else if (Array.isArray(block.content)) {
-            const textContent = block.content
-              .filter(c => c.type === "text")
-              .map(c => c.text)
-              .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",
-            tool_call_id: block.tool_use_id,
-            content: resultContent
-          });
-          break;
-          }
-      }
-    }
-
-    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) {
-      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 convertedMessages;
-    }
-
-    // If has tool calls, return assistant message with tool_calls
-    if (toolCalls.length > 0) {
-      return buildAssistantToolCallMessage(toolCalls, parts, reasoningContent);
-    }
-
-    // Return content
-    if (parts.length > 0 || reasoningContent) {
-      const result = {
-        role,
-        ...(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
-    if (msg.content.length === 0) {
-      return { role, content: "" };
-    }
-  }
-
-  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";
-  if (typeof choice === "string") return choice;
-  
-  switch (choice.type) {
-    case "auto": return "auto";
-    case "any": return "required";
-    case "tool": return { type: "function", function: { name: choice.name } };
-    default: return "auto";
-  }
-}
-
-// Register
-register(FORMATS.CLAUDE, FORMATS.OPENAI, claudeToOpenAIRequest, null);

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

@@ -1,147 +0,0 @@
-import { register } from "../index.js";
-import { FORMATS } from "../formats.js";
-import { adjustMaxTokens } from "../helpers/maxTokensHelper.js";
-
-// Convert Gemini request to OpenAI format
-export function geminiToOpenAIRequest(model, body, stream) {
-  const result = {
-    model: model,
-    messages: [],
-    stream: stream
-  };
-
-  // Generation config
-  if (body.generationConfig) {
-    const config = body.generationConfig;
-    if (config.maxOutputTokens) {
-      const tempBody = { max_tokens: config.maxOutputTokens, tools: body.tools };
-      result.max_tokens = adjustMaxTokens(tempBody);
-    }
-    if (config.temperature !== undefined) {
-      result.temperature = config.temperature;
-    }
-    if (config.topP !== undefined) {
-      result.top_p = config.topP;
-    }
-  }
-
-  // System instruction
-  if (body.systemInstruction) {
-    const systemText = extractGeminiText(body.systemInstruction);
-    if (systemText) {
-      result.messages.push({
-        role: "system",
-        content: systemText
-      });
-    }
-  }
-
-  // Convert contents to messages
-  if (body.contents && Array.isArray(body.contents)) {
-    for (const content of body.contents) {
-      const converted = convertGeminiContent(content);
-      if (converted) {
-        result.messages.push(converted);
-      }
-    }
-  }
-
-  // Tools
-  if (body.tools && Array.isArray(body.tools)) {
-    result.tools = [];
-    for (const tool of body.tools) {
-      if (tool.functionDeclarations) {
-        for (const func of tool.functionDeclarations) {
-          result.tools.push({
-            type: "function",
-            function: {
-              name: func.name,
-              description: func.description || "",
-              parameters: func.parameters || { type: "object", properties: {} }
-            }
-          });
-        }
-      }
-    }
-  }
-
-  return result;
-}
-
-// Convert Gemini content to OpenAI message
-function convertGeminiContent(content) {
-  const role = content.role === "user" ? "user" : "assistant";
-  
-  if (!content.parts || !Array.isArray(content.parts)) {
-    return null;
-  }
-
-  const parts = [];
-  const toolCalls = [];
-
-  for (const part of content.parts) {
-    if (part.text !== undefined) {
-      parts.push({ type: "text", text: part.text });
-    }
-
-    if (part.inlineData) {
-      parts.push({
-        type: "image_url",
-        image_url: {
-          url: `data:${part.inlineData.mimeType};base64,${part.inlineData.data}`
-        }
-      });
-    }
-
-    if (part.functionCall) {
-      toolCalls.push({
-        id: `call_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
-        type: "function",
-        function: {
-          name: part.functionCall.name,
-          arguments: JSON.stringify(part.functionCall.args || {})
-        }
-      });
-    }
-
-    if (part.functionResponse) {
-      return {
-        role: "tool",
-        tool_call_id: part.functionResponse.id || part.functionResponse.name,
-        content: JSON.stringify(part.functionResponse.response?.result || part.functionResponse.response || {})
-      };
-    }
-  }
-
-  if (toolCalls.length > 0) {
-    const result = { role: "assistant" };
-    if (parts.length > 0) {
-      result.content = parts.length === 1 ? parts[0].text : parts;
-    }
-    result.tool_calls = toolCalls;
-    return result;
-  }
-
-  if (parts.length > 0) {
-    return {
-      role,
-      content: parts.length === 1 && parts[0].type === "text" ? parts[0].text : parts
-    };
-  }
-
-  return null;
-}
-
-// Extract text from Gemini content
-function extractGeminiText(content) {
-  if (typeof content === "string") return content;
-  if (content.parts && Array.isArray(content.parts)) {
-    return content.parts.map(p => p.text || "").join("");
-  }
-  return "";
-}
-
-// Register
-register(FORMATS.GEMINI, FORMATS.OPENAI, geminiToOpenAIRequest, null);
-register(FORMATS.GEMINI_CLI, FORMATS.OPENAI, geminiToOpenAIRequest, null);
-

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

@@ -1,212 +0,0 @@
-/**
- * Translator: OpenAI Responses API → OpenAI Chat Completions
- * 
- * Responses API uses: { input: [...], instructions: "..." }
- * Chat API uses: { messages: [...] }
- */
-import { register } from "../index.js";
-import { FORMATS } from "../formats.js";
-import { convertResponsesApiFormat } from "../helpers/responsesApiHelper.js";
-
-// Responses API enforces max 64 chars on call_id (#393)
-const MAX_CALL_ID_LEN = 64;
-const clampCallId = (id) => (typeof id === "string" && id.length > MAX_CALL_ID_LEN ? id.substring(0, MAX_CALL_ID_LEN) : id);
-
-/**
- * Convert OpenAI Responses API request to OpenAI Chat Completions format
- */
-export function openaiResponsesToOpenAIRequest(model, body, stream, credentials) {
-  return convertResponsesApiFormat(body);
-}
-
-/**
- * Ensure object schema always has properties field (required by Codex Responses API)
- */
-function normalizeToolParameters(params) {
-  if (!params) return { type: "object", properties: {} };
-  if (params.type === "object" && !params.properties) return { ...params, properties: {} };
-  return params;
-}
-
-/**
- * Convert OpenAI Chat Completions to OpenAI Responses API format
- */
-export function openaiToOpenAIResponsesRequest(model, body, stream, credentials) {
-  // Body already in Responses API format (e.g. Cursor CLI calling /chat/completions with input[])
-  if (body && typeof body === "object" && "input" in body) {
-    return { ...body, model, stream: stream === true };
-  }
-
-  const result = {
-    model,
-    input: [],
-    stream: stream === true,
-    store: 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" || msg.role === "developer") {
-      const text = extractInstructionText(msg.content);
-      if (text) instructionParts.push(text);
-      continue;
-    }
-
-    // Convert user/assistant messages to input items
-    if (msg.role === "user" || msg.role === "assistant") {
-      const contentType = msg.role === "user" ? "input_text" : "output_text";
-      const content = typeof msg.content === "string"
-        ? [{ type: contentType, text: msg.content }]
-        : Array.isArray(msg.content)
-          ? msg.content.map(c => {
-            if (c.type === "text") return { type: contentType, text: c.text };
-            // Convert Chat Completions image_url → Responses API input_image
-            // Responses API expects: { type: "input_image", image_url: "<url string>" }
-            // Chat Completions sends: { type: "image_url", image_url: { url: "...", detail: "..." } }
-            if (c.type === "image_url") {
-              const url = typeof c.image_url === "string" ? c.image_url : c.image_url?.url;
-              return { type: "input_image", image_url: url, detail: c.image_url?.detail || "auto" };
-            }
-            if (c.type === "input_image") return c;
-            // Serialize any unknown type (tool_use, tool_result, thinking, etc.) as text
-            const text = c.text || c.content || JSON.stringify(c);
-            return { type: contentType, text: typeof text === "string" ? text : JSON.stringify(text) };
-          })
-          : [];
-
-      // Only push a message block if content is non-empty.
-      // Assistant messages with only tool_calls have content: null — skip the
-      // message block in that case; the tool_calls are pushed separately below.
-      if (content.length > 0) {
-        result.input.push({
-          type: "message",
-          role: msg.role,
-          content
-        });
-      }
-    }
-
-    // Convert tool calls
-    if (msg.role === "assistant" && msg.tool_calls) {
-      for (const tc of msg.tool_calls) {
-        result.input.push({
-          type: "function_call",
-          call_id: clampCallId(tc.id),
-          name: normalizeFunctionName(tc.function?.name),
-          arguments: serializeValue(tc.function?.arguments, "{}")
-        });
-      }
-    }
-
-    // Convert tool results - output must be a string for Responses API
-    if (msg.role === "tool") {
-      const output = typeof msg.content === "string"
-        ? msg.content
-        : Array.isArray(msg.content)
-          ? msg.content.map(c => c.text || JSON.stringify(c)).join("")
-          : serializeValue(msg.content, "");
-      result.input.push({
-        type: "function_call_output",
-        call_id: clampCallId(msg.tool_call_id),
-        output
-      });
-    }
-  }
-
-  // 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" && tool.function) {
-        return {
-          type: "function",
-          name: normalizeFunctionName(tool.function.name),
-          description: String(tool.function.description || ""),
-          parameters: normalizeToolParameters(tool.function.parameters),
-          strict: tool.function.strict
-        };
-      }
-      return tool;
-    });
-  }
-
-  // Pass through other relevant fields
-  if (body.temperature !== undefined) result.temperature = body.temperature;
-  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);