zevairouter 1.0.12 → 1.0.14

package/cli/app/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zevairouter",
-  "version": "1.0.12",
+  "version": "1.0.14",
   "description": "ZevaiRouter - AI Router with provider automation, multi-account workflows, and quota tracking",
   "bin": {
     "zevai": "./cli/cli.js"
@@ -62,7 +62,7 @@
     "socks-proxy-agent": "^10.1.0",
     "sql.js": "^1.14.1",
     "undici": "^8.4.1",
-    "uuid": "^13.0.0",
+    "uuid": "^14.0.1",
     "zustand": "^5.0.10"
   },
   "optionalDependencies": {
@@ -74,7 +74,7 @@
   "comment_camoufox_js": "optional stealth-Firefox engine for bulk-import; runtime auto-installs to user data dir if user picks Camoufox in the modal but the package is missing — Chromium remains the default and works without this dep",
   "devDependencies": {
     "@tailwindcss/postcss": "^4.1.18",
-    "esbuild": "^0.25.12",
+    "esbuild": "^0.28.1",
     "eslint": "^9",
     "eslint-config-next": "16.2.9",
     "postcss": "^8.5.6",

package/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zevairouter-cli",
-  "version": "1.0.12",
+  "version": "1.0.14",
   "description": "ZevaiRouter CLI - Start and manage ZevaiRouter server",
   "bin": {
     "zevai": "./cli.js"

package/open-sse/config/appConstants.js

@@ -56,7 +56,7 @@ export function getPlatformEnum() {
 }
 
 export function getPlatformUserAgent() {
-  return `antigravity/1.104.0 ${platform()}/${arch()}`;
+  return antigravityUserAgent();
 }
 
 export const CLIENT_METADATA = {
@@ -124,9 +124,34 @@ export const AG_DEFAULT_TOOLS = new Set([
   "write_to_file"
 ]);
 
+// Antigravity desktop client fingerprint. The real Antigravity app is an
+// Electron/Chromium build; matching its User-Agent (instead of a bare
+// "antigravity/x.y.z linux/x64") avoids the third-party-client signal Google
+// uses to flag accounts. Chrome/Electron versions synced with the Antigravity
+// desktop build (see OmniRoute antigravityHeaders.ts).
+export const ANTIGRAVITY_VERSION = "1.107.0";
+export const ANTIGRAVITY_CHROME_VERSION = "142.0.7444.175";
+export const ANTIGRAVITY_ELECTRON_VERSION = "39.2.3";
+
+function antigravityPlatformInfo() {
+  switch (platform()) {
+    case "darwin":
+      return "Macintosh; Intel Mac OS X 10_15_7";
+    case "win32":
+      return "Windows NT 10.0; Win64; x64";
+    case "linux":
+    default:
+      return "X11; Linux x86_64";
+  }
+}
+
+export function antigravityUserAgent() {
+  return `Antigravity/${ANTIGRAVITY_VERSION} (${antigravityPlatformInfo()}) Chrome/${ANTIGRAVITY_CHROME_VERSION} Electron/${ANTIGRAVITY_ELECTRON_VERSION}`;
+}
+
 // Antigravity chat/stream headers
 export const ANTIGRAVITY_HEADERS = {
-  "User-Agent": `antigravity/1.107.0 ${platform()}/${arch()}`
+  "User-Agent": antigravityUserAgent()
 };
 
 // Cloud Code Assist API

package/open-sse/config/providers.js

@@ -1,4 +1,5 @@
 import { platform, arch } from "os";
+import { antigravityUserAgent } from "./appConstants.js";
 
 // === OS/Arch helpers ===
 function mapStainlessOs() {
@@ -108,7 +109,7 @@ export const PROVIDERS = {
       "https://daily-cloudcode-pa.sandbox.googleapis.com",
     ],
     format: "antigravity",
-    headers: { "User-Agent": `antigravity/1.107.0 ${platform()}/${arch()}` },
+    headers: { "User-Agent": antigravityUserAgent() },
     clientId: "1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com",
     clientSecret: "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"
   },

package/open-sse/executors/antigravity.js

@@ -3,9 +3,16 @@ 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 { deriveSessionId } from "../utils/sessionManager.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) {
@@ -31,11 +38,13 @@ export class AntigravityExecutor extends BaseExecutor {
   }
 
   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"
     };
@@ -91,7 +100,7 @@ export class AntigravityExecutor extends BaseExecutor {
       generationConfig,
       ...(contents && { contents }),
       ...(tools && { tools }),
-      sessionId: body.request?.sessionId || deriveSessionId(credentials?.email || credentials?.connectionId),
+      sessionId: body.request?.sessionId || getAntigravitySessionId(credentials),
       safetySettings: undefined,
       ...(tools?.length > 0 && { toolConfig: { functionCallingConfig: { mode: "VALIDATED" } } })
     };
@@ -100,9 +109,9 @@ export class AntigravityExecutor extends BaseExecutor {
       ...body,
       project: projectId,
       model: model,
-      userAgent: "antigravity",
+      userAgent: getAntigravityEnvelopeUserAgent(credentials),
       requestType: "agent",
-      requestId: `agent-${crypto.randomUUID()}`,
+      requestId: generateAntigravityRequestId(),
       request: transformedRequest
     };
   }
@@ -204,12 +213,20 @@ export class AntigravityExecutor extends BaseExecutor {
     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);
-      const transformedBody = this.transformRequest(model, body, stream, credentials);
+      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 = this.buildHeaders(credentials, stream, sessionId);
+      const headers = scrubProxyAndFingerprintHeaders(this.buildHeaders(credentials, stream, sessionId));
 
       // Initialize retry counters for this URL
       if (!retryAttemptsByUrl[urlIndex]) {
@@ -232,17 +249,31 @@ export class AntigravityExecutor extends BaseExecutor {
           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);
-              const errorMessage = errorJson?.error?.message || errorJson?.message || "";
-              retryMs = this.parseRetryFromErrorMessage(errorMessage);
+              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;
+          }
+
           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})`);

package/open-sse/services/antigravityHeaderScrub.js

@@ -0,0 +1,75 @@
+/**
+ * Antigravity header scrubbing.
+ *
+ * Real Antigravity is a Node.js desktop app. Its outbound HTTP requests never
+ * include proxy-tracing headers, Stainless SDK headers, or Chromium Sec-Ch-*
+ * fingerprint headers. Sending any of these reveals that the request came
+ * through a third-party proxy/tool, which Google can use to flag the account.
+ *
+ * Ported from OmniRoute's antigravityHeaderScrub.ts (mirrors CLIProxyAPI's
+ * ScrubProxyAndFingerprintHeaders in misc/header_utils.go).
+ */
+
+const HEADERS_TO_REMOVE = new Set([
+  // Proxy tracing
+  "x-forwarded-for",
+  "x-forwarded-host",
+  "x-forwarded-proto",
+  "x-forwarded-port",
+  "x-real-ip",
+  "forwarded",
+  "via",
+  // Client identity (Stainless SDK — Claude Code specific, not Antigravity)
+  "x-title",
+  "x-stainless-lang",
+  "x-stainless-package-version",
+  "x-stainless-os",
+  "x-stainless-arch",
+  "x-stainless-runtime",
+  "x-stainless-runtime-version",
+  "x-stainless-timeout",
+  "x-stainless-retry-count",
+  "x-stainless-helper-method",
+  "http-referer",
+  "referer",
+  // Browser / Chromium fingerprint (Electron clients, NOT Node.js)
+  "sec-ch-ua",
+  "sec-ch-ua-mobile",
+  "sec-ch-ua-platform",
+  "sec-fetch-mode",
+  "sec-fetch-site",
+  "sec-fetch-dest",
+  "priority",
+  // Encoding: Antigravity (Node.js) sends "gzip, deflate, br"; Electron adds
+  // "zstd" which is a fingerprint mismatch.
+  "accept-encoding",
+]);
+
+/**
+ * Remove headers that reveal proxy infrastructure or a non-native client
+ * identity from an outgoing Antigravity upstream request. Returns a new object;
+ * the input is not mutated. Authorization is deferred so it serializes last,
+ * matching the native Antigravity request fingerprint.
+ */
+export function scrubProxyAndFingerprintHeaders(headers) {
+  const cleaned = {};
+  let authorizationValue;
+  for (const [key, value] of Object.entries(headers || {})) {
+    const lowerKey = key.toLowerCase();
+    if (lowerKey.startsWith("x-zevai-") || HEADERS_TO_REMOVE.has(lowerKey)) {
+      continue;
+    }
+    if (lowerKey === "authorization") {
+      authorizationValue = value;
+      continue;
+    }
+    cleaned[key] = value;
+  }
+  cleaned["Accept-Encoding"] = "gzip, deflate, br";
+  if (authorizationValue !== undefined) {
+    cleaned["Authorization"] = authorizationValue;
+  }
+  return cleaned;
+}
+
+export const __HEADERS_SCRUBBED = HEADERS_TO_REMOVE;

package/open-sse/services/antigravityIdentity.js

@@ -0,0 +1,115 @@
+/**
+ * Antigravity request identity helpers.
+ *
+ * Antigravity's real client sends a stable per-account session id, a machine id,
+ * a request id, and an "envelope" client tag (antigravity vs jetski). Matching
+ * these makes our requests look like the native client instead of a proxy.
+ *
+ * Ported from OmniRoute's antigravityIdentity.ts (mirrors Antigravity-Manager).
+ */
+
+import crypto from "crypto";
+import { createRequire } from "module";
+
+// 64-bit FNV-1a constants (as signed int64) — must match Antigravity-Manager's
+// session-id derivation so the same email always yields the same session id.
+const FNV_OFFSET_I64 = -3750763034362895579n;
+const FNV_PRIME_I64 = 1099511628211n;
+
+// One random VS Code session id per process, like a running IDE instance.
+const PROCESS_SESSION_ID = crypto.randomUUID();
+
+const nodeRequire = createRequire(import.meta.url);
+let systemMachineIdSync = null;
+try {
+  const mod = nodeRequire("node-machine-id");
+  systemMachineIdSync = mod.machineIdSync || mod.default?.machineIdSync || null;
+} catch {
+  systemMachineIdSync = null;
+}
+
+function toNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+
+function getProviderDataString(credentials, key) {
+  const data = credentials?.providerSpecificData;
+  return data && typeof data === "object" ? toNonEmptyString(data[key]) : null;
+}
+
+/** Stable key identifying the account (email preferred, then id). */
+export function getAntigravityAccountKey(credentials) {
+  return (
+    toNonEmptyString(credentials?.email) ||
+    getProviderDataString(credentials, "email") ||
+    getProviderDataString(credentials, "accountId") ||
+    toNonEmptyString(credentials?.connectionId) ||
+    null
+  );
+}
+
+/** Non-gmail accounts are treated as enterprise ("jetski" envelope). */
+export function isAntigravityEnterpriseAccount(credentials) {
+  const email =
+    toNonEmptyString(credentials?.email) || getProviderDataString(credentials, "email") || "";
+  return !!email && !/@(?:gmail|googlemail)\.com$/i.test(email);
+}
+
+/** Envelope client tag the native client sends per account type. */
+export function getAntigravityEnvelopeUserAgent(credentials) {
+  return isAntigravityEnterpriseAccount(credentials) ? "jetski" : "antigravity";
+}
+
+/** Request id: "agent/<epoch-ms>/<hex>" — matches the native client format. */
+export function generateAntigravityRequestId() {
+  return `agent/${Date.now()}/${crypto.randomBytes(4).toString("hex")}`;
+}
+
+/** Random signed-int64-ish session id (used only when no account key exists). */
+export function generateAntigravitySessionId() {
+  const max = 18446744073709551615n; // 2^64 - 1
+  const target = 9_000_000_000_000_000_000n;
+  // Rejection sampling to avoid modulo bias.
+  const limit = max - (max % target);
+  let value;
+  do {
+    value = crypto.randomBytes(8).readBigUInt64BE();
+  } while (value >= limit);
+  return `-${(value % target).toString()}`;
+}
+
+/** Deterministic session id derived from the account key via 64-bit FNV-1a. */
+export function deriveAntigravitySessionId(accountKey) {
+  const key = toNonEmptyString(accountKey);
+  if (!key) return null;
+  let hash = FNV_OFFSET_I64;
+  for (const byte of Buffer.from(key, "utf8")) {
+    hash = BigInt.asIntN(64, hash ^ BigInt(byte));
+    hash = BigInt.asIntN(64, hash * FNV_PRIME_I64);
+  }
+  return hash.toString();
+}
+
+/** Session id for a request: derived-from-account → fallback → random. */
+export function getAntigravitySessionId(credentials, fallback) {
+  return (
+    deriveAntigravitySessionId(getAntigravityAccountKey(credentials)) ||
+    toNonEmptyString(fallback) ||
+    generateAntigravitySessionId()
+  );
+}
+
+/** OS machine id, or null (native client omits x-machine-id when unavailable). */
+export function deriveAntigravityMachineId() {
+  try {
+    const id = toNonEmptyString(systemMachineIdSync?.(true));
+    if (id) return id;
+  } catch {
+    // omit header when the OS machine id can't be read
+  }
+  return null;
+}
+
+export function getAntigravityVscodeSessionId() {
+  return PROCESS_SESSION_ID;
+}

package/open-sse/services/antigravityObfuscation.js

@@ -0,0 +1,92 @@
+/**
+ * Sensitive word obfuscation for Antigravity requests.
+ *
+ * Google's Antigravity backend scans request bodies for third-party coding-tool
+ * names (OpenCode, Cursor, Claude Code, etc.). Requests carrying those names are
+ * a signal used to flag/ban accounts. We insert a zero-width joiner (U+200D) after
+ * the first character of each match so the word no longer matches a literal grep
+ * yet still renders identically to a human reader.
+ *
+ * Ported from OmniRoute's antigravityObfuscation.ts (which mirrors CLIProxyAPI's
+ * cloak system and ZeroGravity's ZEROGRAVITY_SENSITIVE_WORDS).
+ */
+
+const ZWJ = "‍";
+
+const DEFAULT_WORDS = [
+  "opencode",
+  "open-code",
+  "cline",
+  "roo-cline",
+  "roo_cline",
+  "cursor",
+  "windsurf",
+  "aider",
+  "continue.dev",
+  "copilot",
+  "avante",
+  "codecompanion",
+  "claude code",
+  "claude-code",
+  "kilo code",
+  "kilocode",
+  "zevairouter",
+  "9router",
+];
+
+let words = [...DEFAULT_WORDS];
+
+export function setAntigravitySensitiveWords(w) {
+  words = Array.isArray(w) && w.length > 0 ? w : [...DEFAULT_WORDS];
+}
+
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// Per-word regex cache — avoids recompiling one RegExp per word on every request
+// body. Global regexes are safe to reuse (String.replace resets lastIndex).
+const _obfuscationRegexCache = new Map();
+function getObfuscationRegex(word) {
+  let regex = _obfuscationRegexCache.get(word);
+  if (!regex) {
+    if (_obfuscationRegexCache.size > 2000) _obfuscationRegexCache.clear();
+    regex = new RegExp(escapeRegex(word), "gi");
+    _obfuscationRegexCache.set(word, regex);
+  }
+  return regex;
+}
+
+/**
+ * Insert a zero-width joiner after the first character of every sensitive word
+ * found in `text`. Single-character matches are left untouched.
+ */
+export function obfuscateSensitiveWords(text) {
+  if (!text || words.length === 0) return text;
+  let result = text;
+  for (const word of words) {
+    if (!word) continue;
+    const regex = getObfuscationRegex(word);
+    result = result.replace(regex, (m) => (m.length <= 1 ? m : m[0] + ZWJ + m.slice(1)));
+  }
+  return result;
+}
+
+/**
+ * Obfuscate sensitive words inside a JSON-serializable request body by
+ * round-tripping through its string form. Returns a new object; the input is
+ * not mutated. Falls back to the original body if (de)serialization fails.
+ */
+export function obfuscateRequestBody(body) {
+  if (body == null || typeof body !== "object") return body;
+  try {
+    const serialized = JSON.stringify(body);
+    const obfuscated = obfuscateSensitiveWords(serialized);
+    if (obfuscated === serialized) return body;
+    return JSON.parse(obfuscated);
+  } catch {
+    return body;
+  }
+}
+
+export const __DEFAULT_SENSITIVE_WORDS = DEFAULT_WORDS;