@fudrouter/fsrouter 0.6.59 → 0.6.61

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

@@ -1,185 +0,0 @@
-/**
- * OpenAI to Cursor Request Translator
- * Converts OpenAI messages to Cursor ask/agent format.
- *
- * Important: Cursor can loop when tool outputs are sent via protobuf tool_results
- * with partial schema mismatches. For stability, tool outputs are represented as
- * structured text blocks in user messages.
- */
-import { register } from "../index.js";
-import { FORMATS } from "../formats.js";
-import { ROLE, OPENAI_BLOCK, CLAUDE_BLOCK } from "../schema/index.js";
-import { DEFAULT_MIN_TOKENS } from "../../config/runtimeConfig.js";
-
-function extractContent(content) {
-  if (typeof content === "string") return content;
-  if (Array.isArray(content)) {
-    return content
-      .filter(part => {
-        if (!part || typeof part !== "object") return false;
-        return part.type === OPENAI_BLOCK.TEXT && typeof part.text === "string";
-      })
-      .map(part => part.text || "")
-      .join("");
-  }
-  return "";
-}
-
-function sanitizeToolResultText(text) {
-  // Strip non-printable control chars that can produce backend request errors
-  return text.replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, "");
-}
-
-function escapeXml(text) {
-  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-
-function buildToolResultBlock(toolName, toolCallId, resultText) {
-  const cleanResult = sanitizeToolResultText(resultText || "");
-  return [
-    "<tool_result>",
-    `<tool_name>${escapeXml(toolName || "tool")}</tool_name>`,
-    `<tool_call_id>${escapeXml(toolCallId || "")}</tool_call_id>`,
-    `<result>${escapeXml(cleanResult)}</result>`,
-    "</tool_result>"
-  ].join("\n");
-}
-
-function normalizeToolCallId(id) {
-  return typeof id === "string" ? id.split("\n")[0] : "";
-}
-
-function convertMessages(messages) {
-  const result = [];
-  
-  // Build a map of tool_call_id -> tool name from assistant tool calls
-  const toolCallMetaMap = new Map();
-  const rememberToolMeta = (toolCallId, toolName) => {
-    if (!toolCallId) return;
-    const name = toolName || "tool";
-    toolCallMetaMap.set(toolCallId, { name });
-    const normalized = normalizeToolCallId(toolCallId);
-    if (normalized && normalized !== toolCallId) {
-      toolCallMetaMap.set(normalized, { name });
-    }
-  };
-
-  for (const msg of messages) {
-    if (msg.role === ROLE.ASSISTANT && msg.tool_calls) {
-      for (const tc of msg.tool_calls) {
-        rememberToolMeta(tc.id || "", tc.function?.name || "tool");
-      }
-    }
-    if (msg.role === ROLE.ASSISTANT && Array.isArray(msg.content)) {
-      for (const part of msg.content) {
-        if (part?.type !== CLAUDE_BLOCK.TOOL_USE) continue;
-        rememberToolMeta(part.id || "", part.name || "tool");
-      }
-    }
-  }
-
-  for (let i = 0; i < messages.length; i++) {
-    const msg = messages[i];
-
-    if (msg.role === ROLE.SYSTEM) {
-      result.push({
-        role: ROLE.USER,
-        content: `[System Instructions]\n${extractContent(msg.content)}`
-      });
-      continue;
-    }
-
-    if (msg.role === ROLE.TOOL) {
-      const toolContent = extractContent(msg.content);
-      const toolCallId = msg.tool_call_id || "";
-      const toolMeta = toolCallMetaMap.get(toolCallId) || {};
-      const toolName = msg.name || toolMeta.name || "tool";
-      result.push({
-        role: ROLE.USER,
-        content: buildToolResultBlock(toolName, toolCallId, toolContent)
-      });
-      continue;
-    }
-
-    if (msg.role === ROLE.USER || msg.role === ROLE.ASSISTANT) {
-      if (msg.role === ROLE.USER && Array.isArray(msg.content)) {
-        const parts = [];
-        for (const block of msg.content) {
-          if (!block || typeof block !== "object") continue;
-          if (block.type === CLAUDE_BLOCK.TEXT) {
-            if (typeof block.text === "string") {
-              parts.push(block.text || "");
-            }
-            continue;
-          }
-          if (block.type === CLAUDE_BLOCK.TOOL_RESULT) {
-            const toolCallId = block.tool_use_id || "";
-            const toolMeta =
-              toolCallMetaMap.get(toolCallId) ||
-              toolCallMetaMap.get(normalizeToolCallId(toolCallId));
-            const toolName = toolMeta?.name || "tool";
-            const toolContent = extractContent(block.content);
-            parts.push(buildToolResultBlock(toolName, toolCallId, toolContent));
-          }
-        }
-        const joined = parts.filter(Boolean).join("\n");
-        if (joined) result.push({ role: ROLE.USER, content: joined });
-        continue;
-      }
-
-      const content = extractContent(msg.content);
-
-      if (msg.role === ROLE.ASSISTANT && msg.tool_calls && msg.tool_calls.length > 0) {
-        const assistantMsg = { role: ROLE.ASSISTANT, content: content || "" };
-        assistantMsg.tool_calls = msg.tool_calls.map(tc => {
-          const { index, ...rest } = tc || {};
-          return rest;
-        });
-        result.push(assistantMsg);
-      } else if (msg.role === ROLE.ASSISTANT && Array.isArray(msg.content)) {
-        const extractedToolCalls = msg.content
-          .filter(b => b?.type === CLAUDE_BLOCK.TOOL_USE)
-          .map(b => ({
-            id: b.id || "",
-            type: OPENAI_BLOCK.FUNCTION,
-            function: {
-              name: b.name || "tool",
-              arguments: JSON.stringify(b.input || {})
-            }
-          }))
-          .filter(tc => tc.id);
-
-        if (extractedToolCalls.length > 0) {
-          result.push({
-            role: ROLE.ASSISTANT,
-            content: content || "",
-            tool_calls: extractedToolCalls
-          });
-        } else if (content) {
-          result.push({ role: ROLE.ASSISTANT, content });
-        }
-      } else {
-        if (content) {
-          result.push({ role: msg.role, content });
-        }
-      }
-    }
-  }
-
-  return result;
-}
-
-export function openaiToCursorRequest(model, body, stream, credentials) {
-  const messages = convertMessages(body.messages || []);
-
-  // Strip fields irrelevant to Cursor (OpenAI/Anthropic-specific)
-  const { user, metadata, tool_choice, stream_options, system, ...rest } = body;
-
-  return {
-    ...rest,
-    messages,
-    max_tokens: DEFAULT_MIN_TOKENS
-  };
-}
-
-register(FORMATS.OPENAI, FORMATS.CURSOR, openaiToCursorRequest, null);

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

@@ -1,442 +0,0 @@
-import { register } from "../index.js";
-import { FORMATS } from "../formats.js";
-import { DEFAULT_THINKING_AG_SIGNATURE, DEFAULT_THINKING_GEMINI_CLI_SIGNATURE } from "../../config/defaultThinkingSignature.js";
-import { openaiToClaudeRequestForAntigravity } from "./openai-to-claude.js";
-function generateUUID() {
-  return crypto.randomUUID();
-}
-
-import {
-  DEFAULT_SAFETY_SETTINGS,
-  convertOpenAIContentToParts,
-  extractTextContent,
-  tryParseJSON,
-  generateRequestId,
-  generateSessionId,
-  generateProjectId,
-  cleanJSONSchemaForAntigravity
-} from "../formats/gemini.js";
-import { deriveSessionId, toNumericSessionId } from "../../utils/sessionManager.js";
-import { ROLE, GEMINI_ROLE, OPENAI_BLOCK, CLAUDE_BLOCK } from "../schema/index.js";
-
-// Sanitize function names for Gemini API.
-// Gemini requires: starts with [a-zA-Z_], followed by [a-zA-Z0-9_.:\-], max 64 chars.
-// Replace any invalid character with '_' and truncate to 64.
-function sanitizeGeminiFunctionName(name) {
-  if (!name) return "_unknown";
-  // Replace any char not in [a-zA-Z0-9_.:\-] with '_'
-  let sanitized = name.replace(/[^a-zA-Z0-9_.:\-]/g, "_");
-  // First char must be letter or underscore
-  if (!/^[a-zA-Z_]/.test(sanitized)) {
-    sanitized = "_" + sanitized;
-  }
-  // Truncate to 64 chars
-  return sanitized.substring(0, 64);
-}
-
-function normalizeGeminiContents(contents) {
-  const out = [];
-  for (const c of contents || []) {
-    if (!c?.role || !Array.isArray(c.parts) || c.parts.length === 0) continue;
-    const last = out.at(-1);
-    if (last?.role === c.role) last.parts.push(...c.parts);
-    else out.push({ ...c, parts: [...c.parts] });
-  }
-  return out;
-}
-
-// Core: Convert OpenAI request to Gemini format (base for all variants)
-function openaiToGeminiBase(model, body, stream, signature = DEFAULT_THINKING_AG_SIGNATURE) {
-  const result = {
-    model: model,
-    contents: [],
-    generationConfig: {},
-    safetySettings: DEFAULT_SAFETY_SETTINGS
-  };
-
-  // Generation config
-  if (body.temperature !== undefined) {
-    result.generationConfig.temperature = body.temperature;
-  }
-  if (body.top_p !== undefined) {
-    result.generationConfig.topP = body.top_p;
-  }
-  if (body.top_k !== undefined) {
-    result.generationConfig.topK = body.top_k;
-  }
-  if (body.max_tokens !== undefined) {
-    result.generationConfig.maxOutputTokens = body.max_tokens;
-  }
-
-  // Build tool_call_id -> name map
-  const tcID2Name = {};
-  if (body.messages && Array.isArray(body.messages)) {
-    for (const msg of body.messages) {
-      if (msg.role === ROLE.ASSISTANT && msg.tool_calls) {
-        for (const tc of msg.tool_calls) {
-          if (tc.type === OPENAI_BLOCK.FUNCTION && tc.id && tc.function?.name) {
-            tcID2Name[tc.id] = tc.function.name;
-          }
-        }
-      }
-    }
-  }
-
-  // Build tool responses cache
-  const toolResponses = {};
-  if (body.messages && Array.isArray(body.messages)) {
-    for (const msg of body.messages) {
-      if (msg.role === ROLE.TOOL && msg.tool_call_id) {
-        toolResponses[msg.tool_call_id] = msg.content;
-      }
-    }
-  }
-
-  // Convert messages
-  if (body.messages && Array.isArray(body.messages)) {
-    for (let i = 0; i < body.messages.length; i++) {
-      const msg = body.messages[i];
-      const role = msg.role;
-      const content = msg.content;
-
-      if (role === ROLE.SYSTEM && body.messages.length > 1) {
-        result.systemInstruction = {
-          role: GEMINI_ROLE.USER,
-          parts: [{ text: typeof content === "string" ? content : extractTextContent(content) }]
-        };
-      } else if (role === ROLE.USER || (role === ROLE.SYSTEM && body.messages.length === 1)) {
-        const parts = convertOpenAIContentToParts(content);
-        if (parts.length > 0) {
-          result.contents.push({ role: GEMINI_ROLE.USER, parts });
-        }
-      } else if (role === ROLE.ASSISTANT) {
-        const parts = [];
-
-        // Thinking/reasoning → thought part with signature
-        if (msg.reasoning_content) {
-          parts.push({
-            thought: true,
-            text: msg.reasoning_content
-          });
-          parts.push({
-            thoughtSignature: signature,
-            text: ""
-          });
-        }
-
-        if (content) {
-          const text = typeof content === "string" ? content : extractTextContent(content);
-          if (text) {
-            parts.push({ text });
-          }
-        }
-
-        if (msg.tool_calls && Array.isArray(msg.tool_calls)) {
-          const toolCallIds = [];
-          for (const tc of msg.tool_calls) {
-            if (tc.type !== OPENAI_BLOCK.FUNCTION) continue;
-
-            const args = tryParseJSON(tc.function?.arguments || "{}");
-            parts.push({
-              thoughtSignature: signature,
-              functionCall: {
-                id: tc.id,
-                name: sanitizeGeminiFunctionName(tc.function.name),
-                args: args
-              }
-            });
-            toolCallIds.push(tc.id);
-          }
-
-          if (parts.length > 0) {
-            result.contents.push({ role: GEMINI_ROLE.MODEL, parts });
-          }
-
-          // Check if there are actual tool responses in the next messages
-          const hasActualResponses = toolCallIds.some(fid => toolResponses[fid]);
-
-          if (hasActualResponses) {
-            const toolParts = [];
-            for (const fid of toolCallIds) {
-              if (!toolResponses[fid]) continue;
-
-              let name = tcID2Name[fid];
-              if (!name) {
-                const idParts = fid.split("-");
-                if (idParts.length > 2) {
-                  name = idParts.slice(0, -2).join("-");
-                } else {
-                  name = fid;
-                }
-              }
-
-              let resp = toolResponses[fid];
-              let parsedResp = tryParseJSON(resp);
-              if (parsedResp === null) {
-                parsedResp = { result: resp };
-              } else if (typeof parsedResp !== "object") {
-                parsedResp = { result: parsedResp };
-              }
-
-              toolParts.push({
-                functionResponse: {
-                  id: fid,
-                  name: sanitizeGeminiFunctionName(name),
-                  response: { result: parsedResp }
-                }
-              });
-            }
-            if (toolParts.length > 0) {
-              result.contents.push({ role: GEMINI_ROLE.USER, parts: toolParts });
-            }
-          }
-        } else if (parts.length > 0) {
-          result.contents.push({ role: GEMINI_ROLE.MODEL, parts });
-        }
-      }
-    }
-  }
-
-  // Convert tools
-  if (body.tools && Array.isArray(body.tools) && body.tools.length > 0) {
-    const functionDeclarations = [];
-    for (const t of body.tools) {
-      // Check if already in Anthropic/Claude format (no type field, direct name/description/input_schema)
-      if (t.name && t.input_schema) {
-        const cleanedSchema = cleanJSONSchemaForAntigravity(structuredClone(t.input_schema || { type: "object", properties: {} }));
-        functionDeclarations.push({
-          name: sanitizeGeminiFunctionName(t.name),
-          description: t.description || "",
-          parameters: cleanedSchema
-        });
-      }
-      // OpenAI format
-      else if (t.type === OPENAI_BLOCK.FUNCTION && t.function) {
-        const fn = t.function;
-        const cleanedSchema = cleanJSONSchemaForAntigravity(structuredClone(fn.parameters || { type: "object", properties: {} }));
-        functionDeclarations.push({
-          name: sanitizeGeminiFunctionName(fn.name),
-          description: fn.description || "",
-          parameters: cleanedSchema
-        });
-      }
-    }
-
-    if (functionDeclarations.length > 0) {
-      result.tools = [{ functionDeclarations }];
-    }
-  }
-
-  result.contents = normalizeGeminiContents(result.contents);
-  return result;
-}
-
-// OpenAI -> Gemini (standard API)
-export function openaiToGeminiRequest(model, body, stream) {
-  return openaiToGeminiBase(model, body, stream);
-}
-
-// OpenAI -> Gemini CLI (Cloud Code Assist)
-export function openaiToGeminiCLIRequest(model, body, stream) {
-  const gemini = openaiToGeminiBase(model, body, stream, DEFAULT_THINKING_GEMINI_CLI_SIGNATURE);
-  // Thinking is normalized centrally by applyThinking (thinkingUnified.js) after translation.
-
-  // Clean schema for tools
-  if (gemini.tools?.[0]?.functionDeclarations) {
-    for (const fn of gemini.tools[0].functionDeclarations) {
-      if (fn.parameters) {
-        const cleanedSchema = cleanJSONSchemaForAntigravity(fn.parameters);
-        fn.parameters = cleanedSchema;
-        // if (isClaude) {
-        //   fn.parameters = cleanedSchema;
-        // } else {
-        //   fn.parametersJsonSchema = cleanedSchema;
-        //   delete fn.parameters;
-        // }
-      }
-    }
-  }
-
-  return gemini;
-}
-
-// Wrap Gemini CLI format in Cloud Code wrapper
-function wrapInCloudCodeEnvelope(model, geminiCLI, credentials = null, isAntigravity = false) {
-  const projectId = credentials?.projectId || generateProjectId();
-
-  const envelope = {
-    project: projectId,
-    model: model,
-    userAgent: isAntigravity ? "antigravity" : "gemini-cli",
-    requestId: isAntigravity ? `agent-${generateUUID()}` : generateRequestId(),
-    request: {
-      sessionId: toNumericSessionId(credentials?._clientSessionId) || (isAntigravity ? deriveSessionId(credentials?.email || credentials?.connectionId) : generateSessionId()),
-      contents: geminiCLI.contents,
-      systemInstruction: geminiCLI.systemInstruction,
-      generationConfig: geminiCLI.generationConfig,
-      tools: geminiCLI.tools,
-    }
-  };
-
-  // Antigravity specific fields
-  if (isAntigravity) {
-    envelope.requestType = "agent";
-  } else {
-    // Keep safetySettings for Gemini CLI
-    envelope.request.safetySettings = geminiCLI.safetySettings;
-  }
-
-  if (geminiCLI.tools?.length > 0) {
-    envelope.request.toolConfig = {
-      functionCallingConfig: { mode: "VALIDATED" }
-    };
-  }
-
-  return envelope;
-}
-
-// Wrap Claude format in Cloud Code envelope for Antigravity
-function wrapInCloudCodeEnvelopeForClaude(model, claudeRequest, credentials = null, signature = DEFAULT_THINKING_AG_SIGNATURE) {
-  const projectId = credentials?.projectId || generateProjectId();
-
-  const envelope = {
-    project: projectId,
-    model: model,
-    userAgent: "antigravity",
-    requestId: `agent-${generateUUID()}`,
-    requestType: "agent",
-    request: {
-      sessionId: toNumericSessionId(credentials?._clientSessionId) || deriveSessionId(credentials?.email || credentials?.connectionId),
-      contents: [],
-      generationConfig: {
-        temperature: claudeRequest.temperature || 1,
-        maxOutputTokens: claudeRequest.max_tokens || 4096
-      }
-    }
-  };
-
-  // Build tool_use id -> name map so functionResponse can use the correct name
-  const toolUseIdToName = {};
-  if (claudeRequest.messages && Array.isArray(claudeRequest.messages)) {
-    for (const msg of claudeRequest.messages) {
-      if (Array.isArray(msg.content)) {
-        for (const block of msg.content) {
-          if (block.type === CLAUDE_BLOCK.TOOL_USE && block.id && block.name) {
-            toolUseIdToName[block.id] = block.name;
-          }
-        }
-      }
-    }
-  }
-
-  // Convert Claude messages to Gemini contents
-  if (claudeRequest.messages && Array.isArray(claudeRequest.messages)) {
-    for (const msg of claudeRequest.messages) {
-      const parts = [];
-
-      if (Array.isArray(msg.content)) {
-        for (const block of msg.content) {
-          if (block.type === CLAUDE_BLOCK.TEXT) {
-            parts.push({ text: block.text });
-          } else if (block.type === CLAUDE_BLOCK.TOOL_USE) {
-            parts.push({
-              thoughtSignature: signature,
-              functionCall: {
-                id: block.id,
-                name: sanitizeGeminiFunctionName(block.name),
-                args: block.input || {}
-              }
-            });
-          } else if (block.type === CLAUDE_BLOCK.TOOL_RESULT) {
-            let content = block.content;
-            if (Array.isArray(content)) {
-              content = content.map(c => c.type === CLAUDE_BLOCK.TEXT ? c.text : JSON.stringify(c)).join("\n");
-            }
-            // Resolve the original tool name from the id — Gemini requires it to match the functionCall name
-            const resolvedName = toolUseIdToName[block.tool_use_id]
-              ? sanitizeGeminiFunctionName(toolUseIdToName[block.tool_use_id])
-              : "tool";
-            parts.push({
-              functionResponse: {
-                id: block.tool_use_id,
-                name: resolvedName,
-                response: { result: tryParseJSON(content) || content }
-              }
-            });
-          }
-        }
-      } else if (typeof msg.content === "string") {
-        parts.push({ text: msg.content });
-      }
-
-      if (parts.length > 0) {
-        envelope.request.contents.push({
-          role: msg.role === ROLE.ASSISTANT ? GEMINI_ROLE.MODEL : GEMINI_ROLE.USER,
-          parts
-        });
-      }
-    }
-  }
-
-  // Convert Claude tools to Gemini functionDeclarations
-  if (claudeRequest.tools && Array.isArray(claudeRequest.tools)) {
-    const functionDeclarations = [];
-    for (const tool of claudeRequest.tools) {
-      if (tool.name && tool.input_schema) {
-        const cleanedSchema = cleanJSONSchemaForAntigravity(tool.input_schema);
-        functionDeclarations.push({
-          name: sanitizeGeminiFunctionName(tool.name),
-          description: tool.description || "",
-          parameters: cleanedSchema
-        });
-      }
-    }
-    if (functionDeclarations.length > 0) {
-      envelope.request.tools = [{ functionDeclarations }];
-      envelope.request.toolConfig = {
-        functionCallingConfig: { mode: "VALIDATED" }
-      };
-    }
-  }
-
-  const systemParts = [];
-  // Merge user system prompt from claudeRequest
-  if (claudeRequest.system) {
-    if (Array.isArray(claudeRequest.system)) {
-      for (const block of claudeRequest.system) {
-        if (block.text) systemParts.push({ text: block.text });
-      }
-    } else if (typeof claudeRequest.system === "string") {
-      systemParts.push({ text: claudeRequest.system });
-    }
-  }
-
-  if (systemParts.length > 0) {
-    envelope.request.systemInstruction = { role: GEMINI_ROLE.USER, parts: systemParts };
-  }
-
-  envelope.request.contents = normalizeGeminiContents(envelope.request.contents);
-  return envelope;
-}
-
-// Detect if model should use Claude backend in Antigravity
-// Claude models have specific ID patterns — more reliable than caps at routing level
-function isClaudeModel(model) {
-  return model.toLowerCase().includes("claude");
-}
-
-// OpenAI -> Antigravity (Sandbox Cloud Code with wrapper)
-export function openaiToAntigravityRequest(model, body, stream, credentials = null) {
-  if (isClaudeModel(model)) {
-    const claudeRequest = openaiToClaudeRequestForAntigravity(model, body, stream);
-    return wrapInCloudCodeEnvelopeForClaude(model, claudeRequest, credentials);
-  }
-
-  const geminiCLI = openaiToGeminiCLIRequest(model, body, stream);
-  return wrapInCloudCodeEnvelope(model, geminiCLI, credentials, true);
-}
-
-// Register
-register(FORMATS.OPENAI, FORMATS.GEMINI, openaiToGeminiRequest, null);
-register(FORMATS.OPENAI, FORMATS.GEMINI_CLI, (model, body, stream, credentials) => wrapInCloudCodeEnvelope(model, openaiToGeminiCLIRequest(model, body, stream), credentials), null);
-register(FORMATS.OPENAI, FORMATS.ANTIGRAVITY, openaiToAntigravityRequest, null);