zevairouter 1.0.154 → 1.0.155

package/open-sse/executors/antigravity.js

@@ -1,605 +0,0 @@
-import crypto from "crypto";
-import { BaseExecutor } from "./base.js";
-import { PROVIDERS } from "../config/providers.js";
-import { OAUTH_ENDPOINTS, ANTIGRAVITY_HEADERS, INTERNAL_REQUEST_HEADER, AG_DEFAULT_TOOLS, AG_TOOL_SUFFIX } from "../config/appConstants.js";
-import { HTTP_STATUS } from "../config/runtimeConfig.js";
-import { proxyAwareFetch } from "../utils/proxyFetch.js";
-import { cleanJSONSchemaForAntigravity } from "../translator/helpers/geminiHelper.js";
-import { obfuscateRequestBody } from "../services/antigravityObfuscation.js";
-import { scrubProxyAndFingerprintHeaders } from "../services/antigravityHeaderScrub.js";
-import {
-  getAntigravitySessionId,
-  generateAntigravityRequestId,
-  getAntigravityEnvelopeUserAgent,
-  deriveAntigravityMachineId,
-} from "../services/antigravityIdentity.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) {
-    const machineId = deriveAntigravityMachineId();
-    return {
-      "Content-Type": "application/json",
-      "Authorization": `Bearer ${credentials.accessToken}`,
-      "User-Agent": this.config.headers?.["User-Agent"] || ANTIGRAVITY_HEADERS["User-Agent"],
-      [INTERNAL_REQUEST_HEADER.name]: INTERNAL_REQUEST_HEADER.value,
-      ...(machineId && { "x-machine-id": machineId }),
-      ...(sessionId && { "X-Machine-Session-Id": sessionId }),
-      "Accept": stream ? "text/event-stream" : "application/json"
-    };
-  }
-
-  transformRequest(model, body, stream, credentials) {
-    // Prefer a real Cloud Code project id from the connection (loadCodeAssist /
-    // free-tier onboard / peer fallback). Brand-new random ids often 403; stick to
-    // a previously working managed id when possible.
-    const projectId =
-      credentials?.projectId ||
-      credentials?.providerSpecificData?.projectId ||
-      this.generateProjectId();
-
-    // Fix contents for Claude models via Antigravity
-    const contents = body.request?.contents?.map(c => {
-      let role = c.role;
-      // functionResponse must be role "user" for Claude models
-      if (c.parts?.some(p => p.functionResponse)) {
-        role = "user";
-      }
-      // Strip thought-only parts, keep thoughtSignature on functionCall parts (Gemini 3+ requires it)
-      const parts = c.parts?.filter(p => {
-        if (p.thought && !p.functionCall) return false;
-        if (p.thoughtSignature && !p.functionCall && !p.text) return false;
-        return true;
-      });
-      if (role !== c.role || parts?.length !== c.parts?.length) {
-        return { ...c, role, parts };
-      }
-      return c;
-    });
-
-    // Sanitize tool schemas and function names before sending to Antigravity.
-    let tools = body.request?.tools;
-
-    if (tools && tools.length > 0) {
-      // Merge all groups into a single functionDeclarations group (Gemini expects 1 group)
-      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 { tools: _originalTools, toolConfig: _originalToolConfig, ...requestWithoutTools } = body.request || {};
-    const generationConfig = { ...(requestWithoutTools.generationConfig || {}) };
-    if (generationConfig.maxOutputTokens > MAX_ANTIGRAVITY_OUTPUT_TOKENS) {
-      generationConfig.maxOutputTokens = MAX_ANTIGRAVITY_OUTPUT_TOKENS;
-    }
-
-    const transformedRequest = {
-      ...requestWithoutTools,
-      generationConfig,
-      ...(contents && { contents }),
-      ...(tools && { tools }),
-      sessionId: body.request?.sessionId || getAntigravitySessionId(credentials),
-      safetySettings: undefined,
-      ...(tools?.length > 0 && { toolConfig: { functionCallingConfig: { mode: "VALIDATED" } } })
-    };
-
-    return {
-      ...body,
-      project: projectId,
-      model: model,
-      userAgent: getAntigravityEnvelopeUserAgent(credentials),
-      requestType: "agent",
-      requestId: generateAntigravityRequestId(),
-      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;
-    }
-  }
-
-  // Stable-ish managed-style project id. Google accepts some existing Cloud Code
-  // project strings for GSuite without a user-owned GCP project; brand-new random
-  // names usually 403. Prefer connection.projectId from loadCodeAssist/onboard.
-  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.
-  // Known Google formats:
-  //   "Your quota will reset after 2h7m23s"
-  //   "Individual quota reached. ... Resets in 158h12m52s."
-  //   "1h30m" / "45m" / "30s"
-  parseRetryFromErrorMessage(errorMessage) {
-    if (!errorMessage || typeof errorMessage !== "string") return null;
-
-    const match = errorMessage.match(/reset(?:s)?(?: after| in)?\s*:?\s*(\d+h)?(\d+m)?(\d+(?:\.\d+)?s)?/i);
-    if (!match || (!match[1] && !match[2] && !match[3])) 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 += Math.round(parseFloat(match[3]) * 1000); // seconds
-
-    return totalMs > 0 ? totalMs : null;
-  }
-
-  /**
-   * Parse Google RPC 429s to extract the REAL quota reset time so the account
-   * gets locked until then — not for the generic few-minute backoff.
-   *
-   * Body shape (cloudcode-pa.googleapis.com):
-   *   error.details[] → ErrorInfo.metadata.quotaResetTimeStamp (ISO)
-   *                                  .quotaResetDelay ("158h12m52.12s" proto duration)
-   *                     RetryInfo.retryDelay ("569572.120814663s")
-   * Without this, a 6-day quota exhaustion produced ~1min model locks and the
-   * account kept getting re-picked, wasting ~30s of futile retries per request.
-   */
-  parseError(response, bodyText) {
-    if (response.status === HTTP_STATUS.RATE_LIMITED && bodyText) {
-      try {
-        const json = JSON.parse(bodyText);
-        const err = json?.error;
-        const details = Array.isArray(err?.details) ? err.details : [];
-        const now = Date.now();
-        let resetsAtMs = null;
-
-        for (const d of details) {
-          const meta = d?.metadata;
-          if (meta?.quotaResetTimeStamp) {
-            const ts = Date.parse(meta.quotaResetTimeStamp);
-            if (!Number.isNaN(ts) && ts > now) { resetsAtMs = ts; break; }
-          }
-          const delayStr = meta?.quotaResetDelay || d?.retryDelay;
-          if (typeof delayStr === "string" && delayStr.endsWith("s")) {
-            const seconds = parseFloat(delayStr.slice(0, -1));
-            if (Number.isFinite(seconds) && seconds > 0) {
-              const ts = now + Math.round(seconds * 1000);
-              if (!resetsAtMs || ts > resetsAtMs) resetsAtMs = ts;
-            }
-          }
-        }
-
-        if (resetsAtMs) {
-          return { status: 429, message: err?.message || bodyText, resetsAtMs };
-        }
-      } catch { /* fall through to default */ }
-    }
-    return super.parseError(response, bodyText);
-  }
-
-  async execute({ model, body, stream, credentials, signal, log, proxyOptions = null }) {
-    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
-    let creditsRetried = false; // GOOGLE_ONE_AI credits fallback attempted once per request
-    let injectCredits = false; // when true, transformRequest output gets enabledCreditTypes
-
-    for (let urlIndex = 0; urlIndex < fallbackCount; urlIndex++) {
-      const url = this.buildUrl(model, stream, urlIndex);
-      let transformedBody = this.transformRequest(model, body, stream, credentials);
-      // On a quota_exhausted 429, retry once using the account's Google One AI
-      // credit balance (often available on Pro accounts) instead of giving up.
-      if (injectCredits && transformedBody.request) {
-        transformedBody.enabledCreditTypes = ["GOOGLE_ONE_AI"];
-      }
-      transformedBody = obfuscateRequestBody(transformedBody);
-      const sessionId = transformedBody.request?.sessionId;
-      const headers = scrubProxyAndFingerprintHeaders(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);
-
-        if (response.status === HTTP_STATUS.RATE_LIMITED || response.status === HTTP_STATUS.SERVICE_UNAVAILABLE) {
-          // Try to get retry time from headers first
-          let retryMs = this.parseRetryHeaders(response.headers);
-
-          // If no retry time in headers, try to parse from error message body
-          let errorMessageText = "";
-          if (!retryMs) {
-            try {
-              const errorBody = await response.clone().text();
-              const errorJson = JSON.parse(errorBody);
-              errorMessageText = errorJson?.error?.message || errorJson?.message || "";
-              retryMs = this.parseRetryFromErrorMessage(errorMessageText);
-            } catch (e) {
-              // Ignore parse errors, will fall back to exponential backoff
-            }
-          }
-
-          // Quota exhausted → retry once with Google One AI credits injected.
-          if (
-            response.status === HTTP_STATUS.RATE_LIMITED &&
-            !creditsRetried &&
-            /quota[_ ]?exhausted|quota reached|individual quota|enable overages/i.test(errorMessageText)
-          ) {
-            creditsRetried = true;
-            injectCredits = true;
-            log?.debug?.("RETRY", "429 quota exhausted → retrying once with GOOGLE_ONE_AI credits");
-            urlIndex--;
-            continue;
-          }
-
-          // Quota exhaustion with a long reset (hours/days) is not transient —
-          // don't burn ~14s on exponential retries against an account that told
-          // us exactly when it recovers. Fall through so the auth layer can lock
-          // the account until resetsAtMs and move to the next connection fast.
-          const isLongQuotaExhaustion =
-            response.status === HTTP_STATUS.RATE_LIMITED
-            && /quota[_ ]?exhausted|quota reached|individual quota|enable overages/i.test(errorMessageText)
-            && (!retryMs || retryMs > MAX_RETRY_AFTER_MS);
-          if (isLongQuotaExhaustion) {
-            log?.debug?.("RETRY", `429 quota exhausted${retryMs ? ` (resets in ${Math.ceil(retryMs / 3600000)}h)` : ""} — skipping futile retries, moving to next account`);
-            lastStatus = response.status;
-            break; // exit URL loop → error propagates with body intact for resetsAtMs parsing
-          }
-
-          if (retryMs && retryMs <= MAX_RETRY_AFTER_MS && retryAfterAttemptsByUrl[urlIndex] < MAX_RETRY_AFTER_RETRIES) {
-            retryAfterAttemptsByUrl[urlIndex]++;
-            log?.debug?.("RETRY", `${response.status} with Retry-After: ${Math.ceil(retryMs / 1000)}s, waiting... (${retryAfterAttemptsByUrl[urlIndex]}/${MAX_RETRY_AFTER_RETRIES})`);
-            await new Promise(resolve => setTimeout(resolve, retryMs));
-            urlIndex--;
-            continue;
-          }
-
-          // Auto retry only for 429 when retryMs is 0 or undefined
-          if (response.status === HTTP_STATUS.RATE_LIMITED && (!retryMs || retryMs === 0) && retryAttemptsByUrl[urlIndex] < MAX_AUTO_RETRIES) {
-            retryAttemptsByUrl[urlIndex]++;
-            // Exponential backoff: 2s, 4s, 8s...
-            const backoffMs = Math.min(1000 * (2 ** retryAttemptsByUrl[urlIndex]), MAX_RETRY_AFTER_MS);
-            log?.debug?.("RETRY", `429 auto retry ${retryAttemptsByUrl[urlIndex]}/${MAX_AUTO_RETRIES} after ${backoffMs / 1000}s`);
-            await new Promise(resolve => setTimeout(resolve, backoffMs));
-            urlIndex--;
-            continue;
-          }
-
-          log?.debug?.("RETRY", `${response.status}, Retry-After ${retryMs ? `too long (${Math.ceil(retryMs / 1000)}s)` : 'missing'}, trying fallback`);
-          lastStatus = response.status;
-
-          if (urlIndex + 1 < fallbackCount) {
-            continue;
-          }
-        }
-
-        if (this.shouldRetry(response.status, urlIndex)) {
-          log?.debug?.("RETRY", `${response.status} on ${url}, trying fallback ${urlIndex + 1}`);
-          lastStatus = response.status;
-          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;