@co0ontty/wand 4.20.0 → 4.21.0

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
-  "commit": "21ce9fc5eba74a26ce11a25d5542fb0339957cf7",
-  "builtAt": "2026-07-21T00:47:10.060Z",
-  "version": "4.20.0",
+  "commit": "79972abbe91abdb5e1627ebb9eaba7b2e1ef8118",
+  "builtAt": "2026-07-22T05:37:40.056Z",
+  "version": "4.21.0",
   "channel": "stable"
 }

package/dist/models.d.ts

@@ -1,4 +1,10 @@
 import { ClaudeModelInfo } from "./types.js";
+/**
+ * The complete server-side model catalog. Keep this separate from the Claude
+ * verification cache: the former is a client-facing snapshot for every
+ * provider, whereas the latter records evidence from individual probes.
+ */
+export declare const MODEL_CATALOG_CACHE_KEY = "model-catalog-v1";
 export interface ModelCacheStorage {
     getConfigValue(key: string): string | null;
     setConfigValue(key: string, value: string): void;
@@ -40,6 +46,21 @@ export interface ModelCache {
     opencodeVersion: string | null;
     refreshedAt: string;
 }
+/** Immutable-looking snapshot returned to API clients. */
+export interface ModelCatalogSnapshot extends ModelCache {
+    /** SHA-256 of the catalog excluding `refreshedAt`. Changes only with content. */
+    revision: string;
+}
+export interface ModelCatalogRefreshResult extends ModelCatalogSnapshot {
+    /** True only when the persisted catalog content changed (or was first saved). */
+    changed: boolean;
+    /** Time this server-side refresh check ran; it is deliberately not persisted. */
+    checkedAt: string;
+}
+export interface ModelCatalogRefreshRequest {
+    /** Administrator-triggered refreshes may also validate Claude candidates. */
+    verifyClaudeCandidates?: boolean;
+}
 /**
  * Parse `grok models` human-readable output:
  *
@@ -61,5 +82,33 @@ export declare function parseQoderModels(stdout: string): ClaudeModelInfo[];
 export declare function parseOpenCodeModels(stdout: string): ClaudeModelInfo[];
 /** Parse the machine-readable model registry emitted by the installed Codex CLI. */
 export declare function parseCodexModels(stdout: string): ClaudeModelInfo[];
+/**
+ * Server-owned, persisted model directory.
+ *
+ * It deliberately has a tiny surface: clients read `snapshot`; only server
+ * jobs and an administrator route may call `refresh`. Each service instance
+ * owns its cache and single-flight lock, so test servers and multiple hosts in
+ * the same Node process cannot leak a catalog into one another.
+ */
+export declare class ModelCatalogService {
+    private readonly getOptions;
+    private cache;
+    private revision;
+    private hasPersistedSnapshot;
+    private refreshPromise;
+    private inFlightIncludesVerification;
+    constructor(getOptions: () => ModelRefreshOptions);
+    snapshot(): ModelCatalogSnapshot;
+    refresh(request?: ModelCatalogRefreshRequest): Promise<ModelCatalogRefreshResult>;
+    private performRefresh;
+}
+/**
+ * Compatibility helper for callers that only need a synchronous fallback
+ * catalog. It intentionally does not own or mutate process-global state.
+ */
 export declare function getCachedModels(options?: ModelRefreshOptions): ModelCache;
+/**
+ * Compatibility helper for direct callers and unit tests. Server code should
+ * use `ModelCatalogService` so the result is persisted and diffed.
+ */
 export declare function refreshModels(options?: ModelRefreshOptions): Promise<ModelCache>;

package/dist/models.js

@@ -1,10 +1,18 @@
 import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
 import { promisify } from "node:util";
 import Anthropic from "@anthropic-ai/sdk";
 import { buildChildEnv } from "./env-utils.js";
 import { extractSemver } from "./version-utils.js";
 const execFileAsync = promisify(execFile);
 const CLAUDE_VERIFICATION_CACHE_KEY = "claude-model-verifications-v1";
+/**
+ * The complete server-side model catalog. Keep this separate from the Claude
+ * verification cache: the former is a client-facing snapshot for every
+ * provider, whereas the latter records evidence from individual probes.
+ */
+export const MODEL_CATALOG_CACHE_KEY = "model-catalog-v1";
+const MODEL_CATALOG_CACHE_VERSION = 1;
 const CLAUDE_VERIFICATION_TTL_MS = 7 * 24 * 60 * 60 * 1000;
 const CLAUDE_PROBE_TIMEOUT_MS = 15_000;
 const MAX_CLAUDE_MODEL_PROBES = 12;
@@ -45,9 +53,25 @@ const QODER_FALLBACK_MODELS = [
     { id: "performance", label: "Performance" },
     { id: "ultimate", label: "Ultimate" },
 ];
-let cache = null;
 function cloneModels(models) {
-    return models.map((model) => ({ ...model }));
+    return models.map((model) => ({
+        ...model,
+        ...(model.reasoningEfforts
+            ? { reasoningEfforts: model.reasoningEfforts.map((level) => ({ ...level })) }
+            : {}),
+    }));
+}
+function cloneCache(cache) {
+    return {
+        models: cloneModels(cache.models),
+        codexModels: cloneModels(cache.codexModels),
+        opencodeModels: cloneModels(cache.opencodeModels),
+        grokModels: cloneModels(cache.grokModels),
+        qoderModels: cloneModels(cache.qoderModels),
+        claudeVersion: cache.claudeVersion,
+        opencodeVersion: cache.opencodeVersion,
+        refreshedAt: cache.refreshedAt,
+    };
 }
 function defaultCommandRunner(file, args, options) {
     return execFileAsync(file, args, {
@@ -216,25 +240,13 @@ function createInitialCache(options) {
         refreshedAt: now.toISOString(),
     };
 }
-function refreshCachedClaudeModels(options) {
-    if (!cache)
-        return;
-    const now = options.now?.() ?? new Date();
-    cache.models = buildClaudeModels({
-        configuredClaudeModels: options.configuredClaudeModels,
-        existingModels: cache.models,
-        verifications: loadClaudeVerifications(options.storage),
-        claudeVersion: cache.claudeVersion,
-        now,
-    });
-}
 async function probeClaudeVersion(runner, env) {
     try {
         const { stdout } = await runner("claude", ["--version"], { env, timeout: 5000 });
-        return extractSemver(stdout) ?? (stdout.trim().slice(0, 64) || null);
+        return { ok: true, value: extractSemver(stdout) ?? (stdout.trim().slice(0, 64) || null) };
     }
     catch {
-        return null;
+        return { ok: false };
     }
 }
 async function probeClaudeModel(id, runner, env) {
@@ -252,10 +264,10 @@ async function probeClaudeModel(id, runner, env) {
 async function probeCodexModels(runner, env) {
     try {
         const { stdout } = await runner("codex", ["debug", "models"], { env, timeout: 8000 });
-        return parseCodexModels(stdout);
+        return { ok: true, value: parseCodexModels(stdout) };
     }
     catch {
-        return cloneModels(CODEX_FALLBACK_MODELS);
+        return { ok: false };
     }
 }
 async function probeOpenCode(runner, env) {
@@ -264,29 +276,32 @@ async function probeOpenCode(runner, env) {
         runner("opencode", ["--version"], { env, timeout: 5000 }),
     ]);
     const models = modelsResult.status === "fulfilled"
-        ? parseOpenCodeModels(modelsResult.value.stdout)
-        : cloneModels(OPENCODE_FALLBACK_MODELS);
+        ? { ok: true, value: parseOpenCodeModels(modelsResult.value.stdout) }
+        : { ok: false };
     const version = versionResult.status === "fulfilled"
-        ? extractSemver(versionResult.value.stdout) ?? (versionResult.value.stdout.trim().slice(0, 64) || null)
-        : null;
+        ? {
+            ok: true,
+            value: extractSemver(versionResult.value.stdout) ?? (versionResult.value.stdout.trim().slice(0, 64) || null),
+        }
+        : { ok: false };
     return { models, version };
 }
 async function probeGrokModels(runner, env) {
     try {
         const { stdout } = await runner("grok", ["models"], { env, timeout: 8000 });
-        return parseGrokModels(stdout);
+        return { ok: true, value: parseGrokModels(stdout) };
     }
     catch {
-        return cloneModels(GROK_FALLBACK_MODELS);
+        return { ok: false };
     }
 }
 async function probeQoderModels(runner, env) {
     try {
         const { stdout } = await runner("qodercli", ["--list-models"], { env, timeout: 8000 });
-        return parseQoderModels(stdout);
+        return { ok: true, value: parseQoderModels(stdout) };
     }
     catch {
-        return cloneModels(QODER_FALLBACK_MODELS);
+        return { ok: false };
     }
 }
 function createOfficialModelsApi(apiKey) {
@@ -298,7 +313,7 @@ function createOfficialModelsApi(apiKey) {
 async function listClaudeModelsFromApi(options, env) {
     const apiKey = options.apiKey?.trim() || env.ANTHROPIC_API_KEY?.trim();
     if (!apiKey)
-        return [];
+        return { ok: false };
     try {
         const api = options.modelsApi ?? createOfficialModelsApi(apiKey);
         const models = [];
@@ -307,10 +322,10 @@ async function listClaudeModelsFromApi(options, env) {
             if (id)
                 models.push({ id, ...(typeof model.display_name === "string" ? { display_name: model.display_name } : {}) });
         }
-        return models;
+        return { ok: true, value: models };
     }
     catch {
-        return [];
+        return { ok: false };
     }
 }
 function probePriority(model) {
@@ -498,20 +513,152 @@ function formatCodexModelLabel(model) {
         ? `${model.display_name} · ${model.slug}`
         : model.slug;
 }
-export function getCachedModels(options = {}) {
-    if (!cache) {
-        cache = createInitialCache(options);
+function catalogRevision(cache) {
+    // `refreshedAt` answers "when did content last change", so it must not
+    // create a false change by itself. JSON keeps the provider/model order that
+    // the CLIs publish; that order is part of the client-facing catalog.
+    const content = JSON.stringify({
+        models: cache.models,
+        codexModels: cache.codexModels,
+        opencodeModels: cache.opencodeModels,
+        grokModels: cache.grokModels,
+        qoderModels: cache.qoderModels,
+        claudeVersion: cache.claudeVersion,
+        opencodeVersion: cache.opencodeVersion,
+    });
+    return createHash("sha256").update(content).digest("hex");
+}
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function safePersistedString(value, maxLength = 512) {
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    return trimmed && trimmed.length <= maxLength ? trimmed : null;
+}
+function parsePersistedModelInfo(value) {
+    if (!isRecord(value))
+        return null;
+    const id = safePersistedString(value.id, 128);
+    const label = safePersistedString(value.label);
+    if (!id || !QODER_MODEL_ID_PATTERN.test(id) || !label)
+        return null;
+    const source = value.source === "builtin" || value.source === "configured"
+        || value.source === "verified-cache" || value.source === "models-api"
+        ? value.source
+        : undefined;
+    const availability = value.availability === "default" || value.availability === "candidate"
+        || value.availability === "verified" || value.availability === "stale"
+        ? value.availability
+        : undefined;
+    const reasoningEfforts = Array.isArray(value.reasoningEfforts)
+        ? value.reasoningEfforts.flatMap((entry) => {
+            if (!isRecord(entry))
+                return [];
+            const effort = safePersistedString(entry.effort, 128);
+            if (!effort)
+                return [];
+            const description = safePersistedString(entry.description);
+            return [{ effort, ...(description ? { description } : {}) }];
+        })
+        : undefined;
+    const note = safePersistedString(value.note);
+    const lastVerifiedAt = safePersistedString(value.lastVerifiedAt, 64);
+    const verifiedWithClaudeVersion = safePersistedString(value.verifiedWithClaudeVersion, 128);
+    const defaultReasoningEffort = safePersistedString(value.defaultReasoningEffort, 128);
+    return {
+        id,
+        label,
+        ...(typeof value.alias === "boolean" ? { alias: value.alias } : {}),
+        ...(source ? { source } : {}),
+        ...(availability ? { availability } : {}),
+        ...(note ? { note } : {}),
+        ...(lastVerifiedAt && !Number.isNaN(Date.parse(lastVerifiedAt)) ? { lastVerifiedAt } : {}),
+        ...(verifiedWithClaudeVersion ? { verifiedWithClaudeVersion } : {}),
+        ...(reasoningEfforts?.length ? { reasoningEfforts } : {}),
+        ...(defaultReasoningEffort ? { defaultReasoningEffort } : {}),
+    };
+}
+function parsePersistedModelList(value) {
+    if (!Array.isArray(value))
+        return null;
+    const result = [];
+    const seen = new Set();
+    for (const entry of value) {
+        const model = parsePersistedModelInfo(entry);
+        if (!model || seen.has(model.id))
+            return null;
+        seen.add(model.id);
+        result.push(model);
+    }
+    return result;
+}
+function parsePersistedModelCatalog(value) {
+    if (!isRecord(value) || value.version !== MODEL_CATALOG_CACHE_VERSION || !isRecord(value.catalog))
+        return null;
+    const catalog = value.catalog;
+    const models = parsePersistedModelList(catalog.models);
+    const codexModels = parsePersistedModelList(catalog.codexModels);
+    const opencodeModels = parsePersistedModelList(catalog.opencodeModels);
+    const grokModels = parsePersistedModelList(catalog.grokModels);
+    const qoderModels = parsePersistedModelList(catalog.qoderModels);
+    const refreshedAt = safePersistedString(catalog.refreshedAt, 64);
+    if (!models || !codexModels || !opencodeModels || !grokModels || !qoderModels
+        || !refreshedAt || Number.isNaN(Date.parse(refreshedAt))) {
+        return null;
+    }
+    const nullableVersion = (field) => field === null ? null : safePersistedString(field, 128) ?? undefined;
+    const claudeVersion = nullableVersion(catalog.claudeVersion);
+    const opencodeVersion = nullableVersion(catalog.opencodeVersion);
+    if (claudeVersion === undefined || opencodeVersion === undefined)
+        return null;
+    const parsedCatalog = {
+        models,
+        codexModels,
+        opencodeModels,
+        grokModels,
+        qoderModels,
+        claudeVersion,
+        opencodeVersion,
+        refreshedAt,
+    };
+    // A stale/missing revision should not make a previously good snapshot
+    // unreadable. It is recomputed instead of trusted.
+    return {
+        version: MODEL_CATALOG_CACHE_VERSION,
+        revision: catalogRevision(parsedCatalog),
+        catalog: parsedCatalog,
+    };
+}
+function loadPersistedModelCatalog(storage) {
+    if (!storage)
+        return null;
+    const raw = storage.getConfigValue(MODEL_CATALOG_CACHE_KEY);
+    if (!raw)
+        return null;
+    try {
+        return parsePersistedModelCatalog(JSON.parse(raw));
     }
-    else if (options.storage || options.configuredClaudeModels) {
-        refreshCachedClaudeModels(options);
+    catch {
+        return null;
     }
-    return cache;
 }
-export async function refreshModels(options = {}) {
+function savePersistedModelCatalog(storage, cache, revision) {
+    if (!storage)
+        return;
+    const persisted = {
+        version: MODEL_CATALOG_CACHE_VERSION,
+        revision,
+        catalog: cloneCache(cache),
+    };
+    storage.setConfigValue(MODEL_CATALOG_CACHE_KEY, JSON.stringify(persisted));
+}
+async function discoverModelCache(options, previous) {
     const now = options.now?.() ?? new Date();
     const env = resolveProbeEnv(options);
     const runner = options.commandRunner ?? defaultCommandRunner;
-    const [claudeVersion, codexModels, opencode, grokModels, qoderModels, apiModels] = await Promise.all([
+    const [claudeVersionProbe, codexProbe, opencodeProbe, grokProbe, qoderProbe, apiProbe] = await Promise.all([
         probeClaudeVersion(runner, env),
         probeCodexModels(runner, env),
         probeOpenCode(runner, env),
@@ -519,10 +666,14 @@ export async function refreshModels(options = {}) {
         probeQoderModels(runner, env),
         listClaudeModelsFromApi(options, env),
     ]);
+    const claudeVersion = claudeVersionProbe.ok ? claudeVersionProbe.value : previous.claudeVersion;
     const priorVerifications = loadClaudeVerifications(options.storage);
+    // A failed Models API request is not evidence that its prior models vanished.
+    // Keep the last good candidate set until a successful catalog request says
+    // otherwise; configured and verification-backed candidates are merged below.
     const initialModels = buildClaudeModels({
         configuredClaudeModels: options.configuredClaudeModels,
-        apiModels,
+        ...(apiProbe.ok ? { apiModels: apiProbe.value } : { existingModels: previous.models }),
         verifications: priorVerifications,
         claudeVersion,
         now,
@@ -533,21 +684,101 @@ export async function refreshModels(options = {}) {
     const verifications = mergeVerifications(priorVerifications, initialModels, verifiedIds, claudeVersion, now);
     if (verifiedIds.size > 0)
         saveClaudeVerifications(options.storage, verifications);
-    cache = {
+    return {
         models: buildClaudeModels({
             configuredClaudeModels: options.configuredClaudeModels,
-            apiModels,
+            ...(apiProbe.ok ? { apiModels: apiProbe.value } : { existingModels: previous.models }),
             verifications,
             claudeVersion,
             now,
         }),
-        codexModels,
-        opencodeModels: opencode.models,
-        grokModels,
-        qoderModels,
+        codexModels: codexProbe.ok ? codexProbe.value : cloneModels(previous.codexModels),
+        opencodeModels: opencodeProbe.models.ok ? opencodeProbe.models.value : cloneModels(previous.opencodeModels),
+        grokModels: grokProbe.ok ? grokProbe.value : cloneModels(previous.grokModels),
+        qoderModels: qoderProbe.ok ? qoderProbe.value : cloneModels(previous.qoderModels),
         claudeVersion,
-        opencodeVersion: opencode.version,
+        opencodeVersion: opencodeProbe.version.ok ? opencodeProbe.version.value : previous.opencodeVersion,
         refreshedAt: now.toISOString(),
     };
-    return cache;
+}
+/**
+ * Server-owned, persisted model directory.
+ *
+ * It deliberately has a tiny surface: clients read `snapshot`; only server
+ * jobs and an administrator route may call `refresh`. Each service instance
+ * owns its cache and single-flight lock, so test servers and multiple hosts in
+ * the same Node process cannot leak a catalog into one another.
+ */
+export class ModelCatalogService {
+    getOptions;
+    cache;
+    revision;
+    hasPersistedSnapshot;
+    refreshPromise = null;
+    inFlightIncludesVerification = false;
+    constructor(getOptions) {
+        this.getOptions = getOptions;
+        const initialOptions = getOptions();
+        const persisted = loadPersistedModelCatalog(initialOptions.storage);
+        this.cache = persisted ? cloneCache(persisted.catalog) : createInitialCache(initialOptions);
+        this.revision = persisted?.revision ?? catalogRevision(this.cache);
+        this.hasPersistedSnapshot = persisted !== null;
+    }
+    snapshot() {
+        return { ...cloneCache(this.cache), revision: this.revision };
+    }
+    refresh(request = {}) {
+        const verifyClaudeCandidates = request.verifyClaudeCandidates === true;
+        if (this.refreshPromise) {
+            const sharedRefresh = this.refreshPromise;
+            const sharedIncludesVerification = this.inFlightIncludesVerification;
+            return sharedRefresh.then((result) => verifyClaudeCandidates && !sharedIncludesVerification
+                ? this.refresh({ verifyClaudeCandidates: true })
+                : result);
+        }
+        this.inFlightIncludesVerification = verifyClaudeCandidates;
+        const refresh = this.performRefresh({ verifyClaudeCandidates });
+        this.refreshPromise = refresh;
+        return refresh.finally(() => {
+            if (this.refreshPromise === refresh) {
+                this.refreshPromise = null;
+                this.inFlightIncludesVerification = false;
+            }
+        });
+    }
+    async performRefresh(request) {
+        const baseOptions = this.getOptions();
+        const options = {
+            ...baseOptions,
+            verifyClaudeCandidates: request.verifyClaudeCandidates === true,
+        };
+        const checkedAt = (options.now?.() ?? new Date()).toISOString();
+        const discovered = await discoverModelCache(options, this.cache);
+        const discoveredRevision = catalogRevision(discovered);
+        const changed = !this.hasPersistedSnapshot || discoveredRevision !== this.revision;
+        if (changed) {
+            // The timestamp is only advanced with a meaningful catalog revision.
+            discovered.refreshedAt = checkedAt;
+            this.cache = cloneCache(discovered);
+            this.revision = catalogRevision(this.cache);
+            savePersistedModelCatalog(options.storage, this.cache, this.revision);
+            this.hasPersistedSnapshot = Boolean(options.storage);
+        }
+        return { ...this.snapshot(), changed, checkedAt };
+    }
+}
+/**
+ * Compatibility helper for callers that only need a synchronous fallback
+ * catalog. It intentionally does not own or mutate process-global state.
+ */
+export function getCachedModels(options = {}) {
+    const persisted = loadPersistedModelCatalog(options.storage);
+    return cloneCache(persisted?.catalog ?? createInitialCache(options));
+}
+/**
+ * Compatibility helper for direct callers and unit tests. Server code should
+ * use `ModelCatalogService` so the result is persisted and diffed.
+ */
+export async function refreshModels(options = {}) {
+    return discoverModelCache(options, createInitialCache(options));
 }

package/dist/server-settings-routes.d.ts

@@ -1,5 +1,5 @@
 import type { Express, Request, RequestHandler } from "express";
-import { type ModelRefreshOptions } from "./models.js";
+import type { ModelCatalogService } from "./models.js";
 import { type RuntimeConfigState } from "./runtime-config.js";
 import type { WandStorage } from "./storage.js";
 import type { WandConfig } from "./types.js";
@@ -33,7 +33,7 @@ export interface ServerSettingsRoutesDependencies {
     } | null;
     getUpdateChannel(): "stable" | "beta";
     getDistributionSettings(): Promise<SettingsDistributionPayload>;
-    getModelRefreshOptions(): ModelRefreshOptions;
+    modelCatalog: ModelCatalogService;
     resolveAppConnectCode(req: Request): {
         code: string;
         url: string;

package/dist/server-settings-routes.js

@@ -4,7 +4,6 @@ import { buildChildEnv } from "./env-utils.js";
 import { getErrorMessage } from "./error-utils.js";
 import { asyncRoute } from "./express-async.js";
 import { getProviderDefaultModels, PREFERENCE_KEYS, saveConfig, validateCommitAiConfig, writePreferenceToStorage, } from "./config.js";
-import { getCachedModels, refreshModels } from "./models.js";
 import { DEPLOYMENT_CONFIG_KEYS } from "./runtime-config.js";
 import { discoverCliSystemAiConfigs, normalizeSystemAiConfig } from "./system-ai.js";
 function publicConfig(config) {
@@ -271,7 +270,10 @@ export function registerSettingsRoutes(app, deps) {
         }
     }));
     app.get("/api/models", (_req, res) => {
-        const cached = getCachedModels(deps.getModelRefreshOptions());
+        // Every client reads the server's persisted snapshot. Avoid browser/proxy
+        // cache races after an administrator or scheduled server refresh.
+        res.set("Cache-Control", "no-store");
+        const cached = deps.modelCatalog.snapshot();
         const defaults = getProviderDefaultModels(config);
         res.json({
             ...cached,
@@ -283,9 +285,9 @@ export function registerSettingsRoutes(app, deps) {
             defaultModels: defaults,
         });
     });
-    app.post("/api/models/refresh", asyncRoute(async (_req, res) => {
+    app.post("/api/models/refresh", requireAdmin, asyncRoute(async (_req, res) => {
         try {
-            const refreshed = await refreshModels({ ...deps.getModelRefreshOptions(), verifyClaudeCandidates: true });
+            const refreshed = await deps.modelCatalog.refresh({ verifyClaudeCandidates: true });
             const defaults = getProviderDefaultModels(config);
             res.json({
                 ...refreshed,

package/dist/server-update-routes.d.ts

@@ -1,5 +1,5 @@
 import type { Express, RequestHandler } from "express";
-import { type ModelRefreshOptions } from "./models.js";
+import type { ModelCatalogService } from "./models.js";
 import type { PackageUpdateInfo, UpdateChannel } from "./npm-update-utils.js";
 import { type ProviderCliUpdateStatus } from "./provider-cli-updater.js";
 import type { WandStorage } from "./storage.js";
@@ -46,7 +46,7 @@ export interface AdminUpdateRoutesDependencies {
         androidApk: Record<string, unknown>;
         macosDmg: Record<string, unknown>;
     }>;
-    getModelRefreshOptions(): ModelRefreshOptions;
+    modelCatalog: ModelCatalogService;
     getUpdateChannel(): UpdateChannel;
     checkLatestPackageVersion(channel: UpdateChannel, forceRefresh?: boolean): Promise<PackageUpdateInfo>;
     buildInfo: {

package/dist/server-update-routes.js

@@ -1,6 +1,5 @@
 import { getErrorMessage } from "./error-utils.js";
 import { asyncRoute } from "./express-async.js";
-import { refreshModels } from "./models.js";
 import { checkProviderCliUpdates, updateProviderClis, verifyProviderCliUpdateResults, } from "./provider-cli-updater.js";
 import { streamFileWithRange } from "./server-file-routes.js";
 import { compareApkInstallOrder, compareSemver } from "./version-utils.js";
@@ -137,7 +136,9 @@ export function registerAdminUpdateRoutes(app, deps) {
             });
             const after = await refreshProviderCliUpdateState(state, config);
             const results = verifyProviderCliUpdateResults(commandResults, after.items);
-            void refreshModels(deps.getModelRefreshOptions()).catch(() => { });
+            // Model discovery is server-owned and persisted; clients only consume
+            // the latest snapshot after a CLI update.
+            void deps.modelCatalog.refresh().catch(() => { });
             res.json({ ok: results.every((item) => item.ok), results, ...after, autoUpdate: storage.getConfigValue("autoUpdateProviderClis") === "true" });
         }
         catch (error) {

package/dist/server.d.ts

@@ -1,5 +1,5 @@
 import { AuthService } from "./auth.js";
-import { ModelRefreshOptions } from "./models.js";
+import { type ModelRefreshOptions } from "./models.js";
 import { ProcessManager } from "./process-manager.js";
 import { StructuredSessionManager } from "./structured-session-manager.js";
 import { type PathRepairResult } from "./path-repair.js";