zevairouter 1.0.154 → 1.0.155

package/open-sse/services/antigravityIdentity.js

@@ -1,115 +0,0 @@
-/**
- * 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

@@ -1,92 +0,0 @@
-/**
- * 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",
-  "zevairouter",
-];
-
-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;

package/open-sse/services/clinepassModels.js

@@ -1,63 +0,0 @@
-import { buildClineHeaders } from "../../src/shared/utils/clineAuth.js";
-
-const CLINEPASS_MODELS_ENDPOINT = "https://api.cline.bot/api/v1/models";
-const FETCH_TIMEOUT_MS = 5000;
-
-/**
- * Build request headers for the ClinePass /models endpoint (Cline's upstream API).
- * - API keys are sent as plain Bearer tokens.
- * - OAuth access tokens must carry the WorkOS `workos:` prefix (handled by buildClineHeaders).
- */
-function buildModelListHeaders(token, isApiKey) {
-  if (isApiKey) {
-    return {
-      Accept: "application/json",
-      Authorization: `Bearer ${token}`,
-    };
-  }
-  return buildClineHeaders(token, { Accept: "application/json" });
-}
-
-/**
- * Fetch ClinePass live model catalog from Cline's /models endpoint.
- *
- * @param {object} credentials - Connection credentials ({ accessToken, apiKey })
- * @returns {Promise<{ models: { id: string, name: string }[] } | null>}
- */
-export async function resolveClinepassModels(credentials) {
-  const isApiKey = Boolean(credentials?.apiKey);
-  const token = isApiKey ? credentials.apiKey : credentials?.accessToken;
-  if (!token) return null;
-
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
-
-  try {
-    const headers = buildModelListHeaders(token, isApiKey);
-
-    const response = await fetch(CLINEPASS_MODELS_ENDPOINT, {
-      method: "GET",
-      headers,
-      signal: controller.signal,
-    });
-
-    if (!response.ok) return null;
-
-    const json = await response.json();
-    const rawList = Array.isArray(json) ? json : json?.data;
-    if (!Array.isArray(rawList)) return null;
-
-    const models = rawList
-      .filter((m) => typeof m?.id === "string" && m.id.startsWith("cline-pass/"))
-      .map((m) => ({
-        id: m.id,
-        name: m.name || m.id,
-      }));
-
-    return models.length ? { models } : null;
-  } catch {
-    return null;
-  } finally {
-    clearTimeout(timer);
-  }
-}

package/open-sse/services/combo.js

@@ -1,189 +0,0 @@
-/**
- * Shared combo (model combo) handling with fallback support
- */
-
-import { checkFallbackError, formatRetryAfter } from "./accountFallback.js";
-import { unavailableResponse } from "../utils/error.js";
-
-/**
- * Track rotation state per combo (for round-robin strategy)
- * @type {Map<string, { index: number, consecutiveUseCount: number }>}
- */
-const comboRotationState = new Map();
-
-function normalizeStickyLimit(stickyLimit) {
-  const parsed = Number.parseInt(stickyLimit, 10);
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : 1;
-}
-
-function rotateModelsFromIndex(models, currentIndex) {
-  const rotatedModels = [...models];
-  for (let i = 0; i < currentIndex; i++) {
-    const moved = rotatedModels.shift();
-    rotatedModels.push(moved);
-  }
-  return rotatedModels;
-}
-
-/**
- * Get rotated model list based on strategy
- * @param {string[]} models - Array of model strings
- * @param {string} comboName - Name of the combo
- * @param {string} strategy - "fallback" or "round-robin"
- * @param {number|string} [stickyLimit=1] - Requests per combo model before switching
- * @returns {string[]} Rotated models array
- */
-export function getRotatedModels(models, comboName, strategy, stickyLimit = 1) {
-  if (!models || models.length <= 1 || strategy !== "round-robin") {
-    return models;
-  }
-
-  const rotationKey = comboName || "__default__";
-  const normalizedStickyLimit = normalizeStickyLimit(stickyLimit);
-  const existingState = comboRotationState.get(rotationKey);
-  const state = typeof existingState === "number"
-    ? { index: existingState, consecutiveUseCount: 0 }
-    : (existingState || { index: 0, consecutiveUseCount: 0 });
-
-  const currentIndex = state.index % models.length;
-  const rotatedModels = rotateModelsFromIndex(models, currentIndex);
-  const nextUseCount = state.consecutiveUseCount + 1;
-
-  if (nextUseCount >= normalizedStickyLimit) {
-    comboRotationState.set(rotationKey, {
-      index: (currentIndex + 1) % models.length,
-      consecutiveUseCount: 0,
-    });
-  } else {
-    comboRotationState.set(rotationKey, {
-      index: currentIndex,
-      consecutiveUseCount: nextUseCount,
-    });
-  }
-
-  return rotatedModels;
-}
-
-/**
- * Reset in-memory rotation state when combo/settings change
- * @param {string} [comboName] - Combo name to reset; omit to clear all
- */
-export function resetComboRotation(comboName) {
-  if (comboName) comboRotationState.delete(comboName);
-  else comboRotationState.clear();
-}
-
-/**
- * Get combo models from combos data
- * @param {string} modelStr - Model string to check
- * @param {Array|Object} combosData - Array of combos or object with combos
- * @returns {string[]|null} Array of models or null if not a combo
- */
-export function getComboModelsFromData(modelStr, combosData) {
-  // Don't check if it's in provider/model format
-  if (modelStr.includes("/")) return null;
-  
-  // Handle both array and object formats
-  const combos = Array.isArray(combosData) ? combosData : (combosData?.combos || []);
-  
-  const combo = combos.find(c => c.name === modelStr);
-  if (combo && combo.models && combo.models.length > 0) {
-    return combo.models;
-  }
-  return null;
-}
-
-/**
- * Handle combo chat with fallback
- * @param {Object} options
- * @param {Object} options.body - Request body
- * @param {string[]} options.models - Array of model strings to try
- * @param {Function} options.handleSingleModel - Function to handle single model: (body, modelStr) => Promise<Response>
- * @param {Object} options.log - Logger object
- * @param {string} [options.comboName] - Name of the combo (for round-robin tracking)
- * @param {string} [options.comboStrategy] - Strategy: "fallback" or "round-robin"
- * @param {number|string} [options.comboStickyLimit=1] - Requests per combo model before switching
- * @returns {Promise<Response>}
- */
-export async function handleComboChat({ body, models, handleSingleModel, log, comboName, comboStrategy, comboStickyLimit = 1 }) {
-  // Apply rotation strategy if enabled
-  const rotatedModels = getRotatedModels(models, comboName, comboStrategy, comboStickyLimit);
-  
-  let lastError = null;
-  let earliestRetryAfter = null;
-  let lastStatus = null;
-
-  for (let i = 0; i < rotatedModels.length; i++) {
-    const modelStr = rotatedModels[i];
-    log.info("COMBO", `Trying model ${i + 1}/${rotatedModels.length}: ${modelStr}`);
-
-    try {
-      const result = await handleSingleModel(body, modelStr);
-      
-      // Success (2xx) - return response
-      if (result.ok) {
-        log.info("COMBO", `Model ${modelStr} succeeded`);
-        return result;
-      }
-
-      // Extract error info from response
-      let errorText = result.statusText || "";
-      let retryAfter = null;
-      try {
-        const errorBody = await result.clone().json();
-        errorText = errorBody?.error?.message || errorBody?.error || errorBody?.message || errorText;
-        retryAfter = errorBody?.retryAfter || null;
-      } catch {
-        // Ignore JSON parse errors
-      }
-
-      // Track earliest retryAfter across all combo models
-      if (retryAfter && (!earliestRetryAfter || new Date(retryAfter) < new Date(earliestRetryAfter))) {
-        earliestRetryAfter = retryAfter;
-      }
-
-      // Normalize error text to string (Worker-safe)
-      if (typeof errorText !== "string") {
-        try { errorText = JSON.stringify(errorText); } catch { errorText = String(errorText); }
-      }
-
-      // Check if should fallback to next model
-      const { shouldFallback } = checkFallbackError(result.status, errorText);
-
-      if (!shouldFallback) {
-        log.warn("COMBO", `Model ${modelStr} failed (no fallback)`, { status: result.status });
-        return result;
-      }
-
-      // Fallback to next model
-      lastError = errorText || String(result.status);
-      lastStatus = result.status;
-      log.warn("COMBO", `Model ${modelStr} failed, trying next`, { status: result.status });
-    } catch (error) {
-      // Catch unexpected exceptions to ensure fallback continues
-      lastError = error.message || String(error);
-      lastStatus = 500;
-      log.warn("COMBO", `Model ${modelStr} threw error, trying next`, { error: lastError });
-    }
-  }
-
-  // All models failed
-  // Use 503 (Service Unavailable) rather than 406 (Not Acceptable) — 406 implies
-  // the request itself is invalid, but here the providers are simply unavailable
-  // or have no active credentials. 503 is more accurate and retryable by clients.
-  const allDisabled = lastError && lastError.toLowerCase().includes("no credentials");
-  const status = allDisabled ? 503 : (lastStatus || 503);
-  const msg = lastError || "All combo models unavailable";
-
-  if (earliestRetryAfter) {
-    const retryHuman = formatRetryAfter(earliestRetryAfter);
-    log.warn("COMBO", `All models failed | ${msg} (${retryHuman})`);
-    return unavailableResponse(status, msg, earliestRetryAfter, retryHuman);
-  }
-
-  log.warn("COMBO", `All models failed | ${msg}`);
-  return new Response(
-    JSON.stringify({ error: { message: msg } }),
-    { status, headers: { "Content-Type": "application/json" } }
-  );
-}

package/open-sse/services/compact.js

@@ -1,71 +0,0 @@
-/**
- * Shared combo (model combo) handling with fallback support
- */
-
-/**
- * Get combo models from combos data
- * @param {string} modelStr - Model string to check
- * @param {Array|Object} combosData - Array of combos or object with combos
- * @returns {string[]|null} Array of models or null if not a combo
- */
-export function getComboModelsFromData(modelStr, combosData) {
-  // Don't check if it's in provider/model format
-  if (modelStr.includes("/")) return null;
-  
-  // Handle both array and object formats
-  const combos = Array.isArray(combosData) ? combosData : (combosData?.combos || []);
-  
-  const combo = combos.find(c => c.name === modelStr);
-  if (combo && combo.models && combo.models.length > 0) {
-    return combo.models;
-  }
-  return null;
-}
-
-/**
- * Handle combo chat with fallback
- * @param {Object} options
- * @param {Object} options.body - Request body
- * @param {string[]} options.models - Array of model strings to try
- * @param {Function} options.handleSingleModel - Function to handle single model: (body, modelStr) => Promise<Response>
- * @param {Object} options.log - Logger object
- * @returns {Promise<Response>}
- */
-export async function handleComboChat({ body, models, handleSingleModel, log }) {
-  let lastError = null;
-
-  for (let i = 0; i < models.length; i++) {
-    const modelStr = models[i];
-    log.info("COMBO", `Trying model ${i + 1}/${models.length}: ${modelStr}`);
-
-    let result;
-    try {
-      result = await handleSingleModel(body, modelStr);
-    } catch (e) {
-      lastError = `${modelStr}: ${e.message}`;
-      log.warn("COMBO", `Model threw exception, trying next`, { model: modelStr, error: e.message });
-      continue;
-    }
-
-    // Success or client error - return response
-    if (result.ok || result.status < 500) {
-      return result;
-    }
-
-    // 5xx error - try next model
-    lastError = `${modelStr}: ${result.statusText || result.status}`;
-    log.warn("COMBO", `Model failed, trying next`, { model: modelStr, status: result.status });
-  }
-
-  log.warn("COMBO", "All models failed");
-  
-  // Return 503 with last error
-  return new Response(
-    JSON.stringify({ error: lastError || "All combo models unavailable" }),
-    { 
-      status: 503, 
-      headers: { "Content-Type": "application/json" }
-    }
-  );
-}
-

package/open-sse/services/copilotModels.js

@@ -1,155 +0,0 @@
-/**
- * GitHub Copilot model catalog fetcher.
- *
- * Calls Copilot's `GET /models` endpoint to get the live catalog for an
- * authenticated account, so `/v1/models` reflects what the account can
- * actually use (e.g. newly shipped `claude-opus-4.8`, `gpt-5.5`) instead of
- * the hand-maintained static registry, which inevitably lags behind.
- *
- * Returns chat-capable models the account's policy allows. Embeddings and
- * disabled models are filtered out.
- */
-
-import { proxyAwareFetch } from "../utils/proxyFetch.js";
-import { GITHUB_COPILOT } from "../config/appConstants.js";
-import { refreshCopilotToken } from "./tokenRefresh.js";
-
-const MODELS_URL = "https://api.githubcopilot.com/models";
-const FETCH_TIMEOUT_MS = 10_000;
-const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes per credential
-
-/** @type {Map<string, { expiresAt: number, models: any[] }>} */
-const catalogCache = new Map();
-
-function cacheKey(credentials) {
-  return credentials?.providerSpecificData?.copilotToken
-    || credentials?.accessToken
-    || "copilot-anonymous";
-}
-
-function buildHeaders(token) {
-  return {
-    "Authorization": `Bearer ${token}`,
-    "Content-Type": "application/json",
-    "Copilot-Integration-Id": "vscode-chat",
-    "editor-version": `vscode/${GITHUB_COPILOT.VSCODE_VERSION}`,
-    "editor-plugin-version": `copilot-chat/${GITHUB_COPILOT.COPILOT_CHAT_VERSION}`,
-    "user-agent": GITHUB_COPILOT.USER_AGENT,
-    "x-github-api-version": GITHUB_COPILOT.API_VERSION,
-  };
-}
-
-async function fetchCatalogRaw(token, signal) {
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
-  try {
-    const response = await proxyAwareFetch(MODELS_URL, {
-      method: "GET",
-      headers: buildHeaders(token),
-      cache: "no-store",
-      signal: signal || controller.signal,
-    });
-    if (!response.ok) {
-      const err = new Error(`Copilot /models returned ${response.status}`);
-      err.status = response.status;
-      throw err;
-    }
-    const data = await response.json();
-    return Array.isArray(data?.data) ? data.data : [];
-  } finally {
-    clearTimeout(timeoutId);
-  }
-}
-
-// Keep only chat models the account is allowed to use. The static registry
-// surfaced disabled/embedding entries inconsistently; here we trust upstream.
-function expandCatalog(raw) {
-  const seen = new Set();
-  const models = [];
-  for (const m of raw) {
-    if (!m || typeof m !== "object") continue;
-    if (m.capabilities?.type !== "chat") continue;
-    if (m.policy && m.policy.state !== "enabled") continue;
-    const id = m.id;
-    if (!id || seen.has(id)) continue;
-    seen.add(id);
-    models.push({ id, name: m.name || id });
-  }
-  return models;
-}
-
-/**
- * Resolve the live Copilot model catalog for a connection.
- *
- * @param {object} credentials Connection record (accessToken, refreshToken,
- *   providerSpecificData {copilotToken, copilotTokenExpiresAt}).
- * @param {object} [options]
- * @param {boolean} [options.forceRefresh] Bypass the per-credential cache.
- * @param {object}  [options.log] Logger.
- * @param {function} [options.onCredentialsRefreshed] Persist a refreshed
- *   Copilot token back to your store. Called with `{ copilotToken,
- *   copilotTokenExpiresAt }` whenever a 401 triggers a refresh.
- * @returns {Promise<{ models: object[] } | null>}
- */
-export async function resolveCopilotModels(credentials, options = {}) {
-  const token = credentials?.providerSpecificData?.copilotToken || credentials?.accessToken;
-  if (!token) {
-    options.log?.debug?.("COPILOT_MODELS", "No copilotToken/accessToken; skipping live fetch");
-    return null;
-  }
-
-  const key = cacheKey(credentials);
-  const now = Date.now();
-  if (!options.forceRefresh) {
-    const cached = catalogCache.get(key);
-    if (cached && cached.expiresAt > now) {
-      return { models: cached.models };
-    }
-  }
-
-  let raw;
-  try {
-    raw = await fetchCatalogRaw(token, options.signal);
-  } catch (err) {
-    // A 401/403 means the Copilot token is stale — refresh from the GitHub
-    // access token and retry once.
-    if (err && (err.status === 401 || err.status === 403) && credentials.accessToken) {
-      options.log?.info?.("COPILOT_MODELS", `Got ${err.status}; refreshing Copilot token`);
-      const refreshed = await refreshCopilotToken(credentials.accessToken);
-      if (refreshed?.token) {
-        if (typeof options.onCredentialsRefreshed === "function") {
-          try {
-            await options.onCredentialsRefreshed({
-              copilotToken: refreshed.token,
-              copilotTokenExpiresAt: refreshed.expiresAt,
-            });
-          } catch (e) {
-            options.log?.warn?.("COPILOT_MODELS", `onCredentialsRefreshed failed: ${e?.message || e}`);
-          }
-        }
-        try {
-          raw = await fetchCatalogRaw(refreshed.token, options.signal);
-        } catch (err2) {
-          options.log?.warn?.("COPILOT_MODELS", `Retry after refresh failed: ${err2?.message || err2}`);
-          return null;
-        }
-      } else {
-        options.log?.warn?.("COPILOT_MODELS", "Token refresh did not return a token");
-        return null;
-      }
-    } else {
-      options.log?.warn?.("COPILOT_MODELS", `Live model fetch failed: ${err?.message || err}`);
-      return null;
-    }
-  }
-
-  const models = expandCatalog(raw);
-  if (!models.length) return null;
-
-  catalogCache.set(key, { expiresAt: now + CACHE_TTL_MS, models });
-  return { models };
-}
-
-export function clearCopilotModelCache() {
-  catalogCache.clear();
-}