llm-cli-gateway 1.1.0 → 1.4.0

package/dist/model-registry.js

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync, readdirSync, statSync } from "fs";
 import { homedir } from "os";
 import path from "path";
+import { parse as parseToml } from "toml";
 const FALLBACK_INFO = {
     claude: {
         description: "Anthropic's Claude Code CLI - best for code generation, analysis, and agentic coding tasks",
@@ -13,12 +14,17 @@ const FALLBACK_INFO = {
         modelOrder: ["opus", "sonnet", "haiku"],
     },
     codex: {
+        // Note: no hardcoded `defaultModel`. Let Codex CLI pick its own built-in default
+        // unless an explicit value is found via config.toml / env vars in applyCodexOverrides.
+        // This prevents the gateway from pinning a model that may become deprecated upstream.
         description: "OpenAI's Codex CLI - best for code execution in sandboxed environments",
         models: {
-            o3: "Most capable reasoning model. Best for: complex multi-step problems, math, science",
-            "o4-mini": "Fast reasoning model. Best for: coding tasks, quick iterations",
-            "gpt-4.1": "Latest GPT-4 variant. Best for: general coding, instruction following",
+            "gpt-5.4": "Frontier coding and professional-work model. Best for: most Codex tasks, long-running agentic work",
+            "gpt-5.3-codex": "Specialized Codex model. Best for: agentic coding workflows with Codex-tuned behavior",
+            "gpt-5.2": "Strong general-purpose GPT-5 model. Best for: broad coding and reasoning tasks",
+            "gpt-5-pro": "Highest-capability GPT-5 model. Best for: deep reasoning and difficult professional workflows",
         },
+        modelOrder: ["gpt-5.3-codex", "gpt-5.4", "gpt-5.2", "gpt-5-pro"],
     },
     gemini: {
         description: "Google's Gemini CLI - best for multimodal tasks and Google ecosystem integration",
@@ -27,8 +33,25 @@ const FALLBACK_INFO = {
             "gemini-2.5-flash": "Fast model. Best for: quick responses, high throughput, cost-sensitive use",
         },
     },
+    grok: {
+        // No hardcoded `defaultModel`. Let Grok CLI pick its own built-in default
+        // unless an explicit value is found via env vars in applyGrokOverrides.
+        description: "xAI's Grok Build CLI - best for agentic coding tasks via xAI's Grok models",
+        models: {
+            "grok-build": "Default Grok model for code/agentic tasks. Best for: most Grok build sessions",
+        },
+        modelOrder: ["grok-build"],
+    },
 };
 const MODEL_CACHE_TTL_MS = 2 * 60 * 1000;
+const MAX_GEMINI_HISTORY_FILES = 200;
+const MAX_GEMINI_HISTORY_FILE_BYTES = 2 * 1024 * 1024;
+const SOURCE_PRIORITY = {
+    fallback: 0,
+    observed: 1,
+    config: 2,
+    env: 3,
+};
 let cachedInfo = null;
 export function getCliInfo(forceRefresh = false) {
     if (!forceRefresh && cachedInfo && Date.now() - cachedInfo.loadedAt < MODEL_CACHE_TTL_MS) {
@@ -38,6 +61,9 @@ export function getCliInfo(forceRefresh = false) {
     cachedInfo = { loadedAt: Date.now(), info };
     return info;
 }
+export function clearModelRegistryCache() {
+    cachedInfo = null;
+}
 export function resolveModelAlias(cli, model, info) {
     if (!model) {
         return undefined;
@@ -49,7 +75,14 @@ export function resolveModelAlias(cli, model, info) {
     const normalized = trimmed.toLowerCase();
     const cliInfo = info[cli];
     if (normalized === "default" || normalized === "latest") {
-        return cliInfo.defaultModel ?? trimmed;
+        // If no default is configured, return undefined so the CLI picks its own
+        // built-in default. Avoids passing the literal string "default"/"latest"
+        // as a model name to the CLI.
+        return cliInfo.defaultModel;
+    }
+    const alias = resolveConfiguredAlias(cliInfo, normalized);
+    if (alias !== undefined) {
+        return alias;
     }
     if (cli === "gemini") {
         if (normalized === "flash" || normalized === "pro") {
@@ -64,163 +97,403 @@ function buildCliInfo() {
         claude: cloneInfo(FALLBACK_INFO.claude),
         codex: cloneInfo(FALLBACK_INFO.codex),
         gemini: cloneInfo(FALLBACK_INFO.gemini),
+        grok: cloneInfo(FALLBACK_INFO.grok),
     };
     applyClaudeOverrides(info.claude);
     applyCodexOverrides(info.codex);
     applyGeminiOverrides(info.gemini);
+    applyGrokOverrides(info.grok);
     return info;
 }
 function cloneInfo(source) {
-    return {
+    const cloned = {
         description: source.description,
         models: { ...source.models },
         defaultModel: source.defaultModel,
+        defaultModelSource: source.defaultModelSource,
         modelOrder: source.modelOrder ? [...source.modelOrder] : undefined,
+        aliases: source.aliases ? { ...source.aliases } : undefined,
+        modelMetadata: source.modelMetadata ? { ...source.modelMetadata } : {},
+        warnings: source.warnings ? [...source.warnings] : [],
     };
+    Object.keys(cloned.models).forEach(model => {
+        cloned.modelMetadata[model] = cloned.modelMetadata[model] ?? {
+            source: "fallback",
+            sourceDetail: "Bundled fallback registry",
+            confidence: "low",
+        };
+    });
+    return cloned;
+}
+function addWarning(info, warning) {
+    info.warnings = info.warnings ?? [];
+    if (!info.warnings.includes(warning)) {
+        info.warnings.push(warning);
+    }
+}
+function isValidModelName(model) {
+    return model.length > 0 && !/[\u0000-\u001f\u007f]/.test(model) && !/\s/.test(model);
+}
+function addModel(info, model, description, metadata, options = {}) {
+    const normalized = model.trim();
+    if (!isValidModelName(normalized)) {
+        addWarning(info, `Ignored invalid model name from ${metadata.sourceDetail}`);
+        return;
+    }
+    const existingMetadata = info.modelMetadata?.[normalized];
+    const existingPriority = existingMetadata ? SOURCE_PRIORITY[existingMetadata.source] : -1;
+    const incomingPriority = SOURCE_PRIORITY[metadata.source];
+    if (!info.models[normalized] ||
+        options.preferDescription ||
+        incomingPriority > existingPriority) {
+        info.models[normalized] = description;
+    }
+    info.modelMetadata = info.modelMetadata ?? {};
+    if (!existingMetadata || incomingPriority >= existingPriority) {
+        info.modelMetadata[normalized] = metadata;
+    }
+}
+function setDefaultModel(info, model, source, sourceType) {
+    const normalized = model?.trim();
+    if (!normalized) {
+        return;
+    }
+    if (!isValidModelName(normalized)) {
+        addWarning(info, `Ignored invalid default model from ${source}`);
+        return;
+    }
+    addModel(info, normalized, `Configured default from ${source}`, {
+        source: sourceType,
+        sourceDetail: source,
+        confidence: sourceType === "env" ? "high" : "medium",
+    });
+    info.defaultModel = normalized;
+    info.defaultModelSource = source;
+}
+function addAlias(info, alias, target, source) {
+    const normalizedAlias = alias.trim().toLowerCase();
+    const normalizedTarget = target.trim();
+    if (!normalizedAlias || /\s/.test(normalizedAlias) || !normalizedTarget) {
+        addWarning(info, `Ignored invalid alias from ${source}`);
+        return;
+    }
+    if (normalizedTarget !== "default" && !isValidModelName(normalizedTarget)) {
+        addWarning(info, `Ignored invalid alias target from ${source}`);
+        return;
+    }
+    info.aliases = info.aliases ?? {};
+    info.aliases[normalizedAlias] = normalizedTarget;
+}
+function resolveConfiguredAlias(info, normalizedAlias) {
+    const target = info.aliases?.[normalizedAlias];
+    if (!target) {
+        return undefined;
+    }
+    if (target === "default") {
+        return info.defaultModel;
+    }
+    return target;
+}
+function addEnvModels(info, envName) {
+    const entries = parseEnvModelEntries(process.env[envName], envName);
+    entries.forEach(entry => {
+        addModel(info, entry.model, entry.description ?? `Configured via ${envName}`, {
+            source: "env",
+            sourceDetail: envName,
+            confidence: "high",
+        }, { preferDescription: Boolean(entry.description) });
+    });
+}
+function addEnvAliases(info, cli, envName) {
+    parseEnvAliasEntries(process.env[envName], envName, cli).forEach(entry => {
+        addAlias(info, entry.alias, entry.target, envName);
+    });
+}
+function addGlobalEnvAliases(info, cli) {
+    parseEnvAliasEntries(process.env.LLM_GATEWAY_MODEL_ALIASES, "LLM_GATEWAY_MODEL_ALIASES", cli).forEach(entry => {
+        addAlias(info, entry.alias, entry.target, "LLM_GATEWAY_MODEL_ALIASES");
+    });
 }
 function applyClaudeOverrides(info) {
-    const settingsPath = path.join(homedir(), ".claude", "settings.json");
-    const settingsLocalPath = path.join(homedir(), ".claude", "settings.local.json");
+    const settingsPath = process.env.CLAUDE_SETTINGS_PATH || path.join(homedir(), ".claude", "settings.json");
+    const settingsLocalPath = process.env.CLAUDE_SETTINGS_LOCAL_PATH ||
+        path.join(homedir(), ".claude", "settings.local.json");
     const envDefault = process.env.CLAUDE_DEFAULT_MODEL;
-    const localDefault = readJsonValue(settingsLocalPath, "model");
-    const settingsDefault = readJsonValue(settingsPath, "model");
-    const defaultModel = envDefault || localDefault || settingsDefault;
-    const defaultSource = envDefault
-        ? "CLAUDE_DEFAULT_MODEL"
-        : localDefault
-            ? settingsLocalPath
-            : settingsPath;
-    if (defaultModel && typeof defaultModel === "string") {
-        if (!info.models[defaultModel]) {
-            info.models[defaultModel] = `Configured default from ${defaultSource}`;
-        }
-        info.defaultModel = defaultModel;
+    const localDefault = readJsonStringValue(settingsLocalPath, [["model"], ["model", "name"]], info);
+    const settingsDefault = readJsonStringValue(settingsPath, [["model"], ["model", "name"]], info);
+    if (settingsDefault) {
+        setDefaultModel(info, settingsDefault, settingsPath, "config");
     }
-    const envModels = parseEnvModels(process.env.CLAUDE_MODELS);
-    if (envModels.length > 0) {
-        envModels.forEach(model => {
-            if (!info.models[model]) {
-                info.models[model] = "Configured via CLAUDE_MODELS";
-            }
-        });
+    if (localDefault) {
+        setDefaultModel(info, localDefault, settingsLocalPath, "config");
+    }
+    if (envDefault) {
+        setDefaultModel(info, envDefault, "CLAUDE_DEFAULT_MODEL", "env");
     }
+    addEnvModels(info, "CLAUDE_MODELS");
+    addEnvAliases(info, "claude", "CLAUDE_MODEL_ALIASES");
+    addGlobalEnvAliases(info, "claude");
     info.modelOrder = buildOrder(info, info.defaultModel);
 }
 function applyCodexOverrides(info) {
     const configPath = process.env.CODEX_CONFIG_PATH || path.join(homedir(), ".codex", "config.toml");
     const envDefault = process.env.CODEX_DEFAULT_MODEL;
-    const envModels = parseEnvModels(process.env.CODEX_MODELS);
-    const detectedModels = {};
-    let defaultModel;
     if (existsSync(configPath)) {
-        const content = readFileSync(configPath, "utf-8");
-        const model = extractTomlString(content, "model");
-        if (model) {
-            detectedModels[model] = `Default from ${configPath}`;
-            defaultModel = model;
+        try {
+            const content = readFileSync(configPath, "utf-8");
+            const parsed = parseToml(content);
+            const model = readStringProperty(parsed, "model");
+            setDefaultModel(info, model, configPath, "config");
+            const profiles = readRecordProperty(parsed, "profiles");
+            Object.entries(profiles).forEach(([profileName, profile]) => {
+                const profileModel = readStringProperty(profile, "model");
+                if (profileModel) {
+                    addModel(info, profileModel, `Configured in Codex profile '${profileName}'`, {
+                        source: "config",
+                        sourceDetail: `${configPath} profile ${profileName}`,
+                        confidence: "medium",
+                    });
+                }
+            });
+            const notice = readRecordProperty(parsed, "notice");
+            const migrations = readRecordProperty(notice, "model_migrations");
+            Object.entries(migrations).forEach(([from, to]) => {
+                if (typeof to !== "string") {
+                    return;
+                }
+                addModel(info, to, `Migration target for ${from}`, {
+                    source: "config",
+                    sourceDetail: `${configPath} notice.model_migrations`,
+                    confidence: "medium",
+                });
+                addModel(info, from, `Legacy model (migrates to ${to})`, {
+                    source: "config",
+                    sourceDetail: `${configPath} notice.model_migrations`,
+                    confidence: "medium",
+                });
+            });
         }
-        const migrations = extractTomlTableMap(content, "notice.model_migrations");
-        Object.entries(migrations).forEach(([from, to]) => {
-            if (!detectedModels[to]) {
-                detectedModels[to] = `Migrated from ${from}`;
-            }
-            if (!detectedModels[from]) {
-                detectedModels[from] = `Legacy model (migrates to ${to})`;
-            }
-        });
-    }
-    envModels.forEach(model => {
-        if (!detectedModels[model]) {
-            detectedModels[model] = "Configured via CODEX_MODELS";
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            addWarning(info, `Could not parse Codex config ${configPath}: ${message}`);
         }
-    });
-    if (envDefault) {
-        detectedModels[envDefault] = detectedModels[envDefault] || "Default from CODEX_DEFAULT_MODEL";
-        defaultModel = envDefault;
     }
-    if (Object.keys(detectedModels).length > 0) {
-        info.models = detectedModels;
-        info.defaultModel = defaultModel;
-    }
-    else {
-        info.defaultModel = defaultModel;
+    addEnvModels(info, "CODEX_MODELS");
+    addEnvAliases(info, "codex", "CODEX_MODEL_ALIASES");
+    addGlobalEnvAliases(info, "codex");
+    if (envDefault) {
+        setDefaultModel(info, envDefault, "CODEX_DEFAULT_MODEL", "env");
     }
     info.modelOrder = buildOrder(info, info.defaultModel);
 }
 function applyGeminiOverrides(info) {
+    const settingsPath = process.env.GEMINI_SETTINGS_PATH || path.join(homedir(), ".gemini", "settings.json");
+    const settingsDefault = readJsonStringValue(settingsPath, [["model"], ["model", "name"], ["selectedModel"], ["defaultModel"]], info);
     const envDefault = process.env.GEMINI_DEFAULT_MODEL;
-    const envModels = parseEnvModels(process.env.GEMINI_MODELS);
-    const observed = collectGeminiModels();
-    if (Object.keys(observed.models).length > 0) {
-        info.models = observed.models;
-        info.modelOrder = observed.order;
-        info.defaultModel = observed.order[0];
-    }
-    envModels.forEach(model => {
-        if (!info.models[model]) {
-            info.models[model] = "Configured via GEMINI_MODELS";
-        }
-    });
+    if (settingsDefault) {
+        setDefaultModel(info, settingsDefault, settingsPath, "config");
+    }
+    if (!isModelDiscoveryDisabled()) {
+        const observed = collectGeminiModels();
+        observed.forEach(observation => {
+            addModel(info, observation.model, `Observed in local Gemini sessions (last seen ${observation.lastSeen})`, {
+                source: "observed",
+                sourceDetail: observation.filePath,
+                confidence: "low",
+                lastSeen: observation.lastSeen,
+            });
+        });
+    }
+    addEnvModels(info, "GEMINI_MODELS");
+    addEnvAliases(info, "gemini", "GEMINI_MODEL_ALIASES");
+    addGlobalEnvAliases(info, "gemini");
+    if (envDefault) {
+        setDefaultModel(info, envDefault, "GEMINI_DEFAULT_MODEL", "env");
+    }
+    info.modelOrder = buildOrder(info, info.defaultModel);
+}
+function applyGrokOverrides(info) {
+    const envDefault = process.env.GROK_DEFAULT_MODEL;
+    addEnvModels(info, "GROK_MODELS");
+    addEnvAliases(info, "grok", "GROK_MODEL_ALIASES");
+    addGlobalEnvAliases(info, "grok");
     if (envDefault) {
-        info.models[envDefault] = info.models[envDefault] || "Default from GEMINI_DEFAULT_MODEL";
-        info.defaultModel = envDefault;
+        setDefaultModel(info, envDefault, "GROK_DEFAULT_MODEL", "env");
     }
     info.modelOrder = buildOrder(info, info.defaultModel);
 }
-function readJsonValue(filePath, key) {
+function readJsonStringValue(filePath, paths, info) {
     if (!existsSync(filePath)) {
         return undefined;
     }
     try {
         const content = readFileSync(filePath, "utf-8");
         const parsed = JSON.parse(content);
-        const value = parsed?.[key];
-        return typeof value === "string" ? value : undefined;
+        for (const pathParts of paths) {
+            const value = readPath(parsed, pathParts);
+            if (typeof value === "string" && value.trim()) {
+                return value;
+            }
+        }
+        return undefined;
     }
-    catch {
+    catch (error) {
+        if (info) {
+            const message = error instanceof Error ? error.message : String(error);
+            addWarning(info, `Could not parse JSON config ${filePath}: ${message}`);
+        }
+        return undefined;
+    }
+}
+function readPath(value, pathParts) {
+    let current = value;
+    for (const part of pathParts) {
+        if (!current || typeof current !== "object" || Array.isArray(current)) {
+            return undefined;
+        }
+        current = current[part];
+    }
+    return current;
+}
+function readStringProperty(value, key) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
         return undefined;
     }
+    const prop = value[key];
+    return typeof prop === "string" && prop.trim() ? prop : undefined;
 }
-function parseEnvModels(value) {
+function readRecordProperty(value, key) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return {};
+    }
+    const prop = value[key];
+    return prop && typeof prop === "object" && !Array.isArray(prop)
+        ? prop
+        : {};
+}
+function parseEnvModelEntries(value, source) {
     if (!value) {
         return [];
     }
-    return value
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return [];
+    }
+    if (trimmed.startsWith("[") || trimmed.startsWith("{")) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (Array.isArray(parsed)) {
+                return parsed.flatMap(entry => {
+                    if (typeof entry === "string") {
+                        return [{ model: entry }];
+                    }
+                    if (entry && typeof entry === "object") {
+                        const record = entry;
+                        const model = firstString(record.model, record.id, record.name);
+                        const description = firstString(record.description, record.desc);
+                        return model ? [{ model, description }] : [];
+                    }
+                    return [];
+                });
+            }
+            if (parsed && typeof parsed === "object") {
+                return Object.entries(parsed).flatMap(([model, description]) => {
+                    if (typeof description === "string") {
+                        return [{ model, description }];
+                    }
+                    return [{ model }];
+                });
+            }
+        }
+        catch {
+            return [{ model: trimmed, description: `Configured via ${source}` }];
+        }
+    }
+    return trimmed
         .split(/[,\n]/)
         .map(entry => entry.trim())
-        .filter(entry => entry.length > 0);
-}
-function extractTomlString(content, key) {
-    const regex = new RegExp(`^\\s*${escapeRegex(key)}\\s*=\\s*\"([^\"]+)\"`, "m");
-    const match = content.match(regex);
-    return match ? match[1] : undefined;
+        .filter(Boolean)
+        .map(entry => {
+        const eqIndex = entry.indexOf("=");
+        if (eqIndex > 0) {
+            return {
+                model: entry.slice(0, eqIndex).trim(),
+                description: entry.slice(eqIndex + 1).trim() || undefined,
+            };
+        }
+        return { model: entry };
+    });
 }
-function extractTomlTableMap(content, tableName) {
-    const tableRegex = new RegExp(`^\\s*\\[${escapeRegex(tableName)}\\]\\s*$`, "m");
-    const tableMatch = content.match(tableRegex);
-    if (!tableMatch || tableMatch.index === undefined) {
-        return {};
+function parseEnvAliasEntries(value, source, cli) {
+    if (!value) {
+        return [];
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return [];
+    }
+    const entries = [];
+    const addEntry = (rawAlias, rawTarget) => {
+        if (typeof rawTarget !== "string") {
+            return;
+        }
+        let alias = rawAlias.trim();
+        if (source === "LLM_GATEWAY_MODEL_ALIASES") {
+            const prefix = `${cli}.`;
+            if (!alias.startsWith(prefix)) {
+                return;
+            }
+            alias = alias.slice(prefix.length);
+        }
+        entries.push({ alias, target: rawTarget });
+    };
+    if (trimmed.startsWith("{")) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                Object.entries(parsed).forEach(([alias, target]) => addEntry(alias, target));
+                return entries;
+            }
+        }
+        catch {
+            return [];
+        }
     }
-    const startIndex = tableMatch.index + tableMatch[0].length;
-    const rest = content.slice(startIndex);
-    const nextTable = rest.search(/^\s*\[[^\]]+\]\s*$/m);
-    const block = nextTable >= 0 ? rest.slice(0, nextTable) : rest;
-    const map = {};
-    const lineRegex = /"([^"]+)"\s*=\s*"([^"]+)"/g;
-    let match;
-    while ((match = lineRegex.exec(block)) !== null) {
-        map[match[1]] = match[2];
+    trimmed.split(/[,\n]/).forEach(entry => {
+        const eqIndex = entry.indexOf("=");
+        if (eqIndex <= 0) {
+            return;
+        }
+        addEntry(entry.slice(0, eqIndex), entry.slice(eqIndex + 1));
+    });
+    return entries;
+}
+function firstString(...values) {
+    for (const value of values) {
+        if (typeof value === "string" && value.trim()) {
+            return value;
+        }
     }
-    return map;
+    return undefined;
 }
-function escapeRegex(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function isModelDiscoveryDisabled() {
+    return (process.env.LLM_GATEWAY_DISABLE_MODEL_DISCOVERY === "1" ||
+        process.env.GEMINI_DISABLE_HISTORY_DISCOVERY === "1");
+}
+function parsePositiveInt(value, fallback) {
+    if (!value) {
+        return fallback;
+    }
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
 }
 function collectGeminiModels() {
-    const root = path.join(homedir(), ".gemini", "tmp");
+    const root = process.env.GEMINI_HISTORY_ROOT || path.join(homedir(), ".gemini", "tmp");
     if (!existsSync(root)) {
-        return { models: {}, order: [] };
+        return [];
     }
+    const maxFiles = parsePositiveInt(process.env.GEMINI_HISTORY_MAX_FILES, MAX_GEMINI_HISTORY_FILES);
+    const maxFileBytes = parsePositiveInt(process.env.GEMINI_HISTORY_MAX_FILE_BYTES, MAX_GEMINI_HISTORY_FILE_BYTES);
     const candidates = [];
     const roots = safeReadDir(root);
     roots.forEach(entry => {
@@ -238,7 +511,9 @@ function collectGeminiModels() {
             const filePath = path.join(chatsPath, file.name);
             try {
                 const stat = statSync(filePath);
-                candidates.push({ filePath, mtimeMs: stat.mtimeMs });
+                if (stat.size <= maxFileBytes) {
+                    candidates.push({ filePath, mtimeMs: stat.mtimeMs, size: stat.size });
+                }
             }
             catch {
                 return;
@@ -246,44 +521,69 @@ function collectGeminiModels() {
         });
     });
     candidates.sort((a, b) => b.mtimeMs - a.mtimeMs);
-    const maxFiles = 200;
     const recent = candidates.slice(0, maxFiles);
     const models = {};
     for (const candidate of recent) {
-        const model = extractGeminiModel(candidate.filePath);
-        if (!model) {
-            continue;
-        }
-        const existing = models[model]?.lastSeen ?? 0;
-        if (candidate.mtimeMs > existing) {
-            models[model] = { lastSeen: candidate.mtimeMs };
-        }
+        extractGeminiModels(candidate.filePath).forEach(model => {
+            const existing = models[model]?.lastSeenMs ?? 0;
+            if (candidate.mtimeMs > existing) {
+                models[model] = {
+                    model,
+                    lastSeen: formatDate(candidate.mtimeMs),
+                    lastSeenMs: candidate.mtimeMs,
+                    filePath: candidate.filePath,
+                };
+            }
+        });
     }
-    const order = Object.entries(models)
-        .sort((a, b) => {
-        const versionDiff = extractModelVersion(b[0]) - extractModelVersion(a[0]);
+    return Object.values(models).sort((a, b) => {
+        const versionDiff = extractModelVersion(b.model) - extractModelVersion(a.model);
         if (versionDiff !== 0) {
             return versionDiff;
         }
-        return b[1].lastSeen - a[1].lastSeen;
-    })
-        .map(([name]) => name);
-    const describedModels = {};
-    order.forEach(model => {
-        describedModels[model] =
-            `Observed in local Gemini sessions (last seen ${formatDate(models[model].lastSeen)})`;
+        return b.lastSeenMs - a.lastSeenMs;
     });
-    return { models: describedModels, order };
 }
-function extractGeminiModel(filePath) {
+function extractGeminiModels(filePath) {
     try {
         const content = readFileSync(filePath, "utf-8");
-        const match = content.match(/"model"\s*:\s*"([^"]+)"/);
-        return match ? match[1] : undefined;
+        const found = new Set();
+        try {
+            collectModelValues(JSON.parse(content), found);
+        }
+        catch {
+            const regex = /"model(?:Name|Id)?"\s*:\s*"([^"]+)"/g;
+            let match;
+            while ((match = regex.exec(content)) !== null) {
+                found.add(match[1]);
+            }
+        }
+        return [...found].filter(isValidModelName).slice(0, 20);
     }
     catch {
-        return undefined;
+        return [];
+    }
+}
+function collectModelValues(value, found) {
+    if (!value || found.size >= 20) {
+        return;
     }
+    if (Array.isArray(value)) {
+        value.forEach(entry => collectModelValues(entry, found));
+        return;
+    }
+    if (typeof value !== "object") {
+        return;
+    }
+    Object.entries(value).forEach(([key, child]) => {
+        if ((key === "model" || key === "modelName" || key === "modelId") &&
+            typeof child === "string") {
+            found.add(child);
+        }
+        else {
+            collectModelValues(child, found);
+        }
+    });
 }
 function formatDate(timestampMs) {
     try {
@@ -334,11 +634,21 @@ function buildOrder(info, preferred) {
 }
 function pickLatestMatching(info, token) {
     const normalized = token.toLowerCase();
-    const order = info.modelOrder ?? Object.keys(info.models);
-    for (const model of order) {
-        if (model.toLowerCase().includes(normalized)) {
-            return model;
+    const candidates = Object.keys(info.models)
+        .filter(model => model.toLowerCase().includes(normalized))
+        .sort((a, b) => {
+        const versionDiff = extractModelVersion(b) - extractModelVersion(a);
+        if (versionDiff !== 0) {
+            return versionDiff;
         }
-    }
-    return undefined;
+        const aMetadata = info.modelMetadata?.[a];
+        const bMetadata = info.modelMetadata?.[b];
+        const priorityDiff = (bMetadata ? SOURCE_PRIORITY[bMetadata.source] : 0) -
+            (aMetadata ? SOURCE_PRIORITY[aMetadata.source] : 0);
+        if (priorityDiff !== 0) {
+            return priorityDiff;
+        }
+        return a.localeCompare(b);
+    });
+    return candidates[0];
 }