@fudrouter/fsrouter 0.6.64 → 0.6.65

package/open-sse/executors/antigravity.js

@@ -0,0 +1,534 @@
+import crypto from "crypto";
+import { BaseExecutor } from "./base.js";
+import { PROVIDERS } from "../config/providers.js";
+import { OAUTH_ENDPOINTS, INTERNAL_REQUEST_HEADER, AG_DEFAULT_TOOLS, AG_TOOL_SUFFIX } from "../config/appConstants.js";
+import { resolveAntigravityVersion } from "../services/antigravityVersion.js";
+import { antigravityUserAgent } from "../services/antigravityHeaders.js";
+import { HTTP_STATUS } from "../config/runtimeConfig.js";
+import { deriveSessionId } from "../utils/sessionManager.js";
+import { proxyAwareFetch } from "../utils/proxyFetch.js";
+import { cleanJSONSchemaForAntigravity } from "../translator/helpers/geminiHelper.js";
+
+// Sanitize function name: Gemini requires [a-zA-Z_][a-zA-Z0-9_.:\-]{0,63}
+function sanitizeFunctionName(name) {
+  if (!name) return "_unknown";
+  let s = name.replace(/[^a-zA-Z0-9_.:\-]/g, "_");
+  if (!/^[a-zA-Z_]/.test(s)) s = "_" + s;
+  return s.substring(0, 64);
+}
+
+const MAX_RETRY_AFTER_MS = 10000;
+const MAX_ANTIGRAVITY_OUTPUT_TOKENS = 16384;
+
+export class AntigravityExecutor extends BaseExecutor {
+  constructor() {
+    super("antigravity", PROVIDERS.antigravity);
+  }
+
+  buildUrl(model, stream, urlIndex = 0) {
+    const baseUrls = this.getBaseUrls();
+    const baseUrl = baseUrls[urlIndex] || baseUrls[0];
+    const action = stream ? "streamGenerateContent?alt=sse" : "generateContent";
+    return `${baseUrl}/v1internal:${action}`;
+  }
+
+  buildHeaders(credentials, stream = true, sessionId = null) {
+    return {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${credentials.accessToken}`,
+      "User-Agent": this.config.headers?.["User-Agent"] || antigravityUserAgent(),
+      [INTERNAL_REQUEST_HEADER.name]: INTERNAL_REQUEST_HEADER.value,
+      ...(sessionId && { "X-Machine-Session-Id": sessionId }),
+      "Accept": stream ? "text/event-stream" : "application/json"
+    };
+  }
+
+  transformRequest(model, body, stream, credentials) {
+    const projectId = credentials?.projectId?.trim() || this.generateProjectId();
+
+    // Get base request data - handle both envelope and raw body
+    const isEnvelope = body && body.request && (body.model || body.project);
+    const req = isEnvelope ? body.request : (body || {});
+    const { 
+      tools: _originalTools, 
+      toolConfig: _originalToolConfig, 
+      systemInstruction, 
+      // Strip OpenAI fields that Google hates
+      max_tokens,
+      stream: _unusedStream,
+      messages: _unusedMessages,
+      model: _unusedModel,
+      stop: _unusedStop,
+      ...requestWithoutTools 
+    } = req;
+    
+    // Process contents - ensure we don't lose them
+    const rawContents = req.contents || requestWithoutTools.contents || [];
+    let finalContents = rawContents.map(c => {
+      let role = c.role;
+      if (c.parts?.some(p => p.functionResponse)) role = "user";
+      
+      const parts = (c.parts || []).filter(p => {
+        if (p.thought && !p.functionCall) return false;
+        if (p.thoughtSignature && !p.functionCall && !p.text) return false;
+        return true;
+      });
+      
+      return { ...c, role, parts };
+    }).filter(c => c.parts && c.parts.length > 0);
+
+    // Merge systemInstruction into the first user message for maximum compatibility
+    if (systemInstruction?.parts?.length > 0) {
+      const sysText = systemInstruction.parts.map(p => p.text).filter(Boolean).join("\n");
+      if (sysText) {
+        if (finalContents.length > 0 && finalContents[0].role === "user") {
+          // Prepend to first user message
+          finalContents[0].parts = [{ text: sysText + "\n\n" }, ...finalContents[0].parts];
+        } else {
+          // Create new first user message
+          finalContents = [{ role: "user", parts: [{ text: sysText }] }, ...finalContents];
+        }
+      }
+    }
+
+    const generationConfig = { ...(req.generationConfig || {}) };
+    if (generationConfig.maxOutputTokens > MAX_ANTIGRAVITY_OUTPUT_TOKENS) {
+      generationConfig.maxOutputTokens = MAX_ANTIGRAVITY_OUTPUT_TOKENS;
+    }
+
+    // Ensure conversation ends with a user message (required by Claude/Antigravity)
+    while (finalContents.length > 0 && finalContents[finalContents.length - 1].role === "model") {
+      finalContents.pop();
+    }
+
+    // Sanitize tools
+    let tools = req.tools;
+    if (tools && tools.length > 0) {
+      const allDeclarations = tools.flatMap(group =>
+        (group.functionDeclarations || []).map(fn => ({
+          ...fn,
+          name: sanitizeFunctionName(fn.name),
+          parameters: fn.parameters
+            ? cleanJSONSchemaForAntigravity(structuredClone(fn.parameters))
+            : { type: "object", properties: { reason: { type: "string", description: "Brief explanation" } }, required: ["reason"] }
+        }))
+      );
+      tools = allDeclarations.length > 0 ? [{ functionDeclarations: allDeclarations }] : [];
+    }
+
+    const transformedRequest = {
+      contents: finalContents,
+      generationConfig,
+      sessionId: req.sessionId || body.sessionId || deriveSessionId(credentials?.email || credentials?.connectionId),
+      ...(tools?.length > 0 && { tools }),
+      ...(tools?.length > 0 && { toolConfig: { functionCallingConfig: { mode: "VALIDATED" } } })
+    };
+
+    return {
+      project: body.project || projectId,
+      model: model,
+      userAgent: body.userAgent || "antigravity",
+      requestType: body.requestType || "agent",
+      requestId: body.requestId || `agent-${crypto.randomUUID()}`,
+      request: transformedRequest
+    };
+  }
+
+  async refreshCredentials(credentials, log, proxyOptions = null) {
+    if (!credentials.refreshToken) return null;
+
+    try {
+      const response = await proxyAwareFetch(OAUTH_ENDPOINTS.google.token, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json" },
+        body: new URLSearchParams({
+          grant_type: "refresh_token",
+          refresh_token: credentials.refreshToken,
+          client_id: this.config.clientId,
+          client_secret: this.config.clientSecret
+        })
+      }, proxyOptions);
+
+      if (!response.ok) return null;
+
+      const tokens = await response.json();
+      log?.info?.("TOKEN", "Antigravity refreshed");
+
+      return {
+        accessToken: tokens.access_token,
+        refreshToken: tokens.refresh_token || credentials.refreshToken,
+        expiresIn: tokens.expires_in,
+        projectId: credentials.projectId
+      };
+    } catch (error) {
+      log?.error?.("TOKEN", `Antigravity refresh error: ${error.message}`);
+      return null;
+    }
+  }
+
+  generateProjectId() {
+    const adj = ["useful", "bright", "swift", "calm", "bold"][Math.floor(Math.random() * 5)];
+    const noun = ["fuze", "wave", "spark", "flow", "core"][Math.floor(Math.random() * 5)];
+    return `${adj}-${noun}-${crypto.randomUUID().slice(0, 5)}`;
+  }
+
+  generateSessionId() {
+    return crypto.randomUUID() + Date.now().toString();
+  }
+
+  parseRetryHeaders(headers) {
+    if (!headers?.get) return null;
+
+    const retryAfter = headers.get('retry-after');
+    if (retryAfter) {
+      const seconds = parseInt(retryAfter, 10);
+      if (!isNaN(seconds) && seconds > 0) return seconds * 1000;
+
+      const date = new Date(retryAfter);
+      if (!isNaN(date.getTime())) {
+        const diff = date.getTime() - Date.now();
+        return diff > 0 ? diff : null;
+      }
+    }
+
+    const resetAfter = headers.get('x-ratelimit-reset-after');
+    if (resetAfter) {
+      const seconds = parseInt(resetAfter, 10);
+      if (!isNaN(seconds) && seconds > 0) return seconds * 1000;
+    }
+
+    const resetTimestamp = headers.get('x-ratelimit-reset');
+    if (resetTimestamp) {
+      const ts = parseInt(resetTimestamp, 10) * 1000;
+      const diff = ts - Date.now();
+      return diff > 0 ? diff : null;
+    }
+
+    return null;
+  }
+
+  // Parse retry time from Antigravity error message body
+  // Format: "Your quota will reset after 2h7m23s" or "1h30m" or "45m" or "30s"
+  parseRetryFromErrorMessage(errorMessage) {
+    if (!errorMessage || typeof errorMessage !== "string") return null;
+
+    const match = errorMessage.match(/reset after (\d+h)?(\d+m)?(\d+s)?/i);
+    if (!match) return null;
+
+    let totalMs = 0;
+    if (match[1]) totalMs += parseInt(match[1]) * 3600 * 1000; // hours
+    if (match[2]) totalMs += parseInt(match[2]) * 60 * 1000; // minutes
+    if (match[3]) totalMs += parseInt(match[3]) * 1000; // seconds
+
+    return totalMs > 0 ? totalMs : null;
+  }
+
+  parseError(response, bodyText) {
+    let message = bodyText;
+    try {
+      const json = JSON.parse(bodyText);
+      message = json.error?.message || json.message || json.error || bodyText;
+    } catch {}
+
+    const messageStr = typeof message === "string" ? message : JSON.stringify(message);
+    const retryMs = this.parseRetryFromErrorMessage(messageStr);
+
+    if (retryMs) {
+      return {
+        status: HTTP_STATUS.RATE_LIMITED, // Convert 403 quota resets to 429
+        message: messageStr,
+        resetsAtMs: Date.now() + retryMs
+      };
+    }
+
+    return { status: response.status, message: messageStr };
+  }
+
+  async execute({ model, body, stream, credentials, signal, log, proxyOptions = null }) {
+    // Warm up/resolve version cache
+    try {
+      await resolveAntigravityVersion().catch(() => {});
+    } catch {}
+
+    const fallbackCount = this.getFallbackCount();
+    let lastError = null;
+    let lastStatus = 0;
+    const MAX_AUTO_RETRIES = 3;
+    const MAX_RETRY_AFTER_RETRIES = 3;
+    const retryAttemptsByUrl = {}; // Track retry attempts per URL
+    const retryAfterAttemptsByUrl = {}; // Track Retry-After retries per URL
+
+    for (let urlIndex = 0; urlIndex < fallbackCount; urlIndex++) {
+      const url = this.buildUrl(model, stream, urlIndex);
+      const transformedBody = this.transformRequest(model, body, stream, credentials);
+      const sessionId = transformedBody.request?.sessionId;
+      const headers = this.buildHeaders(credentials, stream, sessionId);
+
+      // Initialize retry counters for this URL
+      if (!retryAttemptsByUrl[urlIndex]) {
+        retryAttemptsByUrl[urlIndex] = 0;
+      }
+      if (!retryAfterAttemptsByUrl[urlIndex]) {
+        retryAfterAttemptsByUrl[urlIndex] = 0;
+      }
+
+      try {
+        const response = await proxyAwareFetch(url, {
+          method: "POST",
+          headers,
+          body: JSON.stringify(transformedBody),
+          signal
+        }, proxyOptions);
+
+        const isForbiddenQuota = response.status === HTTP_STATUS.FORBIDDEN;
+        const isRateLimited = response.status === HTTP_STATUS.RATE_LIMITED;
+
+        if (isRateLimited || isForbiddenQuota) {
+          // Return immediately to allow account rotation in the outer loop (chat.js) without testing other fallback URLs
+          return { response, url, headers, transformedBody };
+        }
+
+        if (response.status === HTTP_STATUS.SERVICE_UNAVAILABLE) {
+          // Internal retry only for 503 Service Unavailable
+          if (retryAttemptsByUrl[urlIndex] < MAX_AUTO_RETRIES) {
+            retryAttemptsByUrl[urlIndex]++;
+            const delay = 2000 * Math.pow(2, retryAttemptsByUrl[urlIndex] - 1);
+            log?.warn?.("RETRY", `503 auto retry ${retryAttemptsByUrl[urlIndex]}/${MAX_AUTO_RETRIES} after ${delay/1000}s`);
+            await new Promise(r => setTimeout(r, delay));
+            urlIndex--; // Retry same URL
+            continue;
+          }
+        }
+
+        if (!response.ok) {
+          lastStatus = response.status;
+          lastError = await response.text();
+          if (urlIndex + 1 < fallbackCount) continue;
+        }
+
+        return { response, url, headers, transformedBody };
+      } catch (error) {
+        lastError = error;
+        if (urlIndex + 1 < fallbackCount) {
+          log?.debug?.("RETRY", `Error on ${url}, trying fallback ${urlIndex + 1}`);
+          continue;
+        }
+        throw error;
+      }
+    }
+
+    throw lastError || new Error(`All ${fallbackCount} URLs failed with status ${lastStatus}`);
+  }
+
+  /**
+   * Cloak tools before sending to Antigravity provider (anti-ban):
+   * - Rename client tools with _ide suffix
+   * - Inject AG default decoy tools after client tools
+   * Returns { cloakedBody, toolNameMap } where toolNameMap maps suffixed → original
+   */
+  static cloakTools(body, clientTool = null) {
+    const tools = body.request?.tools;
+    if (!tools || tools.length === 0) {
+      return { cloakedBody: body, toolNameMap: null };
+    }
+
+    const isCopilot = clientTool === "github-copilot";
+    const toolNameMap = new Map();
+    const clientDeclarations = [];
+    const decoyNames = new Set(AG_DECOY_TOOLS.map(tool => tool.name));
+
+    // First: collect renamed client tools
+    for (const toolGroup of tools) {
+      if (!toolGroup.functionDeclarations) continue;
+
+      for (const func of toolGroup.functionDeclarations) {
+        // For GitHub Copilot, avoid emitting duplicate native Antigravity tool names.
+        // Keep the decoys only once in the final declaration list.
+        if (isCopilot && AG_DEFAULT_TOOLS.has(func.name)) {
+          continue;
+        }
+
+        // Skip if already covered by decoys for Copilot
+        if (isCopilot && decoyNames.has(func.name)) {
+          continue;
+        }
+
+        // Preserve native AG names for non-Copilot clients
+        if (AG_DEFAULT_TOOLS.has(func.name)) {
+          clientDeclarations.push(func);
+          continue;
+        }
+
+        const suffixed = `${func.name}${AG_TOOL_SUFFIX}`;
+        toolNameMap.set(suffixed, func.name);
+        clientDeclarations.push({ ...func, name: suffixed });
+      }
+    }
+
+    // Client tools first, then AG decoy tools
+    const allDeclarations = [];
+    const seenNames = new Set();
+    for (const decl of [...clientDeclarations, ...AG_DECOY_TOOLS]) {
+      if (!decl?.name || seenNames.has(decl.name)) continue;
+      seenNames.add(decl.name);
+      allDeclarations.push(decl);
+    }
+
+    // Rename tool names in conversation history (contents)
+    const cloakedContents = body.request?.contents?.map(msg => {
+      if (!msg.parts) return msg;
+      
+      const cloakedParts = msg.parts.map(part => {
+        // Rename functionCall.name
+        if (part.functionCall && !AG_DEFAULT_TOOLS.has(part.functionCall.name)) {
+          return {
+            ...part,
+            functionCall: {
+              ...part.functionCall,
+              name: `${part.functionCall.name}${AG_TOOL_SUFFIX}`
+            }
+          };
+        }
+        
+        // Rename functionResponse.name
+        if (part.functionResponse && !AG_DEFAULT_TOOLS.has(part.functionResponse.name)) {
+          return {
+            ...part,
+            functionResponse: {
+              ...part.functionResponse,
+              name: `${part.functionResponse.name}${AG_TOOL_SUFFIX}`
+            }
+          };
+        }
+        
+        return part;
+      });
+      
+      return { ...msg, parts: cloakedParts };
+    });
+
+    // Single functionDeclarations group: client tools first, then decoys
+    return {
+      cloakedBody: {
+        ...body,
+        request: {
+          ...body.request,
+          tools: [{ functionDeclarations: allDeclarations }],
+          contents: cloakedContents || body.request.contents
+        }
+      },
+      toolNameMap
+    };
+  }
+}
+
+// AG decoy tools — same names as AG native defaults, redirect to _ide suffixed tools
+const AG_DECOY_TOOLS = [
+  {
+    name: "browser_subagent",
+    description: "This tool is currently unavailable.",
+    parameters: { type: "OBJECT", properties: {}, required: [] }
+  },
+  {
+    name: "command_status",
+    description: "This tool is currently unavailable.",
+    parameters: { type: "OBJECT", properties: {}, required: [] }
+  },
+  {
+    name: "find_by_name",
+    description: "This tool is currently unavailable.",
+    parameters: { type: "OBJECT", properties: {}, required: [] }
+  },
+  {
+    name: "generate_image",
+    description: "This tool is currently unavailable.",
+    parameters: { type: "OBJECT", properties: {}, required: [] }
+  },
+  {
+    name: "grep_search",
+    description: "This tool is currently unavailable.",
+    parameters: { type: "OBJECT", properties: {}, required: [] }
+  },
+  {
+    name: "list_dir",
+    description: "This tool is currently unavailable.",
+    parameters: { type: "OBJECT", properties: {}, required: [] }
+  },
+  {
+    name: "list_resources",
+    description: "This tool is currently unavailable.",
+    parameters: { type: "OBJECT", properties: {}, required: [] }
+  },
+  {
+    name: "mcp_sequential-thinking_sequentialthinking",
+    description: "This tool is currently unavailable.",
+    parameters: { type: "OBJECT", properties: {}, required: [] }
+  },
+  {
+    name: "multi_replace_file_content",
+    description: "This tool is currently unavailable.",
+    parameters: { type: "OBJECT", properties: {}, required: [] }
+  },
+  {
+    name: "notify_user",
+    description: "This tool is currently unavailable.",
+    parameters: { type: "OBJECT", properties: {}, required: [] }
+  },
+  {
+    name: "read_resource",
+    description: "This tool is currently unavailable.",
+    parameters: { type: "OBJECT", properties: {}, required: [] }
+  },
+  {
+    name: "read_terminal",
+    description: "This tool is currently unavailable.",
+    parameters: { type: "OBJECT", properties: {}, required: [] }
+  },
+  {
+    name: "read_url_content",
+    description: "This tool is currently unavailable.",
+    parameters: { type: "OBJECT", properties: {}, required: [] }
+  },
+  {
+    name: "replace_file_content",
+    description: "This tool is currently unavailable.",
+    parameters: { type: "OBJECT", properties: {}, required: [] }
+  },
+  {
+    name: "run_command",
+    description: "This tool is currently unavailable.",
+    parameters: { type: "OBJECT", properties: {}, required: [] }
+  },
+  {
+    name: "search_web",
+    description: "This tool is currently unavailable.",
+    parameters: { type: "OBJECT", properties: {}, required: [] }
+  },
+  {
+    name: "send_command_input",
+    description: "This tool is currently unavailable.",
+    parameters: { type: "OBJECT", properties: {}, required: [] }
+  },
+  {
+    name: "task_boundary",
+    description: "This tool is currently unavailable.",
+    parameters: { type: "OBJECT", properties: {}, required: [] }
+  },
+  {
+    name: "view_content_chunk",
+    description: "This tool is currently unavailable.",
+    parameters: { type: "OBJECT", properties: {}, required: [] }
+  },
+  {
+    name: "view_file",
+    description: "This tool is currently unavailable.",
+    parameters: { type: "OBJECT", properties: {}, required: [] }
+  },
+  {
+    name: "write_to_file",
+    description: "This tool is currently unavailable.",
+    parameters: { type: "OBJECT", properties: {}, required: [] }
+  }
+];
+
+export default AntigravityExecutor;

package/open-sse/executors/antigravityUpstreamError.js

@@ -0,0 +1,13 @@
+import { buildErrorBody } from "../utils/error.js";
+function buildAntigravityUpstreamError(status, statusText, rawBody) {
+  let upstreamDetails;
+  try {
+    upstreamDetails = JSON.parse(rawBody);
+  } catch {
+  }
+  const suffix = statusText ? `: ${statusText}` : "";
+  return buildErrorBody(status, `Antigravity upstream error (${status})${suffix}`, upstreamDetails);
+}
+export {
+  buildAntigravityUpstreamError
+};