wyxrouter 0.4.71

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

@@ -0,0 +1,216 @@
+// Claude helper functions for translator
+import { DEFAULT_THINKING_CLAUDE_SIGNATURE } from "../../config/defaultThinkingSignature.js";
+import { adjustMaxTokens } from "./maxTokensHelper.js";
+import { applyCloaking } from "../../utils/claudeCloaking.js";
+import { deriveSessionId } from "../../utils/sessionManager.js";
+
+// Check if message has valid non-empty content
+export function hasValidContent(msg) {
+  if (typeof msg.content === "string" && msg.content.trim()) return true;
+  if (Array.isArray(msg.content)) {
+    return msg.content.some(block =>
+      (block.type === "text" && block.text?.trim()) ||
+      block.type === "tool_use" ||
+      block.type === "tool_result"
+    );
+  }
+  return false;
+}
+
+// Fix tool_use/tool_result ordering for Claude API
+// 1. Assistant message with tool_use: remove text AFTER tool_use (Claude doesn't allow)
+// 2. Merge consecutive same-role messages
+export function fixToolUseOrdering(messages) {
+  if (messages.length <= 1) return messages;
+
+  // Pass 1: Fix assistant messages with tool_use - remove text after tool_use
+  for (const msg of messages) {
+    if (msg.role === "assistant" && Array.isArray(msg.content)) {
+      const hasToolUse = msg.content.some(b => b.type === "tool_use");
+      if (hasToolUse) {
+        // Keep only: thinking blocks + tool_use blocks (remove text blocks after tool_use)
+        const newContent = [];
+        let foundToolUse = false;
+
+        for (const block of msg.content) {
+          if (block.type === "tool_use") {
+            foundToolUse = true;
+            newContent.push(block);
+          } else if (block.type === "thinking" || block.type === "redacted_thinking") {
+            newContent.push(block);
+          } else if (!foundToolUse) {
+            // Keep text blocks BEFORE tool_use
+            newContent.push(block);
+          }
+          // Skip text blocks AFTER tool_use
+        }
+
+        msg.content = newContent;
+      }
+    }
+  }
+
+  // Pass 2: Merge consecutive same-role messages
+  const merged = [];
+
+  for (const msg of messages) {
+    const last = merged[merged.length - 1];
+
+    if (last && last.role === msg.role) {
+      // Merge content arrays
+      const lastContent = Array.isArray(last.content) ? last.content : [{ type: "text", text: last.content }];
+      const msgContent = Array.isArray(msg.content) ? msg.content : [{ type: "text", text: msg.content }];
+
+      // Put tool_result first, then other content
+      const toolResults = [...lastContent.filter(b => b.type === "tool_result"), ...msgContent.filter(b => b.type === "tool_result")];
+      const otherContent = [...lastContent.filter(b => b.type !== "tool_result"), ...msgContent.filter(b => b.type !== "tool_result")];
+
+      last.content = [...toolResults, ...otherContent];
+    } else {
+      // Ensure content is array
+      const content = Array.isArray(msg.content) ? msg.content : [{ type: "text", text: msg.content }];
+      merged.push({ role: msg.role, content: [...content] });
+    }
+  }
+
+  return merged;
+}
+
+const CLAUDE_FORMAT_PROVIDERS_WITHOUT_OUTPUT_CONFIG = new Set(["minimax", "minimax-cn"]);
+
+// Prepare request for Claude format endpoints
+// - Cleanup cache_control
+// - Filter empty messages
+// - Add thinking block for Anthropic endpoint (provider === "claude")
+// - Fix tool_use/tool_result ordering
+// - Apply cloaking (billing header + fake user ID) for OAuth tokens
+export function prepareClaudeRequest(body, provider = null, apiKey = null, connectionId = null) {
+  // MiniMax exposes a Claude-compatible endpoint but rejects Anthropic's extended
+  // structured output parameter with a generic 400 "invalid params" response.
+  if (CLAUDE_FORMAT_PROVIDERS_WITHOUT_OUTPUT_CONFIG.has(provider)) {
+    delete body.output_config;
+  }
+
+  // 1. System: remove all cache_control, add only to last block with ttl 1h
+  if (body.system && Array.isArray(body.system)) {
+    body.system = body.system.map((block, i) => {
+      const { cache_control, ...rest } = block;
+      if (i === body.system.length - 1) {
+        return { ...rest, cache_control: { type: "ephemeral", ttl: "1h" } };
+      }
+      return rest;
+    });
+  }
+
+  // 2. Messages: process in optimized passes
+  if (body.messages && Array.isArray(body.messages)) {
+    const len = body.messages.length;
+    let filtered = [];
+
+    // Pass 1: remove cache_control + filter empty messages
+    for (let i = 0; i < len; i++) {
+      const msg = body.messages[i];
+
+      // Remove cache_control from content blocks
+      if (Array.isArray(msg.content)) {
+        for (const block of msg.content) {
+          delete block.cache_control;
+        }
+      }
+
+      // Keep final assistant even if empty, otherwise check valid content
+      const isFinalAssistant = i === len - 1 && msg.role === "assistant";
+      if (isFinalAssistant || hasValidContent(msg)) {
+        filtered.push(msg);
+      }
+    }
+
+    // Pass 1.5: Fix tool_use/tool_result ordering
+    // Each tool_use must have tool_result in the NEXT message (not same message with other content)
+    filtered = fixToolUseOrdering(filtered);
+
+    body.messages = filtered;
+
+    // Check if thinking is enabled AND last message is from user
+    const lastMessage = filtered[filtered.length - 1];
+    const lastMessageIsUser = lastMessage?.role === "user";
+    const thinkingEnabled = body.thinking?.type === "enabled" && lastMessageIsUser;
+
+    // Pass 2 (reverse): add cache_control to last assistant + handle thinking for Anthropic
+    let lastAssistantProcessed = false;
+    for (let i = filtered.length - 1; i >= 0; i--) {
+      const msg = filtered[i];
+
+      if (msg.role === "assistant" && Array.isArray(msg.content)) {
+        // Add cache_control to last non-thinking block of first (from end) assistant with content
+        // thinking/redacted_thinking blocks do not support cache_control
+        if (!lastAssistantProcessed && msg.content.length > 0) {
+          for (let j = msg.content.length - 1; j >= 0; j--) {
+            const block = msg.content[j];
+            if (block.type !== "thinking" && block.type !== "redacted_thinking") {
+              block.cache_control = { type: "ephemeral" };
+              break;
+            }
+          }
+          lastAssistantProcessed = true;
+        }
+
+        // Handle thinking blocks for Anthropic endpoint only
+        if (provider === "claude" || provider?.startsWith("anthropic-compatible")) {
+          let hasToolUse = false;
+          let hasThinking = false;
+
+          // Always replace signature for all thinking blocks
+          for (const block of msg.content) {
+            if (block.type === "thinking" || block.type === "redacted_thinking") {
+              block.signature = DEFAULT_THINKING_CLAUDE_SIGNATURE;
+              hasThinking = true;
+            }
+            if (block.type === "tool_use") hasToolUse = true;
+          }
+
+          // Add thinking block if thinking enabled + has tool_use but no thinking
+          if (thinkingEnabled && !hasThinking && hasToolUse) {
+            msg.content.unshift({
+              type: "thinking",
+              thinking: ".",
+              signature: DEFAULT_THINKING_CLAUDE_SIGNATURE
+            });
+          }
+        }
+      }
+    }
+  }
+
+  // 3. Tools: filter built-in tools for non-Anthropic providers, then handle cache_control
+  if (body.tools && Array.isArray(body.tools)) {
+    // Strip built-in tools (e.g. web_search_20250305) for providers that don't support them
+    if (provider !== "claude") {
+      body.tools = body.tools.filter(tool => !tool.type || tool.type === "function");
+    }
+
+    body.tools = body.tools.map((tool, i) => {
+      const { cache_control, ...rest } = tool;
+      if (i === body.tools.length - 1) {
+        return { ...rest, cache_control: { type: "ephemeral", ttl: "1h" } };
+      }
+      return rest;
+    });
+
+    // Remove tools array and tool_choice if empty after filtering
+    if (body.tools.length === 0) {
+      delete body.tools;
+      delete body.tool_choice;
+    }
+  }
+
+  // Apply cloaking for OAuth tokens (billing header + fake user ID)
+  // session_id in user_id must match X-Claude-Code-Session-Id for fingerprint consistency
+  if ((provider === "claude" || provider?.startsWith("anthropic-compatible")) && apiKey) {
+    const sessionId = connectionId ? deriveSessionId(connectionId) : null;
+    body = applyCloaking(body, apiKey, sessionId);
+  }
+
+  return body;
+}
+

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

@@ -0,0 +1,372 @@
+// Gemini helper functions for translator
+
+// Unsupported JSON Schema constraints that should be removed for Antigravity
+export const UNSUPPORTED_SCHEMA_CONSTRAINTS = [
+  // Basic constraints (not supported by Gemini API)
+  "minLength", "maxLength", "exclusiveMinimum", "exclusiveMaximum",
+  "pattern", "minItems", "maxItems", "format",
+  // Claude rejects these in VALIDATED mode
+  "default", "examples",
+  // JSON Schema meta keywords
+  "$schema", "$defs", "definitions", "const", "$ref", "$comment",
+  // Object validation keywords (not supported)
+  "additionalProperties", "propertyNames", "patternProperties", "enumDescriptions",
+  // Complex schema keywords (handled by flattenAnyOfOneOf/mergeAllOf)
+  "anyOf", "oneOf", "allOf", "not",
+  // Dependency keywords (not supported)
+  "dependencies", "dependentSchemas", "dependentRequired",
+  // Other unsupported keywords
+  "title", "if", "then", "else", "contentMediaType", "contentEncoding",
+  // UI/Styling properties (from Cursor tools - NOT JSON Schema standard)
+  "cornerRadius", "fillColor", "fontFamily", "fontSize", "fontWeight",
+  "gap", "padding", "strokeColor", "strokeThickness", "textColor"
+];
+
+// Default safety settings
+export const DEFAULT_SAFETY_SETTINGS = [
+  { category: "HARM_CATEGORY_HATE_SPEECH", threshold: "OFF" },
+  { category: "HARM_CATEGORY_DANGEROUS_CONTENT", threshold: "OFF" },
+  { category: "HARM_CATEGORY_SEXUALLY_EXPLICIT", threshold: "OFF" },
+  { category: "HARM_CATEGORY_HARASSMENT", threshold: "OFF" },
+  { category: "HARM_CATEGORY_CIVIC_INTEGRITY", threshold: "OFF" }
+];
+
+// Convert OpenAI content to Gemini parts
+export function convertOpenAIContentToParts(content) {
+  const parts = [];
+
+  if (typeof content === "string") {
+    parts.push({ text: content });
+  } else if (Array.isArray(content)) {
+    for (const item of content) {
+      if (item.type === "text") {
+        parts.push({ text: item.text });
+      } else if (item.type === "image_url" && item.image_url?.url?.startsWith("data:")) {
+        const url = item.image_url.url;
+        const commaIndex = url.indexOf(",");
+        if (commaIndex !== -1) {
+          const mimePart = url.substring(5, commaIndex); // skip "data:"
+          const data = url.substring(commaIndex + 1);
+          const mimeType = mimePart.split(";")[0];
+
+          parts.push({
+            inlineData: { mime_type: mimeType, data: data }
+          });
+        }
+      } else if (item.type === "image_url" && item.image_url?.url && (item.image_url.url.startsWith("http://") || item.image_url.url.startsWith("https://"))) {
+        parts.push({
+          fileData: { fileUri: item.image_url.url, mimeType: "image/*" }
+        });
+      } else if (item.type === "input_audio" && item.input_audio?.data) {
+        const format = item.input_audio.format || "wav";
+        const mimeType = format === "mp3" ? "audio/mpeg" : `audio/${format}`;
+        parts.push({
+          inlineData: { mime_type: mimeType, data: item.input_audio.data }
+        });
+      } else if (item.type === "audio_url" && item.audio_url?.url?.startsWith("data:")) {
+        const url = item.audio_url.url;
+        const commaIndex = url.indexOf(",");
+        if (commaIndex !== -1) {
+          const mimePart = url.substring(5, commaIndex);
+          const data = url.substring(commaIndex + 1);
+          const mimeType = mimePart.split(";")[0];
+          parts.push({
+            inlineData: { mime_type: mimeType, data: data }
+          });
+        }
+      }
+    }
+  }
+
+  return parts;
+}
+
+// Extract text content from OpenAI content
+export function extractTextContent(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.filter(c => c.type === "text").map(c => c.text).join("");
+  }
+  return "";
+}
+
+// Try parse JSON safely
+export function tryParseJSON(str) {
+  if (typeof str !== "string") return str;
+  try {
+    return JSON.parse(str);
+  } catch {
+    return null;
+  }
+}
+
+// Generate request ID
+export function generateRequestId() {
+  return `agent-${crypto.randomUUID()}`;
+}
+
+// Generate session ID (binary-compatible format: UUID + timestamp)
+export function generateSessionId() {
+  return crypto.randomUUID() + Date.now().toString();
+}
+
+// Generate project ID
+export function generateProjectId() {
+  const adjectives = ["useful", "bright", "swift", "calm", "bold"];
+  const nouns = ["fuze", "wave", "spark", "flow", "core"];
+  const adj = adjectives[Math.floor(Math.random() * adjectives.length)];
+  const noun = nouns[Math.floor(Math.random() * nouns.length)];
+  return `${adj}-${noun}-${crypto.randomUUID().slice(0, 5)}`;
+}
+
+// Helper: Remove unsupported keywords recursively from object/array
+// Also strips all vendor extension fields (x- prefixed) not supported by Gemini
+function removeUnsupportedKeywords(obj, keywords) {
+  if (!obj || typeof obj !== "object") return;
+
+  if (Array.isArray(obj)) {
+    for (const item of obj) {
+      removeUnsupportedKeywords(item, keywords);
+    }
+    return;
+  }
+
+  for (const key of Object.keys(obj)) {
+    if (keywords.includes(key) || key.startsWith("x-")) {
+      delete obj[key];
+      continue;
+    }
+
+    const value = obj[key];
+    if (value && typeof value === "object") {
+      removeUnsupportedKeywords(value, keywords);
+    }
+  }
+}
+
+// Convert const to enum
+function convertConstToEnum(obj) {
+  if (!obj || typeof obj !== "object") return;
+
+  if (obj.const !== undefined && !obj.enum) {
+    obj.enum = [obj.const];
+    delete obj.const;
+  }
+
+  for (const value of Object.values(obj)) {
+    if (value && typeof value === "object") {
+      convertConstToEnum(value);
+    }
+  }
+}
+
+// Convert enum values to strings (Gemini requires string enum values + explicit type:"string")
+function convertEnumValuesToStrings(obj) {
+  if (!obj || typeof obj !== "object") return;
+
+  if (obj.enum && Array.isArray(obj.enum)) {
+    obj.enum = obj.enum.map(v => String(v));
+    // Gemini API requires type:"string" when enum is present — without it returns 400
+    if (!obj.type) {
+      obj.type = "string";
+    }
+  }
+
+  for (const value of Object.values(obj)) {
+    if (value && typeof value === "object") {
+      convertEnumValuesToStrings(value);
+    }
+  }
+}
+
+// Merge allOf schemas
+function mergeAllOf(obj) {
+  if (!obj || typeof obj !== "object") return;
+
+  if (obj.allOf && Array.isArray(obj.allOf)) {
+    const merged = {};
+
+    for (const item of obj.allOf) {
+      if (item.properties) {
+        if (!merged.properties) merged.properties = {};
+        Object.assign(merged.properties, item.properties);
+      }
+      if (item.required && Array.isArray(item.required)) {
+        if (!merged.required) merged.required = [];
+        for (const req of item.required) {
+          if (!merged.required.includes(req)) {
+            merged.required.push(req);
+          }
+        }
+      }
+    }
+
+    delete obj.allOf;
+    if (merged.properties) obj.properties = { ...obj.properties, ...merged.properties };
+    if (merged.required) obj.required = [...(obj.required || []), ...merged.required];
+  }
+
+  for (const value of Object.values(obj)) {
+    if (value && typeof value === "object") {
+      mergeAllOf(value);
+    }
+  }
+}
+
+// Select best schema from anyOf/oneOf
+function selectBest(items) {
+  let bestIdx = 0;
+  let bestScore = -1;
+
+  for (let i = 0; i < items.length; i++) {
+    const item = items[i];
+    let score = 0;
+    const type = item.type;
+
+    if (type === "object" || item.properties) {
+      score = 3;
+    } else if (type === "array" || item.items) {
+      score = 2;
+    } else if (type && type !== "null") {
+      score = 1;
+    }
+
+    if (score > bestScore) {
+      bestScore = score;
+      bestIdx = i;
+    }
+  }
+
+  return bestIdx;
+}
+
+// Flatten anyOf/oneOf
+function flattenAnyOfOneOf(obj) {
+  if (!obj || typeof obj !== "object") return;
+
+  if (obj.anyOf && Array.isArray(obj.anyOf) && obj.anyOf.length > 0) {
+    const nonNullSchemas = obj.anyOf.filter(s => s && s.type !== "null");
+    if (nonNullSchemas.length > 0) {
+      const bestIdx = selectBest(nonNullSchemas);
+      const selected = nonNullSchemas[bestIdx];
+      delete obj.anyOf;
+      Object.assign(obj, selected);
+    }
+  }
+
+  if (obj.oneOf && Array.isArray(obj.oneOf) && obj.oneOf.length > 0) {
+    const nonNullSchemas = obj.oneOf.filter(s => s && s.type !== "null");
+    if (nonNullSchemas.length > 0) {
+      const bestIdx = selectBest(nonNullSchemas);
+      const selected = nonNullSchemas[bestIdx];
+      delete obj.oneOf;
+      Object.assign(obj, selected);
+    }
+  }
+
+  for (const value of Object.values(obj)) {
+    if (value && typeof value === "object") {
+      flattenAnyOfOneOf(value);
+    }
+  }
+}
+
+// Flatten type arrays
+function flattenTypeArrays(obj) {
+  if (!obj || typeof obj !== "object") return;
+
+  if (obj.type && Array.isArray(obj.type)) {
+    const nonNullTypes = obj.type.filter(t => t !== "null");
+    obj.type = nonNullTypes.length > 0 ? nonNullTypes[0] : "string";
+  }
+
+  for (const value of Object.values(obj)) {
+    if (value && typeof value === "object") {
+      flattenTypeArrays(value);
+    }
+  }
+}
+
+// Infer missing type=object when properties exist (Gemini requires explicit type)
+function ensureObjectType(obj) {
+  if (!obj || typeof obj !== "object") return;
+  if (obj.properties && !obj.type) obj.type = "object";
+  for (const v of Object.values(obj)) if (v && typeof v === "object") ensureObjectType(v);
+}
+
+// Clean JSON Schema for Antigravity API compatibility - removes unsupported keywords recursively
+export function cleanJSONSchemaForAntigravity(schema) {
+  if (!schema || typeof schema !== "object") return schema;
+
+  // Mutate directly (schema is only used once per request)
+  let cleaned = schema;
+
+  // Phase 1: Convert and prepare
+  convertConstToEnum(cleaned);
+  convertEnumValuesToStrings(cleaned);
+
+  // Phase 2: Flatten complex structures
+  mergeAllOf(cleaned);
+  flattenAnyOfOneOf(cleaned);
+  flattenTypeArrays(cleaned);
+
+  // Phase 2.5: Infer missing type=object when properties exist (Gemini requirement)
+  ensureObjectType(cleaned);
+
+  // Phase 3: Remove all unsupported keywords at ALL levels (including inside arrays)
+  removeUnsupportedKeywords(cleaned, UNSUPPORTED_SCHEMA_CONSTRAINTS);
+
+  // Phase 4: Cleanup required fields recursively
+  function cleanupRequired(obj) {
+    if (!obj || typeof obj !== "object") return;
+
+    if (obj.required && Array.isArray(obj.required) && obj.properties) {
+      const validRequired = obj.required.filter(field =>
+        Object.prototype.hasOwnProperty.call(obj.properties, field)
+      );
+      if (validRequired.length === 0) {
+        delete obj.required;
+      } else {
+        obj.required = validRequired;
+      }
+    }
+
+    // Recurse into nested objects
+    for (const value of Object.values(obj)) {
+      if (value && typeof value === "object") {
+        cleanupRequired(value);
+      }
+    }
+  }
+
+  cleanupRequired(cleaned);
+
+  // Phase 5: Add placeholder for empty object schemas (Antigravity requirement)
+  function addPlaceholders(obj) {
+    if (!obj || typeof obj !== "object") return;
+
+    if (obj.type === "object") {
+      if (!obj.properties || Object.keys(obj.properties).length === 0) {
+        obj.properties = {
+          reason: {
+            type: "string",
+            description: "Brief explanation of why you are calling this tool"
+          }
+        };
+        obj.required = ["reason"];
+      }
+    }
+
+    // Recurse into nested objects
+    for (const value of Object.values(obj)) {
+      if (value && typeof value === "object") {
+        addPlaceholders(value);
+      }
+    }
+  }
+
+  addPlaceholders(cleaned);
+
+  return cleaned;
+}
+

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

@@ -0,0 +1,34 @@
+/**
+ * Fetch a remote image URL and return it as a base64 data URI.
+ * Used when upstream providers (Codex, etc.) require inline base64 images
+ * instead of remote URLs they cannot fetch.
+ * Returns null if fetch fails.
+ *
+ * @param {string} imageUrl - HTTP(S) URL of the image
+ * @param {object} options - { signal, timeoutMs }
+ * @returns {Promise<{url: string, mimeType: string}|null>}
+ */
+export async function fetchImageAsBase64(imageUrl, options = {}) {
+  const { signal, timeoutMs = 10000 } = options;
+  if (!imageUrl || (!imageUrl.startsWith("http://") && !imageUrl.startsWith("https://"))) {
+    return null;
+  }
+
+  const controller = new AbortController();
+  const timeout = signal ? null : setTimeout(() => controller.abort(), timeoutMs);
+  const fetchSignal = signal || controller.signal;
+
+  try {
+    const response = await fetch(imageUrl, { signal: fetchSignal });
+    if (!response.ok) return null;
+
+    const mimeType = response.headers.get("Content-Type") || "image/jpeg";
+    const arrayBuffer = await response.arrayBuffer();
+    const base64 = Buffer.from(arrayBuffer).toString("base64");
+    return { url: `data:${mimeType};base64,${base64}`, mimeType };
+  } catch {
+    return null;
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+}

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

@@ -0,0 +1,27 @@
+import { DEFAULT_MAX_TOKENS, DEFAULT_MIN_TOKENS } from "../../config/runtimeConfig.js";
+
+/**
+ * Adjust max_tokens based on request context
+ * @param {object} body - Request body
+ * @returns {number} Adjusted max_tokens
+ */
+export function adjustMaxTokens(body) {
+  let maxTokens = body.max_tokens || DEFAULT_MAX_TOKENS;
+
+  // Auto-increase for tool calling to prevent truncated arguments
+  if (body.tools && Array.isArray(body.tools) && body.tools.length > 0) {
+    if (maxTokens < DEFAULT_MIN_TOKENS) {
+      maxTokens = DEFAULT_MIN_TOKENS;
+    }
+  }
+
+  // Ensure max_tokens > thinking.budget_tokens (Claude API requirement)
+  // Claude API requires strictly greater, so add buffer instead of using DEFAULT_MAX_TOKENS
+  // which could equal budget_tokens when budget_tokens >= 64000
+  if (body.thinking?.budget_tokens && maxTokens <= body.thinking.budget_tokens) {
+    maxTokens = body.thinking.budget_tokens + 1024;
+  }
+
+  return maxTokens;
+}
+