llm-switcher 1.3.8 → 1.4.1

package/update.mjs

@@ -1,5 +1,8 @@
-// Brings this install to the newest release: a git checkout pulls fast-forward only, an npm install
-// asks the registry and installs that exact version. Restarting the gateway is the caller's job.
+// Brings this install to the newest release. A release is published to npm, so npm is what is asked
+// first: `npm install -g llm-switcher@<version>` for the exact version the registry names. A git
+// checkout is the one install npm cannot serve, because npm writes into the global prefix while the
+// running code is the checkout itself, so the checkout is asked second and only then. Restarting
+// the gateway is the caller's job.
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
@@ -80,8 +83,9 @@ async function updateNpmInstall(root, run, log, registryUrl) {
     throw failure('npm install', err);
   }
   const to = readVersion(root);
-  // npm can install into another prefix than the one this gateway runs from; then nothing changed here.
-  if (to === from) return noUpdate(from, `npm installed v${latest}, but not into ${root}.`);
+  // npm installs into the global prefix. When this gateway runs from a checkout that is a different
+  // directory, so the registry can name a release this code never receives; `elsewhere` says so.
+  if (to === from) return { ...noUpdate(from, `npm installed v${latest}, but not into ${root}.`), elsewhere: latest };
   return { updated: true, from, to, reason: `Installed v${to} from npm.` };
 }
 
@@ -93,10 +97,27 @@ export async function applyUpdate({
   registryUrl = process.env.LLM_SWITCHER_REGISTRY_URL || REGISTRY_URL,
   running = CURRENT_VERSION
 } = {}) {
-  const r = fs.existsSync(path.join(root, '.git'))
-    ? await updateCheckout(root, run, logger)
-    : await updateNpmInstall(root, run, logger, registryUrl);
-  // Newer code already on disk (a pull or an install outside the gateway) is an update for the
+  // npm writes into the global prefix, so a checkout is the one install it cannot serve: the running
+  // code is this directory, not the prefix. The registry is still asked, because the release on npm
+  // is the release every other install receives, but for a checkout a failed install is not the end
+  // of the update -- the checkout is the thing that can move, so it is asked next.
+  const checkout = fs.existsSync(path.join(root, '.git'));
+  let registry;
+  try {
+    registry = await updateNpmInstall(root, run, logger, registryUrl);
+  } catch (err) {
+    if (!checkout) throw err;
+    logger(`npm could not install it here: ${err.message}`);
+    registry = { ...noUpdate(readVersion(root), `npm could not install it here: ${err.message}`), elsewhere: true };
+  }
+  let r = registry;
+  if (!r.updated && checkout) {
+    r = await updateCheckout(root, run, logger);
+    // Neither could deliver it, and npm held a release this directory cannot take: both facts, because
+    // "already the latest version" on its own would hide the one version the reader does not have.
+    if (!r.updated && registry.elsewhere) r = { ...r, reason: `${registry.reason} ${r.reason}` };
+  }
+  // Newer code already on disk (an install outside the gateway) is an update for the
   // running process: without the restart it keeps the old code and the old version forever.
   const onDisk = readVersion(root);
   if (!r.updated && isNewer(onDisk, running)) {

package/windows.mjs

@@ -0,0 +1,141 @@
+// The real window of every model a profile serves.
+//
+// A coding tool sizes a session, and its auto-compact point, from the window its own catalog
+// gives it. So the gateway reports what the model really has instead of a number someone picked
+// in a checkbox. Two numbers come out of a provider's list:
+//
+//   context  the whole window the model accepts
+//   compact  the window to compress at, which a Codex model publishes as `context_window`
+//            next to `max_context_window` (272K against 872K)
+//
+// A model whose list gives only one window has no compact window, and a provider that lists no
+// limits at all leaves both unknown: the caller then falls back to its own template rather than
+// inventing a number.
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+const ONE_HOUR_MS = 60 * 60 * 1000;
+const DEFAULT_TTL_MS = ONE_HOUR_MS;
+const FETCH_TIMEOUT_MS = 15000;
+
+const n = v => (Number.isFinite(v) && v > 0 ? Math.round(v) : 0);
+
+// One entry of a provider's list -> the two windows, or null when it names none.
+export function parseModelWindows(m) {
+  if (!m || typeof m !== 'object') return null;
+  const top = m.top_provider && typeof m.top_provider === 'object' ? m.top_provider : {};
+  const context = n(m.max_context_window) || n(m.context_length) || n(top.context_length) || n(m.context_window);
+  // intact serves the threshold under its own name; a Codex-shaped list carries it as the
+  // smaller of the two windows it publishes.
+  const compact = n(m.compact_window) || n(m.compaction_threshold)
+    || (context && n(m.context_window) && n(m.context_window) < context ? n(m.context_window) : 0);
+  if (!context && !compact) return null;
+  return { context, compact };
+}
+
+// The list as it names the models, so a caller can look one up by the id a profile maps.
+export function parseModelList(data) {
+  const entries = Array.isArray(data?.data) ? data.data
+    : Array.isArray(data) ? data
+    : Array.isArray(data?.models) ? data.models
+    : [];
+  const out = {};
+  for (const m of entries) {
+    const id = String(typeof m === 'string' ? m : (m?.id || m?.name || '')).replace(/^models\//, '');
+    if (!id) continue;
+    const w = parseModelWindows(m);
+    if (w) out[id] = w;
+  }
+  return out;
+}
+
+/**
+ * Reads a provider's model list for its windows. Returns {} on any failure: a profile whose
+ * upstream cannot be reached keeps the last answer, never a wrong window.
+ */
+export async function fetchProfileWindows(baseURL, apiKey, { timeoutMs = FETCH_TIMEOUT_MS } = {}) {
+  const base = String(baseURL || '').replace(/\/+$/, '');
+  if (!base) return {};
+  try {
+    const headers = { accept: 'application/json' };
+    if (apiKey) {
+      headers.authorization = `Bearer ${apiKey}`;
+      headers['x-api-key'] = apiKey;
+    }
+    const res = await fetch(`${base}/models`, { headers, signal: AbortSignal.timeout(timeoutMs) });
+    if (!res.ok) return {};
+    return parseModelList(await res.json());
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * The windows of a profile's models, from the cache when it is fresh and from the profile's own
+ * list when it is not. A failed read keeps the stale answer, because an old window only sizes a
+ * session slightly wrong, while an empty one would hand the tool a template window it may not
+ * have. Never throws.
+ */
+export async function resolveProfileWindows(stateDir, cacheKey, baseURL, apiKey, { ttlMs = DEFAULT_TTL_MS, now = Date.now() } = {}) {
+  const cache = readWindowsCache(stateDir);
+  const entry = cache[cacheKey] || {};
+  const fresh = entry.at && now - entry.at < ttlMs;
+  if (fresh) return entry.models || {};
+  const models = await fetchProfileWindows(baseURL, apiKey);
+  if (Object.keys(models).length) {
+    cache[cacheKey] = { at: now, baseURL, models };
+    writeWindowsCache(stateDir, cache);
+    return models;
+  }
+  return entry.models || {};
+}
+
+export function windowsCachePath(stateDir) {
+  return path.join(stateDir, 'model-windows.json');
+}
+
+export function readWindowsCache(stateDir) {
+  try {
+    const d = JSON.parse(fs.readFileSync(windowsCachePath(stateDir), 'utf8'));
+    return d && typeof d === 'object' && !Array.isArray(d) ? d : {};
+  } catch {
+    return {};
+  }
+}
+
+export function writeWindowsCache(stateDir, cache) {
+  const p = windowsCachePath(stateDir);
+  const tmp = `${p}.${process.pid}.tmp`;
+  try {
+    fs.writeFileSync(tmp, JSON.stringify(cache), 'utf8');
+    fs.renameSync(tmp, p);
+    return true;
+  } catch {
+    try { fs.rmSync(tmp, { force: true }); } catch {}
+    return false;
+  }
+}
+
+/**
+ * The windows the Codex CLI itself cached for its signed-in account. It is the fallback for a
+ * profile that lists no limits: those numbers came from the provider the CLI uses, so they are
+ * better than the template and never a guess. Returns {} when the tool keeps no list.
+ */
+export function readLocalCodexWindows(sources = {}) {
+  const codexHome = sources.codexHome || process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
+  try {
+    const d = JSON.parse(fs.readFileSync(path.join(codexHome, 'models_cache.json'), 'utf8'));
+    const models = Array.isArray(d?.models) ? d.models : [];
+    const out = {};
+    for (const m of models) {
+      const id = m && typeof m.slug === 'string' ? m.slug : '';
+      const context = n(m?.max_context_window) || n(m?.context_window);
+      const compact = context && n(m.context_window) < context ? n(m.context_window) : 0;
+      if (id && context) out[id] = { context, compact };
+    }
+    return out;
+  } catch {
+    return {};
+  }
+}