@gentbajko/slopify 1.0.0 → 1.1.0

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,189 @@
+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,
+                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) {
+        if (models.has(row.value))
+            continue;
+        const modes = row.supportedEffortLevels?.filter((value) => supportedEfforts.includes(value));
+        models.set(row.value, {
+            id: row.value,
+            name: row.displayName,
+            ...(modes?.length ? { thinkingModes: modes } : {}),
+        });
+    }
+    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,7 +23,7 @@ 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 {
@@ -45,7 +37,10 @@ export async function nodeGeminiModels(binary) {
     }
 }
 function parseGeminiModels(source) {
-    const models = new Map(geminiModels.map((model) => [model.id, model]));
+    const models = new Map();
+    let pro = false;
+    let flash = false;
+    let flashLite = false;
     // Read literal exported 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;
@@ -62,8 +57,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)