@fudrouter/fsrouter 0.6.63 → 0.6.64

package/open-sse/executors/antigravity.js

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

@@ -1,13 +0,0 @@
-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
-};