@mono-agent/agent-app 0.20.10 → 0.20.14

package/dist/wizard/model-discovery.js

@@ -1,13 +1,10 @@
-import { chmod, mkdir, mkdtemp, open, rm } from "node:fs/promises";
-import { homedir, tmpdir } from "node:os";
+import { homedir } from "node:os";
 import { join } from "node:path";
 import { getSupportedThinkingLevels } from "@earendil-works/pi-ai";
 import { builtinModels } from "@earendil-works/pi-ai/providers/all";
-import { discoverClaudeSdkModels } from "@mono-agent/runtime-adapter";
-import { codexModelDiscoveryEnvironment, normalizeEfforts, requestCodexModelList, } from "../codex-model-catalog.js";
+import { EFFORT_LEVELS } from "@mono-agent/config";
 import { inspectPiAuthStore as inspectDefaultPiAuthStore, } from "../pi-auth-store-inspection.js";
-import { credentialNeutralProviderStatusEnvironment, hasDurableProviderEnvironmentCredential, runBoundedProviderCommand, } from "../provider-setup.js";
-export { codexModelDiscoveryEnvironment, };
+import { runBoundedProviderCommand } from "../provider-setup.js";
 /** Cloud Pi providers that guided onboarding can authenticate and prove end to end. */
 export const GUIDED_PI_PROVIDER_IDS = [
     "anthropic",
@@ -17,6 +14,18 @@ export const GUIDED_PI_PROVIDER_IDS = [
 ];
 const GUIDED_PI_PROVIDERS = new Set(GUIDED_PI_PROVIDER_IDS);
 const GUIDED_LOCAL_PI_PROVIDERS = new Set(["ollama", "lmstudio"]);
+const PI_API_KEY_ENV_BY_PROVIDER = {
+    "opencode-go": "OPENCODE_API_KEY",
+};
+/** Whether a selected Pi route has an API key in the destination agent environment. */
+export function hasDurablePiEnvironmentCredential(rawModelRef, persistedEnv) {
+    const separator = rawModelRef.indexOf(":");
+    if (separator <= 0)
+        return false;
+    const provider = rawModelRef.slice(0, separator);
+    const apiKeyEnv = PI_API_KEY_ENV_BY_PROVIDER[provider];
+    return apiKeyEnv !== undefined && (persistedEnv[apiKeyEnv]?.trim().length ?? 0) > 0;
+}
 /** Reject known unsupported remote Pi integrations while leaving custom local ids available. */
 export function guidedPiProviderProblem(provider) {
     if (GUIDED_PI_PROVIDERS.has(provider) || GUIDED_LOCAL_PI_PROVIDERS.has(provider)) {
@@ -42,52 +51,49 @@ function providerDiscoveryCommand(opts) {
     });
 }
 const DEFAULT_DISCOVERY_TIMEOUT_MS = 1200;
-const DEFAULT_OPENCODE_DISCOVERY_TIMEOUT_MS = 5000;
-const PI_OPENAI_CODEX_PROVIDER = "openai-codex";
-const OPENAI_CODEX_MODELS = [
-    { id: "gpt-5.6-terra", name: "GPT-5.6 Terra", minimumCodexCliVersion: [0, 144, 0] },
-    { id: "gpt-5.6-sol", name: "GPT-5.6 Sol", minimumCodexCliVersion: [0, 144, 0] },
-];
+const KNOWN_EFFORTS = new Set(EFFORT_LEVELS);
+function normalizeEfforts(values) {
+    return [...new Set(values
+            .map((value) => value === "off" ? "none" : value)
+            .filter((value) => typeof value === "string" && KNOWN_EFFORTS.has(value)))];
+}
 export const STATIC_MODEL_CANDIDATES = [
-    ...OPENAI_CODEX_MODELS.map(staticDirectCodexCandidate),
-    ...[
-        ["claude-sonnet-5", "Claude Sonnet 5", ["low", "medium", "high", "xhigh", "max"]],
-        ["claude-opus-4-8[1m]", "Claude Opus 4.8 (1M context)", ["low", "medium", "high", "xhigh", "max"]],
-        ["claude-haiku-4-5-20251001", "Claude Haiku 4.5", []],
-    ].map(([model, label, efforts]) => ({
-        value: `claude:${model}`,
-        label: label,
-        hint: "SDK-versioned cached catalog; sign-in required",
-        source: "claude",
+    {
+        value: "openai-codex:gpt-5.6-terra",
+        label: "Pi OpenAI Codex · GPT-5.6 Terra",
+        hint: "OAuth setup available",
+        source: "pi",
+        availability: "catalog_available",
+        authState: "auth_required",
+        setupRequired: true,
+        supportedEfforts: [],
+        providerDefault: true,
+    },
+    {
+        value: "openai-codex:gpt-5.6-sol",
+        label: "Pi OpenAI Codex · GPT-5.6 Sol",
+        hint: "OAuth setup available",
+        source: "pi",
         availability: "catalog_available",
         authState: "auth_required",
-        supportedEfforts: efforts,
         setupRequired: true,
-    })),
+        supportedEfforts: [],
+    },
 ];
 export async function discoverWizardModelCandidates(opts = {}) {
     const timeoutMs = opts.timeoutMs ?? DEFAULT_DISCOVERY_TIMEOUT_MS;
-    const [codex, pi, claude, opencode, ollama, lmstudio] = await Promise.all([
-        discoverDirectCodex({ ...opts, timeoutMs }),
+    const [pi, ollama, lmstudio] = await Promise.all([
         discoverPiModels({ ...opts, timeoutMs }),
-        discoverClaudeModels({ ...opts, timeoutMs }),
-        discoverOpenCodeModels({
-            ...opts,
-            timeoutMs: opts.timeoutMs ?? DEFAULT_OPENCODE_DISCOVERY_TIMEOUT_MS,
-        }),
         discoverOllamaModels({ ...opts, timeoutMs }),
         discoverLmStudioModels({ ...opts, timeoutMs }),
     ]);
     return {
         candidates: rankWizardModelCandidates([
-            ...codex.candidates,
             ...pi.candidates,
-            ...claude.candidates,
-            ...opencode.candidates,
             ...ollama.candidates,
             ...lmstudio.candidates,
         ]),
-        statuses: [codex.status, pi.status, claude.status, opencode.status, ollama.status, lmstudio.status],
+        statuses: [pi.status, ollama.status, lmstudio.status],
     };
 }
 export function rankWizardModelCandidates(candidates) {
@@ -108,88 +114,16 @@ export function defaultEffortForModelRef(modelRef, reasoning) {
     if (reasoning === false) {
         return "none";
     }
-    if (!modelRef.startsWith("pi:")) {
+    const separator = modelRef.indexOf(":");
+    if (separator <= 0 || separator === modelRef.length - 1)
         return undefined;
-    }
-    const [, provider, ...modelParts] = modelRef.split(":");
-    const model = modelParts.join(":");
+    const provider = modelRef.slice(0, separator);
+    const model = modelRef.slice(separator + 1);
     if (provider === "opencode-go" || provider === "ollama" || provider === "lmstudio") {
         return localModelDefaultEffort(model);
     }
     return undefined;
 }
-/** Detect the direct Codex CLI and its account catalog without claiming readiness. */
-async function discoverDirectCodex(opts) {
-    const run = providerDiscoveryCommand(opts);
-    const verified = new Set(opts.verifiedModelRefs ?? []);
-    let version = "";
-    try {
-        const result = await run("codex", ["--version"], { timeout: opts.timeoutMs });
-        version = firstOutputLine(result.stdout);
-    }
-    catch {
-        return {
-            candidates: directCodexCandidates(curatedCodexCatalog(), "install-required", "", verified),
-            status: {
-                provider: "Codex",
-                status: "setup_available",
-                detail: "CLI not found; install Codex and sign in before the readiness check",
-            },
-        };
-    }
-    let catalog = curatedCodexCatalog();
-    try {
-        // Injected command runners are normally deterministic unit-test seams; do
-        // not escape them by starting a real app-server unless a model-list seam
-        // was also supplied.
-        const discoveredCatalog = opts.codexModelList !== undefined
-            ? [...await opts.codexModelList()]
-            : opts.execFile === undefined
-                ? await requestCodexModelList(opts.timeoutMs, codexModelDiscoveryEnvironment(opts.persistedEnv), opts.abortSignal)
-                : catalog;
-        if (discoveredCatalog.length > 0)
-            catalog = discoveredCatalog;
-    }
-    catch {
-        // The exact curated Sol/Terra fallback remains selectable offline.
-    }
-    const durableCredential = hasDurableProviderEnvironmentCredential("codex:gpt-5.6-terra", opts.persistedEnv ?? {});
-    const shellOnlyCredential = !durableCredential
-        && hasDurableProviderEnvironmentCredential("codex:gpt-5.6-terra", process.env);
-    try {
-        if (!durableCredential) {
-            await run("codex", ["login", "status"], {
-                timeout: opts.timeoutMs,
-                env: credentialNeutralProviderStatusEnvironment(process.env, opts.persistedEnv),
-            });
-        }
-        const candidates = directCodexCandidates(catalog, "credential-detected", version, verified);
-        const setupModels = candidates.filter((candidate) => candidate.setupRequired === true);
-        const setupDetails = [...new Set(setupModels.map((candidate) => candidate.hint ?? `${candidate.label} setup required`))];
-        return {
-            candidates,
-            status: {
-                provider: "Codex",
-                status: setupModels.length === 0 ? "detected" : "setup_available",
-                detail: `${version.length > 0 ? `${version}; ` : ""}${durableCredential ? "durable OPENAI_API_KEY detected" : "sign-in detected"} (live readiness not yet verified)${setupModels.length === 0
-                    ? ""
-                    : `; ${setupDetails.join("; ")}`}`,
-            },
-        };
-    }
-    catch {
-        return {
-            candidates: directCodexCandidates(catalog, "login-required", version, verified),
-            status: {
-                provider: "Codex",
-                status: "setup_available",
-                detail: `${version.length > 0 ? `${version}; ` : "CLI installed; "}${shellOnlyCredential
-                    ? "durable sign-in required; shell-only OPENAI_API_KEY ignored"
-                    : "sign-in required"}`,
-            },
-        };
-    }
-}
 async function discoverPiModels(opts) {
     const inspectAuthStore = opts.inspectPiAuthStore ?? inspectDefaultPiAuthStore;
     const authPath = opts.piAuthPath ?? join(homedir(), ".pi", "agent", "auth.json");
@@ -226,7 +160,7 @@ async function discoverPiModels(opts) {
     }
     const preEnvironmentStatus = status;
     for (const provider of GUIDED_PI_PROVIDER_IDS) {
-        if (hasDurableProviderEnvironmentCredential(`pi:${provider}:credential-check`, opts.persistedEnv ?? {})) {
+        if (hasDurablePiEnvironmentCredential(`${provider}:credential-check`, opts.persistedEnv ?? {})) {
             credentialProviders.add(provider);
         }
     }
@@ -238,7 +172,7 @@ async function discoverPiModels(opts) {
         };
     }
     else if (credentialProviders.size === 0
-        && hasDurableProviderEnvironmentCredential("pi:opencode-go:credential-check", process.env)) {
+        && hasDurablePiEnvironmentCredential("opencode-go:credential-check", process.env)) {
         status = {
             provider: "Pi",
             status: "setup_available",
@@ -254,7 +188,7 @@ async function discoverPiModels(opts) {
     const candidates = models.getModels()
         .filter((model) => GUIDED_PI_PROVIDERS.has(model.provider))
         .map((model) => {
-        const value = `pi:${model.provider}:${model.id}`;
+        const value = `${model.provider}:${model.id}`;
         const supportedEfforts = normalizeEfforts(getSupportedThinkingLevels(model));
         const authState = verified.has(value)
             ? "verified"
@@ -263,7 +197,7 @@ async function discoverPiModels(opts) {
                 : "auth_required";
         const defaultEffort = exactDefaultEffortWhenUnambiguous(supportedEfforts);
         const shellOnlyCredential = authState === "auth_required"
-            && hasDurableProviderEnvironmentCredential(value, process.env);
+            && hasDurablePiEnvironmentCredential(value, process.env);
         const providerLabel = model.provider === "opencode-go"
             ? "OpenCode-Go"
             : providerNames.get(model.provider) ?? model.provider;
@@ -309,174 +243,6 @@ function isCredentialString(value) {
         && value.length <= 65_536
         && !value.includes("\0");
 }
-async function discoverClaudeModels(opts) {
-    const run = providerDiscoveryCommand(opts);
-    const verified = new Set(opts.verifiedModelRefs ?? []);
-    let credentialDetected = hasDurableProviderEnvironmentCredential("claude:claude-sonnet-5", opts.persistedEnv ?? {});
-    const durableCredential = credentialDetected;
-    const shellOnlyCredential = !durableCredential
-        && hasDurableProviderEnvironmentCredential("claude:claude-sonnet-5", process.env);
-    if (!credentialDetected) {
-        try {
-            await run("claude", ["auth", "status", "--json"], {
-                timeout: opts.timeoutMs,
-                env: credentialNeutralProviderStatusEnvironment(process.env, opts.persistedEnv),
-            });
-            credentialDetected = true;
-        }
-        catch {
-            // Catalog discovery is deliberately independent from account state.
-        }
-    }
-    let catalog = [];
-    try {
-        catalog = opts.claudeModelList !== undefined
-            ? await opts.claudeModelList()
-            : opts.execFile === undefined
-                ? await discoverClaudeSdkModels({ timeoutMs: Math.max(opts.timeoutMs, 2_000) })
-                : await discoverClaudeSdkModels({ timeoutMs: 1 });
-    }
-    catch {
-        // Static SDK-versioned rows remain available through STATIC_MODEL_CANDIDATES.
-    }
-    const candidates = catalog.map((model) => {
-        const value = model.reference;
-        const authState = verified.has(value)
-            ? "verified"
-            : credentialDetected
-                ? "credential_detected"
-                : "auth_required";
-        const supportedEfforts = normalizeEfforts(model.supportedEfforts);
-        return {
-            value,
-            label: model.displayName,
-            hint: `${model.source === "discovered" ? "discovered from Claude SDK" : "SDK-versioned cached catalog"}; ${authState === "verified" ? "verified" : authState === "credential_detected" ? "credential detected; live readiness pending" : "sign-in required"}`,
-            source: "claude",
-            availability: "catalog_available",
-            authState,
-            supportedEfforts,
-            ...(authState === "verified" ? { discovered: true } : {}),
-            ...(authState === "auth_required" ? { setupRequired: true } : {}),
-        };
-    });
-    return {
-        candidates,
-        status: credentialDetected
-            ? {
-                provider: "Claude",
-                status: "detected",
-                detail: `${durableCredential ? "durable provider credential" : "sign-in"} detected (live readiness not yet verified)`,
-            }
-            : {
-                provider: "Claude",
-                status: "setup_available",
-                detail: `${shellOnlyCredential
-                    ? "durable sign-in required; shell-only Claude credential ignored"
-                    : "sign-in required"}; catalog remains available`,
-            },
-    };
-}
-async function discoverOpenCodeModels(opts) {
-    const run = providerDiscoveryCommand(opts);
-    let isolation;
-    try {
-        isolation = await createOpenCodeDiscoveryIsolation();
-        const { stdout } = await run("opencode", ["models", "opencode-go", "--pure"], {
-            timeout: opts.timeoutMs,
-            env: isolation.env,
-        });
-        const bundledModelIds = new Set(builtinModels().getModels()
-            .filter((model) => model.provider === "opencode-go")
-            .map((model) => model.id));
-        const parsedModels = parseOpenCodeGoModels(stdout);
-        const models = parsedModels.filter((model) => bundledModelIds.has(model));
-        const unsupportedCount = parsedModels.length - models.length;
-        return {
-            candidates: models.map((model) => {
-                const value = `pi:opencode-go:${model}`;
-                return {
-                    value,
-                    label: `OpenCode-Go ${displayModelName(model)}`,
-                    hint: "discovered from opencode; OpenCode-Go API key required",
-                    source: "opencode",
-                    discovered: true,
-                    availability: "catalog_available",
-                    authState: "auth_required",
-                    setupRequired: true,
-                    supportedEfforts: [],
-                };
-            }),
-            status: models.length > 0
-                ? {
-                    provider: "OpenCode-Go",
-                    status: "detected",
-                    detail: `${models.length} runtime-supported model${models.length === 1 ? "" : "s"} found${unsupportedCount === 0
-                        ? ""
-                        : `; ${unsupportedCount} unsupported CLI row${unsupportedCount === 1 ? "" : "s"} ignored`}`,
-                }
-                : parsedModels.length > 0
-                    ? {
-                        provider: "OpenCode-Go",
-                        status: "unavailable",
-                        detail: `no runtime-supported models; ${parsedModels.length} unsupported CLI row${parsedModels.length === 1 ? "" : "s"} ignored`,
-                    }
-                    : { provider: "OpenCode-Go", status: "unavailable", detail: "no models returned" },
-        };
-    }
-    catch {
-        return { candidates: [], status: { provider: "OpenCode-Go", status: "unavailable", detail: "`opencode models opencode-go --pure` unavailable" } };
-    }
-    finally {
-        await isolation?.cleanup();
-    }
-}
-async function createOpenCodeDiscoveryIsolation() {
-    const root = await mkdtemp(join(tmpdir(), "mono-agent-opencode-discovery-"));
-    try {
-        await chmod(root, 0o700);
-        const home = await createPrivateDirectory(root, "home");
-        const config = await createPrivateDirectory(root, "config");
-        const opencodeConfig = await createPrivateDirectory(config, "opencode");
-        if (process.platform !== "win32")
-            await chmod(opencodeConfig, 0o500);
-        const data = await createPrivateDirectory(root, "data");
-        const state = await createPrivateDirectory(root, "state");
-        const cache = await createPrivateDirectory(root, "cache");
-        const opencodeData = await createPrivateDirectory(data, "opencode");
-        const database = join(opencodeData, "opencode.db");
-        const handle = await open(database, "wx", 0o600);
-        await handle.close();
-        await chmod(database, 0o600);
-        const env = safeDiscoveryProcessEnv();
-        Object.assign(env, {
-            OPENCODE_TEST_HOME: home,
-            XDG_CONFIG_HOME: config,
-            XDG_CONFIG_DIRS: config,
-            XDG_DATA_HOME: data,
-            XDG_DATA_DIRS: data,
-            XDG_STATE_HOME: state,
-            XDG_CACHE_HOME: cache,
-            OPENCODE_DB: database,
-            OPENCODE_CONFIG_CONTENT: JSON.stringify({ share: "disabled", autoshare: false }),
-            OPENCODE_DISABLE_PROJECT_CONFIG: "true",
-            OPENCODE_DISABLE_AUTOUPDATE: "true",
-            OPENCODE_DISABLE_SHARE: "true",
-            OPENCODE_AUTO_SHARE: "false",
-            OPENCODE_DISABLE_EXTERNAL_SKILLS: "true",
-            OPENCODE_DISABLE_LSP_DOWNLOAD: "true",
-        });
-        return {
-            env,
-            cleanup: async () => {
-                await rm(root, { recursive: true, force: true }).catch(() => undefined);
-            },
-        };
-    }
-    catch (error) {
-        await rm(root, { recursive: true, force: true }).catch(() => undefined);
-        throw error;
-    }
-}
 function safeDiscoveryProcessEnv(source = process.env) {
     const env = {};
     for (const key of [
@@ -499,12 +265,6 @@ function safeDiscoveryProcessEnv(source = process.env) {
     }
     return env;
 }
-async function createPrivateDirectory(parent, name) {
-    const path = join(parent, name);
-    await mkdir(path, { mode: 0o700 });
-    await chmod(path, 0o700);
-    return path;
-}
 async function discoverOllamaModels(opts) {
     const run = providerDiscoveryCommand(opts);
     try {
@@ -512,7 +272,7 @@ async function discoverOllamaModels(opts) {
         const models = parseOllamaList(stdout);
         return {
             candidates: models.map((model) => {
-                const value = `pi:ollama:${model}`;
+                const value = `ollama:${model}`;
                 return {
                     value,
                     label: `Ollama ${model}`,
@@ -548,7 +308,7 @@ async function discoverLmStudioModels(opts) {
         const models = parseOpenAiModelEntriesBody(body);
         return {
             candidates: models.map((model) => {
-                const value = `pi:lmstudio:${model.id}`;
+                const value = `lmstudio:${model.id}`;
                 return {
                     value,
                     label: `LM Studio ${model.id}`,
@@ -582,7 +342,7 @@ function mergeCandidate(left, right) {
         || right.availability !== undefined
         || right.authState !== undefined;
     const preserveBuiltinPiMetadata = left.source === "pi"
-        && (right.source === "opencode" || right.source === "ollama" || right.source === "lmstudio");
+        && (right.source === "ollama" || right.source === "lmstudio");
     const hint = preserveBuiltinPiMetadata
         ? left.hint
         : rightHasDiscoveryState ? right.hint ?? left.hint : left.hint ?? right.hint;
@@ -626,18 +386,12 @@ function rank(candidate) {
 function modelRank(candidate) {
     if (candidate.providerDefault === true)
         return -100;
-    const directCodexRank = OPENAI_CODEX_MODELS.findIndex((model) => candidate.value === directCodexRef(model));
-    if (directCodexRank >= 0)
-        return directCodexRank;
-    const piOpenAiCodexRank = OPENAI_CODEX_MODELS.findIndex((model) => candidate.value === piOpenAiCodexRef(model));
-    if (piOpenAiCodexRank >= 0)
-        return 10 + piOpenAiCodexRank;
-    if (candidate.source === "claude") {
+    if (candidate.value === "openai-codex:gpt-5.6-terra")
+        return 0;
+    if (candidate.value === "openai-codex:gpt-5.6-sol")
+        return 1;
+    if (candidate.source === "pi")
         return 20;
-    }
-    if (candidate.source === "opencode") {
-        return 30;
-    }
     if (candidate.source === "ollama") {
         return candidate.discovered === true ? 40 : 45;
     }
@@ -646,103 +400,6 @@ function modelRank(candidate) {
     }
     return 90;
 }
-function directCodexRef(model) {
-    return `codex:${model.id}`;
-}
-function piOpenAiCodexRef(model) {
-    return `pi:${PI_OPENAI_CODEX_PROVIDER}:${model.id}`;
-}
-function staticDirectCodexCandidate(model) {
-    return {
-        value: directCodexRef(model),
-        label: `Codex ${model.name}`,
-        ...(model.minimumCodexCliVersion === undefined
-            ? {}
-            : { hint: `requires Codex CLI ${formatVersion(model.minimumCodexCliVersion)}+` }),
-        source: "codex",
-        availability: "catalog_available",
-        authState: "auth_required",
-        // Exact effort support/defaults come from Codex app-server model/list.
-        // Do not fabricate provider metadata when the live catalog is unavailable.
-        supportedEfforts: [],
-        providerDefault: model.id === "gpt-5.6-terra",
-    };
-}
-function directCodexCandidates(catalog, state, version = "", verified = new Set()) {
-    return catalog.map((model) => directCodexCandidate(model, state, version, verified));
-}
-function directCodexCandidate(model, state, version = "", verified = new Set()) {
-    const reference = `codex:${model.id}`;
-    const curated = OPENAI_CODEX_MODELS.find((entry) => entry.id === model.id);
-    const authState = verified.has(reference)
-        ? "verified"
-        : state === "credential-detected"
-            ? "credential_detected"
-            : "auth_required";
-    if (state === "install-required") {
-        const minimum = curated?.minimumCodexCliVersion;
-        return {
-            value: reference,
-            label: `Codex ${model.displayName}`,
-            hint: minimum === undefined
-                ? "install Codex CLI and sign in"
-                : `install Codex CLI ${formatVersion(minimum)}+ and sign in`,
-            source: "codex",
-            setupRequired: true,
-            availability: "catalog_available",
-            authState,
-            supportedEfforts: model.supportedEfforts,
-            ...(model.isDefault === undefined ? {} : { providerDefault: model.isDefault }),
-            ...(model.defaultEffort === undefined ? {} : { defaultEffort: model.defaultEffort }),
-        };
-    }
-    const prerequisites = [];
-    const minimum = curated?.minimumCodexCliVersion;
-    if (minimum !== undefined && !codexVersionMeetsMinimum(version, minimum)) {
-        prerequisites.push(parseCodexVersion(version) === undefined
-            ? `Codex CLI ${formatVersion(minimum)}+ required; installed version could not be verified`
-            : `update Codex CLI to ${formatVersion(minimum)}+ (found ${version})`);
-    }
-    if (state === "login-required")
-        prerequisites.push("Codex sign-in required");
-    if (prerequisites.length === 0) {
-        return {
-            value: reference,
-            label: `Codex ${model.displayName}`,
-            hint: authState === "verified"
-                ? `${version.length > 0 ? `${version}; ` : ""}verified by live readiness`
-                : `${version.length > 0 ? `${version}; ` : ""}sign-in detected; live readiness pending`,
-            source: "codex",
-            discovered: true,
-            availability: "catalog_available",
-            authState,
-            supportedEfforts: model.supportedEfforts,
-            ...(model.isDefault === undefined ? {} : { providerDefault: model.isDefault }),
-            ...(model.defaultEffort === undefined ? {} : { defaultEffort: model.defaultEffort }),
-        };
-    }
-    return {
-        value: reference,
-        label: `Codex ${model.displayName}`,
-        hint: prerequisites.join("; "),
-        source: "codex",
-        setupRequired: true,
-        availability: "catalog_available",
-        authState,
-        supportedEfforts: model.supportedEfforts,
-        ...(model.isDefault === undefined ? {} : { providerDefault: model.isDefault }),
-        ...(model.defaultEffort === undefined ? {} : { defaultEffort: model.defaultEffort }),
-    };
-}
-function curatedCodexCatalog() {
-    return OPENAI_CODEX_MODELS.map((model) => ({
-        id: model.id,
-        displayName: model.name,
-        supportedEfforts: [],
-        // Offline product fallback only; live model/list replaces this flag.
-        isDefault: model.id === "gpt-5.6-terra",
-    }));
-}
 function strongerAuthState(left, right) {
     const order = {
         auth_required: 0,
@@ -759,30 +416,6 @@ function strongerAuthState(left, right) {
 function exactDefaultEffortWhenUnambiguous(supportedEfforts) {
     return supportedEfforts.length === 1 ? supportedEfforts[0] : undefined;
 }
-function parseCodexVersion(version) {
-    const match = /(?:^|\s)v?(\d+)\.(\d+)\.(\d+)(?:[-+\s]|$)/u.exec(version);
-    if (match === null)
-        return undefined;
-    const parts = match.slice(1, 4).map(Number);
-    if (parts.some((part) => !Number.isSafeInteger(part) || part < 0))
-        return undefined;
-    return [parts[0], parts[1], parts[2]];
-}
-function codexVersionMeetsMinimum(version, minimum) {
-    const parsed = parseCodexVersion(version);
-    if (parsed === undefined)
-        return false;
-    for (let index = 0; index < minimum.length; index += 1) {
-        const installedPart = parsed[index] ?? 0;
-        const minimumPart = minimum[index] ?? 0;
-        if (installedPart !== minimumPart)
-            return installedPart > minimumPart;
-    }
-    return true;
-}
-function formatVersion(version) {
-    return version.join(".");
-}
 function parseOllamaList(stdout) {
     const lines = stdout.trim().split(/\r?\n/u).filter(Boolean);
     if (lines.length === 0) {
@@ -793,7 +426,7 @@ function parseOllamaList(stdout) {
         .map((line) => line.trim().split(/\s+/u)[0])
         .filter((name) => name !== undefined && name.length > 0);
 }
-function parseOpenCodeGoModels(stdout) {
+export function parseOpenCodeGoModels(stdout) {
     const prefix = "opencode-go/";
     return stdout
         .split(/\r?\n/u)
@@ -824,9 +457,6 @@ function modelEntryFromUnknown(value) {
         ...(reasoning === undefined ? {} : { reasoning }),
     };
 }
-function displayModelName(model) {
-    return model.startsWith("pi:") ? model.split(":").slice(2).join(":") : model;
-}
 function parseJsonObject(value) {
     const parsed = typeof value === "string" ? JSON.parse(value) : value;
     if (!isRecord(parsed)) {
@@ -834,9 +464,6 @@ function parseJsonObject(value) {
     }
     return parsed;
 }
-function firstOutputLine(value) {
-    return value.split(/\r?\n/u).map((line) => line.trim()).find((line) => line.length > 0)?.slice(0, 120) ?? "";
-}
 function readReasoningCapability(value) {
     for (const field of ["reasoning", "supportsReasoning", "supports_reasoning", "thinking", "supportsThinking", "supports_thinking"]) {
         const result = booleanCapability(value[field]);