@alan-ai-hq/agent-manager 0.1.113 → 0.1.115

package/dist/provider-model-discovery.js

@@ -0,0 +1,731 @@
+import { readFileSync, realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { AVAILABLE_MODELS, isEffortLevel, isOpenCodeProviderKind, normalizeDiscoveredModelVariants, OPENCODE_ZEN_MODELS, PROVIDER_MODELS, } from "@alan-ai/shared/frontend";
+import { collapseCursorDiscoveredModelIds } from "@alan-ai/shared/runtime-discovered-models";
+import { runCliProbeAsync } from "./cli-executable.js";
+export const MODEL_DISCOVERY_TIMEOUT_MS = 8_000;
+const ANTIGRAVITY_MODEL_DISCOVERY_TIMEOUT_MS = 12_000;
+const OPENCODE_ZEN_MODEL_IDS = OPENCODE_ZEN_MODELS.map((model) => model.id);
+/** Static billing fallback for Zen ids when a failed scan carries no live cost data. */
+const OPENCODE_ZEN_STATIC_BILLING = new Map(OPENCODE_ZEN_MODELS.filter((model) => model.billing).map((model) => [model.id, model.billing]));
+const CLAUDE_MODEL_ID_PATTERN = /claude-(?:sonnet|opus|haiku|fable)-[a-z0-9][a-z0-9-]*/g;
+const CLAUDE_MODEL_ALIASES = ["sonnet", "opus", "haiku", "fable"];
+const CLAUDE_MODEL_ALIAS_SET = new Set(CLAUDE_MODEL_ALIASES);
+// Reject unknown alphabetic Claude id segments; scrape regex matched internal codenames like mythos.
+const CLAUDE_MODEL_QUALIFIER_SEGMENTS = new Set(["fast", "thinking", "latest", "preview"]);
+const PROTECTED_CATALOG_MODEL_IDS = new Set(AVAILABLE_MODELS.map((model) => model.id).filter((id) => id.length > 0));
+const CATALOG_MODEL_IDS_BY_PROVIDER = Object.fromEntries(Object.entries(PROVIDER_MODELS).map(([provider, models]) => [
+    provider,
+    models.map((model) => model.id),
+]));
+function readModelId(value) {
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        return trimmed.length > 0 ? trimmed : null;
+    }
+    if (!value || typeof value !== "object")
+        return null;
+    const record = value;
+    return (readModelId(record.slug) ??
+        readModelId(record.id) ??
+        readModelId(record.model) ??
+        readModelId(record.name) ??
+        readModelId(record.value));
+}
+export function extractModelIdsFromJson(value) {
+    if (Array.isArray(value)) {
+        return [...new Set(value.map(readModelId).filter((model) => Boolean(model)))];
+    }
+    if (!value || typeof value !== "object")
+        return [];
+    const record = value;
+    for (const key of ["models", "data", "items"]) {
+        const nested = extractModelIdsFromJson(record[key]);
+        if (nested.length > 0)
+            return nested;
+    }
+    const byProvider = record.opencode ?? record.providers;
+    if (byProvider) {
+        const nested = extractModelIdsFromJson(byProvider);
+        if (nested.length > 0)
+            return nested;
+    }
+    return [];
+}
+export function extractCodexModelSlugsFromDebugJson(value) {
+    if (!value || typeof value !== "object")
+        return [];
+    const models = value.models;
+    if (!Array.isArray(models))
+        return [];
+    const slugs = [];
+    for (const entry of models) {
+        if (!entry || typeof entry !== "object")
+            continue;
+        const record = entry;
+        const visibility = typeof record.visibility === "string" ? record.visibility.toLowerCase() : "list";
+        if (visibility === "hidden" || visibility === "hide")
+            continue;
+        const slug = readModelId(record.slug);
+        if (slug)
+            slugs.push(slug);
+    }
+    return [...new Set(slugs)];
+}
+function normalizeCodexReasoningEffort(effort) {
+    const normalized = effort.trim().toLowerCase();
+    if (!normalized)
+        return null;
+    // Codex/OpenAI use `none`; Alan's picker label is `minimal`.
+    if (normalized === "none")
+        return "minimal";
+    return isEffortLevel(normalized) ? normalized : null;
+}
+export function extractCodexDiscoveredModelIdsFromDebugJson(value) {
+    if (!value || typeof value !== "object")
+        return [];
+    const models = value.models;
+    if (!Array.isArray(models))
+        return [];
+    const ids = [];
+    for (const entry of models) {
+        if (!entry || typeof entry !== "object")
+            continue;
+        const record = entry;
+        const visibility = typeof record.visibility === "string" ? record.visibility.toLowerCase() : "list";
+        if (visibility === "hidden" || visibility === "hide")
+            continue;
+        const slug = readModelId(record.slug);
+        if (!slug)
+            continue;
+        const reasoningLevels = record.supported_reasoning_levels;
+        if (Array.isArray(reasoningLevels) && reasoningLevels.length > 0) {
+            for (const levelEntry of reasoningLevels) {
+                if (!levelEntry || typeof levelEntry !== "object")
+                    continue;
+                const effort = typeof levelEntry.effort === "string"
+                    ? levelEntry.effort
+                    : null;
+                const normalized = effort ? normalizeCodexReasoningEffort(effort) : null;
+                if (normalized)
+                    ids.push(`${slug}-${normalized}`);
+            }
+            continue;
+        }
+        ids.push(slug);
+    }
+    return [...new Set(ids)];
+}
+// OpenRouter ids need multi-slash pattern; single-slash regex dropped z-ai/glm-4.6 models.
+const OPENCODE_MODEL_ID_LINE_PATTERN = /^[a-z0-9][\w.-]*(?:\/[\w.-]+)+$/i;
+function parseOpenCodeVerboseModelOutput(text) {
+    const entries = [];
+    const lines = text.split(/\r?\n/);
+    let i = 0;
+    while (i < lines.length) {
+        const line = (lines[i] ?? "").trim();
+        i += 1;
+        if (!OPENCODE_MODEL_ID_LINE_PATTERN.test(line))
+            continue;
+        let jsonStart = i;
+        while (jsonStart < lines.length && (lines[jsonStart] ?? "").trim() === "")
+            jsonStart += 1;
+        if (jsonStart >= lines.length || !(lines[jsonStart] ?? "").trim().startsWith("{"))
+            continue;
+        let depth = 0;
+        let inString = false;
+        let escaped = false;
+        let endLineIdx = -1;
+        let buffer = "";
+        for (let j = jsonStart; j < lines.length; j += 1) {
+            const raw = lines[j] ?? "";
+            buffer += (buffer ? "\n" : "") + raw;
+            for (const ch of raw) {
+                if (escaped) {
+                    escaped = false;
+                    continue;
+                }
+                if (ch === "\\" && inString) {
+                    escaped = true;
+                    continue;
+                }
+                if (ch === '"') {
+                    inString = !inString;
+                    continue;
+                }
+                if (inString)
+                    continue;
+                if (ch === "{")
+                    depth += 1;
+                else if (ch === "}")
+                    depth -= 1;
+            }
+            if (depth === 0) {
+                endLineIdx = j;
+                break;
+            }
+        }
+        if (endLineIdx === -1)
+            break; // truncated/malformed tail — stop parsing safely
+        try {
+            const obj = JSON.parse(buffer);
+            const inputCost = obj.cost?.input;
+            const outputCost = obj.cost?.output;
+            const hasNumericCost = typeof inputCost === "number" || typeof outputCost === "number";
+            entries.push({
+                id: line,
+                reasoning: obj.capabilities?.reasoning === true,
+                variants: obj.variants ? Object.keys(obj.variants) : [],
+                ...(hasNumericCost
+                    ? {
+                        billing: inputCost === 0 && outputCost === 0 ? "free" : "paid",
+                    }
+                    : {}),
+            });
+        }
+        catch {
+            // Skip this one malformed entry; keep scanning the rest of the stream.
+        }
+        i = endLineIdx + 1;
+    }
+    return entries;
+}
+export function extractOpenCodeModelCapabilitiesFromVerboseOutput(text) {
+    return openCodeCapabilitiesFromEntries(parseOpenCodeVerboseModelOutput(text));
+}
+function openCodeCapabilitiesFromEntries(entries) {
+    return entries.map((entry) => ({
+        id: entry.id,
+        variants: entry.reasoning ? normalizeDiscoveredModelVariants(entry.variants) : [],
+    }));
+}
+export function extractOpenCodeModelBillingFromVerboseOutput(text) {
+    return openCodeBillingFromEntries(parseOpenCodeVerboseModelOutput(text));
+}
+function openCodeBillingFromEntries(entries) {
+    const billing = {};
+    for (const entry of entries) {
+        if (entry.billing)
+            billing[entry.id] = entry.billing;
+    }
+    return billing;
+}
+// Variants stay in modelVariants, not id suffixes — OpenCode names do not match Alan's effort scale.
+export function extractOpenCodeDiscoveredModelIdsFromVerboseOutput(text) {
+    return [...new Set(extractOpenCodeModelCapabilitiesFromVerboseOutput(text).map(({ id }) => id))];
+}
+export function extractModelIdsFromText(value) {
+    const ansiPattern = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
+    const ignoredLinePattern = /^(available models|models|usage|error|flag provided|try |agy\b|warning:)/i;
+    const ids = value
+        .split(/\r?\n/)
+        .map((line) => line
+        .replace(ansiPattern, "")
+        .replace(/^[-*•]\s*/, "")
+        .trim())
+        .filter((line) => line.length > 0 && !ignoredLinePattern.test(line));
+    return [...new Set(ids)];
+}
+export function extractModelIdsFromLabeledList(value) {
+    const ansiPattern = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
+    const ignoredLinePattern = /^(available models|fetching available models|models|usage|error|warning:)/i;
+    const ids = [];
+    for (const rawLine of value.split(/\r?\n/)) {
+        const line = rawLine.replace(ansiPattern, "").trim();
+        if (!line || ignoredLinePattern.test(line))
+            continue;
+        const dashIdx = line.indexOf(" - ");
+        const tabIdx = line.indexOf("\t");
+        const separatorIndexes = [dashIdx, tabIdx].filter((index) => index >= 0);
+        const separatorIdx = separatorIndexes.length > 0 ? Math.min(...separatorIndexes) : -1;
+        if (separatorIdx < 0)
+            continue;
+        const id = line.slice(0, separatorIdx).trim();
+        if (id)
+            ids.push(id);
+    }
+    return [...new Set(ids)];
+}
+export function isValidClaudeModelId(id) {
+    if (CLAUDE_MODEL_ALIAS_SET.has(id))
+        return true;
+    const match = id.match(/^claude-(sonnet|opus|haiku|fable)-([a-z0-9][a-z0-9-]*)$/);
+    if (!match)
+        return false;
+    if (id.includes("."))
+        return false;
+    if (/-\d{8}$/.test(id))
+        return false;
+    if (/-v\d+$/.test(id))
+        return false;
+    // Every segment after the family token must be a version number or a known qualifier.
+    // An unknown alphabetic segment (e.g. "mythos") is an internal binary codename that the
+    // greedy scrape regex ran into, not a real model id.
+    for (const segment of match[2].split("-")) {
+        if (/^\d+$/.test(segment))
+            continue;
+        if (CLAUDE_MODEL_QUALIFIER_SEGMENTS.has(segment))
+            continue;
+        return false;
+    }
+    return true;
+}
+export function filterClaudePrefixModelIds(ids) {
+    const set = new Set(ids);
+    return ids.filter((id) => {
+        // A curated catalogue id is never evicted by a longer scraped sibling — defense in
+        // depth so a future internal codename can't hide a real, shipped model.
+        if (PROTECTED_CATALOG_MODEL_IDS.has(id))
+            return true;
+        for (const other of set) {
+            if (other !== id && other.startsWith(`${id}-`))
+                return false;
+        }
+        return true;
+    });
+}
+export function filterClaudeDatedModelIds(ids) {
+    const set = new Set(ids);
+    return ids.filter((id) => {
+        const dated = id.match(/^(claude-(?:sonnet|opus|haiku|fable)-[a-z0-9][a-z0-9-]*)-\d{8}$/);
+        if (!dated)
+            return true;
+        return !set.has(dated[1]);
+    });
+}
+function resolveExecutableForModelScan(executable) {
+    try {
+        return realpathSync(executable);
+    }
+    catch {
+        return executable;
+    }
+}
+export function extractClaudeModelIdsFromExecutable(executable) {
+    try {
+        const resolved = resolveExecutableForModelScan(executable);
+        const text = readFileSync(resolved).toString("latin1");
+        const matches = text.match(CLAUDE_MODEL_ID_PATTERN) ?? [];
+        const unique = [
+            ...new Set(matches.map((id) => id.trim()).filter((id) => isValidClaudeModelId(id))),
+            ...CLAUDE_MODEL_ALIASES,
+        ];
+        return filterClaudeDatedModelIds(filterClaudePrefixModelIds(unique));
+    }
+    catch {
+        return [];
+    }
+}
+export function getCatalogModelIds(provider) {
+    const catalogProvider = provider === "opencode_serve" ? "opencode_cli" : provider;
+    return [...(CATALOG_MODEL_IDS_BY_PROVIDER[catalogProvider] ?? [])];
+}
+function withModelProbeEnv(env) {
+    const term = env.TERM;
+    if (term && term !== "dumb")
+        return env;
+    return { ...env, TERM: "xterm-256color" };
+}
+async function probeJsonOrTextModels(executable, env, argSets, options) {
+    const probeEnv = withModelProbeEnv(env);
+    const timeoutMs = options?.timeoutMs ?? MODEL_DISCOVERY_TIMEOUT_MS;
+    for (const args of argSets) {
+        const result = await runCliProbeAsync(executable, probeEnv, args, timeoutMs, options?.closeStdin || options?.maxOutputChars
+            ? { closeStdin: options?.closeStdin, maxOutputChars: options?.maxOutputChars }
+            : undefined);
+        if (!result || result.error || result.status !== 0 || !result.stdout.trim())
+            continue;
+        try {
+            const parsed = JSON.parse(result.stdout);
+            const codexModels = extractCodexDiscoveredModelIdsFromDebugJson(parsed);
+            if (codexModels.length > 0)
+                return codexModels;
+            const models = extractModelIdsFromJson(parsed);
+            if (models.length > 0)
+                return models;
+        }
+        catch {
+            // A capped JSON response is incomplete, not a single model id.
+            if (/^\s*[{[]/.test(result.stdout))
+                continue;
+            const labeled = extractModelIdsFromLabeledList(result.stdout);
+            if (labeled.length > 0)
+                return labeled;
+            const models = extractModelIdsFromText(result.stdout);
+            if (models.length > 0)
+                return models;
+        }
+    }
+    return [];
+}
+const OPENCODE_ZEN_MODELS_URL = "https://opencode.ai/zen/v1/models";
+const ZEN_ENTITLEMENT_TIMEOUT_MS = 5_000;
+/** Only the Zen slice is entitlement-checkable; `opencode-go/` and BYOK ids are not. */
+const OPENCODE_ZEN_ID_PREFIX = "opencode/";
+export function readOpenCodeZenCredential(env) {
+    const direct = env.OPENCODE_API_KEY?.trim();
+    if (direct)
+        return direct;
+    return readZenCredentialFromAuthDocument(readOpenCodeAuthDocument(env) ?? undefined);
+}
+function readOpenCodeAuthDocument(env) {
+    const injected = env.OPENCODE_AUTH_CONTENT?.trim();
+    if (injected)
+        return injected;
+    const dataHome = env.XDG_DATA_HOME?.trim() || join(homedir(), ".local", "share");
+    try {
+        return readFileSync(join(dataHome, "opencode", "auth.json"), "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+// Explicit keys only — ambient AWS/GCP chains listed Bedrock models the user never configured.
+const OPENCODE_PROVIDER_ENV_KEYS = [
+    ["OPENROUTER_API_KEY", "openrouter"],
+    ["ANTHROPIC_API_KEY", "anthropic"],
+    ["OPENAI_API_KEY", "openai"],
+    ["GEMINI_API_KEY", "google"],
+    ["GOOGLE_GENERATIVE_AI_API_KEY", "google"],
+    ["XAI_API_KEY", "xai"],
+    ["GROQ_API_KEY", "groq"],
+    ["MISTRAL_API_KEY", "mistral"],
+    ["DEEPSEEK_API_KEY", "deepseek"],
+];
+export function readConfiguredOpenCodeProviders(env) {
+    const configured = new Set(["opencode", "opencode-go"]);
+    const document = readOpenCodeAuthDocument(env);
+    if (document) {
+        try {
+            const parsed = JSON.parse(document);
+            if (parsed && typeof parsed === "object") {
+                for (const providerId of Object.keys(parsed))
+                    configured.add(providerId);
+            }
+        }
+        catch {
+            // Unreadable document contributes nothing; env keys below still apply.
+        }
+    }
+    for (const [envKey, namespace] of OPENCODE_PROVIDER_ENV_KEYS) {
+        if (env[envKey]?.trim())
+            configured.add(namespace);
+    }
+    return configured;
+}
+function readZenCredentialFromAuthDocument(content) {
+    const trimmed = content?.trim();
+    if (!trimmed)
+        return null;
+    try {
+        const entry = JSON.parse(trimmed).opencode;
+        if (!entry || typeof entry !== "object")
+            return null;
+        const { key, access } = entry;
+        for (const candidate of [key, access]) {
+            if (typeof candidate === "string" && candidate.trim())
+                return candidate.trim();
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+// Zen /models is per-key entitlement; null on failure keeps the unfiltered scan.
+async function fetchZenEntitledModelIds(credential) {
+    try {
+        const response = await fetch(OPENCODE_ZEN_MODELS_URL, {
+            headers: credential ? { Authorization: `Bearer ${credential}` } : {},
+            signal: AbortSignal.timeout(ZEN_ENTITLEMENT_TIMEOUT_MS),
+        });
+        if (!response.ok)
+            return null;
+        const data = (await response.json())?.data;
+        if (!Array.isArray(data))
+            return null;
+        const ids = data
+            .map((entry) => entry?.id)
+            .filter((id) => typeof id === "string" && id.length > 0);
+        return ids.length > 0 ? new Set(ids) : null;
+    }
+    catch {
+        return null;
+    }
+}
+// Filter Zen ids to entitlement; add entitled ids missing from verbose scan (e.g. laguna-s-2.1-free).
+export function applyZenEntitlement(discovery, entitled) {
+    const zenId = (id) => `${OPENCODE_ZEN_ID_PREFIX}${id}`;
+    const kept = discovery.models.filter((id) => !id.startsWith(OPENCODE_ZEN_ID_PREFIX) ||
+        entitled.has(id.slice(OPENCODE_ZEN_ID_PREFIX.length)));
+    const keptSet = new Set(kept);
+    const scannedSet = new Set(discovery.models);
+    const unscannedEntitled = [...entitled].map(zenId);
+    return {
+        ...discovery,
+        models: [...kept, ...unscannedEntitled.filter((id) => !keptSet.has(id))],
+        catalogModels: [
+            ...(discovery.catalogModels ?? discovery.models),
+            ...unscannedEntitled.filter((id) => !scannedSet.has(id)),
+        ],
+    };
+}
+const OPENCODE_CATALOGUE_CACHE_SEGMENTS = ["opencode", "models.json"];
+/** Cache provider keys whose models map onto Alan's `<provider>/<model>` ids. */
+const OPENCODE_CACHE_PROVIDER_KEYS = ["opencode", "opencode-go"];
+// Hydrate from ~/.cache/opencode/models.json; skip empty variant lists (budget_tokens models).
+function readOpenCodeCatalogueCache(env) {
+    const cacheHome = env.XDG_CACHE_HOME?.trim() || join(homedir(), ".cache");
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(join(cacheHome, ...OPENCODE_CATALOGUE_CACHE_SEGMENTS), "utf8"));
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== "object")
+        return null;
+    const variants = {};
+    const billing = {};
+    const deprecated = new Set();
+    for (const providerKey of OPENCODE_CACHE_PROVIDER_KEYS) {
+        const models = parsed[providerKey]?.models;
+        if (!models || typeof models !== "object")
+            continue;
+        for (const [modelId, entry] of Object.entries(models)) {
+            if (!entry || typeof entry !== "object")
+                continue;
+            const id = `${providerKey}/${modelId}`;
+            const record = entry;
+            if (record.status === "deprecated")
+                deprecated.add(id);
+            const options = Array.isArray(record.reasoning_options) ? record.reasoning_options : [];
+            const effort = options.find((option) => option?.type === "effort");
+            const values = Array.isArray(effort?.values)
+                ? effort.values.filter((value) => typeof value === "string")
+                : [];
+            if (values.length > 0)
+                variants[id] = values;
+            const cost = record.cost;
+            if (typeof cost?.input === "number" && typeof cost?.output === "number") {
+                billing[id] = cost.input === 0 && cost.output === 0 ? "free" : "paid";
+            }
+        }
+    }
+    return Object.keys(variants).length > 0 || Object.keys(billing).length > 0
+        ? { variants, billing, deprecated }
+        : null;
+}
+function hydrateOpenCodeMetadata(discovery, cache) {
+    const ids = new Set([...discovery.models, ...(discovery.catalogModels ?? [])]);
+    const modelVariants = { ...discovery.modelVariants };
+    const modelBilling = { ...discovery.modelBilling };
+    for (const id of ids) {
+        if (!Object.hasOwn(modelVariants, id) && cache.variants[id]) {
+            modelVariants[id] = cache.variants[id];
+        }
+        if (!Object.hasOwn(modelBilling, id) && cache.billing[id]) {
+            modelBilling[id] = cache.billing[id];
+        }
+    }
+    return {
+        ...discovery,
+        ...(Object.keys(modelVariants).length > 0 ? { modelVariants } : {}),
+        ...(Object.keys(modelBilling).length > 0 ? { modelBilling } : {}),
+    };
+}
+async function discoverOpenCodeModels(executable, env) {
+    const credential = readOpenCodeZenCredential(env);
+    const [rawScan, entitled] = await Promise.all([
+        scanOpenCodeModels(executable, env),
+        fetchZenEntitledModelIds(credential),
+    ]);
+    // Providers the user never configured inside OpenCode (ambient AWS chain → Bedrock)
+    // are cut before anything downstream sees them, catalogue feed included.
+    const configured = readConfiguredOpenCodeProviders(env);
+    const inConfigured = (id) => {
+        const slash = id.indexOf("/");
+        return slash > 0 && configured.has(id.slice(0, slash));
+    };
+    const scanned = {
+        ...rawScan,
+        models: rawScan.models.filter(inConfigured),
+        ...(rawScan.catalogModels ? { catalogModels: rawScan.catalogModels.filter(inConfigured) } : {}),
+    };
+    const filtered = entitled ? applyZenEntitlement(scanned, entitled) : scanned;
+    // After the scan, never before: running it is what refreshes the cache file.
+    const cache = readOpenCodeCatalogueCache(env);
+    const hydrated = cache ? hydrateOpenCodeMetadata(filtered, cache) : filtered;
+    // Hide deprecated Zen ids except entitled ones (laguna-s-2.1-free still dispatches).
+    const keyEntitled = credential && entitled ? entitled : null;
+    const withoutDeprecated = cache
+        ? hydrated.models.filter((id) => !cache.deprecated.has(id) ||
+            (keyEntitled !== null &&
+                id.startsWith(OPENCODE_ZEN_ID_PREFIX) &&
+                keyEntitled.has(id.slice(OPENCODE_ZEN_ID_PREFIX.length))))
+        : hydrated.models;
+    return {
+        ...hydrated,
+        models: credential
+            ? withoutDeprecated
+            : filterZenToFreeModels(withoutDeprecated, hydrated.modelBilling),
+    };
+}
+// No credential: offer only free Zen ids; unknown billing is dropped, not guessed.
+function filterZenToFreeModels(models, billing) {
+    return models.filter((id) => {
+        if (!id.startsWith("opencode/") && !id.startsWith("opencode-go/"))
+            return true;
+        return (billing?.[id] ?? OPENCODE_ZEN_STATIC_BILLING.get(id)) === "free";
+    });
+}
+async function scanOpenCodeModels(executable, env) {
+    // Real command (verified live): `opencode models --verbose` prints per-model
+    // reasoning/variant capability — see extractOpenCodeModelCapabilitiesFromVerboseOutput.
+    // `--json`/`list --json` variants below are NOT real opencode flags (they exit 1 with
+    // opencode's own --help text); kept only as a last-resort probe in case some other
+    // OpenCode-compatible CLI build genuinely supports them.
+    const verbose = await runCliProbeAsync(executable, withModelProbeEnv(env), ["models", "--verbose"], MODEL_DISCOVERY_TIMEOUT_MS);
+    if (verbose && !verbose.error && verbose.status === 0 && verbose.stdout.trim()) {
+        const entries = parseOpenCodeVerboseModelOutput(verbose.stdout);
+        const modelCapabilities = openCodeCapabilitiesFromEntries(entries);
+        if (modelCapabilities.length > 0) {
+            const modelBilling = openCodeBillingFromEntries(entries);
+            return {
+                models: modelCapabilities.map(({ id }) => id),
+                modelVariants: Object.fromEntries(modelCapabilities.map(({ id, variants }) => [id, variants])),
+                ...(Object.keys(modelBilling).length > 0 ? { modelBilling } : {}),
+            };
+        }
+    }
+    const plain = await probeJsonOrTextModels(executable, env, [["models"]]);
+    if (plain.length > 0)
+        return { models: plain };
+    const legacy = await probeJsonOrTextModels(executable, env, [
+        ["models", "--json"],
+        ["models", "list", "--json"],
+        ["model", "list", "--json"],
+    ]);
+    return { models: legacy.length > 0 ? legacy : OPENCODE_ZEN_MODEL_IDS };
+}
+async function discoverAntigravityModels(executable, env) {
+    return probeJsonOrTextModels(executable, env, [["models"]], {
+        closeStdin: true,
+        timeoutMs: ANTIGRAVITY_MODEL_DISCOVERY_TIMEOUT_MS,
+    });
+}
+async function discoverCursorAgentModels(executable, env) {
+    return probeJsonOrTextModels(executable, env, [
+        ["models", "--json"],
+        ["models"],
+        ["--list-models"],
+    ]);
+}
+async function discoverCodexModels(executable, env) {
+    // Codex embeds full model instructions in this JSON; current lists exceed 500 KB.
+    return probeJsonOrTextModels(executable, env, [["debug", "models"]], {
+        maxOutputChars: 1024 * 1024,
+    });
+}
+async function discoverClaudeModels(executable, env) {
+    const fromCli = await probeJsonOrTextModels(executable, env, [
+        ["model", "list", "--json"],
+        ["models", "--json"],
+        ["models", "list", "--json"],
+    ]);
+    if (fromCli.length > 0) {
+        return collapseCursorDiscoveredModelIds(fromCli);
+    }
+    return extractClaudeModelIdsFromExecutable(executable);
+}
+async function discoverGenericModels(executable, env) {
+    return probeJsonOrTextModels(executable, env, [
+        ["models", "--json"],
+        ["models", "list", "--json"],
+        ["models"],
+    ]);
+}
+// Parse grok bullet rows only; generic parser treated login banner lines as model ids.
+export function extractGrokModelIdsFromModelsOutput(value) {
+    const ansiPattern = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
+    const ids = [];
+    let defaultId = null;
+    for (const rawLine of value.split(/\r?\n/)) {
+        const line = rawLine.replace(ansiPattern, "").trim();
+        if (!line)
+            continue;
+        const defaultMatch = /^Default model:\s*(grok[\w./-]*)\s*$/i.exec(line);
+        if (defaultMatch?.[1]) {
+            defaultId = defaultMatch[1];
+            continue;
+        }
+        // Bullet rows only — never scrape "You are logged in with grok.com."
+        const bullet = /^[*•-]\s+(grok[\w./-]*)(?:\s+\(.*\))?\s*$/i.exec(line);
+        if (!bullet?.[1])
+            continue;
+        const id = bullet[1];
+        if (!ids.includes(id))
+            ids.push(id);
+        if (/\(default\)/i.test(line))
+            defaultId = id;
+    }
+    if (ids.length === 0)
+        return defaultId ? [defaultId] : [];
+    if (defaultId && ids.includes(defaultId)) {
+        return [defaultId, ...ids.filter((id) => id !== defaultId)];
+    }
+    return ids;
+}
+async function discoverGrokModels(executable, env) {
+    const result = await runCliProbeAsync(executable, withModelProbeEnv(env), ["models"], MODEL_DISCOVERY_TIMEOUT_MS);
+    if (!result || result.error || result.status !== 0 || !result.stdout.trim())
+        return [];
+    return extractGrokModelIdsFromModelsOutput(result.stdout);
+}
+// copilot_cli has no non-interactive model list; probing only burns the timeout.
+const CATALOG_ONLY_PROVIDERS = new Set([
+    "supatest_cli",
+    "droid_cli",
+    "copilot_cli",
+    "command_code_cli",
+]);
+export function supportsProviderModelDiscovery(provider) {
+    return provider === "opencode_serve" || provider in CATALOG_MODEL_IDS_BY_PROVIDER;
+}
+export async function discoverProviderModels(provider, executable, env) {
+    return (await discoverProviderModelDetails(provider, executable, env)).models;
+}
+export async function discoverProviderModelDetails(provider, executable, env) {
+    if (CATALOG_ONLY_PROVIDERS.has(provider)) {
+        return { models: getCatalogModelIds(provider) };
+    }
+    let probed = [];
+    if (isOpenCodeProviderKind(provider)) {
+        const discovered = await discoverOpenCodeModels(executable, env);
+        if (discovered.models.length > 0)
+            return discovered;
+    }
+    else if (provider === "antigravity_cli") {
+        probed = await discoverAntigravityModels(executable, env);
+    }
+    else if (provider === "cursor_agent_cli") {
+        probed = await discoverCursorAgentModels(executable, env);
+    }
+    else if (provider === "codex_app_server") {
+        probed = await discoverCodexModels(executable, env);
+    }
+    else if (provider === "claude_cli") {
+        probed = await discoverClaudeModels(executable, env);
+    }
+    else if (provider === "grok_cli") {
+        probed = await discoverGrokModels(executable, env);
+    }
+    else if (provider === "kimi_cli") {
+        probed = await discoverGenericModels(executable, env);
+    }
+    if (probed.length > 0)
+        return { models: probed };
+    return { models: getCatalogModelIds(provider) };
+}
+//# sourceMappingURL=provider-model-discovery.js.map