@botcord/daemon 0.2.77 → 0.2.79

package/dist/runtime-models.js

@@ -0,0 +1,953 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+const MODEL_LIST_TIMEOUT_MS = 5000;
+const MODEL_LIST_MAX_BUFFER = 16 * 1024 * 1024;
+const RUNTIME_CATALOG_CACHE_VERSION = 1;
+const RUNTIME_CATALOG_CACHE_FRESH_MS = 10 * 60 * 1000;
+const DEFAULT_RUNTIME_CATALOG_CACHE_DIR = path.join(homedir(), ".botcord", "daemon", "runtime-catalog-cache");
+const CLAUDE_ALIAS_MODELS = [
+    { id: "default", displayName: "Default", provider: "anthropic", source: "builtin" },
+    { id: "best", displayName: "Best", provider: "anthropic", source: "builtin" },
+    { id: "sonnet", displayName: "Sonnet", provider: "anthropic", source: "builtin" },
+    { id: "opus", displayName: "Opus", provider: "anthropic", source: "builtin" },
+    { id: "haiku", displayName: "Haiku", provider: "anthropic", source: "builtin" },
+    { id: "sonnet[1m]", displayName: "Sonnet 1M", provider: "anthropic", source: "builtin" },
+    { id: "opus[1m]", displayName: "Opus 1M", provider: "anthropic", source: "builtin" },
+    { id: "opusplan", displayName: "Opus Plan", provider: "anthropic", source: "builtin" },
+];
+const CLAUDE_EFFORT_VALUES = ["low", "medium", "high", "xhigh", "max"];
+const CLAUDE_PERMISSION_MODE_VALUES = [
+    "acceptEdits",
+    "auto",
+    "bypassPermissions",
+    "default",
+    "dontAsk",
+    "plan",
+];
+const CODEX_SANDBOX_MODES = ["read-only", "workspace-write", "danger-full-access"];
+const CODEX_APPROVAL_POLICIES = ["untrusted", "on-failure", "on-request", "never"];
+const DEEPSEEK_PROVIDER_VALUES = [
+    "deepseek",
+    "nvidia-nim",
+    "openai",
+    "openrouter",
+    "novita",
+    "fireworks",
+    "sglang",
+    "vllm",
+    "ollama",
+];
+const CODEX_FALLBACK_MODELS = [
+    { id: "gpt-5.2", displayName: "GPT-5.2", provider: "openai", source: "builtin" },
+    { id: "gpt-5.1", displayName: "GPT-5.1", provider: "openai", source: "builtin" },
+    { id: "gpt-5", displayName: "GPT-5", provider: "openai", source: "builtin" },
+    { id: "o4-mini", displayName: "o4-mini", provider: "openai", source: "builtin" },
+];
+const DEEPSEEK_FALLBACK_MODELS = [
+    { id: "deepseek-v4-flash", displayName: "deepseek-v4-flash", provider: "deepseek", source: "builtin" },
+];
+const KIMI_FALLBACK_MODELS = [
+    { id: "kimi-code/kimi-for-coding", displayName: "Kimi for Coding", provider: "managed:kimi-code", source: "builtin" },
+    { id: "kimi-k2-5", displayName: "kimi-k2-5", provider: "kimi", source: "builtin" },
+    { id: "kimi-k2-5-preview", displayName: "kimi-k2-5-preview", provider: "kimi", source: "builtin" },
+    { id: "kimi-k2-0711", displayName: "kimi-k2-0711", provider: "kimi", source: "builtin" },
+];
+const backgroundRefreshes = new Set();
+export function discoverRuntimeModelCatalog(entry) {
+    if (!entry.result.available)
+        return {};
+    const strategy = runtimeCatalogStrategy(entry);
+    if (!strategy)
+        return {};
+    return discoverRuntimeCatalogWithCache(strategy);
+}
+function runtimeCatalogStrategy(entry) {
+    switch (entry.id) {
+        case "claude-code":
+            return {
+                id: entry.id,
+                contextKey: runtimeCatalogContextKey(entry, {
+                    settings: fileStatKey(path.join(homedir(), ".claude", "settings.json")),
+                    env: pickEnv([
+                        "ANTHROPIC_DEFAULT_OPUS_MODEL",
+                        "ANTHROPIC_DEFAULT_SONNET_MODEL",
+                        "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+                        "ANTHROPIC_CUSTOM_MODEL_OPTION",
+                    ]),
+                }),
+                discoverFresh: discoverClaudeCatalog,
+                fallback: () => ({ models: CLAUDE_ALIAS_MODELS.slice(), parameters: discoverClaudeParameters() }),
+            };
+        case "codex":
+            return {
+                id: entry.id,
+                contextKey: runtimeCatalogContextKey(entry, {
+                    codexHome: codexHomeDir(),
+                    config: fileStatKey(path.join(codexHomeDir(), "config.toml")),
+                    cliCache: fileStatKey(codexModelCachePath()),
+                    env: pickEnv(["OPENAI_BASE_URL", "CODEX_HOME"]),
+                }),
+                discoverFresh: () => discoverCodexCatalog(entry.result.path),
+                fallback: () => ({ models: CODEX_FALLBACK_MODELS.slice(), parameters: discoverCodexParameters(null) }),
+            };
+        case "deepseek-tui":
+            return {
+                id: entry.id,
+                contextKey: runtimeCatalogContextKey(entry, {
+                    config: fileStatKey(path.join(homedir(), ".deepseek", "config.toml")),
+                    env: pickEnv(["BOTCORD_DEEPSEEK_TUI_BIN", "BOTCORD_DEEPSEEK_TUI_URL"]),
+                }),
+                discoverFresh: () => discoverDeepseekCatalog(entry.result.path),
+                fallback: () => ({
+                    models: DEEPSEEK_FALLBACK_MODELS.slice(),
+                    parameters: discoverDeepseekParameters(),
+                }),
+            };
+        case "kimi-cli":
+            return {
+                id: entry.id,
+                contextKey: runtimeCatalogContextKey(entry, {
+                    config: fileStatKey(path.join(homedir(), ".kimi", "config.toml")),
+                    env: pickEnv(["BOTCORD_KIMI_CLI_BIN"]),
+                }),
+                discoverFresh: discoverKimiCatalog,
+                fallback: () => ({
+                    models: KIMI_FALLBACK_MODELS.slice(),
+                    parameters: [
+                        {
+                            id: "thinking",
+                            displayName: "Thinking",
+                            type: "boolean",
+                            flag: "--thinking/--no-thinking",
+                            source: "builtin",
+                        },
+                    ],
+                }),
+            };
+        default:
+            return null;
+    }
+}
+function discoverRuntimeCatalogWithCache(strategy) {
+    const cached = readRuntimeCatalogCache(strategy.id, strategy.contextKey);
+    if (cached && Date.now() - cached.updatedAt < RUNTIME_CATALOG_CACHE_FRESH_MS) {
+        scheduleRuntimeCatalogRefresh(strategy);
+        return cached.catalog;
+    }
+    try {
+        const fresh = completeCatalogWithFallback(strategy.discoverFresh(), strategy);
+        if (hasCatalogData(fresh)) {
+            writeRuntimeCatalogCache(strategy.id, strategy.contextKey, fresh);
+            return fresh;
+        }
+    }
+    catch {
+        // Fall through to stale cache or built-in fallback.
+    }
+    if (cached)
+        return cached.catalog;
+    try {
+        const fallback = strategy.fallback?.() ?? {};
+        return hasCatalogData(fallback) ? fallback : {};
+    }
+    catch {
+        return {};
+    }
+}
+export function discoverRuntimeModels(entry) {
+    return discoverRuntimeModelCatalog(entry).models;
+}
+export function discoverRuntimeParameters(entry) {
+    return discoverRuntimeModelCatalog(entry).parameters;
+}
+function completeCatalogWithFallback(catalog, strategy) {
+    if (catalog.models?.length)
+        return catalog;
+    const fallback = strategy.fallback?.();
+    if (!fallback?.models?.length)
+        return catalog;
+    return {
+        ...catalog,
+        models: fallback.models,
+    };
+}
+function discoverClaudeCatalog() {
+    return {
+        models: discoverClaudeModels(),
+        parameters: discoverClaudeParameters(),
+    };
+}
+export function discoverClaudeModels() {
+    const models = new Map();
+    const add = (model) => {
+        if (!model.id)
+            return;
+        const existing = models.get(model.id);
+        models.set(model.id, { ...existing, ...model });
+    };
+    for (const model of CLAUDE_ALIAS_MODELS)
+        add(model);
+    const settings = readJsonObject(path.join(homedir(), ".claude", "settings.json"));
+    const defaultModel = stringField(settings, "model");
+    if (defaultModel) {
+        add({
+            id: defaultModel,
+            displayName: defaultModel,
+            provider: "anthropic",
+            source: "config",
+            isDefault: true,
+        });
+    }
+    for (const item of arrayField(settings, "availableModels")) {
+        if (typeof item === "string" && item) {
+            add({ id: item, displayName: item, provider: "anthropic", source: "config" });
+        }
+    }
+    for (const envName of [
+        "ANTHROPIC_DEFAULT_OPUS_MODEL",
+        "ANTHROPIC_DEFAULT_SONNET_MODEL",
+        "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+        "ANTHROPIC_CUSTOM_MODEL_OPTION",
+    ]) {
+        const value = process.env[envName];
+        if (value) {
+            add({
+                id: value,
+                displayName: value,
+                provider: "anthropic",
+                source: "env",
+                metadata: { env: envName },
+            });
+        }
+    }
+    return Array.from(models.values());
+}
+function discoverClaudeParameters() {
+    const settings = readJsonObject(path.join(homedir(), ".claude", "settings.json"));
+    const effort = stringField(settings, "effort");
+    const permissionMode = stringField(settings, "permissionMode") ?? stringField(settings, "permission-mode");
+    const out = [
+        {
+            id: "effort",
+            displayName: "Effort",
+            type: "enum",
+            flag: "--effort",
+            values: CLAUDE_EFFORT_VALUES,
+            source: "cli",
+        },
+        {
+            id: "permission_mode",
+            displayName: "Permission mode",
+            type: "enum",
+            flag: "--permission-mode",
+            values: CLAUDE_PERMISSION_MODE_VALUES,
+            source: "cli",
+        },
+    ];
+    if (effort)
+        out[0] = { ...out[0], defaultValue: effort, source: "config" };
+    if (permissionMode)
+        out[1] = { ...out[1], defaultValue: permissionMode, source: "config" };
+    return out;
+}
+function discoverCodexCatalog(command) {
+    const raw = runCommand(codexCommand(command), ["debug", "models"]);
+    const fallbackRaw = raw ?? readCodexModelCacheRaw();
+    return {
+        models: fallbackRaw ? parseCodexModelCatalog(fallbackRaw) : undefined,
+        parameters: discoverCodexParameters(fallbackRaw),
+    };
+}
+export function discoverCodexModels(command) {
+    return discoverCodexCatalog(command).models;
+}
+export function parseCodexModelCatalog(raw) {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed.models))
+        return undefined;
+    const out = [];
+    for (const item of parsed.models) {
+        if (!item || typeof item !== "object")
+            continue;
+        const obj = item;
+        const id = stringField(obj, "slug");
+        if (!id)
+            continue;
+        if (stringField(obj, "visibility") === "hide")
+            continue;
+        const model = {
+            id,
+            provider: "openai",
+            source: "cli",
+        };
+        const displayName = stringField(obj, "display_name") ?? stringField(obj, "description");
+        if (displayName)
+            model.displayName = displayName;
+        const metadata = {};
+        const supportedInApi = obj.supported_in_api;
+        if (typeof supportedInApi === "boolean")
+            metadata.supportedInApi = supportedInApi;
+        const defaultReasoningLevel = stringField(obj, "default_reasoning_level");
+        if (defaultReasoningLevel)
+            metadata.defaultReasoningLevel = defaultReasoningLevel;
+        const supportedReasoningLevels = arrayField(obj, "supported_reasoning_levels")
+            .map((level) => level && typeof level === "object"
+            ? stringField(level, "effort")
+            : undefined)
+            .filter((level) => !!level);
+        if (supportedReasoningLevels.length)
+            metadata.supportedReasoningLevels = supportedReasoningLevels;
+        if (Object.keys(metadata).length)
+            model.metadata = metadata;
+        if (supportedReasoningLevels.length) {
+            model.parameters = [
+                {
+                    id: "reasoning_effort",
+                    displayName: "Reasoning effort",
+                    type: "enum",
+                    flag: "-c model_reasoning_effort=<value>",
+                    values: supportedReasoningLevels,
+                    ...(defaultReasoningLevel ? { defaultValue: defaultReasoningLevel } : {}),
+                    source: "cli",
+                },
+            ];
+        }
+        out.push(model);
+    }
+    return out.length ? out : undefined;
+}
+function discoverCodexParameters(rawCatalog) {
+    const config = readConfigScalars(path.join(homedir(), ".codex", "config.toml"));
+    const reasoningValues = new Set();
+    if (rawCatalog) {
+        try {
+            const parsed = JSON.parse(rawCatalog);
+            if (Array.isArray(parsed.models)) {
+                for (const item of parsed.models) {
+                    if (!item || typeof item !== "object")
+                        continue;
+                    for (const level of arrayField(item, "supported_reasoning_levels")) {
+                        if (!level || typeof level !== "object")
+                            continue;
+                        const effort = stringField(level, "effort");
+                        if (effort)
+                            reasoningValues.add(effort);
+                    }
+                }
+            }
+        }
+        catch {
+            // ignore malformed catalog; runtime-level defaults still come from config.
+        }
+    }
+    return [
+        compactParameter({
+            id: "model",
+            displayName: "Default model",
+            type: "string",
+            flag: "-m, --model",
+            defaultValue: config.model,
+            source: config.model ? "config" : "cli",
+        }),
+        compactParameter({
+            id: "reasoning_effort",
+            displayName: "Reasoning effort",
+            type: reasoningValues.size > 0 ? "enum" : "string",
+            flag: "-c model_reasoning_effort=<value>",
+            values: reasoningValues.size > 0 ? Array.from(reasoningValues) : undefined,
+            defaultValue: config.model_reasoning_effort,
+            source: config.model_reasoning_effort ? "config" : "cli",
+            metadata: { scope: "per-model-values-may-differ" },
+        }),
+        compactParameter({
+            id: "approval_policy",
+            displayName: "Approval policy",
+            type: "enum",
+            flag: "-a, --ask-for-approval",
+            values: CODEX_APPROVAL_POLICIES,
+            defaultValue: config.approval_policy,
+            source: config.approval_policy ? "config" : "cli",
+        }),
+        compactParameter({
+            id: "sandbox_mode",
+            displayName: "Sandbox mode",
+            type: "enum",
+            flag: "-s, --sandbox",
+            values: CODEX_SANDBOX_MODES,
+            defaultValue: config.sandbox_mode,
+            source: config.sandbox_mode ? "config" : "cli",
+        }),
+        compactParameter({
+            id: "web_search",
+            displayName: "Web search",
+            type: "boolean",
+            flag: "--search",
+            defaultValue: parseTomlBool(config.web_search),
+            source: config.web_search ? "config" : "cli",
+        }),
+    ];
+}
+function discoverDeepseekCatalog(command) {
+    return {
+        models: discoverDeepseekModels(command),
+        parameters: discoverDeepseekParameters(),
+    };
+}
+export function discoverDeepseekModels(command) {
+    const raw = runCommand([command ?? "deepseek"], ["model", "list"]);
+    if (!raw)
+        return undefined;
+    return parseDeepseekModelList(raw);
+}
+export function parseDeepseekModelList(raw) {
+    const out = [];
+    for (const line of raw.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        const match = trimmed.match(/^(.+?)\s+\(([^()]+)\)$/);
+        const id = match ? match[1].trim() : trimmed;
+        const provider = match ? match[2].trim() : "deepseek";
+        if (!id)
+            continue;
+        out.push({ id, displayName: id, provider, source: "cli" });
+    }
+    return out.length ? out : undefined;
+}
+function discoverDeepseekParameters() {
+    const config = readConfigScalars(path.join(homedir(), ".deepseek", "config.toml"));
+    return [
+        compactParameter({
+            id: "model",
+            displayName: "Default model",
+            type: "string",
+            flag: "--model",
+            defaultValue: config.default_text_model,
+            source: config.default_text_model ? "config" : "cli",
+        }),
+        compactParameter({
+            id: "provider",
+            displayName: "Provider",
+            type: "enum",
+            flag: "--provider",
+            values: DEEPSEEK_PROVIDER_VALUES,
+            defaultValue: config.provider,
+            source: config.provider ? "config" : "cli",
+        }),
+        compactParameter({
+            id: "reasoning_effort",
+            displayName: "Reasoning effort",
+            type: "string",
+            flag: "reasoning_effort",
+            defaultValue: config.reasoning_effort,
+            source: config.reasoning_effort ? "config" : "cli",
+        }),
+        compactParameter({
+            id: "approval_policy",
+            displayName: "Approval policy",
+            type: "string",
+            flag: "--approval-policy",
+            defaultValue: config.approval_policy,
+            source: config.approval_policy ? "config" : "cli",
+        }),
+        compactParameter({
+            id: "sandbox_mode",
+            displayName: "Sandbox mode",
+            type: "string",
+            flag: "--sandbox-mode",
+            defaultValue: config.sandbox_mode,
+            source: config.sandbox_mode ? "config" : "cli",
+        }),
+    ];
+}
+function discoverKimiCatalog() {
+    const configPath = path.join(homedir(), ".kimi", "config.toml");
+    if (!existsSync(configPath))
+        return {};
+    const raw = readFileSync(configPath, "utf8");
+    return {
+        models: parseKimiConfigModels(raw),
+        parameters: parseKimiRuntimeParameters(raw),
+    };
+}
+export function discoverKimiModels() {
+    return discoverKimiCatalog().models;
+}
+export function parseKimiConfigModels(raw) {
+    const defaultModel = matchScalar(raw, /^default_model\s*=\s*["']([^"']+)["']/m);
+    const out = [];
+    const sectionRe = /^\[models\."([^"]+)"\]\s*$/gm;
+    const matches = Array.from(raw.matchAll(sectionRe));
+    for (let i = 0; i < matches.length; i += 1) {
+        const match = matches[i];
+        const id = match[1];
+        const start = (match.index ?? 0) + match[0].length;
+        const end = i + 1 < matches.length ? matches[i + 1].index ?? raw.length : raw.length;
+        const body = raw.slice(start, end);
+        const model = {
+            id,
+            source: "config",
+            isDefault: id === defaultModel,
+        };
+        const provider = matchScalar(body, /^\s*provider\s*=\s*["']([^"']+)["']/m);
+        if (provider)
+            model.provider = provider;
+        const displayName = matchScalar(body, /^\s*display_name\s*=\s*["']([^"']+)["']/m);
+        if (displayName)
+            model.displayName = displayName;
+        const contextLength = matchScalar(body, /^\s*max_context_size\s*=\s*(\d+)/m);
+        if (contextLength)
+            model.contextLength = Number(contextLength);
+        const capabilities = matchArray(body, /^\s*capabilities\s*=\s*\[([^\]]*)\]/m);
+        if (capabilities.length)
+            model.capabilities = capabilities;
+        if (capabilities.includes("thinking")) {
+            const defaultThinking = parseTomlBool(matchScalar(raw, /^default_thinking\s*=\s*(true|false)/m));
+            model.parameters = [
+                compactParameter({
+                    id: "thinking",
+                    displayName: "Thinking",
+                    type: "boolean",
+                    flag: "--thinking/--no-thinking",
+                    defaultValue: defaultThinking,
+                    source: defaultThinking === undefined ? "cli" : "config",
+                }),
+            ];
+        }
+        const runtimeModel = matchScalar(body, /^\s*model\s*=\s*["']([^"']+)["']/m);
+        if (runtimeModel)
+            model.metadata = { model: runtimeModel };
+        out.push(model);
+    }
+    return out.length ? out : undefined;
+}
+export function parseKimiRuntimeParameters(raw) {
+    return [
+        compactParameter({
+            id: "model",
+            displayName: "Default model",
+            type: "string",
+            flag: "-m, --model",
+            defaultValue: matchScalar(raw, /^default_model\s*=\s*["']([^"']+)["']/m),
+            source: "config",
+        }),
+        compactParameter({
+            id: "thinking",
+            displayName: "Thinking",
+            type: "boolean",
+            flag: "--thinking/--no-thinking",
+            defaultValue: parseTomlBool(matchScalar(raw, /^default_thinking\s*=\s*(true|false)/m)),
+            source: "config",
+        }),
+        compactParameter({
+            id: "show_thinking_stream",
+            displayName: "Show thinking stream",
+            type: "boolean",
+            defaultValue: parseTomlBool(matchScalar(raw, /^show_thinking_stream\s*=\s*(true|false)/m)),
+            source: "config",
+        }),
+        compactParameter({
+            id: "yolo",
+            displayName: "Auto approve",
+            type: "boolean",
+            flag: "--yolo, --yes, -y",
+            defaultValue: parseTomlBool(matchScalar(raw, /^default_yolo\s*=\s*(true|false)/m)),
+            source: "config",
+        }),
+        compactParameter({
+            id: "plan_mode",
+            displayName: "Plan mode",
+            type: "boolean",
+            flag: "--plan",
+            defaultValue: parseTomlBool(matchScalar(raw, /^default_plan_mode\s*=\s*(true|false)/m)),
+            source: "config",
+        }),
+        compactParameter({
+            id: "max_steps_per_turn",
+            displayName: "Max steps per turn",
+            type: "integer",
+            flag: "--max-steps-per-turn",
+            defaultValue: parseTomlInt(matchScalar(raw, /^max_steps_per_turn\s*=\s*(\d+)/m)),
+            minimum: 1,
+            source: "config",
+        }),
+        compactParameter({
+            id: "max_retries_per_step",
+            displayName: "Max retries per step",
+            type: "integer",
+            flag: "--max-retries-per-step",
+            defaultValue: parseTomlInt(matchScalar(raw, /^max_retries_per_step\s*=\s*(\d+)/m)),
+            minimum: 1,
+            source: "config",
+        }),
+        compactParameter({
+            id: "max_ralph_iterations",
+            displayName: "Max Ralph iterations",
+            type: "integer",
+            flag: "--max-ralph-iterations",
+            defaultValue: parseTomlInt(matchScalar(raw, /^max_ralph_iterations\s*=\s*(-?\d+)/m)),
+            minimum: -1,
+            source: "config",
+        }),
+        compactParameter({
+            id: "reserved_context_size",
+            displayName: "Reserved context size",
+            type: "integer",
+            defaultValue: parseTomlInt(matchScalar(raw, /^reserved_context_size\s*=\s*(\d+)/m)),
+            minimum: 0,
+            source: "config",
+        }),
+    ];
+}
+function runtimeCatalogContextKey(entry, extra) {
+    return JSON.stringify({
+        runtime: entry.id,
+        path: entry.result.path ?? null,
+        version: entry.result.version ?? null,
+        home: homedir(),
+        ...extra,
+    });
+}
+function runtimeCatalogCacheDir() {
+    const explicit = process.env.BOTCORD_RUNTIME_CATALOG_CACHE_DIR;
+    if (explicit && explicit.length > 0)
+        return expandLeadingTilde(explicit);
+    // Keep unit tests from writing to a developer's real ~/.botcord unless a
+    // test opts into a temp cache directory explicitly.
+    if (process.env.NODE_ENV === "test")
+        return null;
+    if (process.env.BOTCORD_RUNTIME_CATALOG_CACHE === "0")
+        return null;
+    return DEFAULT_RUNTIME_CATALOG_CACHE_DIR;
+}
+function runtimeCatalogCachePath(runtimeId) {
+    const dir = runtimeCatalogCacheDir();
+    if (!dir)
+        return null;
+    const safe = runtimeId.replace(/[^A-Za-z0-9_.-]+/g, "_");
+    return path.join(dir, `${safe}.json`);
+}
+function readRuntimeCatalogCache(runtimeId, contextKey) {
+    const file = runtimeCatalogCachePath(runtimeId);
+    if (!file)
+        return null;
+    try {
+        const parsed = JSON.parse(readFileSync(file, "utf8"));
+        if (!parsed || typeof parsed !== "object")
+            return null;
+        if (parsed.version !== RUNTIME_CATALOG_CACHE_VERSION)
+            return null;
+        if (parsed.runtimeId !== runtimeId || parsed.contextKey !== contextKey)
+            return null;
+        if (typeof parsed.updatedAt !== "number" || parsed.updatedAt <= 0)
+            return null;
+        const catalog = normalizeCachedCatalog(parsed.catalog);
+        if (!catalog)
+            return null;
+        return { updatedAt: parsed.updatedAt, catalog };
+    }
+    catch {
+        return null;
+    }
+}
+function writeRuntimeCatalogCache(runtimeId, contextKey, catalog) {
+    if (!hasCatalogData(catalog))
+        return;
+    const file = runtimeCatalogCachePath(runtimeId);
+    if (!file)
+        return;
+    try {
+        mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+        const tmp = `${file}.${process.pid}.tmp`;
+        const payload = {
+            version: RUNTIME_CATALOG_CACHE_VERSION,
+            runtimeId,
+            contextKey,
+            updatedAt: Date.now(),
+            catalog,
+        };
+        writeFileSync(tmp, JSON.stringify(payload, null, 2), { mode: 0o600 });
+        renameSync(tmp, file);
+    }
+    catch {
+        // Cache writes must never affect runtime discovery.
+    }
+}
+function scheduleRuntimeCatalogRefresh(strategy) {
+    if (process.env.NODE_ENV === "test")
+        return;
+    if (process.env.BOTCORD_RUNTIME_CATALOG_BACKGROUND_REFRESH === "0")
+        return;
+    const cacheKey = `${strategy.id}:${strategy.contextKey}`;
+    if (backgroundRefreshes.has(cacheKey))
+        return;
+    backgroundRefreshes.add(cacheKey);
+    const timer = setTimeout(() => {
+        try {
+            const fresh = completeCatalogWithFallback(strategy.discoverFresh(), strategy);
+            if (hasCatalogData(fresh)) {
+                writeRuntimeCatalogCache(strategy.id, strategy.contextKey, fresh);
+            }
+        }
+        catch {
+            // Keep serving the previous cache entry.
+        }
+        finally {
+            backgroundRefreshes.delete(cacheKey);
+        }
+    }, 0);
+    timer.unref?.();
+}
+function normalizeCachedCatalog(raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        return null;
+    const obj = raw;
+    const models = normalizeCachedModels(obj.models);
+    const parameters = normalizeCachedParameters(obj.parameters);
+    const out = {};
+    if (models?.length)
+        out.models = models;
+    if (parameters?.length)
+        out.parameters = parameters;
+    return hasCatalogData(out) ? out : null;
+}
+function normalizeCachedModels(raw) {
+    if (!Array.isArray(raw))
+        return undefined;
+    const models = raw
+        .map((item) => {
+        if (!item || typeof item !== "object" || Array.isArray(item))
+            return null;
+        const obj = item;
+        const id = stringField(obj, "id");
+        if (!id)
+            return null;
+        const model = { id };
+        const displayName = stringField(obj, "displayName");
+        if (displayName)
+            model.displayName = displayName;
+        const provider = stringField(obj, "provider");
+        if (provider)
+            model.provider = provider;
+        const source = stringField(obj, "source");
+        if (isRuntimeCatalogSource(source))
+            model.source = source;
+        if (obj.isDefault === true)
+            model.isDefault = true;
+        const capabilities = arrayField(obj, "capabilities").filter((cap) => typeof cap === "string" && cap.length > 0);
+        if (capabilities.length)
+            model.capabilities = capabilities;
+        if (typeof obj.contextLength === "number")
+            model.contextLength = obj.contextLength;
+        if (obj.metadata && typeof obj.metadata === "object" && !Array.isArray(obj.metadata)) {
+            model.metadata = obj.metadata;
+        }
+        const parameters = normalizeCachedParameters(obj.parameters);
+        if (parameters?.length)
+            model.parameters = parameters;
+        return model;
+    })
+        .filter((model) => !!model);
+    return models.length ? models : undefined;
+}
+function normalizeCachedParameters(raw) {
+    if (!Array.isArray(raw))
+        return undefined;
+    const parameters = raw
+        .map((item) => {
+        if (!item || typeof item !== "object" || Array.isArray(item))
+            return null;
+        const obj = item;
+        const id = stringField(obj, "id");
+        const type = stringField(obj, "type");
+        if (!id || !isRuntimeParameterType(type))
+            return null;
+        const param = { id, type };
+        const displayName = stringField(obj, "displayName");
+        if (displayName)
+            param.displayName = displayName;
+        const flag = stringField(obj, "flag");
+        if (flag)
+            param.flag = flag;
+        const values = arrayField(obj, "values").filter(isRuntimeParameterValue);
+        if (values.length)
+            param.values = values;
+        if (isRuntimeParameterValue(obj.defaultValue))
+            param.defaultValue = obj.defaultValue;
+        if (typeof obj.minimum === "number")
+            param.minimum = obj.minimum;
+        if (typeof obj.maximum === "number")
+            param.maximum = obj.maximum;
+        const source = stringField(obj, "source");
+        if (isRuntimeCatalogSource(source))
+            param.source = source;
+        if (obj.metadata && typeof obj.metadata === "object" && !Array.isArray(obj.metadata)) {
+            param.metadata = obj.metadata;
+        }
+        return param;
+    })
+        .filter((param) => !!param);
+    return parameters.length ? parameters : undefined;
+}
+function isRuntimeCatalogSource(value) {
+    return (value === "builtin" ||
+        value === "config" ||
+        value === "cli" ||
+        value === "api" ||
+        value === "gateway" ||
+        value === "env");
+}
+function isRuntimeParameterType(value) {
+    return value === "enum" || value === "boolean" || value === "integer" || value === "string";
+}
+function isRuntimeParameterValue(value) {
+    return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function hasCatalogData(catalog) {
+    return !!(catalog.models?.length || catalog.parameters?.length);
+}
+function fileStatKey(file) {
+    try {
+        const st = statSync(file);
+        return `${st.mtimeMs}:${st.size}`;
+    }
+    catch {
+        return null;
+    }
+}
+function pickEnv(names) {
+    const out = {};
+    for (const name of names) {
+        const value = process.env[name];
+        if (value)
+            out[name] = value;
+    }
+    return out;
+}
+function codexHomeDir() {
+    return process.env.CODEX_HOME ? expandLeadingTilde(process.env.CODEX_HOME) : path.join(homedir(), ".codex");
+}
+function codexModelCachePath() {
+    return path.join(codexHomeDir(), "models_cache.json");
+}
+function readCodexModelCacheRaw() {
+    try {
+        return readFileSync(codexModelCachePath(), "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+function expandLeadingTilde(value) {
+    if (value === "~")
+        return homedir();
+    if (value.startsWith("~/"))
+        return path.join(homedir(), value.slice(2));
+    return value;
+}
+function codexCommand(command) {
+    if (command?.endsWith(".js"))
+        return [process.execPath, command];
+    return [command ?? "codex"];
+}
+function runCommand(command, args) {
+    try {
+        return execFileSync(command[0], [...command.slice(1), ...args], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: MODEL_LIST_TIMEOUT_MS,
+            maxBuffer: MODEL_LIST_MAX_BUFFER,
+            env: { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1" },
+        });
+    }
+    catch {
+        return null;
+    }
+}
+function readJsonObject(file) {
+    try {
+        const parsed = JSON.parse(readFileSync(file, "utf8"));
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function readConfigScalars(file) {
+    try {
+        const raw = readFileSync(file, "utf8");
+        const out = {};
+        for (const match of raw.matchAll(/^([A-Za-z0-9_.-]+)\s*=\s*(.+?)\s*$/gm)) {
+            const key = match[1];
+            const rawValue = match[2]?.trim();
+            if (!key || !rawValue)
+                continue;
+            out[key] = rawValue.replace(/^["']|["']$/g, "");
+        }
+        return out;
+    }
+    catch {
+        return {};
+    }
+}
+function compactParameter(param) {
+    const out = {
+        id: param.id,
+        type: param.type,
+    };
+    if (param.displayName)
+        out.displayName = param.displayName;
+    if (param.flag)
+        out.flag = param.flag;
+    if (param.values?.length)
+        out.values = param.values;
+    if (param.defaultValue !== undefined)
+        out.defaultValue = param.defaultValue;
+    if (param.minimum !== undefined)
+        out.minimum = param.minimum;
+    if (param.maximum !== undefined)
+        out.maximum = param.maximum;
+    if (param.source)
+        out.source = param.source;
+    if (param.metadata && Object.keys(param.metadata).length > 0)
+        out.metadata = param.metadata;
+    return out;
+}
+function parseTomlBool(value) {
+    if (value === "true")
+        return true;
+    if (value === "false")
+        return false;
+    return undefined;
+}
+function parseTomlInt(value) {
+    if (value === undefined)
+        return undefined;
+    const n = Number(value);
+    return Number.isInteger(n) ? n : undefined;
+}
+function stringField(obj, key) {
+    const value = obj?.[key];
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function arrayField(obj, key) {
+    const value = obj?.[key];
+    return Array.isArray(value) ? value : [];
+}
+function matchScalar(raw, re) {
+    const match = raw.match(re);
+    return match?.[1]?.trim() || undefined;
+}
+function matchArray(raw, re) {
+    const match = raw.match(re);
+    if (!match?.[1])
+        return [];
+    return match[1]
+        .split(",")
+        .map((part) => part.trim().replace(/^["']|["']$/g, ""))
+        .filter(Boolean);
+}