@fudrouter/fsrouter 0.6.63 → 0.6.64

package/open-sse/rtk/registry.js

@@ -1,38 +0,0 @@
-import { FILTERS } from "./constants.js";
-import { gitDiff } from "./filters/gitDiff.js";
-import { gitStatus } from "./filters/gitStatus.js";
-import { grep } from "./filters/grep.js";
-import { find } from "./filters/find.js";
-import { dedupLog } from "./filters/dedupLog.js";
-import { ls } from "./filters/ls.js";
-import { tree } from "./filters/tree.js";
-import { smartTruncate } from "./filters/smartTruncate.js";
-import { readNumbered } from "./filters/readNumbered.js";
-import { searchList } from "./filters/searchList.js";
-
-const REGISTRY = {
-  [FILTERS.GIT_DIFF]: gitDiff,
-  [FILTERS.GIT_STATUS]: gitStatus,
-  [FILTERS.GREP]: grep,
-  [FILTERS.FIND]: find,
-  [FILTERS.DEDUP_LOG]: dedupLog,
-  [FILTERS.LS]: ls,
-  [FILTERS.TREE]: tree,
-  [FILTERS.SMART_TRUNCATE]: smartTruncate,
-  [FILTERS.READ_NUMBERED]: readNumbered,
-  [FILTERS.SEARCH_LIST]: searchList
-};
-
-// Rust resolve_filter aliases (pipe_cmd.rs): grep|rg, find|fd
-const ALIASES = {
-  rg: grep,
-  fd: find
-};
-
-export function resolveFilter(name) {
-  return REGISTRY[name] || ALIASES[name] || null;
-}
-
-export function allFilters() {
-  return REGISTRY;
-}

package/open-sse/rtk/systemInject.js

@@ -1,98 +0,0 @@
-// Shared system-prompt injector: appends an instruction into the system message of
-// the final request body, dispatching by format so it works for translated and
-// native-passthrough flows. Used by caveman.js and ponytail.js.
-
-import { FORMATS } from "../translator/formats.js";
-
-const SEP = "\n\n";
-
-export function injectSystemPrompt(body, format, prompt) {
-  if (!body || !prompt) return;
-
-  switch (format) {
-    case FORMATS.CLAUDE:
-      injectClaudeSystem(body, prompt);
-      return;
-    case FORMATS.GEMINI:
-    case FORMATS.GEMINI_CLI:
-    case FORMATS.VERTEX:
-    case FORMATS.ANTIGRAVITY:
-      // Antigravity wraps Gemini shape in body.request → injectGeminiSystem handles it
-      injectGeminiSystem(body, prompt);
-      return;
-    default:
-      // OpenAI and OpenAI-shaped formats (responses/codex/cursor/kiro/ollama)
-      injectMessagesSystem(body, prompt);
-  }
-}
-
-// OpenAI-shaped: messages[] (chat) or input[] (responses) or instructions (responses string)
-function injectMessagesSystem(body, prompt) {
-  // OpenAI Responses API: top-level string field
-  if (typeof body.instructions === "string") {
-    body.instructions = body.instructions
-      ? `${body.instructions}${SEP}${prompt}`
-      : prompt;
-    return;
-  }
-
-  const arr = Array.isArray(body.messages) ? body.messages
-    : Array.isArray(body.input) ? body.input
-    : null;
-  if (!arr) return;
-
-  const idx = arr.findIndex(m => m && (m.role === "system" || m.role === "developer"));
-  if (idx >= 0) {
-    appendToOpenAIMessage(arr[idx], prompt);
-  } else {
-    arr.unshift({ role: "system", content: prompt });
-  }
-}
-
-function appendToOpenAIMessage(msg, prompt) {
-  if (typeof msg.content === "string") {
-    msg.content = `${msg.content}${SEP}${prompt}`;
-  } else if (Array.isArray(msg.content)) {
-    // Responses-style array of parts {type:"input_text"|"text", text}
-    msg.content.push({ type: "input_text", text: prompt });
-  } else {
-    msg.content = prompt;
-  }
-}
-
-// Claude shape: body.system as string | array of {type:"text", text}
-// Insert before the last cache_control block to keep injection inside the cached prefix.
-function injectClaudeSystem(body, prompt) {
-  if (typeof body.system === "string" && body.system.length > 0) {
-    body.system = `${body.system}${SEP}${prompt}`;
-    return;
-  }
-  if (Array.isArray(body.system)) {
-    const block = { type: "text", text: prompt };
-    let lastCacheIdx = -1;
-    for (let i = body.system.length - 1; i >= 0; i--) {
-      if (body.system[i]?.cache_control) { lastCacheIdx = i; break; }
-    }
-    if (lastCacheIdx >= 0) {
-      body.system.splice(lastCacheIdx, 0, block);
-    } else {
-      body.system.push(block);
-    }
-    return;
-  }
-  body.system = prompt;
-}
-
-// Gemini shape: body.system_instruction | body.systemInstruction | body.request.systemInstruction
-// Each shape: { parts: [{ text }] }
-function injectGeminiSystem(body, prompt) {
-  const target = body.request && typeof body.request === "object" ? body.request : body;
-  const useSnake = Object.prototype.hasOwnProperty.call(target, "system_instruction");
-  const key = useSnake ? "system_instruction" : "systemInstruction";
-  const sys = target[key];
-  if (sys && Array.isArray(sys.parts)) {
-    sys.parts.push({ text: prompt });
-    return;
-  }
-  target[key] = { parts: [{ text: prompt }] };
-}

package/open-sse/services/accountFallback.js

@@ -1,323 +0,0 @@
-import { ERROR_RULES, BACKOFF_CONFIG, TRANSIENT_COOLDOWN_MS } from "../config/errorConfig.js";
-
-/**
- * Calculate exponential backoff cooldown for rate limits (429)
- * Level 1: 1s, Level 2: 2s, Level 3: 4s... → max 4 min
- * @param {number} backoffLevel - Current backoff level
- * @returns {number} Cooldown in milliseconds
- */
-export function getQuotaCooldown(backoffLevel = 0) {
-  const level = Math.max(0, backoffLevel - 1);
-  const cooldown = BACKOFF_CONFIG.base * Math.pow(2, level);
-  return Math.min(cooldown, BACKOFF_CONFIG.max);
-}
-
-/**
- * Check if error should trigger account fallback (switch to next account)
- * Config-driven: matches ERROR_RULES top-to-bottom (text rules first, then status)
- * @param {number} status - HTTP status code
- * @param {string} errorText - Error message text
- * @param {number} backoffLevel - Current backoff level for exponential backoff
- * @returns {{ shouldFallback: boolean, cooldownMs: number, newBackoffLevel?: number }}
- */
-export function checkFallbackError(status, errorText, backoffLevel = 0) {
-  const lowerError = errorText
-    ? (typeof errorText === "string" ? errorText : JSON.stringify(errorText)).toLowerCase()
-    : "";
-
-  for (const rule of ERROR_RULES) {
-    // Text-based rule: match substring in error message
-    if (rule.text && lowerError && lowerError.includes(rule.text)) {
-      if (rule.backoff) {
-        const newLevel = Math.min(backoffLevel + 1, BACKOFF_CONFIG.maxLevel);
-        return { shouldFallback: true, cooldownMs: getQuotaCooldown(newLevel), newBackoffLevel: newLevel };
-      }
-      return { shouldFallback: true, cooldownMs: rule.cooldownMs };
-    }
-
-    // Status-based rule: match HTTP status code
-    if (rule.status && rule.status === status) {
-      if (rule.backoff) {
-        const newLevel = Math.min(backoffLevel + 1, BACKOFF_CONFIG.maxLevel);
-        return { shouldFallback: true, cooldownMs: getQuotaCooldown(newLevel), newBackoffLevel: newLevel };
-      }
-      return { shouldFallback: true, cooldownMs: rule.cooldownMs };
-    }
-  }
-
-  // Default: transient cooldown for any unmatched error
-  return { shouldFallback: true, cooldownMs: TRANSIENT_COOLDOWN_MS };
-}
-
-/**
- * Check if account is currently unavailable (cooldown not expired)
- */
-export function isAccountUnavailable(unavailableUntil) {
-  if (!unavailableUntil) return false;
-  return new Date(unavailableUntil).getTime() > Date.now();
-}
-
-/**
- * Calculate unavailable until timestamp
- */
-export function getUnavailableUntil(cooldownMs) {
-  return new Date(Date.now() + cooldownMs).toISOString();
-}
-
-/**
- * Get the earliest rateLimitedUntil from a list of accounts
- * @param {Array} accounts - Array of account objects with rateLimitedUntil
- * @returns {string|null} Earliest rateLimitedUntil ISO string, or null
- */
-export function getEarliestRateLimitedUntil(accounts) {
-  let earliest = null;
-  const now = Date.now();
-  for (const acc of accounts) {
-    if (!acc.rateLimitedUntil) continue;
-    const until = new Date(acc.rateLimitedUntil).getTime();
-    if (until <= now) continue;
-    if (!earliest || until < earliest) earliest = until;
-  }
-  if (!earliest) return null;
-  return new Date(earliest).toISOString();
-}
-
-/**
- * Format rateLimitedUntil to human-readable "reset after Xm Ys"
- * @param {string} rateLimitedUntil - ISO timestamp
- * @returns {string} e.g. "reset after 2m 30s"
- */
-export function formatRetryAfter(rateLimitedUntil) {
-  if (!rateLimitedUntil) return "";
-  const diffMs = new Date(rateLimitedUntil).getTime() - Date.now();
-  if (diffMs <= 0) return "reset after 0s";
-  const totalSec = Math.ceil(diffMs / 1000);
-  const h = Math.floor(totalSec / 3600);
-  const m = Math.floor((totalSec % 3600) / 60);
-  const s = totalSec % 60;
-  const parts = [];
-  if (h > 0) parts.push(`${h}h`);
-  if (m > 0) parts.push(`${m}m`);
-  if (s > 0 || parts.length === 0) parts.push(`${s}s`);
-  return `reset after ${parts.join(" ")}`;
-}
-
-/** Prefix for model lock flat fields on connection record */
-export const MODEL_LOCK_PREFIX = "modelLock_";
-
-/** Special key used when no model is known (account-level lock) */
-export const MODEL_LOCK_ALL = `${MODEL_LOCK_PREFIX}__all`;
-
-/** Build the flat field key for a model lock */
-export function getModelLockKey(model) {
-  return model ? `${MODEL_LOCK_PREFIX}${model}` : MODEL_LOCK_ALL;
-}
-
-/**
- * Check if a model lock on a connection is still active.
- * Reads flat field `modelLock_${model}` (or `modelLock___all` when model=null).
- */
-export function isModelLockActive(connection, model) {
-  const key = getModelLockKey(model);
-  const expiry = connection[key] || connection[MODEL_LOCK_ALL];
-  if (!expiry) return false;
-  return new Date(expiry).getTime() > Date.now();
-}
-
-/**
- * Get earliest active model lock expiry across all modelLock_* fields.
- * Used for UI cooldown display.
- */
-export function getEarliestModelLockUntil(connection) {
-  if (!connection) return null;
-  let earliest = null;
-  const now = Date.now();
-  for (const [key, val] of Object.entries(connection)) {
-    if (!key.startsWith(MODEL_LOCK_PREFIX) || !val) continue;
-    const t = new Date(val).getTime();
-    if (t <= now) continue;
-    if (!earliest || t < earliest) earliest = t;
-  }
-  return earliest ? new Date(earliest).toISOString() : null;
-}
-
-/**
- * Build update object to set a model lock on a connection.
- */
-export function buildModelLockUpdate(model, cooldownMs) {
-  const key = getModelLockKey(model);
-  return { [key]: new Date(Date.now() + cooldownMs).toISOString() };
-}
-
-/**
- * Build update object to clear all model locks on a connection.
- */
-export function buildClearModelLocksUpdate(connection) {
-  const cleared = {};
-  for (const key of Object.keys(connection)) {
-    if (key.startsWith(MODEL_LOCK_PREFIX)) cleared[key] = null;
-  }
-  return cleared;
-}
-
-/**
- * Filter available accounts (not in cooldown)
- */
-export function filterAvailableAccounts(accounts, excludeId = null) {
-  const now = Date.now();
-  return accounts.filter(acc => {
-    if (excludeId && acc.id === excludeId) return false;
-    if (acc.rateLimitedUntil) {
-      const until = new Date(acc.rateLimitedUntil).getTime();
-      if (until > now) return false;
-    }
-    return true;
-  });
-}
-
-/**
- * Reset account state when request succeeds
- * Clears cooldown and resets backoff level to 0
- * @param {object} account - Account object
- * @returns {object} Updated account with reset state
- */
-export function resetAccountState(account) {
-  if (!account) return account;
-  return {
-    ...account,
-    rateLimitedUntil: null,
-    backoffLevel: 0,
-    lastError: null,
-    status: "active"
-  };
-}
-
-/**
- * Apply error state to account
- * @param {object} account - Account object
- * @param {number} status - HTTP status code
- * @param {string} errorText - Error message
- * @returns {object} Updated account with error state
- */
-export function applyErrorState(account, status, errorText) {
-  if (!account) return account;
-
-  const backoffLevel = account.backoffLevel || 0;
-  const { cooldownMs, newBackoffLevel } = checkFallbackError(status, errorText, backoffLevel);
-
-  return {
-    ...account,
-    rateLimitedUntil: cooldownMs > 0 ? getUnavailableUntil(cooldownMs) : null,
-    backoffLevel: newBackoffLevel ?? backoffLevel,
-    lastError: { status, message: errorText, timestamp: new Date().toISOString() },
-    status: "error"
-  };
-}
-
-// ── Error classification stubs (used by errorClassifier.js) ─────────────────
-
-/**
- * Check if error text indicates the account has been deactivated/disabled.
- */
-export function isAccountDeactivated(text) {
-  if (!text || typeof text !== 'string') return false;
-  const lower = text.toLowerCase();
-  return (
-    lower.includes('account disabled') ||
-    lower.includes('account_deactivated') ||
-    lower.includes('account has been deactivated') ||
-    lower.includes('account is no longer active') ||
-    lower.includes('organization has been disabled')
-  );
-}
-
-/**
- * Check if error text indicates credits/billing exhaustion.
- */
-export function isCreditsExhausted(text) {
-  if (!text || typeof text !== 'string') return false;
-  const lower = text.toLowerCase();
-  return (
-    lower.includes('insufficient funds') ||
-    lower.includes('insufficient_funds') ||
-    lower.includes('credits exhausted') ||
-    lower.includes('out of credits') ||
-    lower.includes('no credits') ||
-    lower.includes('credit limit') ||
-    lower.includes('payment required') ||
-    lower.includes('spending limit') ||
-    lower.includes('quota exceeded') ||
-    lower.includes('quota_exceeded') ||
-    lower.includes('budget exceeded') ||
-    lower.includes('budget_exceeded')
-  );
-}
-
-/**
- * Check if error text indicates daily quota exhaustion (for 429 responses).
- */
-export function isDailyQuotaExhausted(text) {
-  if (!text || typeof text !== 'string') return false;
-  const lower = text.toLowerCase();
-  return (
-    lower.includes('daily') ||
-    lower.includes('per day') ||
-    lower.includes('daily limit') ||
-    lower.includes('rate limit reached') ||
-    lower.includes('daily quota')
-  );
-}
-
-/**
- * Check if error text indicates an invalid/expired OAuth token.
- */
-export function isOAuthInvalidToken(text) {
-  if (!text || typeof text !== 'string') return false;
-  const lower = text.toLowerCase();
-  return (
-    lower.includes('invalid_token') ||
-    lower.includes('invalid token') ||
-    lower.includes('token expired') ||
-    lower.includes('token has expired') ||
-    lower.includes('access token is invalid')
-  );
-}
-
-/**
- * Parse retry-after from a response body (JSON or string).
- * Returns { retryAfterMs, reason }.
- */
-export function parseRetryAfterFromBody(responseBody) {
-  if (!responseBody) return { retryAfterMs: 0, reason: null };
-  const text = typeof responseBody === 'string' ? responseBody : JSON.stringify(responseBody);
-
-  let retryAfterMs = 0;
-  let reason = null;
-
-  if (typeof responseBody === 'object' && responseBody !== null) {
-    const raw = responseBody.retry_after ?? responseBody.retryAfter ?? responseBody.retry_after_seconds;
-    if (typeof raw === 'number' && raw > 0) {
-      retryAfterMs = raw < 1e12 ? raw * 1000 : raw - Date.now();
-      reason = 'retry_after header';
-    } else if (typeof raw === 'string') {
-      const parsed = Number(raw);
-      if (Number.isFinite(parsed) && parsed > 0) {
-        retryAfterMs = parsed < 1e12 ? parsed * 1000 : parsed - Date.now();
-        reason = 'retry_after header';
-      }
-    }
-  }
-
-  if (retryAfterMs === 0) {
-    const match = text.match(/retry.*?(\d+)\s*(?:second|minute|hour)/i);
-    if (match) {
-      const val = Number(match[1]);
-      if (text.includes('minute')) retryAfterMs = val * 60 * 1000;
-      else if (text.includes('hour')) retryAfterMs = val * 3600 * 1000;
-      else retryAfterMs = val * 1000;
-      reason = 'body text pattern';
-    }
-  }
-
-  return { retryAfterMs, reason };
-}

package/open-sse/services/antigravityHeaders.js

@@ -1,91 +0,0 @@
-import { platform, arch } from "os";
-import {
-  ANTIGRAVITY_FALLBACK_VERSION,
-  getCachedAntigravityVersion,
-  resolveAntigravityVersion,
-} from "./antigravityVersion.js";
-
-const ANTIGRAVITY_VERSION = ANTIGRAVITY_FALLBACK_VERSION;
-export const ANTIGRAVITY_CHROME_VERSION = "142.0.7444.175";
-export const ANTIGRAVITY_ELECTRON_VERSION = "39.2.3";
-export const ANTIGRAVITY_LOAD_CODE_ASSIST_USER_AGENT = `vscode/1.X.X (Antigravity/${ANTIGRAVITY_FALLBACK_VERSION})`;
-export const ANTIGRAVITY_LOAD_CODE_ASSIST_API_CLIENT = "";
-export const ANTIGRAVITY_NODE_API_CLIENT = "google-api-nodejs-client/10.3.0";
-export const ANTIGRAVITY_CREDIT_PROBE_API_CLIENT = "gl-node/22.21.1";
-export const ANTIGRAVITY_API_CLIENT = ANTIGRAVITY_CREDIT_PROBE_API_CLIENT;
-
-function withOptionalBearerAuth(headers, accessToken) {
-  if (accessToken) {
-    headers.Authorization = `Bearer ${accessToken}`;
-  }
-  return headers;
-}
-
-function getAntigravityPlatformInfo(platformName = platform()) {
-  switch (platformName) {
-    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(version = getCachedAntigravityVersion(), platformName = platform()) {
-  return `Antigravity/${version} (${getAntigravityPlatformInfo(platformName)}) Chrome/${ANTIGRAVITY_CHROME_VERSION} Electron/${ANTIGRAVITY_ELECTRON_VERSION}`;
-}
-
-export async function resolveAntigravityUserAgent(platformName = platform()) {
-  const version = await resolveAntigravityVersion();
-  return antigravityUserAgent(version, platformName);
-}
-
-export function antigravityNativeOAuthUserAgent() {
-  return `vscode/1.X.X (Antigravity/${getCachedAntigravityVersion()})`;
-}
-
-export function getAntigravityLoadCodeAssistMetadata() {
-  return {
-    ideType: "ANTIGRAVITY",
-  };
-}
-
-export function getAntigravityLoadCodeAssistClientMetadata() {
-  return JSON.stringify(getAntigravityLoadCodeAssistMetadata());
-}
-
-export function getAntigravityHeaders(profile, accessToken) {
-  switch (profile) {
-    case "loadCodeAssist":
-      return withOptionalBearerAuth(
-        {
-          "Content-Type": "application/json",
-          "User-Agent": antigravityNativeOAuthUserAgent(),
-        },
-        accessToken
-      );
-    case "fetchAvailableModels":
-    case "models":
-      return withOptionalBearerAuth(
-        {
-          "Content-Type": "application/json",
-          "User-Agent": antigravityUserAgent(),
-        },
-        accessToken
-      );
-    default:
-      return withOptionalBearerAuth({ "Content-Type": "application/json" }, accessToken);
-  }
-}
-
-export function getAntigravityCreditProbeApiClientHeader() {
-  return ANTIGRAVITY_CREDIT_PROBE_API_CLIENT;
-}
-
-export function getAntigravityApiClientHeader() {
-  return ANTIGRAVITY_API_CLIENT;
-}
-
-export { ANTIGRAVITY_VERSION };

package/open-sse/services/antigravityVersion.js

@@ -1,154 +0,0 @@
-const ANTIGRAVITY_RELEASE_FEED_URL =
-  "https://antigravity-auto-updater-974169037036.us-central1.run.app/releases";
-const ANTIGRAVITY_GITHUB_RELEASE_URL =
-  "https://api.github.com/repos/antigravityide/antigravity/releases/latest";
-
-export const ANTIGRAVITY_VERSION_CACHE_TTL_MS = 6 * 60 * 60 * 1000;
-export const ANTIGRAVITY_VERSION_FETCH_TIMEOUT_MS = 5000;
-// Floor version synced with Antigravity-Manager v4.2.0 KNOWN_STABLE_VERSION.
-export const ANTIGRAVITY_FALLBACK_VERSION = "4.2.0";
-
-let versionCache = null;
-let inFlightRequest = null;
-
-function normalizeVersion(value) {
-  if (typeof value !== "string") return null;
-  const trimmed = value.trim().replace(/^v/i, "");
-  const match = trimmed.match(/^(\d+\.\d+\.\d+)\b/);
-  return match ? match[1] : null;
-}
-
-function compareSemver(a, b) {
-  const aParts = a.split(".").map((part) => Number.parseInt(part, 10) || 0);
-  const bParts = b.split(".").map((part) => Number.parseInt(part, 10) || 0);
-  for (let i = 0; i < 3; i += 1) {
-    if (aParts[i] !== bParts[i]) return aParts[i] - bParts[i];
-  }
-  return 0;
-}
-
-function pickNewestVersion(...versions) {
-  return versions
-    .map((version) => normalizeVersion(version))
-    .filter((version) => !!version)
-    .reduce(
-      (best, version) => (compareSemver(version, best) > 0 ? version : best),
-      ANTIGRAVITY_FALLBACK_VERSION
-    );
-}
-
-async function fetchJsonWithTimeout(fetchImpl, url) {
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), ANTIGRAVITY_VERSION_FETCH_TIMEOUT_MS);
-
-  try {
-    const response = await fetchImpl(url, {
-      headers: {
-        Accept: "application/json",
-        "User-Agent": "OmniRoute-AntigravityVersion/1.0",
-      },
-      signal: controller.signal,
-    });
-
-    if (!response.ok) {
-      throw new Error(`Version source ${url} returned ${response.status}`);
-    }
-
-    return response.json();
-  } finally {
-    clearTimeout(timeoutId);
-  }
-}
-
-function parseOfficialReleaseFeed(payload) {
-  if (!Array.isArray(payload)) return null;
-
-  for (const entry of payload) {
-    const version = normalizeVersion(entry?.version);
-    if (version) return version;
-  }
-
-  return null;
-}
-
-function parseGitHubRelease(payload) {
-  if (!payload || typeof payload !== "object") return null;
-
-  const candidate = payload.tag_name ?? payload.name;
-  return normalizeVersion(candidate);
-}
-
-async function fetchLatestAntigravityVersion(fetchImpl) {
-  const sources = [
-    {
-      parse: parseOfficialReleaseFeed,
-      url: ANTIGRAVITY_RELEASE_FEED_URL,
-    },
-    {
-      parse: parseGitHubRelease,
-      url: ANTIGRAVITY_GITHUB_RELEASE_URL,
-    },
-  ];
-
-  for (const source of sources) {
-    try {
-      const payload = await fetchJsonWithTimeout(fetchImpl, source.url);
-      const version = source.parse(payload);
-      if (version) return version;
-    } catch {
-      // Try next
-    }
-  }
-
-  return null;
-}
-
-export async function resolveAntigravityVersion(fetchImpl = fetch) {
-  const now = Date.now();
-
-  if (versionCache && now - versionCache.fetchedAt < ANTIGRAVITY_VERSION_CACHE_TTL_MS) {
-    return versionCache.version;
-  }
-
-  if (inFlightRequest) {
-    return inFlightRequest;
-  }
-
-  inFlightRequest = (async () => {
-    const resolved = await fetchLatestAntigravityVersion(fetchImpl);
-    const version = resolved
-      ? pickNewestVersion(resolved, ANTIGRAVITY_FALLBACK_VERSION)
-      : pickNewestVersion(versionCache?.version, ANTIGRAVITY_FALLBACK_VERSION);
-
-    if (resolved) {
-      versionCache = {
-        fetchedAt: Date.now(),
-        version,
-      };
-    }
-
-    return version;
-  })();
-
-  try {
-    return await inFlightRequest;
-  } finally {
-    inFlightRequest = null;
-  }
-}
-
-export function getCachedAntigravityVersion() {
-  return versionCache?.version || ANTIGRAVITY_FALLBACK_VERSION;
-}
-
-export function seedAntigravityVersionCache(version, fetchedAt = Date.now()) {
-  versionCache = {
-    fetchedAt,
-    version,
-  };
-}
-
-export function clearAntigravityVersionCache() {
-  versionCache = null;
-  inFlightRequest = null;
-}