@gentbajko/slopify 1.0.1 → 1.1.1

package/dist/adapter-registry.js

@@ -3,6 +3,7 @@ import { googleImage } from "./adapters/image/google.js";
 import { openAiImage } from "./adapters/image/openai.js";
 import { replicateImage } from "./adapters/image/replicate.js";
 import { claudeCodeLlm } from "./adapters/llm/claude-code.js";
+import { nodeClaudeCodeModels } from "./adapters/llm/claude-code-models.js";
 import { codexLlm } from "./adapters/llm/codex.js";
 import { nodeCodexModels } from "./adapters/llm/codex-models.js";
 import { geminiLlm } from "./adapters/llm/gemini.js";
@@ -28,7 +29,13 @@ export function buildRegistry(deps) {
     const llms = new Map([
         ["openrouter", openRouterLlm({ fetch: deps.fetch, key: keyOf("openrouter") })],
         // Each CLI authenticates with its own login.
-        ["claude-code", claudeCodeLlm({ run: cliFor("claude-code") })],
+        [
+            "claude-code",
+            claudeCodeLlm({
+                run: cliFor("claude-code"),
+                readModels: () => nodeClaudeCodeModels(cliBinary(deps.db, "claude-code")),
+            }),
+        ],
         ["codex", codexLlm({ run: cliFor("codex"), readModels: () => nodeCodexModels() })],
         [
             "gemini",

package/dist/adapters/llm/claude-code-models.js

@@ -0,0 +1,200 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+import { cliCommand } from "../../kernel/cli-command.js";
+const maxOutputBytes = 1024 * 1024;
+const modelId = z
+    .string()
+    .trim()
+    .min(1)
+    .max(256)
+    .refine((value) => [...value].every((character) => {
+    const code = character.charCodeAt(0);
+    return code >= 33 && code !== 127;
+}));
+const modelName = z.string().trim().min(1).max(256);
+const responseSchema = z.object({
+    type: z.literal("control_response"),
+    response: z.object({
+        request_id: z.string(),
+        subtype: z.literal("success"),
+        response: z.object({
+            models: z
+                .array(z.object({
+                value: modelId,
+                resolvedModel: modelId.optional(),
+                displayName: modelName,
+                supportedEffortLevels: z.array(z.string()).max(10).optional(),
+            }))
+                .min(1)
+                .max(100),
+        }),
+    }),
+});
+const supportedEfforts = ["low", "medium", "high", "xhigh"];
+function unavailable() {
+    return new Error("Claude Code model discovery is unavailable. Refresh the list or enter an exact model ID.");
+}
+function discoveryEnv() {
+    const names = [
+        "HOME",
+        "USER",
+        "LOGNAME",
+        "USERPROFILE",
+        "APPDATA",
+        "LOCALAPPDATA",
+        "XDG_CONFIG_HOME",
+        "XDG_DATA_HOME",
+        "XDG_CACHE_HOME",
+        "PATH",
+        "PATHEXT",
+        "LANG",
+        "LC_ALL",
+        "LC_CTYPE",
+        "TMPDIR",
+        "TEMP",
+        "TMP",
+        "SystemRoot",
+        "WINDIR",
+    ];
+    const env = {};
+    for (const name of names) {
+        if (process.env[name] !== undefined)
+            env[name] = process.env[name];
+    }
+    return env;
+}
+function choices(event, requestId) {
+    const parsed = responseSchema.safeParse(event);
+    if (!parsed.success || parsed.data.response.request_id !== requestId)
+        throw unavailable();
+    const models = new Map();
+    for (const row of parsed.data.response.response.models) {
+        const modes = row.supportedEffortLevels?.filter((value) => supportedEfforts.includes(value));
+        const thinking = modes?.length ? { thinkingModes: modes } : {};
+        if (!models.has(row.value))
+            models.set(row.value, {
+                id: row.value,
+                name: row.resolvedModel === undefined || row.resolvedModel === row.value
+                    ? row.displayName
+                    : `${row.displayName} → ${row.resolvedModel}`,
+                ...thinking,
+            });
+        // Claude advertises stable aliases and their current concrete targets.
+        // Offer both so the user can choose a moving alias or pin a version.
+        if (row.resolvedModel !== undefined && !models.has(row.resolvedModel))
+            models.set(row.resolvedModel, {
+                id: row.resolvedModel,
+                name: `${row.resolvedModel} (exact model)`,
+                ...thinking,
+            });
+    }
+    return [...models.values()];
+}
+// The installed CLI has no model-list command; initialize is a no-prompt
+// stream-JSON control exchange. Treat protocol drift as unavailable metadata.
+export async function nodeClaudeCodeModels(binary, timeoutMs = 15_000) {
+    const directory = await mkdtemp(join(tmpdir(), "slopify-claude-models-"));
+    const requestId = randomUUID();
+    const command = cliCommand(binary);
+    const child = spawn(command.file, [
+        ...command.args,
+        "-p",
+        "--input-format",
+        "stream-json",
+        "--output-format",
+        "stream-json",
+        "--verbose",
+        "--safe-mode",
+        "--tools",
+        "",
+        "--strict-mcp-config",
+        "--no-session-persistence",
+    ], {
+        cwd: directory,
+        env: discoveryEnv(),
+        stdio: ["pipe", "pipe", "pipe"],
+        windowsHide: true,
+        detached: process.platform !== "win32",
+    });
+    child.on("error", () => { });
+    child.stdin.on("error", () => { });
+    child.stderr.resume();
+    const closed = new Promise((resolve) => child.once("close", () => resolve()));
+    const terminate = (force) => {
+        const signal = force ? "SIGKILL" : "SIGTERM";
+        if (process.platform !== "win32" && child.pid !== undefined) {
+            try {
+                process.kill(-child.pid, signal);
+                return;
+            }
+            catch {
+                // A child that already exited has no process group to signal.
+            }
+        }
+        child.kill(signal);
+    };
+    let forceTimer;
+    const timer = setTimeout(() => {
+        terminate(false);
+        forceTimer = setTimeout(() => terminate(true), 500);
+    }, timeoutMs);
+    try {
+        child.stdin.write(`${JSON.stringify({
+            request_id: requestId,
+            type: "control_request",
+            request: { subtype: "initialize" },
+        })}\n`);
+        let output = "";
+        let bytes = 0;
+        for await (const piece of child.stdout) {
+            bytes += piece.length;
+            if (bytes > maxOutputBytes)
+                throw unavailable();
+            output += piece.toString();
+            let newline = output.indexOf("\n");
+            while (newline >= 0) {
+                const line = output.slice(0, newline).trim();
+                output = output.slice(newline + 1);
+                if (line !== "") {
+                    let event;
+                    try {
+                        event = JSON.parse(line);
+                    }
+                    catch {
+                        throw unavailable();
+                    }
+                    if (typeof event === "object" &&
+                        event !== null &&
+                        "type" in event &&
+                        event.type === "control_response") {
+                        return choices(event, requestId);
+                    }
+                }
+                newline = output.indexOf("\n");
+            }
+        }
+        throw unavailable();
+    }
+    catch {
+        throw unavailable();
+    }
+    finally {
+        clearTimeout(timer);
+        if (forceTimer !== undefined)
+            clearTimeout(forceTimer);
+        terminate(false);
+        const grace = await Promise.race([
+            closed.then(() => true),
+            new Promise((resolve) => setTimeout(() => resolve(false), 500)),
+        ]);
+        if (!grace) {
+            terminate(true);
+            await Promise.race([closed, new Promise((resolve) => setTimeout(resolve, 500))]);
+        }
+        await rm(directory, { recursive: true, force: true, maxRetries: 3, retryDelay: 50 });
+    }
+}

package/dist/adapters/llm/claude-code.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { redact } from "../../kernel/log.js";
 import { providerError } from "../../kernel/ports/model.js";
+import { nodeClaudeCodeModels } from "./claude-code-models.js";
 import { cliEvent, cliShaped, endedWithout, promptOf, stopCliRun } from "./run-cli.js";
 import { lines } from "./sse-lines.js";
 // The local-agent adapter for Claude Code: spawned non-interactively, authenticated by the
@@ -8,15 +9,6 @@ import { lines } from "./sse-lines.js";
 // may not import `slices/**`, and `slices/settings/cli-status.ts` already probes the binary per
 // request. The registry `main.ts` builds is where this adapter and that probe meet.
 export const claudeCodeBinary = "claude";
-// Official stable family aliases resolve to the latest model available to the
-// installed CLI/account. Full model IDs remain available through custom entry.
-// https://code.claude.com/docs/en/model-config
-export const claudeCodeModels = [
-    { id: "fable", name: "Claude Fable (latest)" },
-    { id: "opus", name: "Claude Opus (latest)" },
-    { id: "sonnet", name: "Claude Sonnet (latest)" },
-    { id: "haiku", name: "Claude Haiku (latest)" },
-];
 const writingRole = "You are the writing and research component of Slopify, a video creation app. " +
     "Produce the text requested in the supplied conversation: articles, narration scripts, " +
     "research notes or image prompts. Follow the requested topic, language, tone, length and format. " +
@@ -47,6 +39,7 @@ export function claudeCodeArgs(req) {
             ? ["--tools", "WebSearch", "--allowedTools", "WebSearch"]
             : ["--tools", ""]),
         ...(req.model === "" ? [] : ["--model", req.model]),
+        ...(req.thinking !== undefined && req.thinking !== "off" ? ["--effort", req.thinking] : []),
         // Everything after `--` is the prompt, so a prompt opening with a dash is text and not
         // a flag. It is one argv element: no shell sees it and nothing in it is expanded.
         "--",
@@ -142,7 +135,7 @@ export function claudeCodeLlm(deps) {
         id: "claude-code",
         // Partial messages keep the deadline alive; complete assistant turns supply prose.
         capabilities: { streams: true, reportsUsage: true, webSearch: true },
-        models: () => Promise.resolve(claudeCodeModels),
+        models: deps.readModels ?? (() => nodeClaudeCodeModels(binary)),
         complete,
     };
 }

package/dist/adapters/llm/codex-models.js

@@ -17,6 +17,10 @@ const model = z.object({
     display_name: safeText.optional(),
     visibility: z.literal("list"),
     priority: z.number().finite().optional(),
+    supported_reasoning_levels: z
+        .array(z.object({ effort: z.string() }))
+        .max(20)
+        .optional(),
 });
 export async function nodeCodexModels(env = process.env) {
     try {
@@ -32,7 +36,14 @@ export async function nodeCodexModels(env = process.env) {
         const unique = new Map();
         for (const item of models) {
             if (!unique.has(item.slug)) {
-                unique.set(item.slug, { id: item.slug, name: item.display_name ?? item.slug });
+                const thinkingModes = item.supported_reasoning_levels
+                    ?.map((level) => level.effort)
+                    .filter((level) => ["off", "low", "medium", "high", "xhigh"].includes(level));
+                unique.set(item.slug, {
+                    id: item.slug,
+                    name: item.display_name ?? item.slug,
+                    ...(thinkingModes?.length ? { thinkingModes } : {}),
+                });
             }
         }
         if (unique.size === 0)

package/dist/adapters/llm/codex.js

@@ -4,15 +4,13 @@ import { join } from "node:path";
 import { z } from "zod";
 import { redact } from "../../kernel/log.js";
 import { providerError } from "../../kernel/ports/model.js";
+import { nodeCodexModels } from "./codex-models.js";
 import { cliEvent, cliShaped, endedWithout, promptOf, stopCliRun } from "./run-cli.js";
 import { lines } from "./sse-lines.js";
 // The local-agent adapter for the Codex CLI. Same shape as Claude Code's and a different
 // vocabulary: Codex writes a JSONL thread of `thread.started`, `item.*` and `turn.*`
 // events. No key here either - the CLI's own login authenticates it.
 export const codexBinary = "codex";
-// Codex publishes its account-specific picker in models_cache.json. With no
-// cache, offer custom entry rather than pretending a pinned model is current.
-export const codexModels = [];
 const writingRole = "You are the writing and research component of Slopify, a video creation app. " +
     "Produce the text requested in the supplied conversation: articles, narration scripts, " +
     "research notes or image prompts. Follow the requested topic, language, tone, length and format. " +
@@ -181,7 +179,7 @@ export function codexLlm(deps) {
         id: "codex",
         // Prose arrives as whole messages; other JSONL events carry activity separately.
         capabilities: { streams: true, reportsUsage: true, webSearch: true },
-        models: deps.readModels ?? (() => Promise.resolve(codexModels)),
+        models: deps.readModels ?? (() => nodeCodexModels()),
         complete,
     };
 }

package/dist/adapters/llm/gemini-models.js

@@ -3,14 +3,6 @@ import { access, realpath } from "node:fs/promises";
 import { delimiter, dirname, isAbsolute, join } from "node:path";
 import { cliCommand } from "../../kernel/cli-command.js";
 import { readCatalogueFile } from "./catalogue-files.js";
-// Official CLI aliases follow the installed CLI's model routing and account.
-// https://geminicli.com/docs/cli/model/
-export const geminiModels = [
-    { id: "auto", name: "Gemini Auto (CLI default)" },
-    { id: "pro", name: "Gemini Pro (CLI alias)" },
-    { id: "flash", name: "Gemini Flash (CLI alias)" },
-    { id: "flash-lite", name: "Gemini Flash-Lite (CLI alias)" },
-];
 export async function nodeGeminiModels(binary) {
     try {
         const command = cliCommand(binary);
@@ -31,24 +23,56 @@ export async function nodeGeminiModels(binary) {
         for (const candidate of candidates) {
             try {
                 const models = parseGeminiModels(await readCatalogueFile(candidate, 256 * 1024));
-                if (models.length > geminiModels.length)
+                if (models.length > 1)
                     return models;
             }
             catch {
                 // A candidate is an optional package layout, not the final discovery result.
             }
         }
+        // Recent Gemini CLI releases ship only bundled chunks. Follow the entry
+        // point's literal chunk imports and read their model constants as text.
+        const bundled = await bundledModels(entry);
+        if (bundled.length > 1)
+            return bundled;
         throw new Error("No installed model metadata");
     }
     catch {
         throw new Error("Gemini CLI model metadata is unavailable. Use a documented CLI alias or enter a custom model ID.");
     }
 }
+async function bundledModels(entry) {
+    const source = await readCatalogueFile(entry, 256 * 1024);
+    const imports = new Set();
+    for (const match of source.matchAll(/\b(?:from\s+|import\s*)["']\.\/(chunk-[A-Za-z0-9-]+\.js)["']/g)) {
+        if (match[1] !== undefined)
+            imports.add(match[1]);
+    }
+    if (imports.size === 0 || imports.size > 32)
+        return [];
+    for (const name of imports) {
+        try {
+            const source = await readCatalogueFile(join(dirname(entry), name), 24 * 1024 * 1024);
+            if (!source.includes("packages/core/dist/src/config/models.js"))
+                continue;
+            const models = parseGeminiModels(source);
+            if (models.length > 1)
+                return models;
+        }
+        catch {
+            // Other chunks can be absent or too large; do not execute them.
+        }
+    }
+    return [];
+}
 function parseGeminiModels(source) {
-    const models = new Map(geminiModels.map((model) => [model.id, model]));
-    // Read literal exported model constants only. Never import or execute an
+    const models = new Map();
+    let pro = false;
+    let flash = false;
+    let flashLite = false;
+    // Read literal model constants only. Never import or execute an
     // installed package, parse comments as entries, or inspect login/settings.
-    const declarations = /^export (?:const|let) ([A-Z][A-Z0-9_]*)\s*=\s*(['"])([^'"\r\n]+)\2\s*;/gm;
+    const declarations = /^(?:export\s+)?(?:const|let|var)\s+([A-Z][A-Z0-9_]*)\s*=\s*(['"])([^'"\r\n]+)\2\s*;/gm;
     const uncommented = source.replace(/\/\*[\s\S]*?\*\//g, "");
     for (const match of uncommented.matchAll(declarations)) {
         const name = match[1];
@@ -62,8 +86,22 @@ function parseGeminiModels(source) {
         if (!/^(?:(?:PREVIEW|DEFAULT|SECONDARY)_GEMINI_|GEMMA_)/.test(name))
             continue;
         models.set(id, { id, name: id });
+        if (name.includes("FLASH_LITE") || id.includes("flash-lite"))
+            flashLite = true;
+        else if (name.includes("FLASH") || id.includes("flash"))
+            flash = true;
+        else if (name.includes("PRO") || id.includes("-pro"))
+            pro = true;
     }
-    return [...models.values()];
+    if (models.size === 0)
+        return [];
+    return [
+        { id: "auto", name: "Gemini Auto (CLI default)" },
+        ...(pro ? [{ id: "pro", name: "Gemini Pro (CLI alias)" }] : []),
+        ...(flash ? [{ id: "flash", name: "Gemini Flash (CLI alias)" }] : []),
+        ...(flashLite ? [{ id: "flash-lite", name: "Gemini Flash-Lite (CLI alias)" }] : []),
+        ...models.values(),
+    ];
 }
 async function executablePath(binary) {
     if (isAbsolute(binary) || /[\\/]/.test(binary))

package/dist/adapters/llm/gemini.js

@@ -1,12 +1,11 @@
 import { z } from "zod";
 import { redact } from "../../kernel/log.js";
 import { providerError } from "../../kernel/ports/model.js";
-import { geminiModels } from "./gemini-models.js";
+import { nodeGeminiModels } from "./gemini-models.js";
 import { geminiWorkspace } from "./gemini-workspace.js";
 import { cliEvent, cliShaped, endedWithout, promptOf, stopCliRun } from "./run-cli.js";
 import { lines } from "./sse-lines.js";
 export const geminiBinary = "gemini";
-export { geminiModels } from "./gemini-models.js";
 // Verified against installed Gemini CLI 0.16.0's config/nonInteractiveCli sources.
 // Its --allowed-tools flag bypasses approval; tools.core in the isolated settings
 // actually restricts discovery. Never request yolo/auto_edit.
@@ -103,7 +102,7 @@ export function geminiLlm(deps) {
     return {
         id: "gemini",
         capabilities: { streams: true, reportsUsage: true, webSearch: true },
-        models: deps.readModels ?? (() => Promise.resolve(geminiModels)),
+        models: deps.readModels ?? (() => nodeGeminiModels(binary)),
         complete,
     };
 }

package/dist/assets/models.yaml

@@ -2,16 +2,10 @@
 # A private copy in the Slopify data directory reloads automatically.
 # Omitted pricing means unknown, never free. Provider concurrency is capped at five.
 schemaVersion: 1
-updatedAt: 2026-09-10
+updatedAt: 2026-09-24
 providers:
   openrouter:
     maxConcurrent: 3
-  claude-code:
-    maxConcurrent: 3
-  codex:
-    maxConcurrent: 3
-  gemini:
-    maxConcurrent: 3
   elevenlabs:
     maxConcurrent: 3
   openai-tts:
@@ -29,127 +23,6 @@ providers:
   google-image:
     maxConcurrent: 3
 llm:
-  - provider: claude-code
-    id: opus
-    name: Claude Opus (latest)
-    source: https://code.claude.com/docs/en/model-config
-    keywords:
-      - llm
-    pricing: &a1
-      note: Uses your CLI login and account plan. No per-run price is available; paid
-        overage may apply.
-    llm:
-      webSearch: true
-  - provider: claude-code
-    id: sonnet
-    name: Claude Sonnet (latest)
-    source: https://code.claude.com/docs/en/model-config
-    keywords:
-      - llm
-    pricing: *a1
-    llm:
-      webSearch: true
-  - provider: claude-code
-    id: haiku
-    name: Claude Haiku (latest)
-    source: https://code.claude.com/docs/en/model-config
-    keywords:
-      - llm
-    pricing: *a1
-    llm:
-      webSearch: true
-  - provider: codex
-    id: gpt-6-astra
-    name: GPT-6-Astra
-    source: https://developers.openai.com/codex/models
-    keywords:
-      - llm
-    pricing: *a1
-    llm:
-      webSearch: true
-      thinking: &a2
-        low:
-          effort: low
-        medium:
-          effort: medium
-        high:
-          effort: high
-  - provider: codex
-    id: gpt-5.6-sol
-    name: GPT-5.6-Sol
-    source: https://developers.openai.com/codex/models
-    keywords:
-      - llm
-    pricing: *a1
-    llm:
-      webSearch: true
-      thinking: *a2
-  - provider: codex
-    id: gpt-5.6-terra
-    name: GPT-5.6-Terra
-    source: https://developers.openai.com/codex/models
-    keywords:
-      - llm
-    pricing: *a1
-    llm:
-      webSearch: true
-      thinking: *a2
-  - provider: codex
-    id: gpt-5.6-luna
-    name: GPT-5.6-Luna
-    source: https://developers.openai.com/codex/models
-    keywords:
-      - llm
-    pricing: *a1
-    llm:
-      webSearch: true
-      thinking: *a2
-  - provider: codex
-    id: gpt-5.5
-    name: GPT-5.5
-    source: https://developers.openai.com/codex/models
-    keywords:
-      - llm
-    pricing: *a1
-    llm:
-      webSearch: true
-      thinking: *a2
-  - provider: codex
-    id: gpt-5.3-codex-spark
-    name: GPT-5.3-Codex-Spark
-    source: https://developers.openai.com/codex/models
-    keywords:
-      - llm
-    pricing: *a1
-    llm:
-      webSearch: true
-      thinking: *a2
-  - provider: gemini
-    id: gemini-3.8-flash
-    name: Gemini 3.8 Flash
-    source: https://ai.google.dev/gemini-api/docs/models
-    keywords:
-      - llm
-    pricing: *a1
-    llm:
-      webSearch: true
-      thinking: &a3
-        low:
-          level: low
-        medium:
-          level: medium
-        high:
-          level: high
-  - provider: gemini
-    id: gemini-3.1-pro-preview
-    name: Gemini 3.1 Pro (preview)
-    source: https://ai.google.dev/gemini-api/docs/models
-    keywords:
-      - llm
-    pricing: *a1
-    llm:
-      webSearch: true
-      thinking: *a3
   - provider: openrouter
     id: google/gemini-3.8-flash
     name: "Google: Gemini 3.8 Flash"
@@ -164,7 +37,13 @@ llm:
     llm:
       webSearch: true
       contextTokens: 1048576
-      thinking: *a2
+      thinking: &a2
+        low:
+          effort: low
+        medium:
+          effort: medium
+        high:
+          effort: high
   - provider: openrouter
     id: google/gemini-3.1-pro-preview
     name: "Google: Gemini 3.1 Pro Preview"

package/dist/catalog/registry.js

@@ -1,4 +1,5 @@
 import { providerError } from "../kernel/ports/model.js";
+import { isLocalCliProvider } from "../slices/settings/model.js";
 export function curateRegistry(registry, catalogue) {
     const requireModel = (provider, family, id) => {
         const models = catalogue.models(provider, family);
@@ -14,6 +15,49 @@ export function curateRegistry(registry, catalogue) {
         list: registry.list,
         llm: (id) => {
             const port = registry.llm(id);
+            if (isLocalCliProvider(id)) {
+                return {
+                    ...port,
+                    models: () => port.models(),
+                    complete: async function* (request) {
+                        if (request.model.trim() === "")
+                            throw providerError({ kind: "unsupported", message: "Choose a model ID." });
+                        let models;
+                        try {
+                            models = await port.models();
+                        }
+                        catch {
+                            // A failed metadata read permits an exact manual ID; generation still
+                            // decides whether the installed CLI/account accepts it.
+                        }
+                        const selected = models?.find((model) => model.id === request.model);
+                        if (models !== undefined && selected === undefined)
+                            throw providerError({
+                                kind: "unsupported",
+                                message: "This model is not available in the installed CLI.",
+                            });
+                        if (request.thinking !== undefined &&
+                            selected !== undefined &&
+                            !selected.thinkingModes?.includes(request.thinking))
+                            throw providerError({
+                                kind: "unsupported",
+                                message: "This model does not support the selected thinking setting.",
+                            });
+                        if (request.webSearch && !port.capabilities.webSearch)
+                            throw providerError({
+                                kind: "unsupported",
+                                message: "This CLI does not support research web search.",
+                            });
+                        const thinkingConfig = id === "codex" && request.thinking !== undefined
+                            ? { effort: request.thinking === "off" ? "none" : request.thinking }
+                            : undefined;
+                        yield* port.complete({
+                            ...request,
+                            ...(request.thinkingConfig === undefined && thinkingConfig ? { thinkingConfig } : {}),
+                        });
+                    },
+                };
+            }
             return {
                 ...port,
                 models: async () => catalogue.models(id, "llm").map((m) => ({
@@ -48,6 +92,20 @@ export function curateRegistry(registry, catalogue) {
         },
         image: (id) => {
             const port = registry.image(id);
+            if (id === "codex-image") {
+                return {
+                    ...port,
+                    models: () => port.models(),
+                    generate: async (request) => {
+                        if (!(await port.models()).some((model) => model.id === request.model))
+                            throw providerError({
+                                kind: "unsupported",
+                                message: "The Codex image capability is unavailable.",
+                            });
+                        return port.generate(request);
+                    },
+                };
+            }
             return {
                 ...port,
                 models: async () => catalogue.models(id, "image"),

package/dist/catalog/runtime-models.js

@@ -0,0 +1,16 @@
+import { isLocalCliProvider } from "../slices/settings/model.js";
+export async function checkRuntimeModel(modelsFor, provider, family, id, thinking) {
+    if (id.trim() === "")
+        return "missing";
+    try {
+        const model = (await modelsFor(provider, family)).find((row) => row.id === id);
+        if (model === undefined)
+            return "missing";
+        if (family === "llm" && thinking !== undefined && !model.thinkingModes?.includes(thinking))
+            return "thinking";
+        return "available";
+    }
+    catch {
+        return isLocalCliProvider(provider) && family === "llm" ? "manual" : "missing";
+    }
+}

package/dist/catalog/store.js

@@ -1,12 +1,20 @@
 import { existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { parse } from "yaml";
+import { isLocalCliProvider } from "../slices/settings/model.js";
 import { catalogueSchema } from "./schema.js";
 export const catalogueSource = "https://raw.githubusercontent.com/GentBajko/slopify/main/packages/app/src/assets/models.yaml";
 export function parseCatalogue(text) {
     if (Buffer.byteLength(text) > 1024 * 1024)
         throw new Error("Model catalogue exceeds 1 MB");
-    return catalogueSchema.parse(parse(text, { maxAliasCount: 20, uniqueKeys: true }));
+    const parsed = catalogueSchema.parse(parse(text, { maxAliasCount: 20, uniqueKeys: true }));
+    return {
+        ...parsed,
+        providers: Object.fromEntries(Object.entries(parsed.providers).filter(([id]) => !isLocalCliProvider(id))),
+        llm: parsed.llm.filter((row) => !isLocalCliProvider(row.provider)),
+        image: parsed.image.filter((row) => !isLocalCliProvider(row.provider)),
+        tts: parsed.tts.filter((row) => !isLocalCliProvider(row.provider)),
+    };
 }
 export function createCatalogueStore(deps) {
     const path = join(deps.dataDir, "models.yaml");

package/dist/catalog/validate.js

@@ -1,3 +1,4 @@
+import { isLocalCliProvider } from "../slices/settings/model.js";
 export function modelFields(draft, catalogue) {
     if (!catalogue)
         return [];
@@ -24,7 +25,7 @@ export function modelFields(draft, catalogue) {
         },
     ];
     for (const { field, family, choice, needed } of checks) {
-        if (!needed || !choice)
+        if (!needed || !choice || isLocalCliProvider(choice.provider))
             continue;
         const model = catalogue.models(choice.provider, family).find((m) => m.id === choice.model);
         if (!model)

package/dist/edge/http/providers.js

@@ -3,7 +3,7 @@ import { Hono } from "hono";
 import { z } from "zod";
 import { cliPathMaxLength, saveCliPath } from "../../slices/settings/cli-paths.js";
 import { keyStatus, removeProviderKey, saveProviderKey } from "../../slices/settings/keys.js";
-import { providerById, providerIds } from "../../slices/settings/model.js";
+import { isLocalCliProvider, providerById, providerIds } from "../../slices/settings/model.js";
 import { createModelCatalog } from "../../slices/settings/models.js";
 import { providerStatuses } from "../../slices/settings/readiness.js";
 import { onInvalid, problem, titleOf } from "./problem.js";
@@ -46,7 +46,7 @@ export function providerRoutes(deps) {
         .get("/", async (c) => c.json({ providers: await providerStatuses(readiness) }))
         .get("/:id/models", zValidator("param", providerParam, onInvalid), async (c) => {
         const { id } = c.req.valid("param");
-        if (deps.catalogue)
+        if (deps.catalogue && !isLocalCliProvider(id))
             return c.json({
                 models: deps.catalogue.models(id, providerById(id).family).map((m) => ({
                     ...m,

package/dist/main.js

@@ -43,6 +43,7 @@ import { executionStages, executionStandings, invocationReady, projectStandings,
 import { settleTerminalScheduleRuns } from "./slices/schedules/repo.js";
 import { createScheduleRunner } from "./slices/schedules/scheduler.js";
 import { nodeCliProbe } from "./slices/settings/cli-status.js";
+import { isLocalCliProvider } from "./slices/settings/model.js";
 import { providerStatuses } from "./slices/settings/readiness.js";
 import { reconcileStorage } from "./slices/storage/reconcile.js";
 import { collectorEndpoint, httpPostEvents } from "./slices/telemetry/collector-client.js";
@@ -407,7 +408,7 @@ export function wireRunner({ audioPreviews, db, paths, clock, ids, log, hub, tel
         attempts: sqliteAttempts(db, ids),
         clock,
         log,
-        queue: createProviderQueue((provider) => catalogue.read().providers[provider]?.maxConcurrent ?? 1),
+        queue: createProviderQueue((provider) => isLocalCliProvider(provider) ? 3 : (catalogue.read().providers[provider]?.maxConcurrent ?? 1)),
     };
     const checkpoints = createCheckpointAuthority({
         decide: (work) => checkpointDecisionForWork(execution, work),

package/dist/model-catalog.js

@@ -2,9 +2,6 @@ import { falModels } from "./adapters/image/fal.js";
 import { googleImageModels } from "./adapters/image/google.js";
 import { openAiImageModels } from "./adapters/image/openai.js";
 import { replicateModels } from "./adapters/image/replicate.js";
-import { claudeCodeModels } from "./adapters/llm/claude-code.js";
-import { codexModels } from "./adapters/llm/codex.js";
-import { geminiModels } from "./adapters/llm/gemini.js";
 import { cartesiaModels } from "./adapters/tts/cartesia.js";
 import { elevenLabsModels } from "./adapters/tts/elevenlabs.js";
 import { inworldModels } from "./adapters/tts/inworld.js";
@@ -12,9 +9,6 @@ import { openAiTtsModels } from "./adapters/tts/openai.js";
 // Composition keeps provider-specific fallback data out of the HTTP and settings layers.
 export function modelSources(registry) {
     const fallbacks = {
-        "claude-code": claudeCodeModels,
-        codex: codexModels,
-        gemini: geminiModels,
         elevenlabs: elevenLabsModels,
         "openai-tts": openAiTtsModels,
         cartesia: cartesiaModels,

package/dist/slices/control/providers.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { checkRuntimeModel } from "../../catalog/runtime-models.js";
 import { thinkingModes } from "../../kernel/ports/llm.js";
 import { readinessIsUsable, } from "../../kernel/ports/model.js";
 import { chunkModes } from "../narration/chunk.js";
@@ -64,14 +65,11 @@ export async function validateProviderChanges(changes, current) {
             continue;
         if (current.allowsCustomModels?.(picked.provider) === true)
             continue;
-        const models = await current.modelsFor(picked.provider, families[key]);
-        const model = models.find((model) => model.id === picked.model);
-        if (!model) {
+        const result = await checkRuntimeModel(current.modelsFor, picked.provider, families[key], picked.model, picked.thinking);
+        if (result === "missing") {
             fields.push({ field: `${key}.model`, message: "Choose a model supported by this provider." });
         }
-        else if (key === "llm" &&
-            picked.thinking &&
-            !model.thinkingModes?.includes(picked.thinking)) {
+        else if (result === "thinking") {
             fields.push({ field: `${key}.thinking`, message: "Choose a supported thinking setting." });
         }
     }

package/dist/slices/play-drafts/readiness.js

@@ -1,8 +1,9 @@
+import { checkRuntimeModel } from "../../catalog/runtime-models.js";
 import { modelFields } from "../../catalog/validate.js";
 import { readinessIsUsable } from "../../kernel/ports/model.js";
 import { cliPathStatus } from "../settings/cli-paths.js";
 import { hasKey, listVoices } from "../settings/repo.js";
-function choices(runs) {
+export function choices(runs) {
     const selected = runs
         .flatMap(({ draft: d }) => [
         {
@@ -49,12 +50,17 @@ export async function checkDraftReadiness(deps, runs) {
             });
             continue;
         }
-        const models = await deps.modelsFor(c.provider, c.family);
-        if (!models.some((m) => m.id === c.model))
+        const result = await checkRuntimeModel(deps.modelsFor, c.provider, c.family, c.model, c.thinking);
+        if (result === "missing")
             fields.push({
                 field: `${c.field}.model`,
                 message: "Choose an available model before starting.",
             });
+        else if (result === "thinking")
+            fields.push({
+                field: `${c.field}.thinking`,
+                message: "Choose a supported thinking setting.",
+            });
     }
     return { fields: [...fields, ...localDraftReadiness(deps, runs, providers)], providers };
 }

package/dist/slices/play-drafts/review.js

@@ -1,6 +1,8 @@
 import { z } from "zod";
+import { checkRuntimeModel } from "../../catalog/runtime-models.js";
 import { transact } from "../../kernel/db/tx.js";
 import { isMissingFont } from "../fonts/index.js";
+import { choices } from "./readiness.js";
 import { draftRow } from "./repo.js";
 import { resolveReviewInputs, reviewBinding, reviewRefusal } from "./review-inputs.js";
 import { draftViewSchema, playReviewSchema } from "./schema.js";
@@ -33,6 +35,22 @@ export async function resolvePlayReview(deps, view) {
     const after = resolveReviewInputs(deps, parsed.data, font);
     if (!after.ok)
         return after;
+    const fields = [];
+    for (const choice of choices(after.value.runs)) {
+        const result = await checkRuntimeModel(deps.modelsFor, choice.provider, choice.family, choice.model, choice.thinking);
+        if (result === "missing")
+            fields.push({
+                field: `${choice.field}.model`,
+                message: "Choose an available model before reviewing.",
+            });
+        else if (result === "thinking")
+            fields.push({
+                field: `${choice.field}.thinking`,
+                message: "Choose a supported thinking setting.",
+            });
+    }
+    if (fields.length)
+        return reviewRefusal(view, fields);
     return reviewBinding(before.value) === reviewBinding(after.value)
         ? after
         : reviewRefusal(view, [], "stale-review");

package/dist/slices/rebuild/service-readiness.js

@@ -1,5 +1,7 @@
+import { checkRuntimeModel } from "../../catalog/runtime-models.js";
 import { readinessIsUsable } from "../../kernel/ports/model.js";
 import { cliPathStatus } from "../settings/cli-paths.js";
+import { isLocalCliProvider } from "../settings/model.js";
 import { hasKey, listVoices } from "../settings/repo.js";
 import { requiresNewSubmission } from "./preview-retained.js";
 import { recipeProviderChoice } from "./recipe-provider-choice.js";
@@ -36,12 +38,17 @@ export async function checkReadiness(deps, snapshot, view) {
             });
             continue;
         }
-        const models = await deps.modelsFor(choice.provider, choice.family);
-        if (!models.some((row) => row.id === choice.model))
+        const result = await checkRuntimeModel(deps.modelsFor, choice.provider, choice.family, choice.model, choice.family === "llm" ? (choice.thinking ?? undefined) : undefined);
+        if (result === "missing")
             fields.push({
                 field: `${choice.family}.model`,
                 message: "Choose an available model before rebuilding.",
             });
+        else if (result === "thinking")
+            fields.push({
+                field: `${choice.family}.thinking`,
+                message: "Choose a supported thinking setting.",
+            });
     }
     return { fields, providers };
 }
@@ -52,7 +59,7 @@ export function localReadiness(deps, snapshot, view, providers, catalogue) {
             row.id === choice.model &&
             row.enabled &&
             !row.deprecated);
-        if (model === undefined)
+        if (model === undefined && !isLocalCliProvider(choice.provider))
             fields.push({
                 field: `${choice.family}.model`,
                 message: "The selected model is no longer available.",
@@ -85,6 +92,8 @@ export function localReadiness(deps, snapshot, view, providers, catalogue) {
                 });
         }
         else if (input.kind === "llm") {
+            if (isLocalCliProvider(input.provider))
+                continue;
             const model = catalogue.llm.find((row) => row.provider === input.provider && row.id === input.model);
             if (input.thinking !== null && model?.llm.thinking?.[input.thinking] === undefined)
                 fields.push({

package/dist/slices/settings/model.js

@@ -18,6 +18,9 @@ export const providerIds = [
     "openai-image",
     "google-image",
 ];
+export function isLocalCliProvider(id) {
+    return id === "claude-code" || id === "codex" || id === "gemini" || id === "codex-image";
+}
 export const providers = [
     { id: "openrouter", family: "llm", displayName: "OpenRouter", auth: "key" },
     {

package/dist/slices/settings/models.js

@@ -1,7 +1,8 @@
+import { isLocalCliProvider } from "./model.js";
 // These marketplaces host models with different input schemas. Discovery alone cannot
 // make an arbitrary endpoint compatible with our image request.
 export function allowsCustomModel(provider) {
-    return provider !== "fal" && provider !== "replicate";
+    return provider !== "fal" && provider !== "replicate" && provider !== "codex-image";
 }
 const ttlMs = 5 * 60_000;
 const retryMs = 30_000;
@@ -33,14 +34,19 @@ export function createModelCatalog(deps) {
                 // A catalogue is metadata, not generation. Never expose an upstream response
                 // here: it can quote credentials that belong only inside its adapter.
                 deps.report(provider);
-                const saved = previous?.value.models;
+                const local = isLocalCliProvider(provider);
+                const saved = local ? undefined : previous?.value.models;
                 value = {
-                    models: saved ?? deps.fallback(provider),
+                    models: local ? [] : (saved ?? deps.fallback(provider)),
                     ...catalogNotice(provider),
                     allowsCustom: allowsCustomModel(provider),
-                    warning: saved === undefined
-                        ? "Could not load the model list. Showing bundled choices; refresh to try again."
-                        : "Could not refresh the model list. Showing the last loaded choices.",
+                    warning: local
+                        ? provider === "codex-image"
+                            ? "Could not check the Codex image capability. Refresh after checking the CLI."
+                            : "Could not discover models from this CLI. Enter an exact model ID manually or refresh."
+                        : saved === undefined
+                            ? "Could not load the model list. Showing bundled choices; refresh to try again."
+                            : "Could not refresh the model list. Showing the last loaded choices.",
                 };
                 lifetime = retryMs;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gentbajko/slopify",
-  "version": "1.0.1",
+  "version": "1.1.1",
   "description": "Turn a prompt into a finished video, locally, with your own provider keys",
   "license": "MIT",
   "author": "Gent Bajko",