@gentbajko/slopify 0.5.1 → 0.7.0

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
@@ -59,6 +53,8 @@ export function codexLlm(deps) {
                     continue;
                 }
                 const event = cliEvent(binary, line);
+                yield { type: "activity" };
+                req.signal.throwIfAborted();
                 if (event.type === "item.completed") {
                     const { item } = cliShaped(binary, itemCompleted, event.value);
                     // A turn also completes `reasoning`, `web_search`, `command_execution` and
@@ -111,10 +107,9 @@ export function codexLlm(deps) {
     }
     return {
         id: "codex",
-        // ceiling: one `item.completed` per whole message rather than per token, same as the
-        // other CLI. Enough for the idle timeout to see life on the stream.
+        // 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

@@ -0,0 +1,70 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+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) {
+    const directory = mkdtempSync(join(tmpdir(), "slopify-gemini-"));
+    try {
+        const settings = join(directory, "settings.json");
+        const system = join(directory, "writing.md");
+        const trust = join(directory, "trusted-folders.json");
+        const mcpAllowlist = `slopify-disabled-${directory.split(/[\\/]/).at(-1)}`;
+        writeFileSync(settings, JSON.stringify({
+            tools: {
+                core: webSearch ? ["google_web_search"] : [],
+                allowed: webSearch ? ["google_web_search"] : [],
+                discoveryCommand: "",
+                callCommand: "",
+                enableHooks: false,
+            },
+            mcp: { allowed: [mcpAllowlist], serverCommand: "" },
+            context: {
+                fileName: "SLOPIFY_NO_CONTEXT.md",
+                includeDirectories: [],
+                loadMemoryFromIncludeDirectories: false,
+            },
+            experimental: { codebaseInvestigatorSettings: { enabled: false } },
+            hooks: { enabled: false },
+            skills: { enabled: false },
+            ide: { enabled: false },
+            telemetry: { enabled: false },
+            privacy: { usageStatisticsEnabled: false },
+            advanced: { autoConfigureMemory: false },
+        }), { mode: 0o600 });
+        writeFileSync(system, "You are the writing and research component of Slopify, a video creation app. " +
+            "Write the requested articles, narration, research notes or image prompts. " +
+            "Follow the topic, language, tone, length and format. Return only the requested content. " +
+            "Use web search only when available and useful. Never read or modify local files. " +
+            "A backslash immediately before @ escapes a literal @ in the supplied text.\n", { mode: 0o600 });
+        // Gemini CONCAT-merges includeDirectories (even a null value). Reset the
+        // whole context object at workspace scope before the system context above.
+        // Trust only this new private workspace, leaving the user's trust file untouched.
+        mkdirSync(join(directory, ".gemini"), { mode: 0o700 });
+        writeFileSync(join(directory, ".gemini", "settings.json"), JSON.stringify({ context: null }), {
+            mode: 0o600,
+        });
+        writeFileSync(trust, JSON.stringify({ [directory]: "TRUST_FOLDER" }), { mode: 0o600 });
+        return {
+            mcpAllowlist,
+            options: {
+                cwd: directory,
+                env: {
+                    ...process.env,
+                    GEMINI_CLI_SYSTEM_SETTINGS_PATH: settings,
+                    GEMINI_CLI_TRUSTED_FOLDERS_PATH: trust,
+                    NO_BROWSER: "true",
+                    GEMINI_SYSTEM_MD: system,
+                    GEMINI_WRITE_SYSTEM_MD: "false",
+                    GEMINI_CLI_NO_RELAUNCH: "true",
+                },
+            },
+            remove: () => rmSync(directory, { recursive: true, force: true }),
+        };
+    }
+    catch (error) {
+        rmSync(directory, { recursive: true, force: true });
+        throw error;
+    }
+}

package/dist/adapters/llm/gemini.js

@@ -0,0 +1,138 @@
+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 { 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.
+export function geminiArgs(req, mcpAllowlist) {
+    return [
+        "--output-format",
+        "stream-json",
+        "--approval-mode",
+        "default",
+        "--extensions",
+        "none",
+        "--allowed-mcp-server-names",
+        mcpAllowlist,
+        ...(req.webSearch === true ? ["--allowed-tools", "google_web_search"] : []),
+        ...(req.model === "" ? [] : ["--model", req.model]),
+        "-p",
+        // The prefix prevents slash-command dispatch; escaping @ prevents Gemini's
+        // input preprocessor from reading files even when read tools are disabled.
+        `Produce the requested content from this conversation:\n\n${promptOf(req.messages).replaceAll("@", "\\@")}`,
+    ];
+}
+const messageSchema = z.object({
+    role: z.string(),
+    content: z.string(),
+    delta: z.boolean().optional(),
+});
+const errorSchema = z.object({ severity: z.string(), message: z.string() });
+const resultSchema = z.object({
+    status: z.string(),
+    error: z.object({ message: z.string(), type: z.string().optional() }).optional(),
+    stats: z.object({ input_tokens: z.number(), output_tokens: z.number() }).optional(),
+});
+export function geminiLlm(deps) {
+    const binary = deps.binary ?? geminiBinary;
+    async function* complete(req) {
+        req.signal.throwIfAborted();
+        const workspace = geminiWorkspace(req.webSearch === true);
+        let run;
+        try {
+            run = deps.run(binary, geminiArgs(req, workspace.mcpAllowlist), req.signal, workspace.options);
+            for await (const line of lines(authChecked(run.stdout), req.signal)) {
+                if (line.trim() === "")
+                    continue;
+                const event = cliEvent(binary, line);
+                yield { type: "activity" };
+                req.signal.throwIfAborted();
+                if (event.type === "message") {
+                    const message = cliShaped(binary, messageSchema, event.value);
+                    if (message.role === "assistant" && message.content !== "")
+                        yield { type: "delta", text: message.content };
+                }
+                else if (event.type === "error") {
+                    const error = cliShaped(binary, errorSchema, event.value);
+                    if (error.severity !== "warning")
+                        throw failure(error.message);
+                }
+                else if (event.type === "result") {
+                    const result = cliShaped(binary, resultSchema, event.value);
+                    if (result.status !== "success")
+                        throw failure(result.error?.message ?? result.status);
+                    yield {
+                        type: "done",
+                        usage: result.stats === undefined
+                            ? null
+                            : {
+                                inputTokens: result.stats.input_tokens,
+                                outputTokens: result.stats.output_tokens,
+                            },
+                        finishReason: null,
+                    };
+                    return;
+                }
+            }
+            req.signal.throwIfAborted();
+            const ended = await run.ended;
+            if (authRequired(run.stderr()))
+                throw authFailure();
+            throw failure(endedWithout(binary, ended, run.stderr()));
+        }
+        catch (error) {
+            req.signal.throwIfAborted();
+            throw error;
+        }
+        finally {
+            run?.kill();
+            if (run !== undefined)
+                await run.ended;
+            workspace.remove();
+        }
+    }
+    return {
+        id: "gemini",
+        capabilities: { streams: true, reportsUsage: true, webSearch: true },
+        models: deps.readModels ?? (() => Promise.resolve(geminiModels)),
+        complete,
+    };
+}
+function failure(message) {
+    if (/(?:#?3501\b|do not have a valid licen[cs]e of this product)/i.test(message)) {
+        return providerError({
+            kind: "unsupported",
+            message: "Gemini CLI access was denied by Google's license check (#3501). Update Gemini CLI and sign in again. For a managed account, contact your administrator to request a license.",
+        });
+    }
+    return authRequired(message)
+        ? authFailure()
+        : providerError({ kind: "other", message: redact(message) });
+}
+function authRequired(message) {
+    return /Code Assist login required|authorize the application|authorization code|Please set an Auth method|re-authenticate|reauthenticate/i.test(message);
+}
+function authFailure() {
+    return providerError({
+        kind: "missing_key",
+        message: "Gemini CLI needs sign-in. Run gemini in your terminal, complete login, then retry in Slopify.",
+    });
+}
+async function* authChecked(source) {
+    const decoder = new TextDecoder();
+    let tail = "";
+    for await (const bytes of source) {
+        tail = (tail + decoder.decode(bytes, { stream: true })).slice(-8192);
+        // NO_BROWSER prevents opening OAuth. A logged-out CLI instead writes this
+        // non-JSON prompt without a newline; fail before lines() waits for user input.
+        if (/^(?:Enter the authorization code:|Please visit the following URL to authorize)/m.test(tail))
+            throw authFailure();
+        yield bytes;
+    }
+}

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() }),
@@ -112,6 +116,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 +129,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/llm/run-cli.js

@@ -1,5 +1,6 @@
 import { spawn } from "node:child_process";
 import { z } from "zod";
+import { cliCommand } from "../../kernel/cli-command.js";
 import { redact } from "../../kernel/log.js";
 import { providerError } from "../../kernel/ports/model.js";
 // ceiling: the last 8 KiB of stderr is kept. A CLI that writes megabytes of progress there
@@ -7,16 +8,18 @@ import { providerError } from "../../kernel/ports/model.js";
 // says why it stopped. Streaming stderr to the log is the upgrade if a provider ever
 // buries its reason in the first line of a long report.
 export const stderrMax = 8192;
-export function nodeRunCli(binary, args, signal) {
+export function nodeRunCli(binary, args, signal, options) {
     // An argument array, never a shell string: a prompt carrying backticks, `$(...)`, quotes or
     // newlines is one argv element and nothing in it can become a command. stdin is /dev/null
     // because `codex exec` appends piped stdin to the prompt, and a pipe nobody closes would
     // leave it waiting for an EOF that never comes. `signal` is how the child dies: Node sends it
     // SIGTERM when the stage is cancelled, so no agent session outlives the run that started it.
-    const child = spawn(binary, [...args], {
+    const command = cliCommand(binary);
+    const child = spawn(command.file, [...command.args, ...args], {
         signal,
         stdio: ["ignore", "pipe", "pipe"],
         windowsHide: true,
+        ...options,
     });
     let stderr = "";
     const errorStream = child.stderr;
@@ -38,13 +41,7 @@ export function nodeRunCli(binary, args, signal) {
             resolve({ code, error: spawnError });
         };
         child.once("close", settle);
-        // `close` follows `error` when the streams were opened; this is the belt for the case
-        // where they were not.
-        child.once("error", () => {
-            setImmediate(() => {
-                settle(null);
-            });
-        });
+        // Close follows an error too; waiting for it keeps cleanup behind process exit.
     });
     return {
         pid: child.pid,

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,

package/dist/adapters/tts/elevenlabs.js

@@ -10,9 +10,22 @@ export const elevenLabsBase = "https://api.elevenlabs.io/v1";
 // attempt wrapper measures its 120 s as an idle timeout between chunks only when bytes
 // keep arriving.
 export const elevenLabsModel = "eleven_multilingual_v2";
+export const elevenLabsModels = [
+    { id: "eleven_v3", name: "Eleven v3" },
+    { id: "eleven_multilingual_v2", name: "Eleven Multilingual v2" },
+    { id: "eleven_flash_v2_5", name: "Eleven Flash v2.5" },
+    { id: "eleven_flash_v2", name: "Eleven Flash v2" },
+    { id: "eleven_turbo_v2_5", name: "Eleven Turbo v2.5 (deprecated)" },
+    { id: "eleven_turbo_v2", name: "Eleven Turbo v2 (deprecated)" },
+];
 // mp3 at the port's container, 44.1 kHz, 128 kbps: `kernel/ports/tts.ts` fixes mp3 and the
 // concatenation keeps the provider's own sample rate.
 export const elevenLabsFormat = "mp3_44100_128";
+const modelList = z.array(z.object({
+    model_id: z.string().min(1),
+    name: z.string().optional(),
+    can_do_text_to_speech: z.boolean().optional(),
+}));
 // A wire payload is narrowed, never cast. `detail` is an object on a handled failure and
 // a string on the framework's own; anything else falls back to the raw text.
 const errorBody = z.object({
@@ -25,6 +38,24 @@ export function elevenLabsTts(deps) {
     return {
         id: "elevenlabs",
         capabilities: { streams: true },
+        models: async () => {
+            const response = await deps.fetch(`${elevenLabsBase}/models`, {
+                headers: { "xi-api-key": keyOf(deps) },
+                signal: AbortSignal.timeout(10_000),
+            });
+            if (!response.ok)
+                throw await failure(response);
+            const parsed = modelList.safeParse(safeJson(await response.text()));
+            if (!parsed.success) {
+                throw providerError({
+                    kind: "other",
+                    message: "ElevenLabs' model list was not in the shape this app can read",
+                });
+            }
+            return parsed.data
+                .filter((model) => model.can_do_text_to_speech === true)
+                .map((model) => ({ id: model.model_id, name: model.name || model.model_id }));
+        },
         synthesize: async (req) => {
             const voice = encodeURIComponent(req.voiceId);
             const response = await deps.fetch(`${elevenLabsBase}/text-to-speech/${voice}/stream?output_format=${elevenLabsFormat}`, {
@@ -33,7 +64,7 @@ export function elevenLabsTts(deps) {
                 headers: { "xi-api-key": keyOf(deps), "Content-Type": "application/json" },
                 // No pre-check on length. A text past the model's limit comes
                 // back as the provider's own 400 and that is what the stage shows.
-                body: JSON.stringify({ text: req.text, model_id: elevenLabsModel }),
+                body: JSON.stringify({ text: req.text, model_id: req.model ?? elevenLabsModel }),
             });
             if (!response.ok) {
                 throw await failure(response, req.voiceId);
@@ -75,7 +106,7 @@ async function failure(response, voiceId) {
         kind: kindOf(response.status),
         // A rejected voice ID has to be named, and it is the one part of the
         // request the user chose. It is not secret, unlike everything else on the wire.
-        message: `ElevenLabs answered ${response.status} for voice ${voiceId}: ${message}`,
+        message: `ElevenLabs answered ${response.status}${voiceId === undefined ? "" : ` for voice ${voiceId}`}: ${message}`,
         ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
     });
 }

package/dist/adapters/tts/inworld-async.js

@@ -0,0 +1,150 @@
+import { z } from "zod";
+import { redact } from "../../kernel/log.js";
+import { providerError } from "../../kernel/ports/model.js";
+import { retryAfter } from "../retry-after.js";
+const operationName = /^workspaces\/[A-Za-z0-9_-]+\/ttsAsyncJobs\/[A-Za-z0-9_-]+\/operations\/[A-Za-z0-9_-]+$/;
+const operationSchema = z.object({
+    name: z.string().regex(operationName),
+    done: z.boolean().optional(),
+    error: z.object({ code: z.number().optional(), message: z.string().optional() }).nullish(),
+    response: z.object({ audioUri: z.string() }).nullish(),
+});
+// Async is documented for TTS-2 only. Flash continues using the streaming API.
+// A continuation survives automatic retries of this call; pausing/restarting a
+// stage stops local polling but cannot cancel an already accepted remote job.
+export async function* inworldAsync(deps, request, key) {
+    if (request.text.length > 100_000) {
+        throw providerError({
+            kind: "unsupported",
+            message: "Inworld async accepts up to 100,000 characters per request (10,000 for On-Demand accounts). Select paragraph chunking for longer articles.",
+        });
+    }
+    const headers = { Authorization: `Basic ${key}`, "Content-Type": "application/json" };
+    const saved = request.continuation?.read();
+    if (saved && !operationName.test(saved))
+        throw invalid("returned an invalid operation name");
+    request.signal.throwIfAborted();
+    let response = await deps.fetch(saved
+        ? `https://api.inworld.ai/lro/v1alpha/${saved}`
+        : "https://api.inworld.ai/tts/v1/voice:synthesizeAsync", {
+        method: saved ? "GET" : "POST",
+        headers,
+        signal: request.signal,
+        redirect: "error",
+        ...(saved
+            ? {}
+            : {
+                body: JSON.stringify({
+                    text: request.text,
+                    voiceId: request.voiceId,
+                    modelId: request.model ?? "inworld-tts-2",
+                    audioConfig: { audioEncoding: "MP3", sampleRateHertz: 48_000, bitRate: 128_000 },
+                }),
+            }),
+    });
+    let expected = saved;
+    for (;;) {
+        request.signal.throwIfAborted();
+        await check(response, key);
+        const parsed = operationSchema.safeParse(await response.json().catch(() => null));
+        if (!parsed.success || (expected && parsed.data.name !== expected))
+            throw invalid("returned an invalid operation");
+        const operation = parsed.data;
+        expected = operation.name;
+        request.continuation?.write(operation.name);
+        request.onActivity?.();
+        request.signal.throwIfAborted();
+        if (operation.done) {
+            if (operation.error) {
+                const { code, message } = operation.error;
+                throw providerError({
+                    kind: code === 7 || code === 16
+                        ? "auth"
+                        : code === 8
+                            ? "rate_limit"
+                            : code === 3 || code === 5 || code === 9
+                                ? "unsupported"
+                                : "other",
+                    message: `Inworld async job failed: ${clean(message ?? "audio generation stopped", key)}`,
+                });
+            }
+            if (!operation.response)
+                throw invalid("finished without an audio download");
+            yield* download(deps.fetch, operation.response.audioUri, request.signal);
+            return;
+        }
+        await deps.clock.sleep(5000, request.signal);
+        request.signal.throwIfAborted();
+        response = await deps.fetch(`https://api.inworld.ai/lro/v1alpha/${operation.name}`, {
+            headers,
+            signal: request.signal,
+            redirect: "error",
+        });
+    }
+}
+async function* download(fetch, uri, signal) {
+    const url = URL.parse(uri);
+    if (url?.protocol !== "https:" || url.username || url.password)
+        throw invalid("returned an invalid audio download URL");
+    // This is a signed storage URL, not an Inworld API endpoint. Never forward Basic auth.
+    let response;
+    try {
+        response = await fetch(url.href, { signal, redirect: "error" });
+    }
+    catch {
+        signal.throwIfAborted();
+        // Signed query parameters must not become a persisted error or log entry.
+        throw invalid("audio download could not be reached; retrying the existing job");
+    }
+    if (!response.ok)
+        throw invalid(`audio download answered ${response.status}; retrying the existing job`);
+    if (!response.body)
+        throw invalid("answered with no audio");
+    const reader = response.body.getReader();
+    let heard = false;
+    try {
+        for (;;) {
+            const { value, done } = await reader.read();
+            signal.throwIfAborted();
+            if (done)
+                break;
+            if (value.length) {
+                heard = true;
+                yield value;
+            }
+        }
+    }
+    catch {
+        signal.throwIfAborted();
+        throw invalid("audio download stopped; retrying the existing job");
+    }
+    finally {
+        await reader.cancel().catch(() => { });
+        reader.releaseLock();
+    }
+    if (!heard)
+        throw invalid("answered with no audio");
+}
+async function check(response, key) {
+    if (response.ok)
+        return;
+    const detail = clean(await response.text().catch(() => ""), key);
+    const retryAfterMs = retryAfter(response.headers.get("retry-after"));
+    throw providerError({
+        kind: response.status === 401 || response.status === 403
+            ? "auth"
+            : response.status === 429
+                ? "rate_limit"
+                : response.status === 400 || response.status === 404
+                    ? "unsupported"
+                    : "other",
+        message: `Inworld async answered ${response.status}: ${detail || response.statusText}`,
+        ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
+    });
+}
+function clean(message, key) {
+    return redact(message.replaceAll(key, "[redacted]"));
+}
+function invalid(detail) {
+    return providerError({ kind: "other", message: `Inworld ${detail}.` });
+}