@gentbajko/slopify 0.6.1 → 0.8.0

package/README.md

@@ -1,4 +1,15 @@
-# Slopify
+<h1 align="center">
+  <a href="https://slopify.stream"><img src="https://slopify.stream/assets/favicon.svg" width="40" height="40" align="middle" alt="" /></a>
+  Slopify
+</h1>
+
+<p align="center">
+  <a href="https://slopify.stream">slopify.stream</a>
+  &nbsp;·&nbsp;
+  <a href="https://www.patreon.com/cw/GentBajko"><img src="https://slopify.stream/assets/patreon-green.svg" width="14" height="14" align="middle" alt="" /> Patreon</a>
+  &nbsp;·&nbsp;
+  <a href="https://buymeacoffee.com/gentbajko"><img src="https://slopify.stream/assets/buymeacoffee-green.svg" width="14" height="14" align="middle" alt="" /> Buy Me a Coffee</a>
+</p>
 
 A prompt and a few keywords in. A narrated slideshow video out. Your keys, your machine, free.
 
@@ -14,6 +25,23 @@ Six stages run as a graph: research, article, narration, images, thumbnail, vide
 Generate any of them, or provide the output yourself and that stage is skipped. The
 video is a slideshow with alternating zoom over the narration, rendered with ffmpeg.
 
+## Inworld narration
+
+In Settings, add the **Base64 credentials** from Inworld's API Keys page, then add an
+Inworld voice ID (for example `Dennis`, or a voice from your workspace). In Play,
+choose **Realtime TTS-2** or **Realtime TTS-2 Flash** and that voice.
+
+Short text streams immediately. TTS-2 text over 4,000 characters uses one async job,
+up to 100,000 characters; Inworld caps On-Demand accounts at 10,000. Audio becomes
+available once that job finishes. Flash uses streamed parts of at most 4,000 characters.
+For longer articles, select paragraph chunking. Successful status checks keep long jobs
+alive, and automatic polling/download retries reuse the accepted job. Pausing stops
+local requests; Inworld may still finish and bill an accepted job. Resuming after a
+pause or app restart starts a new request for unfinished narration.
+
+See [Inworld's async API](https://docs.inworld.ai/api-reference/ttsAPI/texttospeech/synthesize-speech-async)
+for account limits. Both model IDs are bundled; Inworld's LLM catalogue does not list TTS models.
+
 ## Options
 
 | Flag | Environment variable | Default |
@@ -67,6 +95,13 @@ Never your keys, prompts, keywords, titles, article text, filenames, or anything
 your machine. A notice says all of this the first time you run it, before the machine
 id exists, and the Usage screen shows you your own numbers at any time.
 
+## Supporting the project
+
+Slopify is free and always will be. If it is worth something to you, there is
+[Patreon](https://www.patreon.com/cw/GentBajko) and
+[Buy Me a Coffee](https://buymeacoffee.com/gentbajko). The people who do are listed
+in [SUPPORTERS.md](https://github.com/GentBajko/slopify/blob/main/SUPPORTERS.md).
+
 ## Licence
 
 MIT. The ffmpeg binary fetched at install time is a separate GPL-3.0-or-later program,

package/SUBTITLES.md

@@ -1,12 +1,12 @@
-# Subtitles in Slopify 0.6
+# Subtitles in Slopify
 
 1. In Play, enable narration or provide matching English audio and article text.
 2. In Subtitles, choose **Subtitle files (.srt + .vtt)** or **Burn into video + files**.
-3. For burned captions, select a bundled or system font, or upload a `.ttf` or `.otf` file (up to 32 MiB). Preview the font and choose a size from 16 to 120.
+3. For burned captions, select a bundled or system font, or upload a `.ttf` or `.otf` file (up to 32 MiB). Choose a size from 16 to 120 and a position: top, upper-middle, center, lower-middle or bottom. The side preview shows the selected font, size and position in a 16:9 or 9:16 frame.
 4. Start the run. Slopify times the article against the actual narration on your computer. The first use downloads an approximately 95 MB English speech model; later runs work offline with the cached model. Allow roughly 1 GB of available memory during alignment. No extra API key, Python, or compiler is needed.
 5. Download SRT/VTT beside the final export. Files mode adds an optional native caption track to the in-app video preview. Burned captions remain visible in the downloaded MP4.
 
-For a completed project, open its final Video or Audio export section, set subtitles, and click **Save subtitles**. This rebuilds only the local export from saved narration and images. Changing font or size reuses word timing when the audio and spoken text are unchanged. A paused run saves these choices until Resume; pause an active run before editing. Failed alignment or rendering keeps the previous finished export.
+For a completed project, open its final Video or Audio export section, set subtitles, and click **Save subtitles**. This rebuilds only the local export from saved narration and images. Changing font, size or position reuses word timing when the audio and spoken text are unchanged. A paused run saves these choices until Resume; pause an active run before editing. Failed alignment or rendering keeps the previous finished export.
 
 Audio Off disables subtitles. Video Off produces WAV audio with separate subtitle files. Uploaded audio must match the article; substantial mismatches fail with a message to correct the transcript. Review timing and spelling before publishing. English is supported first; unusual pronunciations and non-English passages can fail alignment.
 

package/dist/adapter-registry.js

@@ -4,10 +4,13 @@ import { openAiImage } from "./adapters/image/openai.js";
 import { replicateImage } from "./adapters/image/replicate.js";
 import { claudeCodeLlm } from "./adapters/llm/claude-code.js";
 import { codexLlm } from "./adapters/llm/codex.js";
+import { nodeCodexModels } from "./adapters/llm/codex-models.js";
 import { geminiLlm } from "./adapters/llm/gemini.js";
+import { nodeGeminiModels } from "./adapters/llm/gemini-models.js";
 import { openRouterLlm } from "./adapters/llm/openrouter.js";
 import { cartesiaTts } from "./adapters/tts/cartesia.js";
 import { elevenLabsTts } from "./adapters/tts/elevenlabs.js";
+import { inworldTts } from "./adapters/tts/inworld.js";
 import { openAiTts } from "./adapters/tts/openai.js";
 import { cliBinary } from "./slices/settings/cli-paths.js";
 import { keyForAttempt } from "./slices/settings/keys.js";
@@ -26,8 +29,14 @@ export function buildRegistry(deps) {
         ["openrouter", openRouterLlm({ fetch: deps.fetch, key: keyOf("openrouter") })],
         // Each CLI authenticates with its own login.
         ["claude-code", claudeCodeLlm({ run: cliFor("claude-code") })],
-        ["codex", codexLlm({ run: cliFor("codex") })],
-        ["gemini", geminiLlm({ run: cliFor("gemini") })],
+        ["codex", codexLlm({ run: cliFor("codex"), readModels: () => nodeCodexModels() })],
+        [
+            "gemini",
+            geminiLlm({
+                run: cliFor("gemini"),
+                readModels: () => nodeGeminiModels(cliBinary(deps.db, "gemini")),
+            }),
+        ],
     ]);
     // One key per provider, so each adapter is handed the reader for its own row and no other.
     // OpenAI keeps two rows because it ships an adapter in two families and a user may key one
@@ -36,6 +45,7 @@ export function buildRegistry(deps) {
         ["elevenlabs", elevenLabsTts({ fetch: deps.fetch, key: keyOf("elevenlabs") })],
         ["openai-tts", openAiTts({ fetch: deps.fetch, key: keyOf("openai-tts") })],
         ["cartesia", cartesiaTts({ fetch: deps.fetch, key: keyOf("cartesia") })],
+        ["inworld", inworldTts({ fetch: deps.fetch, key: keyOf("inworld"), clock: deps.clock })],
     ]);
     // Four image providers behind one port, each handed the reader for its own key row.
     // Replicate also takes the clock: `Prefer: wait` gives up after 60 s and the prediction has

package/dist/adapters/image/google.js

@@ -3,28 +3,21 @@ import { redact } from "../../kernel/log.js";
 import { providerError } from "../../kernel/ports/model.js";
 import { retryAfter } from "../retry-after.js";
 import { describeBytes, sniffImage } from "./bytes.js";
+import { discoverGoogleImages } from "./models.js";
 // The HTTP gateway adapter for Google's own image generation, billed to a Gemini API key
 // rather than to a host reselling the same models. Like the OpenAI one it hands back the
-// bytes with the call, so there is no link to follow; unlike it, the whole interaction is
-// one `input` string and a `response_format`, with no per-model size table to keep.
+// bytes with the call, so there is no link to follow.
 export const googleImagesBase = "https://generativelanguage.googleapis.com/v1beta";
-// The dropdown is filled from what the provider offers, and Google's model list carries every
-// text and embedding model too, so the image shortlist is this adapter's own data. Named as
-// Google markets them: "Nano Banana" is the family, `gemini-*-image` is what the API answers
-// to, and the picker shows the name a user would recognise. Newest first.
-//
-// A Gemini model without the `-image` suffix returns text and cannot be used here, whatever
-// its version number: `gemini-3.8-flash` is newer than all of these and generates no images.
+// Offline choices only; the picker normally loads the provider catalogue.
 export const googleImageModels = [
     { id: "gemini-3.1-flash-image", name: "Nano Banana 2" },
     { id: "gemini-3.1-flash-lite-image", name: "Nano Banana 2 Lite" },
     { id: "gemini-3-pro-image", name: "Nano Banana Pro" },
     { id: "gemini-2.5-flash-image", name: "Nano Banana" },
 ];
-// The API takes the aspect in the run's own words, so the closest supported size is exact
-// and the render crops nothing. `2K` is the middle of the documented ladder: enough to
-// survive the 4x pre-scale the zoom needs without paying for 4K on every slide.
-const imageSize = "2K";
+// 2.5 and Flash Lite cannot generate 2K images. Unknown models keep their own default
+// resolution until their capabilities are known; discovery alone does not describe sizes.
+const highResolutionModel = /^gemini-(?:3(?:\.1)?-pro|3\.1-flash)-image(?:-preview(?:-\d{2}-\d{2})?)?$/;
 // A wire payload is narrowed, never cast. The image arrives as one content part of a
 // `model_output` step, beside any text the model chose to write, so both the step and the
 // part are searched for by type rather than read off a fixed index.
@@ -58,7 +51,7 @@ const refusalWords = /\b(safety|blocked|content polic|prohibited|violat)/i;
 export function googleImage(deps) {
     return {
         id: "google-image",
-        models: () => Promise.resolve(googleImageModels),
+        models: () => discoverGoogleImages(deps),
         generate: async (req) => {
             const response = await deps.fetch(`${googleImagesBase}/interactions`, {
                 method: "POST",
@@ -72,7 +65,11 @@ export function googleImage(deps) {
                     // The stage sends Number as that many independent calls, one piece each, so one
                     // image per request is what it asks for. Nothing about style is set: the stage
                     // asks for the provider's own.
-                    response_format: { type: "image", aspect_ratio: req.aspect, image_size: imageSize },
+                    response_format: {
+                        type: "image",
+                        aspect_ratio: req.aspect,
+                        ...(highResolutionModel.test(req.model) ? { image_size: "2K" } : {}),
+                    },
                 }),
             });
             if (!response.ok) {

package/dist/adapters/image/models.js

@@ -0,0 +1,72 @@
+import { z } from "zod";
+import { providerError } from "../../kernel/ports/model.js";
+const openAiModels = z.object({ data: z.array(z.object({ id: z.string() })) });
+const googleModels = z.object({
+    models: z
+        .array(z.object({
+        name: z.string(),
+        displayName: z.string().optional(),
+        supportedGenerationMethods: z.array(z.string()).optional(),
+    }))
+        .default([]),
+    nextPageToken: z.string().optional(),
+});
+export async function discoverOpenAiImages(deps) {
+    const response = await deps.fetch("https://api.openai.com/v1/models", {
+        headers: { Authorization: `Bearer ${requireKey(deps)}` },
+        signal: AbortSignal.timeout(10_000),
+    });
+    if (!response.ok)
+        throw unavailable();
+    const parsed = openAiModels.safeParse(await response.json());
+    if (!parsed.success)
+        throw unavailable();
+    return parsed.data.data
+        .filter(({ id }) => id.startsWith("gpt-image-"))
+        .map(({ id }) => ({ id, name: id }));
+}
+export async function discoverGoogleImages(deps) {
+    const headers = { "x-goog-api-key": requireKey(deps) };
+    const signal = AbortSignal.timeout(10_000);
+    const result = [];
+    const tokens = new Set();
+    let page = "";
+    // Bound a malformed provider's pagination while allowing 20,000 model records.
+    for (let count = 0; count < 20; count++) {
+        const url = new URL("https://generativelanguage.googleapis.com/v1beta/models");
+        url.searchParams.set("pageSize", "1000");
+        if (page !== "")
+            url.searchParams.set("pageToken", page);
+        const response = await deps.fetch(url, { headers, signal });
+        if (!response.ok)
+            throw unavailable();
+        const parsed = googleModels.safeParse(await response.json());
+        if (!parsed.success)
+            throw unavailable();
+        for (const model of parsed.data.models) {
+            const id = model.name.replace(/^models\//, "");
+            // Imagen uses a different generation API. Only Gemini image models share this adapter.
+            if (id.startsWith("gemini-") &&
+                /-image(?:-|$)/.test(id) &&
+                model.supportedGenerationMethods?.includes("generateContent") === true) {
+                result.push({ id, name: model.displayName ?? id });
+            }
+        }
+        page = parsed.data.nextPageToken ?? "";
+        if (page === "")
+            return result;
+        if (tokens.has(page))
+            throw unavailable();
+        tokens.add(page);
+    }
+    throw unavailable();
+}
+function requireKey(deps) {
+    const key = deps.key();
+    if (key === undefined || key === "")
+        throw providerError({ kind: "missing_key", message: "Save an API key to load models." });
+    return key;
+}
+function unavailable() {
+    return providerError({ kind: "other", message: "The provider model list could not be loaded." });
+}

package/dist/adapters/image/openai.js

@@ -3,15 +3,13 @@ import { redact } from "../../kernel/log.js";
 import { providerError } from "../../kernel/ports/model.js";
 import { retryAfter } from "../retry-after.js";
 import { describeBytes, sniffImage } from "./bytes.js";
+import { discoverOpenAiImages } from "./models.js";
 // The HTTP gateway adapter for OpenAI's images endpoint: the platform's own `fetch` and
 // nothing else, because the whole call is one request. Unlike fal and Replicate this one
 // hands back the image itself - a GPT image model always answers with base64, never a URL -
 // so there is no link to follow.
 export const openAiImagesBase = "https://api.openai.com/v1";
-// The dropdown is filled from what the provider offers, and `/v1/models`
-// lists every model on the account, chat and embeddings among them, so the image
-// shortlist is this adapter's own data. These are the four GPT image models OpenAI
-// documents; adding the next one is a line here and no code change anywhere else.
+// Offline choices only; the picker normally loads the provider catalogue.
 export const openAiImageModels = [
     { id: "gpt-image-2", name: "GPT Image 2" },
     { id: "gpt-image-1.5", name: "GPT Image 1.5" },
@@ -52,7 +50,7 @@ export function sizeFor(model, aspect) {
 export function openAiImage(deps) {
     return {
         id: "openai-image",
-        models: () => Promise.resolve(openAiImageModels),
+        models: () => discoverOpenAiImages(deps),
         generate: async (req) => {
             const response = await deps.fetch(`${openAiImagesBase}/images/generations`, {
                 method: "POST",

package/dist/adapters/llm/catalogue-files.js

@@ -0,0 +1,23 @@
+import { open } from "node:fs/promises";
+// Bound both the initial read and a file that grows between stat and read. Model
+// metadata is data only: none of the installed CLI's modules are evaluated.
+export async function readCatalogueFile(path, maxBytes) {
+    const file = await open(path, "r");
+    try {
+        const info = await file.stat();
+        if (!info.isFile() || info.size > maxBytes)
+            throw new Error("Invalid model metadata file");
+        const bytes = Buffer.alloc(maxBytes + 1);
+        let size = 0;
+        while (size <= maxBytes) {
+            const chunk = await file.read(bytes, size, bytes.length - size, null);
+            if (chunk.bytesRead === 0)
+                return bytes.toString("utf8", 0, size);
+            size += chunk.bytesRead;
+        }
+        throw new Error("Model metadata file is too large");
+    }
+    finally {
+        await file.close();
+    }
+}

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

@@ -8,10 +8,9 @@ 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";
-// The CLI takes an alias for the latest model of a family (`claude --help`, 2.1.258).
-// ceiling: a fixed list, because the CLI has no offline command that prints the models an
-// account may use. A user whose plan carries a model not listed here cannot pick it;
-// reading the list off the CLI is the upgrade when it can print one.
+// 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)" },

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

@@ -0,0 +1,46 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+import { readCatalogueFile } from "./catalogue-files.js";
+const safeText = z
+    .string()
+    .trim()
+    .min(1)
+    .max(256)
+    .refine((text) => [...text].every((character) => character.charCodeAt(0) >= 32 && character.charCodeAt(0) !== 127));
+// Deliberately omit model instructions, capabilities and every authentication
+// file. Visibility refers to the CLI picker, not supported_in_api: some visible
+// CLI-only models cannot be called through the public API.
+const cache = z.object({ models: z.array(z.unknown()).max(1000) });
+const model = z.object({
+    slug: safeText.refine((id) => !/\s/.test(id)),
+    display_name: safeText.optional(),
+    visibility: z.literal("list"),
+    priority: z.number().finite().optional(),
+});
+export async function nodeCodexModels(env = process.env) {
+    try {
+        const directory = env.CODEX_HOME?.trim() || join(homedir(), ".codex");
+        const source = await readCatalogueFile(join(directory, "models_cache.json"), 8 * 1024 * 1024);
+        const parsed = cache.parse(JSON.parse(source));
+        const models = parsed.models
+            .flatMap((entry) => {
+            const parsed = model.safeParse(entry);
+            return parsed.success ? [parsed.data] : [];
+        })
+            .sort((left, right) => (left.priority ?? Infinity) - (right.priority ?? Infinity));
+        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 });
+            }
+        }
+        if (unique.size === 0)
+            throw new Error("No visible models");
+        return [...unique.values()];
+    }
+    catch {
+        // Do not expose cache contents, home paths or raw JSON errors to the browser.
+        throw new Error("Codex model metadata is unavailable. Open Codex once to refresh its model list, or enter a custom model ID.");
+    }
+}

package/dist/adapters/llm/codex.js

@@ -7,15 +7,9 @@ import { lines } from "./sse-lines.js";
 // 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";
-// ceiling: a fixed list. `codex` has no offline command that prints the models an account
-// may use - `codex doctor` reports the install, not the catalogue, and the model refresh
-// it does at start needs the login this list is meant to be readable without. These two
-// are the ids this machine's `~/.codex/config.toml` names; reading the real catalogue is
-// the upgrade when the CLI grows a command that prints it.
-export const codexModels = [
-    { id: "gpt-5.1-codex-max", name: "GPT-5.1 Codex Max" },
-    { id: "gpt-5.6-sol", name: "GPT-5.6 Sol" },
-];
+// 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 = [];
 // `codex exec --help` (0.149.1) for the flags. `-c web_search=<mode>` is a TOML override, and
 // the binary's own error names the modes: "unknown variant `bogus`, expected one of `disabled`,
 // `cached`, `indexed`, `live`". `live` is the grounded mode research asks for and `disabled` is
@@ -31,6 +25,9 @@ export function codexArgs(req) {
         "--skip-git-repo-check",
         "-c",
         `web_search="${req.webSearch === true ? "live" : "disabled"}"`,
+        ...(req.thinkingConfig?.effort
+            ? ["-c", `model_reasoning_effort="${req.thinkingConfig.effort}"`]
+            : []),
         ...(req.model === "" ? [] : ["-m", req.model]),
         // The prompt is one argv element after `--`, so a leading dash is text, not a flag.
         "--",
@@ -115,7 +112,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: () => Promise.resolve(codexModels),
+        models: deps.readModels ?? (() => Promise.resolve(codexModels)),
         complete,
     };
 }

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

@@ -0,0 +1,85 @@
+import { constants } from "node:fs";
+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);
+        const entry = await executablePath(command.args[0] ?? command.file);
+        const candidates = new Set();
+        let directory = dirname(entry);
+        // npm and bun can install the core package nested under gemini-cli or
+        // hoisted beside it. Resolve the configured executable's symlinks first.
+        for (let depth = 0; depth < 10; depth += 1) {
+            const suffix = "gemini-cli-core/dist/src/config/models.js";
+            candidates.add(join(directory, "node_modules/@google", suffix));
+            candidates.add(join(directory, suffix));
+            const parent = dirname(directory);
+            if (parent === directory)
+                break;
+            directory = parent;
+        }
+        for (const candidate of candidates) {
+            try {
+                const models = parseGeminiModels(await readCatalogueFile(candidate, 256 * 1024));
+                if (models.length > geminiModels.length)
+                    return models;
+            }
+            catch {
+                // A candidate is an optional package layout, not the final discovery result.
+            }
+        }
+        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.");
+    }
+}
+function parseGeminiModels(source) {
+    const models = new Map(geminiModels.map((model) => [model.id, model]));
+    // 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;
+    const uncommented = source.replace(/\/\*[\s\S]*?\*\//g, "");
+    for (const match of uncommented.matchAll(declarations)) {
+        const name = match[1];
+        const id = match[3];
+        if (name === undefined ||
+            id === undefined ||
+            !name.includes("MODEL") ||
+            name.includes("EMBEDDING") ||
+            !/^(?:gemini|gemma)-[a-z0-9.-]+$/.test(id))
+            continue;
+        if (!/^(?:(?:PREVIEW|DEFAULT|SECONDARY)_GEMINI_|GEMMA_)/.test(name))
+            continue;
+        models.set(id, { id, name: id });
+    }
+    return [...models.values()];
+}
+async function executablePath(binary) {
+    if (isAbsolute(binary) || /[\\/]/.test(binary))
+        return realpath(binary);
+    const path = Object.entries(process.env).find(([key]) => key.toLowerCase() === "path")?.[1] ?? "";
+    for (const directory of path.split(delimiter).slice(0, 128)) {
+        if (directory === "")
+            continue;
+        const candidate = join(directory.replace(/^"|"$/g, ""), binary);
+        try {
+            await access(candidate, constants.X_OK);
+            return await realpath(candidate);
+        }
+        catch {
+            // Continue normal PATH lookup; no process is launched for discovery.
+        }
+    }
+    throw new Error("Gemini executable was not found");
+}

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

@@ -4,7 +4,7 @@ import { join } from "node:path";
 // Gemini 0.16 supports stream-json and tools.core, but headless default mode still
 // exposes file-reading tools. Isolate each writing call while retaining ~/.gemini
 // authentication. Nothing is written into the user's settings or project.
-export function geminiWorkspace(webSearch) {
+export function geminiWorkspace(webSearch, request) {
     const directory = mkdtempSync(join(tmpdir(), "slopify-gemini-"));
     try {
         const settings = join(directory, "settings.json");
@@ -12,6 +12,29 @@ export function geminiWorkspace(webSearch) {
         const trust = join(directory, "trusted-folders.json");
         const mcpAllowlist = `slopify-disabled-${directory.split(/[\\/]/).at(-1)}`;
         writeFileSync(settings, JSON.stringify({
+            ...(request?.thinkingConfig
+                ? {
+                    modelConfigs: {
+                        customOverrides: [
+                            {
+                                match: { model: request.model },
+                                modelConfig: {
+                                    generateContentConfig: {
+                                        thinkingConfig: {
+                                            ...(request.thinkingConfig.level === undefined
+                                                ? {}
+                                                : { thinkingLevel: request.thinkingConfig.level }),
+                                            ...(request.thinkingConfig.budget === undefined
+                                                ? {}
+                                                : { thinkingBudget: request.thinkingConfig.budget }),
+                                        },
+                                    },
+                                },
+                            },
+                        ],
+                    },
+                }
+                : {}),
             tools: {
                 core: webSearch ? ["google_web_search"] : [],
                 allowed: webSearch ? ["google_web_search"] : [],

package/dist/adapters/llm/gemini.js

@@ -1,15 +1,12 @@
 import { z } from "zod";
 import { redact } from "../../kernel/log.js";
 import { providerError } from "../../kernel/ports/model.js";
+import { geminiModels } from "./gemini-models.js";
 import { geminiWorkspace } from "./gemini-workspace.js";
 import { cliEvent, cliShaped, endedWithout, promptOf } from "./run-cli.js";
 import { lines } from "./sse-lines.js";
 export const geminiBinary = "gemini";
-export const geminiModels = [
-    { id: "gemini-2.5-pro", name: "Gemini 2.5 Pro" },
-    { id: "gemini-2.5-flash", name: "Gemini 2.5 Flash" },
-    { id: "gemini-2.5-flash-lite", name: "Gemini 2.5 Flash-Lite" },
-];
+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.
@@ -46,7 +43,7 @@ export function geminiLlm(deps) {
     const binary = deps.binary ?? geminiBinary;
     async function* complete(req) {
         req.signal.throwIfAborted();
-        const workspace = geminiWorkspace(req.webSearch === true);
+        const workspace = geminiWorkspace(req.webSearch === true, req);
         let run;
         try {
             run = deps.run(binary, geminiArgs(req, workspace.mcpAllowlist), req.signal, workspace.options);
@@ -103,7 +100,7 @@ export function geminiLlm(deps) {
     return {
         id: "gemini",
         capabilities: { streams: true, reportsUsage: true, webSearch: true },
-        models: () => Promise.resolve(geminiModels),
+        models: deps.readModels ?? (() => Promise.resolve(geminiModels)),
         complete,
     };
 }

package/dist/adapters/llm/openrouter.js

@@ -14,7 +14,11 @@ const appHeaders = {
 // A wire payload is narrowed, never cast: everything unlisted is dropped at the seam so
 // no vendor shape can leak past this file.
 const modelList = z.object({
-    data: z.array(z.object({ id: z.string(), name: z.string().optional() })),
+    data: z.array(z.object({
+        id: z.string(),
+        name: z.string().optional(),
+        architecture: z.object({ output_modalities: z.array(z.string()).optional() }).optional(),
+    })),
 });
 const errorBody = z.object({
     error: z.object({ message: z.string(), code: z.union([z.number(), z.string()]).optional() }),
@@ -43,6 +47,7 @@ export function openRouterLlm(deps) {
                     role: message.role,
                     content: message.content,
                 })),
+                ...(req.thinkingConfig?.effort ? { reasoning: { effort: req.thinkingConfig.effort } } : {}),
                 stream: true,
                 // The usage-accounting flag: without it the final chunk carries no token counts
                 // and the Usage page would have nothing to count.
@@ -112,6 +117,7 @@ export function openRouterLlm(deps) {
         capabilities: { streams: true, reportsUsage: true, webSearch: true },
         models: async () => {
             const response = await deps.fetch(`${openRouterBase}/models`, {
+                signal: AbortSignal.timeout(10_000),
                 headers: headers(deps.key()),
             });
             if (!response.ok) {
@@ -124,7 +130,11 @@ export function openRouterLlm(deps) {
                     message: "OpenRouter's model list was not in the shape this app can read",
                 });
             }
-            return parsed.data.data.map((model) => ({ id: model.id, name: model.name ?? model.id }));
+            // /models defaults to text output. Also reject an explicit non-text row
+            // if a gateway response includes one; Slopify sends chat completions here.
+            return parsed.data.data
+                .filter((model) => model.architecture?.output_modalities?.includes("text") !== false)
+                .map((model) => ({ id: model.id, name: model.name ?? model.id }));
         },
         complete,
     };

package/dist/adapters/tts/cartesia.js

@@ -11,6 +11,13 @@ export const cartesiaBase = "https://api.cartesia.ai";
 // constant rather than left to the account's default.
 export const cartesiaVersion = "2026-03-01";
 export const cartesiaModel = "sonic-3.5";
+// Cartesia publishes model IDs in its docs, with no model-list API. Stable family aliases
+// receive new snapshots automatically: https://docs.cartesia.ai/build-with-cartesia/tts-models/latest
+export const cartesiaModels = [
+    { id: "sonic-3.6", name: "Sonic 3.6" },
+    { id: "sonic-3.5", name: "Sonic 3.5" },
+    { id: "sonic-3", name: "Sonic 3" },
+];
 // mp3 is the port's container; `bit_rate` is required for it and `sample_rate` fixes the
 // rate the concatenation then keeps.
 const outputFormat = { container: "mp3", bit_rate: 128_000, sample_rate: 44_100 };
@@ -24,6 +31,7 @@ export function cartesiaTts(deps) {
     return {
         id: "cartesia",
         capabilities: { streams: true },
+        models: async () => cartesiaModels,
         synthesize: async (req) => {
             const response = await deps.fetch(`${cartesiaBase}/tts/bytes`, {
                 method: "POST",
@@ -36,7 +44,7 @@ export function cartesiaTts(deps) {
                 // No pre-check on length; Cartesia's own limit surfaces as its
                 // error. `language` is left out so the model reads it off the transcript.
                 body: JSON.stringify({
-                    model_id: cartesiaModel,
+                    model_id: req.model ?? cartesiaModel,
                     transcript: req.text,
                     voice: { mode: "id", id: req.voiceId },
                     output_format: outputFormat,