zevairouter 1.0.39 → 1.0.41

package/open-sse/rtk/headroom.js

@@ -0,0 +1,348 @@
+import { claudeToOpenAIRequest } from "../translator/request/claude-to-openai.js";
+import { openaiToClaudeRequest } from "../translator/request/openai-to-claude.js";
+import {
+  openaiResponsesToOpenAIRequest,
+  openaiToOpenAIResponsesRequest,
+} from "../translator/request/openai-responses.js";
+
+const DEFAULT_TIMEOUT_MS = 3000;
+
+function jsonBytes(value) {
+  try {
+    return new TextEncoder().encode(JSON.stringify(value) || "").length;
+  } catch {
+    return 0;
+  }
+}
+
+function messagePayload(body) {
+  if (Array.isArray(body?.messages)) return body.messages;
+  if (Array.isArray(body?.input)) return body.input;
+  const kiro = collectKiroHeadroomMessages(body);
+  if (kiro) return kiro.messages;
+  return null;
+}
+
+function captureSizeSnapshot(body) {
+  const messages = messagePayload(body);
+  return {
+    bodyBytes: jsonBytes(body),
+    messageBytes: messages ? jsonBytes(messages) : 0,
+  };
+}
+
+function setDiagnostic(diagnostics, reason) {
+  if (diagnostics && !diagnostics.reason) diagnostics.reason = reason;
+}
+
+function scrubSensitiveUrlText(text) {
+  return String(text)
+    .replace(/\/\/[^/@\s]+@/g, "//")
+    .replace(/(https?:\/\/[^\s?#]+)[?#][^\s)]*/g, "$1");
+}
+
+function describeFetchError(error) {
+  const cause = error?.cause;
+  const code = cause?.code || error?.code;
+  const message = scrubSensitiveUrlText(cause?.message || error?.message || String(error));
+  return code ? `${code}: ${message}` : message;
+}
+
+function buildCompressEndpoint(url) {
+  try {
+    const parsed = new URL(url);
+    parsed.pathname = `${parsed.pathname.replace(/\/$/, "")}/v1/compress`;
+    parsed.hash = "";
+    return parsed.toString();
+  } catch {
+    const raw = String(url).replace(/#.*$/, "");
+    const [base, query = ""] = raw.split("?", 2);
+    const endpoint = `${base.replace(/\/$/, "")}/v1/compress`;
+    return query ? `${endpoint}?${query}` : endpoint;
+  }
+}
+
+function maskEndpoint(endpoint) {
+  try {
+    const parsed = new URL(endpoint);
+    parsed.username = "";
+    parsed.password = "";
+    parsed.search = "";
+    parsed.hash = "";
+    return parsed.toString();
+  } catch {
+    return String(endpoint).replace(/\/\/[^/@\s]+@/, "//").replace(/[?#].*$/, "");
+  }
+}
+
+function hasUnsafeResponsesInputForCompression(body) {
+  if (!Array.isArray(body?.input)) return false;
+  return body.input.some((item) => {
+    if (!item || typeof item !== "object" || Array.isArray(item)) return false;
+    return typeof item.type === "string" && item.type !== "message";
+  });
+}
+
+function collectKiroHeadroomMessages(body) {
+  const state = body?.conversationState;
+  if (!state || typeof state !== "object") return null;
+
+  const messages = [];
+  const targets = [];
+
+  const addTextTarget = (role, text, target, extra = {}) => {
+    if (typeof text !== "string") return;
+    messages.push({ role, content: text, ...extra });
+    targets.push(target);
+  };
+
+  const toToolCalls = (toolUses) => {
+    if (!Array.isArray(toolUses) || toolUses.length === 0) return undefined;
+    const calls = toolUses.map((toolUse) => ({
+      id: toolUse?.toolUseId,
+      type: "function",
+      function: {
+        name: toolUse?.name || "",
+        arguments: JSON.stringify(toolUse?.input || {}),
+      },
+    })).filter((call) => call.id || call.function.name);
+    return calls.length > 0 ? calls : undefined;
+  };
+
+  const visit = (item) => {
+    const user = item?.userInputMessage;
+    if (user) {
+      addTextTarget("system", user.systemInstruction, { object: user, key: "systemInstruction" });
+      addTextTarget("user", user.content, { object: user, key: "content" });
+
+      const toolResults = user.userInputMessageContext?.toolResults;
+      if (Array.isArray(toolResults)) {
+        for (const toolResult of toolResults) {
+          const content = toolResult?.content;
+          if (!Array.isArray(content)) continue;
+          for (const part of content) {
+            addTextTarget(
+              "tool",
+              part?.text,
+              { object: part, key: "text" },
+              toolResult?.toolUseId ? { tool_call_id: toolResult.toolUseId } : {}
+            );
+          }
+        }
+      }
+      return;
+    }
+
+    const assistant = item?.assistantResponseMessage;
+    if (assistant) {
+      const toolCalls = toToolCalls(assistant.toolUses);
+      addTextTarget(
+        "assistant",
+        assistant.content,
+        { object: assistant, key: "content" },
+        toolCalls ? { tool_calls: toolCalls } : {}
+      );
+    }
+  };
+
+  if (Array.isArray(state.history)) {
+    for (const item of state.history) visit(item);
+  }
+  if (state.currentMessage) visit(state.currentMessage);
+
+  return messages.length > 0 ? { messages, targets } : null;
+}
+
+function textFromHeadroomMessage(message) {
+  const content = message?.content;
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return null;
+
+  const parts = [];
+  for (const part of content) {
+    if (typeof part === "string") {
+      parts.push(part);
+    } else if (typeof part?.text === "string") {
+      parts.push(part.text);
+    }
+  }
+  return parts.length > 0 ? parts.join("\n") : null;
+}
+
+function applyKiroHeadroomMessages(projection, compressedMessages, diagnostics) {
+  if (!Array.isArray(compressedMessages) || compressedMessages.length !== projection.messages.length) {
+    setDiagnostic(diagnostics, "proxy response did not match Kiro message count");
+    return false;
+  }
+
+  const updates = [];
+  for (let i = 0; i < projection.messages.length; i++) {
+    const expected = projection.messages[i];
+    const actual = compressedMessages[i];
+    if (!actual || actual.role !== expected.role) {
+      setDiagnostic(diagnostics, "proxy response did not preserve Kiro message order");
+      return false;
+    }
+
+    const text = textFromHeadroomMessage(actual);
+    if (text === null) {
+      setDiagnostic(diagnostics, "proxy response missing Kiro text content");
+      return false;
+    }
+    updates.push({ target: projection.targets[i], text });
+  }
+
+  for (const update of updates) {
+    update.target.object[update.target.key] = update.text;
+  }
+  return true;
+}
+
+// POST messages to Headroom /v1/compress; returns compressed messages + stats or null.
+async function callCompress(url, messages, model, timeoutMs, compressUserMessages, diagnostics) {
+  const endpoint = buildCompressEndpoint(url);
+  diagnostics.endpoint = maskEndpoint(endpoint);
+  const payload = { messages, model };
+  if (compressUserMessages) payload.config = { compress_user_messages: true };
+  let res;
+  try {
+    res = await fetch(endpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+  } catch (error) {
+    setDiagnostic(diagnostics, `request failed: ${describeFetchError(error)}`);
+    return null;
+  }
+  if (!res.ok) {
+    setDiagnostic(diagnostics, `proxy returned HTTP ${res.status}`);
+    return null;
+  }
+  const data = await res.json();
+  if (!Array.isArray(data?.messages)) {
+    setDiagnostic(diagnostics, "proxy response missing messages[]");
+    return null;
+  }
+  return data;
+}
+
+// Compress request body via Headroom proxy. Fail-open: returns null on any error.
+// /v1/compress only understands OpenAI shape, so Claude bodies are translated
+// to OpenAI, compressed, then translated back using 9Router's own translators.
+export async function compressWithHeadroom(body, { enabled, url, model, format, compressUserMessages, timeoutMs = DEFAULT_TIMEOUT_MS, diagnostics = null } = {}) {
+  if (!enabled) {
+    setDiagnostic(diagnostics, "disabled");
+    return null;
+  }
+  if (!url) {
+    setDiagnostic(diagnostics, "missing proxy URL");
+    return null;
+  }
+  if (!body) {
+    setDiagnostic(diagnostics, "missing request body");
+    return null;
+  }
+
+  try {
+    if (diagnostics) diagnostics.before = captureSizeSnapshot(body);
+
+    // Claude shape: translate → OpenAI → compress → translate back.
+    if (format === "claude") {
+      const oai = claudeToOpenAIRequest(model, body, false);
+      if (!Array.isArray(oai?.messages)) {
+        setDiagnostic(diagnostics, "Claude request did not translate to messages[]");
+        return null;
+      }
+      const data = await callCompress(url, oai.messages, model, timeoutMs, compressUserMessages, diagnostics || {});
+      if (!data) return null;
+      const claudeBody = openaiToClaudeRequest(model, { ...oai, messages: data.messages }, false);
+      if (Array.isArray(claudeBody?.messages)) body.messages = claudeBody.messages;
+      if (claudeBody?.system !== undefined) body.system = claudeBody.system;
+      if (diagnostics) diagnostics.after = captureSizeSnapshot(body);
+      return data;
+    }
+
+    // OpenAI Responses shape (Codex): body.input holds Responses items, NOT OpenAI
+    // messages. Translate input -> OpenAI -> compress -> translate back to input so
+    // body.input keeps the Responses contract (the proxy only understands OpenAI). (#1998)
+    if (format === "openai-responses") {
+      if (hasUnsafeResponsesInputForCompression(body)) {
+        setDiagnostic(diagnostics, "skipped: openai-responses tool/reasoning input is not safe to compress");
+        return null;
+      }
+      const oai = openaiResponsesToOpenAIRequest(model, body, false);
+      if (!Array.isArray(oai?.messages)) return null;
+      const data = await callCompress(url, oai.messages, model, timeoutMs, compressUserMessages, diagnostics || {});
+      if (!data) return null;
+      // input: undefined so the translator rebuilds input from the compressed
+      // messages instead of returning the original input unchanged.
+      const responsesBody = openaiToOpenAIResponsesRequest(
+        model,
+        { ...oai, input: undefined, messages: data.messages },
+        false
+      );
+      if (Array.isArray(responsesBody?.input)) body.input = responsesBody.input;
+      if (diagnostics) diagnostics.after = captureSizeSnapshot(body);
+      return data;
+    }
+
+    // Kiro shape: conversationState.history/currentMessage are projected to
+    // OpenAI messages for the proxy, then copied back into the original Kiro
+    // fields. Keep the provider payload shape intact for Kiro's executor.
+    if (format === "kiro") {
+      const projection = collectKiroHeadroomMessages(body);
+      if (!projection) {
+        setDiagnostic(diagnostics, "Kiro request did not project to messages[]");
+        return null;
+      }
+      const data = await callCompress(url, projection.messages, model, timeoutMs, compressUserMessages, diagnostics || {});
+      if (!data) return null;
+      if (!applyKiroHeadroomMessages(projection, data.messages, diagnostics)) return null;
+      if (diagnostics) diagnostics.after = captureSizeSnapshot(body);
+      return data;
+    }
+
+    // OpenAI shape: messages/input go straight to the proxy.
+    const key = Array.isArray(body.messages) ? "messages"
+      : Array.isArray(body.input) ? "input"
+      : null;
+    if (!key) {
+      setDiagnostic(diagnostics, `unsupported ${format || "unknown"} request shape`);
+      return null;
+    }
+    const data = await callCompress(url, body[key], model, timeoutMs, compressUserMessages, diagnostics || {});
+    if (!data) return null;
+    body[key] = data.messages;
+    if (diagnostics) diagnostics.after = captureSizeSnapshot(body);
+    return data;
+  } catch (error) {
+    setDiagnostic(diagnostics, `unexpected error: ${error?.message || String(error)}`);
+    return null;
+  }
+}
+
+export function formatHeadroomLog(stats) {
+  if (!stats) return null;
+  const before = stats.tokens_before || 0;
+  const after = stats.tokens_after || 0;
+  const delta = stats.tokens_saved || 0;
+  const pct = before > 0 ? ((delta / before) * 100).toFixed(1) : "0";
+  return `reported token delta=${delta} before=${before}${after ? ` after=${after}` : ""} (${pct}%)`.trim();
+}
+
+export function formatHeadroomSizeLog(diagnostics) {
+  const before = diagnostics?.before;
+  const after = diagnostics?.after;
+  if (!before || !after) return "";
+  return `body=${before.bodyBytes}B→${after.bodyBytes}B messages=${before.messageBytes}B→${after.messageBytes}B`;
+}
+
+export function isHeadroomPhantomSavings(stats, diagnostics, minShrinkRatio = 0.05) {
+  if (!stats?.tokens_saved || stats.tokens_saved <= 0) return false;
+  const before = diagnostics?.before?.bodyBytes || 0;
+  const after = diagnostics?.after?.bodyBytes || 0;
+  if (before <= 0 || after <= 0) return false;
+  return after >= before * (1 - minShrinkRatio);
+}

package/open-sse/rtk/pxpipe.js

@@ -0,0 +1,104 @@
+// PXPIPE: render bulky Claude-format context as dense PNGs via pxpipe-proxy's
+// library API (transformAnthropicMessages). Fail-open like every token saver:
+// any error/timeout returns { body: null, summary } and leaves the request untouched.
+import { FORMATS } from "../translator/formats.js";
+
+const DEFAULT_TIMEOUT_MS = 15000;
+const DEFAULT_MIN_CHARS = 25000;
+// pxpipe's own profitability gate assumes ~4 chars/token; reuse it for the
+// estimated before/after numbers surfaced in stats (marked "estimated" in UI).
+const EST_CHARS_PER_TOKEN = 4;
+
+function bodyChars(body) {
+  try {
+    return JSON.stringify(body)?.length || 0;
+  } catch {
+    return 0;
+  }
+}
+
+function estTokens(chars) {
+  return Math.round(chars / EST_CHARS_PER_TOKEN);
+}
+
+function skipped(reason, extra = {}) {
+  return { body: null, summary: { applied: false, reason, ...extra } };
+}
+
+// Transform a Claude-format request body through pxpipe. Returns
+// { body: <new body object> | null, summary } — body is null when nothing changed.
+// opts.transform is injected by the host (src side) so open-sse stays free of
+// filesystem/install concerns and remains usable standalone.
+export async function compressWithPxpipe(body, { enabled, format, model, minChars, timeoutMs, transform } = {}) {
+  if (!enabled) return skipped("disabled");
+  if (typeof transform !== "function") return skipped("not_installed");
+  if (!body) return skipped("missing_body");
+  if (format !== FORMATS.CLAUDE) return skipped("unsupported_format", { detail: format });
+
+  const startedAt = Date.now();
+  const originalChars = bodyChars(body);
+  const threshold = Number(minChars) > 0 ? Number(minChars) : DEFAULT_MIN_CHARS;
+  if (originalChars < threshold) {
+    return skipped("below_threshold", { originalChars, threshold });
+  }
+
+  try {
+    const encoded = new TextEncoder().encode(JSON.stringify(body));
+    const budget = Number(timeoutMs) > 0 ? Number(timeoutMs) : DEFAULT_TIMEOUT_MS;
+    // transformAnthropicMessages is local CPU work and can't be aborted; race a
+    // timer and discard the result if it loses (input body is never mutated).
+    const result = await Promise.race([
+      transform({
+        body: encoded,
+        model,
+        options: { minCompressChars: threshold },
+      }),
+      new Promise((resolve) => setTimeout(() => resolve(null), budget)),
+    ]);
+    if (!result) return skipped("timeout", { originalChars, durationMs: Date.now() - startedAt });
+    if (!result.applied) {
+      return skipped(result.reason || "passthrough", {
+        detail: result.detail,
+        originalChars,
+        durationMs: Date.now() - startedAt,
+      });
+    }
+
+    const newBody = JSON.parse(new TextDecoder().decode(result.body));
+    const compressedBodyChars = bodyChars(newBody);
+    const info = result.info || {};
+    const imagedChars = info.compressedChars || 0;
+    // The transformed body is BIGGER in bytes (base64 PNGs) but cheaper in tokens:
+    // images bill by pixels (Anthropic: pixels/750), not by encoded length. So the
+    // after-estimate is remaining-text tokens + image tokens — never chars/4 of the
+    // new body. Provider-billed usage recorded per request stays the ground truth.
+    const imageTokensEst = info.imageTokens
+      || (info.imagePixels ? Math.round(info.imagePixels / 750) : (info.imageCount || 0) * 4761);
+    const summary = {
+      applied: true,
+      reason: "applied",
+      originalChars,
+      compressedBodyChars,
+      imagedChars,
+      imageCount: info.imageCount || 0,
+      imageBytes: info.imageBytes || 0,
+      tokensBeforeEst: info.baselineTokens || estTokens(originalChars),
+      tokensAfterEst: estTokens(Math.max(0, originalChars - imagedChars)) + imageTokensEst,
+      durationMs: Date.now() - startedAt,
+      cacheOwnsControl: result.cache?.ownsCacheControl === true,
+    };
+    summary.tokensSavedEst = Math.max(0, summary.tokensBeforeEst - summary.tokensAfterEst);
+    summary.savedPct = summary.tokensBeforeEst > 0
+      ? +((summary.tokensSavedEst / summary.tokensBeforeEst) * 100).toFixed(2)
+      : 0;
+    return { body: newBody, summary };
+  } catch (e) {
+    return skipped("transform_error", { detail: e?.message || String(e), originalChars, durationMs: Date.now() - startedAt });
+  }
+}
+
+export function formatPxpipeLog(summary) {
+  if (!summary) return null;
+  if (!summary.applied) return null;
+  return `imaged ${summary.imagedChars}ch → ${summary.imageCount} image(s) | est ${summary.tokensBeforeEst}→${summary.tokensAfterEst} tokens (-${summary.savedPct}%) | ${summary.durationMs}ms`;
+}

package/open-sse/services/clinepassModels.js

@@ -0,0 +1,63 @@
+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/copilotModels.js

@@ -0,0 +1,155 @@
+/**
+ * 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();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zevairouter",
-  "version": "1.0.39",
+  "version": "1.0.41",
   "description": "ZevaiRouter - AI Router with provider automation, multi-account workflows, and quota tracking",
   "bin": {
     "zevai": "./cli/cli.js"