@gentbajko/slopify 2.5.0 → 3.0.1

package/dist/adapters/llm/codex.js

@@ -6,9 +6,11 @@ import { redact } from "../../kernel/log.js";
 import { providerError } from "../../kernel/ports/model.js";
 import { cliCheck, cliReported } from "../explain.js";
 import { cliLoginError } from "./cli-login-error.js";
+import { codexPlanLimit } from "./codex-limits.js";
 import { nodeCodexModels } from "./codex-models.js";
 import { documentServerName, documentTool, documentWorkspace, } from "./document-workspace.js";
-import { cliEvent, cliInput, cliShaped, deliveredInput, endedWithout, promptOf, stopCliRun, stuckCli, } from "./run-cli.js";
+import { imageWorkspace } from "./image-workspace.js";
+import { cliEvent, cliInput, cliShaped, deliveredInput, endedKind, endedWithout, promptOf, stopCliRun, stuckCli, } 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.*`
@@ -45,7 +47,12 @@ const disabledFeatures = [
 // plus a zero project-doc budget excludes AGENTS.md and project `.codex` context. Read-only is
 // defense in depth if a future release exposes a new filesystem tool. The TOML strings keep their
 // quotes because each `-c` value is parsed as TOML rather than as a shell expression.
-export function codexArgs(req, directory, documents) {
+//
+// Pictures (a review's) are attached to the prompt with `--image` (`codex exec --help` 0.155.1:
+// "-i, --image <FILE>... Optional image(s) to attach to the initial prompt"), which needs no
+// tool: `view_image` stays disabled. Each is given as its own flag so a path is never read as
+// the prompt.
+export function codexArgs(req, directory, documents, images) {
     return [
         "exec",
         "--json",
@@ -100,19 +107,29 @@ export function codexArgs(req, directory, documents) {
                 }).flatMap(([key, value]) => ["-c", `mcp_servers.${documentServerName}.${key}=${value}`]),
             ]
             : []),
+        ...(images?.files.flatMap((one) => ["--image", one.path]) ?? []),
         // A literal '-' requests stdin; report bodies never become OS arguments.
         "--",
         "-",
     ];
 }
+const itemProgress = z.object({
+    item: z.object({ id: z.string().optional(), type: z.string(), text: z.string().optional() }),
+});
 const itemCompleted = z.object({
     item: z.object({ type: z.string(), text: z.string().optional() }),
 });
 // The field names are the shipped binary's own: `TurnCompletedEvent` carries `usage`, and
 // its counts are `input_tokens`, `cached_input_tokens`, `cache_write_input_tokens`,
-// `output_tokens`, `reasoning_output_tokens`. Only the two the port has a home for are read.
+// `output_tokens`, `reasoning_output_tokens`. `input_tokens` already counts the cached ones.
 const turnCompleted = z.object({
-    usage: z.object({ input_tokens: z.number(), output_tokens: z.number() }).nullish(),
+    usage: z
+        .object({
+        input_tokens: z.number(),
+        output_tokens: z.number(),
+        cached_input_tokens: z.number().optional(),
+    })
+        .nullish(),
 });
 const turnFailed = z.object({ error: z.object({ message: z.string() }) });
 // The top-level `error` event carries its text in `message`, not in `error.message`.
@@ -123,13 +140,27 @@ export function codexLlm(deps) {
         req.signal.throwIfAborted();
         const workspace = codexWorkspace(deps.env ?? process.env);
         let documents;
+        const typed = new Map();
+        let images;
         let run;
         let ended;
+        // Asked beside the run rather than before it: the read takes about a second and the
+        // turn spends nothing until its first answer, so the reading is still the one before.
+        const before = deps.readLimits?.().catch(() => null);
         try {
             documents = documentWorkspace(req.documents);
-            run = deps.run(binary, codexArgs(req, workspace.directory, documents), req.signal, {
+            images = imageWorkspace(req.images);
+            run = deps.run(binary, codexArgs(req, workspace.directory, documents, images), req.signal, {
                 ...workspace.options,
-                stdin: cliInput([documents?.instructions, promptOf(req.messages)].filter(Boolean).join("\n\n")),
+                stdin: cliInput([
+                    documents?.instructions,
+                    images === undefined
+                        ? undefined
+                        : `The attached images, in order:\n${images.files.map((one, index) => `${String(index + 1)}. ${one.name}`).join("\n")}`,
+                    promptOf(req.messages),
+                ]
+                    .filter(Boolean)
+                    .join("\n\n")),
             });
             for await (const line of lines(run.stdout, req.signal)) {
                 if (line.trim() === "") {
@@ -138,6 +169,21 @@ export function codexLlm(deps) {
                 const event = cliEvent(binary, line);
                 yield { type: "activity" };
                 req.signal.throwIfAborted();
+                // An agent message may be reported while it is written; its text so far is shown on
+                // the live panel, and only the completed item becomes the answer.
+                if (event.type === "item.started" || event.type === "item.updated") {
+                    const item = itemProgress.safeParse(event.value);
+                    if (item.success && item.data.item.type === "agent_message") {
+                        const id = item.data.item.id ?? "";
+                        const seen = typed.get(id) ?? "";
+                        const text = item.data.item.text ?? "";
+                        if (text.length > seen.length && text.startsWith(seen)) {
+                            typed.set(id, text);
+                            yield { type: "partial", text: text.slice(seen.length) };
+                        }
+                    }
+                    continue;
+                }
                 if (event.type === "item.completed") {
                     const { item } = cliShaped(binary, itemCompleted, event.value);
                     // A turn also completes `reasoning`, `web_search`, `command_execution` and
@@ -156,22 +202,36 @@ export function codexLlm(deps) {
                     // ceiling: Codex reports no stop reason, so the continuation loop cannot tell a
                     // finished answer from one cut at the output limit. A `--output-schema` run
                     // would, at the cost of constraining every stage's answer.
-                    yield { type: "done", usage: usageOf(usage), finishReason: null };
+                    const limits = await readingOf(before, deps.readLimits);
+                    yield {
+                        type: "done",
+                        usage: usageOf(usage),
+                        finishReason: null,
+                        ...(limits === undefined ? {} : { limits }),
+                    };
                     return;
                 }
                 if (event.type === "turn.failed") {
-                    const login = cliLoginError("codex", cliShaped(binary, turnFailed, event.value).error.message);
+                    const failed = cliShaped(binary, turnFailed, event.value).error.message;
+                    const login = cliLoginError("codex", failed);
                     if (login)
                         throw login;
+                    const planLimit = codexPlanLimit(failed, (deps.now ?? (() => new Date()))());
+                    if (planLimit !== undefined)
+                        throw codexLimitError(failed, planLimit);
                     throw providerError({
                         kind: "other",
                         message: cliReported(binary, redact(cliShaped(binary, turnFailed, event.value).error.message), cliCheck(binary)),
                     });
                 }
                 if (event.type === "error") {
-                    const login = cliLoginError("codex", cliShaped(binary, errorEvent, event.value).message);
+                    const failed = cliShaped(binary, errorEvent, event.value).message;
+                    const login = cliLoginError("codex", failed);
                     if (login)
                         throw login;
+                    const planLimit = codexPlanLimit(failed, (deps.now ?? (() => new Date()))());
+                    if (planLimit !== undefined)
+                        throw codexLimitError(failed, planLimit);
                     throw providerError({
                         kind: "other",
                         message: cliReported(binary, redact(cliShaped(binary, errorEvent, event.value).message), cliCheck(binary)),
@@ -190,6 +250,7 @@ export function codexLlm(deps) {
             }
             finally {
                 documents?.remove();
+                images?.remove();
                 workspace.remove();
             }
         }
@@ -201,15 +262,18 @@ export function codexLlm(deps) {
         const login = cliLoginError("codex", run.stderr());
         if (login)
             throw login;
+        const planLimit = codexPlanLimit(run.stderr(), (deps.now ?? (() => new Date()))());
+        if (planLimit !== undefined)
+            throw codexLimitError(run.stderr().trim(), planLimit);
         throw providerError({
-            kind: "other",
+            kind: endedKind(ended),
             message: ended === undefined ? stuckCli(binary) : endedWithout(binary, ended, run.stderr()),
         });
     }
     return {
         id: "codex",
         // Prose arrives as whole messages; other JSONL events carry activity separately.
-        capabilities: { streams: true, reportsUsage: true, webSearch: true },
+        capabilities: { streams: true, reportsUsage: true, webSearch: true, images: true },
         models: deps.readModels ?? (() => nodeCodexModels(process.env, binary)),
         complete,
     };
@@ -238,5 +302,28 @@ function codexWorkspace(sourceEnv) {
 function usageOf(usage) {
     return usage === null || usage === undefined
         ? null
-        : { inputTokens: usage.input_tokens, outputTokens: usage.output_tokens };
+        : {
+            inputTokens: usage.input_tokens,
+            outputTokens: usage.output_tokens,
+            ...(usage.cached_input_tokens ? { cachedInputTokens: usage.cached_input_tokens } : {}),
+        };
+}
+// The windows before (already asked) and after the call; undefined when neither arrived.
+export async function readingOf(before, read) {
+    if (read === undefined)
+        return undefined;
+    const [start, end] = await Promise.all([before, read().catch(() => null)]);
+    if (!start?.length && !end?.length)
+        return undefined;
+    return {
+        ...(start?.length ? { before: start } : {}),
+        ...(end?.length ? { after: end } : {}),
+    };
+}
+export function codexLimitError(message, planLimit) {
+    return providerError({
+        kind: "rate_limit",
+        message: `Your Codex plan's usage limit is used up (the Codex CLI said: ${redact(message)}). Slopify waits for it to reset and then carries on by itself.`,
+        planLimit,
+    });
 }

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

@@ -16,7 +16,7 @@ export function documentWorkspace(input) {
     if (!parsed.success)
         throw providerError({
             kind: "unsupported",
-            message: "The research notes are too large, or not in a form the AI model can be given, so nothing was sent. Make the inputs shorter in Edit project, then use Retry stage; if it keeps happening, use Download diagnostics in Settings and report it.",
+            message: "The research notes are too large, or not in a form the AI model can be given, so nothing was sent. Make the inputs shorter in Edit project, then use Try again; if it keeps happening, use Download diagnostics in Settings and report it.",
         });
     const documents = parsed.data;
     const directory = mkdtempSync(join(tmpdir(), "slopify-documents-"));
@@ -82,6 +82,6 @@ export function documentWorkspace(input) {
 function unread() {
     return providerError({
         kind: "unavailable",
-        message: "The AI model did not read all of the research notes, so its answer was not used (the attempt may still have used your quota). Use Retry stage; if it keeps happening, choose another model in the Providers section of Edit project.",
+        message: "The AI model did not read all of the research notes, so its answer was not used (the attempt may still have used your quota). Use Try again; if it keeps happening, choose another model in the Providers section of Edit project.",
     });
 }

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

@@ -33,7 +33,7 @@ export function geminiWorkspace(webSearch, request, documents, env = process.env
             catch {
                 throw providerError({
                     kind: "unavailable",
-                    message: "Slopify could not read the Gemini CLI's settings file (settings.json in the .gemini folder of your home directory), which says how it signs in. Fix or remove that file, run gemini in a terminal to sign in again, then use Retry stage.",
+                    message: "Slopify could not read the Gemini CLI's settings file (settings.json in the .gemini folder of your home directory), which says how it signs in. Fix or remove that file, run gemini in a terminal to sign in again, then use Try again.",
                 });
             }
         const oauth = join(originalState, "oauth_creds.json");

package/dist/adapters/llm/gemini.js

@@ -5,6 +5,7 @@ import { cliCheck, cliName, cliReported } from "../explain.js";
 import { documentWorkspace } from "./document-workspace.js";
 import { nodeGeminiModels } from "./gemini-models.js";
 import { geminiWorkspace } from "./gemini-workspace.js";
+import { noImages } from "./image-workspace.js";
 import { cliEvent, cliInput, cliShaped, deliveredInput, endedWithout, promptOf, stopCliRun, stuckCli, } from "./run-cli.js";
 import { lines } from "./sse-lines.js";
 export const geminiBinary = "gemini";
@@ -42,6 +43,9 @@ export function geminiLlm(deps) {
     const binary = deps.binary ?? geminiBinary;
     async function* complete(req) {
         req.signal.throwIfAborted();
+        // Its CLI has no image flag, and `@file` inclusion would need a file tool this adapter keeps off.
+        if (req.images?.length)
+            throw noImages("the Gemini CLI");
         const documents = documentWorkspace(req.documents);
         let workspace;
         let run;
@@ -104,7 +108,7 @@ export function geminiLlm(deps) {
         }
         req.signal.throwIfAborted();
         if (run === undefined)
-            throw failure(binary, "", `The ${cliName(binary)} could not be started. Check it is installed and set up in Settings → Providers, then use Retry stage.`);
+            throw failure(binary, "", `The ${cliName(binary)} could not be started. Check it is installed and set up in Settings → Providers, then use Try again.`);
         if (authRequired(run.stderr()))
             throw authFailure();
         throw failure(binary, run.stderr(), ended === undefined ? stuckCli(binary) : endedWithout(binary, ended, run.stderr()));
@@ -122,7 +126,16 @@ function failure(binary, message, sentence) {
     if (/(?:#?3501\b|do not have a valid licen[cs]e of this product)/i.test(message)) {
         return providerError({
             kind: "unsupported",
-            message: "Google refused the Gemini CLI because the signed-in account has no licence for it (#3501). Update the Gemini CLI, run gemini in a terminal to sign in again, then use Retry stage; for a work or school account, ask your administrator for a Gemini licence.",
+            message: "Google refused the Gemini CLI because the signed-in account has no licence for it (#3501). Update the Gemini CLI, run gemini in a terminal to sign in again, then use Try again; for a work or school account, ask your administrator for a Gemini licence.",
+        });
+    }
+    // The daily allowance of a signed-in Gemini plan. The CLI names no reset time, so the wait
+    // checks again later; a per-minute quota is an ordinary rate limit and is retried as one.
+    if (/(?:daily|per.day).{0,40}quota|quota.{0,40}(?:daily|per.day)/i.test(message)) {
+        return providerError({
+            kind: "rate_limit",
+            message: `Your Gemini plan's daily quota is used up (the Gemini CLI said: ${redact(message)}). Slopify waits and tries again later by itself.`,
+            planLimit: { account: "gemini", resetsAt: null },
         });
     }
     return authRequired(message)
@@ -138,7 +151,7 @@ function authRequired(message) {
 function authFailure() {
     return providerError({
         kind: "missing_key",
-        message: 'The Gemini CLI is not signed in, or its sign-in has expired. Open a terminal on the computer running the CLI, run "gemini" and sign in, then use Retry stage.',
+        message: 'The Gemini CLI is not signed in, or its sign-in has expired. Open a terminal on the computer running the CLI, run "gemini" and sign in, then use Try again.',
     });
 }
 async function* authChecked(source) {

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

@@ -0,0 +1,58 @@
+import { copyFileSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, extname, join } from "node:path";
+import { providerError } from "../../kernel/ports/model.js";
+const extensions = new Set([".png", ".jpg", ".jpeg", ".webp"]);
+// ceiling: a review shows one image, or a short's handful plus the establishing image.
+export const imagesMax = 12;
+// The pictures a CLI model is asked to look at, copied into a private folder of their own so
+// the CLI's file tool can be confined to it: nothing else on the disk is in reach.
+export function imageWorkspace(input) {
+    if (!input?.length)
+        return undefined;
+    if (input.length > imagesMax ||
+        input.some((image) => !extensions.has(extname(image.path).toLowerCase())))
+        throw providerError({
+            kind: "unsupported",
+            message: "Slopify could not hand these pictures to the reviewer (too many, or not PNG, JPEG or WebP files), so nothing was sent. Use Try again; if it happens again, use Download diagnostics in Settings and report it.",
+        });
+    const directory = mkdtempSync(join(tmpdir(), "slopify-images-"));
+    const remove = () => rmSync(directory, { recursive: true, force: true, maxRetries: 3 });
+    try {
+        const files = input.map((image, index) => {
+            const file = `image-${String(index + 1)}${extname(image.path).toLowerCase()}`;
+            copyFileSync(image.path, join(directory, file));
+            return { file, path: join(directory, file), name: image.name };
+        });
+        return {
+            directory,
+            files,
+            remove,
+            instructions: `Open and look at every one of these image files with the Read tool before you answer; they are in the current folder and are the only files you may open:\n${files.map((one) => `- ${one.file}: ${one.name}`).join("\n")}`,
+            // Which files a Read call named, by file name: the CLI may report a relative or an
+            // absolute path.
+            unread(read) {
+                return files.filter((one) => !read.has(one.file)).map((one) => one.file);
+            },
+        };
+    }
+    catch (error) {
+        remove();
+        throw error;
+    }
+}
+export function readFileName(path) {
+    return typeof path === "string" && path !== "" ? basename(path) : undefined;
+}
+export function unseenImages() {
+    return providerError({
+        kind: "unavailable",
+        message: "The reviewer answered without opening every picture it was given, so its verdict was not used (the attempt may still have used your quota). Use Try again; if it keeps happening, choose Codex as the reviewer in Edit project → Reviews.",
+    });
+}
+export function noImages(provider) {
+    return providerError({
+        kind: "unsupported",
+        message: `Slopify can't show pictures to ${provider}, so a review that needs them was not sent. In Edit project → Reviews, choose Claude Code or Codex as the reviewer, or set the picture reviews to Off, then use Try again.`,
+    });
+}

package/dist/adapters/llm/openrouter.js

@@ -4,6 +4,7 @@ import { documentMessages } from "../../kernel/ports/llm-documents.js";
 import { providerError } from "../../kernel/ports/model.js";
 import { droppedStream, httpFailure, missingKey, providerSaid, refreshList, unreadable, } from "../explain.js";
 import { retryAfter } from "../retry-after.js";
+import { noImages } from "./image-workspace.js";
 import { sseData } from "./sse-lines.js";
 // The HTTP gateway adapter: the platform's own `fetch` plus the line reader beside this
 // file, no SDK. Neither is worth a dependency.
@@ -39,6 +40,10 @@ const streamChunk = z.object({
 });
 export function openRouterLlm(deps) {
     async function* complete(req) {
+        // ceiling: text only. The catalogue does not yet say which models take images, and an older
+        // Slopify parses the fetched catalogue strictly, so a new key there would break it.
+        if (req.images?.length)
+            throw noImages("OpenRouter models");
         const response = await deps.fetch(`${openRouterBase}/chat/completions`, {
             method: "POST",
             signal: req.signal,
@@ -63,7 +68,7 @@ export function openRouterLlm(deps) {
             throw await failure(response);
         }
         if (response.body === null) {
-            throw providerError({ kind: "other", message: droppedStream("OpenRouter") });
+            throw providerError({ kind: "dropped", message: droppedStream("OpenRouter") });
         }
         let usage = null;
         let finishReason = null;
@@ -108,7 +113,7 @@ export function openRouterLlm(deps) {
             // Neither `[DONE]` nor the usage frame arrived, so the connection dropped part-way.
             // Saying so is what stops a truncated answer being stored as a whole one.
             throw providerError({
-                kind: "other",
+                kind: "dropped",
                 message: droppedStream("OpenRouter"),
             });
         }
@@ -162,6 +167,9 @@ function kindOf(status) {
     // ceiling: everything else is `other` and is retried, so a 400 or a 402 fails the same
     // way four times over. A terminal "this will never work" kind has to reach the port's
     // error contract first, which is not this adapter's to widen.
+    // The provider's own server failed; the same request may well succeed later.
+    if (status >= 500)
+        return "dropped";
     return "other";
 }
 async function failure(response, next) {
@@ -185,7 +193,7 @@ async function failure(response, next) {
 function streamFailure(status, detail) {
     return status >= 400
         ? httpFailure({ provider: "OpenRouter", status, detail })
-        : providerSaid("OpenRouter", "stopped part-way through the answer", detail, "Use Retry stage; if it keeps happening, choose another model in the Providers section of Edit project.");
+        : providerSaid("OpenRouter", "stopped part-way through the answer", detail, "Use Try again; if it keeps happening, choose another model in the Providers section of Edit project.");
 }
 function statusOf(code) {
     return typeof code === "number" ? code : Number(code ?? 0);

package/dist/adapters/llm/run-cli.js

@@ -130,7 +130,7 @@ export async function deliveredInput(run) {
     catch {
         throw providerError({
             kind: "unavailable",
-            message: "Slopify could not hand the whole prompt to the CLI, so it cannot tell what the CLI worked on (it may already have used your quota). Use Retry stage to run it again.",
+            message: "Slopify could not hand the whole prompt to the CLI, so it cannot tell what the CLI worked on (it may already have used your quota). Use Try again to run it again.",
         });
     }
 }
@@ -139,7 +139,7 @@ export function cliInput(text) {
     if (Buffer.byteLength(text) >= 8 * 1024 * 1024)
         throw providerError({
             kind: "unsupported",
-            message: "This prompt is larger than the CLI accepts (8 MB), so nothing was sent. Make the inputs shorter in Edit project, or choose an API provider such as OpenRouter in its Providers section, then use Retry stage.",
+            message: "This prompt is larger than the CLI accepts (8 MB), so nothing was sent. Make the inputs shorter in Edit project, or choose an API provider such as OpenRouter in its Providers section, then use Try again.",
         });
     return text;
 }
@@ -168,13 +168,18 @@ export function promptOf(messages) {
 export function endedWithout(binary, ended, stderr) {
     const said = redact(stderr.trim());
     if (ended.error !== null)
-        return `The ${cliName(binary)} could not be started${quoted("", redact(ended.error.message))}. Check it is installed and set up in Settings → Providers, then use Retry stage.`;
+        return `The ${cliName(binary)} could not be started${quoted("", redact(ended.error.message))}. Check it is installed and set up in Settings → Providers, then use Try again.`;
     const how = ended.code === null ? "killed by the system" : `exit code ${String(ended.code)}`;
-    return `The ${cliName(binary)} stopped without answering${quoted(how, said)}. Run ${commandOf(binary)} in a terminal to check it works and is signed in, then use Retry stage.`;
+    return `The ${cliName(binary)} stopped without answering${quoted(how, said)}. Run ${commandOf(binary)} in a terminal to check it works and is signed in, then use Try again.`;
+}
+// A CLI the system killed mid-answer (out of memory, a sleep, a closed session) dropped the
+// call; one that exited with an error of its own said something about the request.
+export function endedKind(ended) {
+    return ended !== undefined && ended.error === null && ended.code === null ? "dropped" : "other";
 }
 // The run outlived both the polite and the forced stop.
 export function stuckCli(binary) {
-    return `The ${cliName(binary)} stopped responding and could not be shut down. Close any leftover ${commandOf(binary)} processes or restart your computer, then use Retry stage.`;
+    return `The ${cliName(binary)} stopped responding and could not be shut down. Close any leftover ${commandOf(binary)} processes or restart your computer, then use Try again.`;
 }
 // Unreachable while stdio names `pipe` for fd 1; it is here so the type carries no null
 // and no non-null assertion is needed to read the stream.
@@ -195,7 +200,7 @@ export function cliEvent(binary, line) {
         // know. The text is not echoed back: half a JSON object is noise to the user.
         throw providerError({
             kind: "other",
-            message: `The ${cliName(binary)} sent output Slopify could not read. Update it to the latest version, then use Retry stage.`,
+            message: `The ${cliName(binary)} sent output Slopify could not read. Update it to the latest version, then use Try again.`,
         });
     }
     return { type: parsed.data.type, value };
@@ -205,7 +210,7 @@ export function cliShaped(binary, schema, value) {
     if (!parsed.success) {
         throw providerError({
             kind: "other",
-            message: `The ${cliName(binary)} sent output Slopify could not read. Update it to the latest version, then use Retry stage.`,
+            message: `The ${cliName(binary)} sent output Slopify could not read. Update it to the latest version, then use Try again.`,
         });
     }
     return parsed.data;

package/dist/adapters/tts/cartesia.js

@@ -3,6 +3,7 @@ import { redact } from "../../kernel/log.js";
 import { providerError } from "../../kernel/ports/model.js";
 import { httpFailure, missingKey, noAudio, voiceFix } from "../explain.js";
 import { retryAfter } from "../retry-after.js";
+import { cartesiaLanguages, lookUp } from "./voice-languages.js";
 // The HTTP gateway adapter for Cartesia. `fetch` and
 // nothing else; `/tts/bytes` streams the audio it renders, so the response body is
 // already the stream the port asks for.
@@ -32,6 +33,12 @@ export function cartesiaTts(deps) {
     return {
         id: "cartesia",
         capabilities: { streams: true },
+        voiceLanguages: async (voiceId, signal) => {
+            const key = deps.key();
+            if (key === undefined || key === "")
+                return undefined;
+            return cartesiaLanguages(await lookUp(deps.fetch, `${cartesiaBase}/voices/${encodeURIComponent(voiceId)}`, { "X-API-Key": key, "Cartesia-Version": cartesiaVersion }, signal));
+        },
         models: async () => cartesiaModels,
         synthesize: async (req) => {
             const response = await deps.fetch(`${cartesiaBase}/tts/bytes`, {
@@ -79,6 +86,9 @@ function kindOf(status) {
         return "rate_limit";
     }
     // ceiling: as in the other two adapters, everything else is `other` and is retried.
+    // The provider's own server failed; the same request may well succeed later.
+    if (status >= 500)
+        return "dropped";
     return "other";
 }
 async function failure(response, voiceId) {

package/dist/adapters/tts/elevenlabs.js

@@ -3,6 +3,7 @@ import { redact } from "../../kernel/log.js";
 import { providerError } from "../../kernel/ports/model.js";
 import { httpFailure, missingKey, noAudio, refreshList, unreadable, voiceFix } from "../explain.js";
 import { retryAfter } from "../retry-after.js";
+import { elevenLabsLanguages, lookUp } from "./voice-languages.js";
 // The HTTP gateway adapter for ElevenLabs: the platform's own `fetch` and nothing else. The
 // response body already is the `ReadableStream<Uint8Array>` the port asks for, so an SDK
 // would buy nothing but a dependency.
@@ -19,6 +20,7 @@ export const elevenLabsModels = [
     { id: "eleven_turbo_v2_5", name: "Eleven Turbo v2.5 (deprecated)" },
     { id: "eleven_turbo_v2", name: "Eleven Turbo v2 (deprecated)" },
 ];
+export const elevenLabsDialogueModel = "eleven_v3";
 // 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";
@@ -38,7 +40,13 @@ const errorBody = z.object({
 export function elevenLabsTts(deps) {
     return {
         id: "elevenlabs",
-        capabilities: { streams: true },
+        capabilities: { streams: true, dialogue: true },
+        voiceLanguages: async (voiceId, signal) => {
+            const key = deps.key();
+            if (key === undefined || key === "")
+                return undefined;
+            return elevenLabsLanguages(await lookUp(deps.fetch, `${elevenLabsBase}/voices/${encodeURIComponent(voiceId)}`, { "xi-api-key": key }, signal));
+        },
         models: async () => {
             const response = await deps.fetch(`${elevenLabsBase}/models`, {
                 headers: { "xi-api-key": keyOf(deps) },
@@ -59,14 +67,25 @@ export function elevenLabsTts(deps) {
         },
         synthesize: async (req) => {
             const voice = encodeURIComponent(req.voiceId);
-            const response = await deps.fetch(`${elevenLabsBase}/text-to-speech/${voice}/stream?output_format=${elevenLabsFormat}`, {
-                method: "POST",
-                signal: req.signal,
-                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: req.model ?? elevenLabsModel }),
-            });
+            const response = req.dialogue === undefined
+                ? await deps.fetch(`${elevenLabsBase}/text-to-speech/${voice}/stream?output_format=${elevenLabsFormat}`, {
+                    method: "POST",
+                    signal: req.signal,
+                    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: req.model ?? elevenLabsModel }),
+                })
+                : // Text to Dialogue: several voices in one conversation, on eleven_v3.
+                    await deps.fetch(`${elevenLabsBase}/text-to-dialogue/stream?output_format=${elevenLabsFormat}`, {
+                        method: "POST",
+                        signal: req.signal,
+                        headers: { "xi-api-key": keyOf(deps), "Content-Type": "application/json" },
+                        body: JSON.stringify({
+                            inputs: req.dialogue.map((line) => ({ text: line.text, voice_id: line.voiceId })),
+                            model_id: req.model ?? elevenLabsDialogueModel,
+                        }),
+                    });
             if (!response.ok) {
                 throw await failure(response, req.voiceId);
             }
@@ -96,6 +115,9 @@ function kindOf(status) {
     // ceiling: everything else is `other` and is retried, so a text past the character limit
     // fails the same way four times over. A terminal "this will never work" kind has to reach the
     // port's error contract first, which is not this adapter's to widen.
+    // The provider's own server failed; the same request may well succeed later.
+    if (status >= 500)
+        return "dropped";
     return "other";
 }
 async function failure(response, voiceId, next) {