@fudrouter/fsrouter 0.6.63 → 0.6.64

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

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

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

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

@@ -1,252 +0,0 @@
-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();
-
-// Eagerly pre-load all translators at module load time
-// (prevents race condition with mixed sync require() + dynamic import())
-const reqMods = [
-  "./request/claude-to-openai.js",
-  "./request/openai-to-claude.js",
-  "./request/gemini-to-openai.js",
-  "./request/openai-to-gemini.js",
-  "./request/openai-to-vertex.js",
-  "./request/antigravity-to-openai.js",
-  "./request/openai-responses.js",
-  "./request/openai-to-kiro.js",
-  "./request/openai-to-cursor.js",
-  "./request/openai-to-ollama.js",
-  "./request/openai-to-commandcode.js",
-];
-const resMods = [
-  "./response/claude-to-openai.js",
-  "./response/openai-to-claude.js",
-  "./response/gemini-to-openai.js",
-  "./response/openai-to-antigravity.js",
-  "./response/openai-responses.js",
-  "./response/kiro-to-openai.js",
-  "./response/cursor-to-openai.js",
-  "./response/ollama-to-openai.js",
-  "./response/commandcode-to-openai.js",
-];
-await Promise.all([...reqMods, ...resMods].map(m => import(m)));
-
-// Track initialization state
-let initialized = true;
-
-// 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 (no-op, loaded eagerly at module level)
-async function ensureInitialized() {}
-
-// 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();
-}