@gentbajko/slopify 2.5.0 → 3.0.1

package/dist/adapters/image/codex.js

@@ -7,9 +7,12 @@ import { agentImageTimeoutMs, } from "../../kernel/ports/image.js";
 import { providerError } from "../../kernel/ports/model.js";
 import { cliReported, quoted, refusedImage } from "../explain.js";
 import { cliLoginError } from "../llm/cli-login-error.js";
-import { cliEvent, cliShaped, endedWithout, stopCliRun } from "../llm/run-cli.js";
+import { codexLimitError, readingOf } from "../llm/codex.js";
+import { codexPlanLimit } from "../llm/codex-limits.js";
+import { cliEvent, cliShaped, endedKind, endedWithout, stopCliRun, } from "../llm/run-cli.js";
 import { lines } from "../llm/sse-lines.js";
 import { codexGeneratedImage, codexImageCount } from "./codex-output.js";
+import { referencePictures } from "./reference.js";
 // "Codex default" puts no model and no effort on the command line, so the CLI's own defaults
 // draw the image; it is what every project saved before the choice existed runs. Every other
 // model id is one of the Codex CLI's own models - the list the Codex text provider shows -
@@ -41,7 +44,9 @@ const alwaysDisabled = [
     "workspace_dependencies",
 ];
 function reviews(req) {
-    return (req.model !== codexImageModel.id || req.thinking !== undefined || req.reference !== undefined);
+    return (req.model !== codexImageModel.id ||
+        req.thinking !== undefined ||
+        referencePictures(req).length > 0);
 }
 // The binary's image tool (`ImagegenArgs`: prompt, referenced_image_paths,
 // num_last_images_to_include) takes each referenced image as an absolute path it reads
@@ -49,15 +54,41 @@ function reviews(req) {
 export function codexReferencePath(directory, image) {
     return join(directory, image.mime === "image/jpeg" ? "reference.jpg" : "reference.png");
 }
-export function codexImageInstructions(req, reference) {
+// Every picture the request carries, each at its own path: the establishing image keeps the
+// name it always had, the cast pictures follow it as reference-2, reference-3 and so on.
+export function codexReferencePaths(directory, req) {
+    return referencePictures(req).map((picture, index) => ({
+        picture,
+        path: index === 0
+            ? codexReferencePath(directory, picture.image)
+            : join(directory, `reference-${String(index + 1)}${picture.image.mime === "image/jpeg" ? ".jpg" : ".png"}`),
+    }));
+}
+function castInstructions(req, directory) {
+    const paths = codexReferencePaths(directory, req);
+    return [
+        `Reference images are saved at these paths. Pass all of them in referenced_image_paths on every image generation call: ${paths.map((row) => row.path).join(", ")}.`,
+        ...paths.map((row) => row.picture.member === undefined
+            ? `${row.path} is the establishing image: keep its characters, rendering style and colour palette.`
+            : `${row.path} shows ${row.picture.member}${describeMember(req, row.picture.member)}: draw ${row.picture.member} to look exactly like this.`),
+        "Use them as references only: do not copy their composition, pose or framing; compose this image from the brief.",
+    ].join(" ");
+}
+function describeMember(req, name) {
+    const description = req.cast?.find((member) => member.name === name)?.description.trim() ?? "";
+    return description === "" ? "" : ` (${description})`;
+}
+export function codexImageInstructions(req, reference, directory) {
     return [
         "You are making one finished image for Slopify, a video creation app, with the image generation tool.",
         "Fidelity to the brief comes first. Before calling the tool, write its prompt yourself as a detailed, faithful visual description of the brief: the subject and what it is doing, the setting, composition and framing for the target aspect ratio, lighting, colour palette, style and mood, and any text that must appear, spelled exactly. Take every element from the brief and keep its wording where it is specific. Do not add subjects, text, logos or story the brief does not ask for, and do not pad the prompt with generic quality words.",
-        ...(reference === undefined
-            ? []
-            : [
-                `A reference image is saved at ${reference}. Pass exactly that path in referenced_image_paths on every image generation call. Use it as the reference for style, characters and palette: keep the same characters, rendering style and colour palette, but do not copy its composition, pose or framing; compose this image from the brief.`,
-            ]),
+        ...(req.cast !== undefined && req.cast.length > 0 && directory !== undefined
+            ? [castInstructions(req, directory)]
+            : reference === undefined
+                ? []
+                : [
+                    `A reference image is saved at ${reference}. Pass exactly that path in referenced_image_paths on every image generation call. Use it as the reference for style, characters and palette: keep the same characters, rendering style and colour palette, but do not copy its composition, pose or framing; compose this image from the brief.`,
+                ]),
         "Take the time you need. After each image, look at it and compare it with the brief; if anything is missing, wrong or distorted, revise the prompt and generate again. Deliver exactly one final image: the last image you generate is the one Slopify uses, so stop once it matches the brief.",
         "Let the image generation tool save its output in its default location. Slopify will collect it. Use PNG or JPEG. Do not copy, rename, edit or create any other file, and do not put the image or a link in your reply.",
         `Target aspect ratio: ${req.aspect}.`,
@@ -115,10 +146,19 @@ export function codexImageArgs(req, directory) {
             : ["-c", `model_reasoning_effort="${req.thinking === "off" ? "none" : req.thinking}"`]),
         ...(req.model === codexImageModel.id ? [] : ["-m", req.model]),
         "--",
-        codexImageInstructions(req, reference),
+        codexImageInstructions(req, reference, directory),
     ];
 }
 const failure = z.object({ error: z.object({ message: z.string() }) });
+const turnUsage = z.object({
+    usage: z
+        .object({
+        input_tokens: z.number(),
+        output_tokens: z.number(),
+        cached_input_tokens: z.number().optional(),
+    })
+        .nullish(),
+});
 const errorEvent = z.object({ message: z.string() });
 const item = z.object({ item: z.object({ type: z.string(), text: z.string().optional() }) });
 export function codexImage(deps) {
@@ -140,7 +180,7 @@ export function codexImage(deps) {
             if (req.model.trim() === "" || req.model.startsWith("-"))
                 throw providerError({
                     kind: "unsupported",
-                    message: "No Codex model is chosen for images. Choose one (or Codex default) for images in the Providers section of Edit project, then use Retry stage.",
+                    message: "No Codex model is chosen for images. Choose one (or Codex default) for images in the Providers section of Edit project, then use Try again.",
                 });
             req.signal.throwIfAborted();
             const directory = mkdtempSync(join(tmpdir(), "slopify-codex-image-"));
@@ -149,6 +189,8 @@ export function codexImage(deps) {
             let threadId;
             let run;
             let reported = -1;
+            let usage;
+            const before = deps.readLimits?.().catch(() => null);
             // A line for the stage's live panel each time this thread's image count moves.
             const report = () => {
                 if (req.onProgress === undefined)
@@ -167,10 +209,8 @@ export function codexImage(deps) {
                 }
             };
             try {
-                if (req.reference !== undefined)
-                    writeFileSync(codexReferencePath(directory, req.reference), req.reference.bytes, {
-                        mode: 0o600,
-                    });
+                for (const { path, picture } of codexReferencePaths(directory, req))
+                    writeFileSync(path, picture.image.bytes, { mode: 0o600 });
                 report();
                 try {
                     run = deps.run(binary, codexImageArgs(req, directory), req.signal, {
@@ -181,7 +221,7 @@ export function codexImage(deps) {
                 catch {
                     throw providerError({
                         kind: "unsupported",
-                        message: "The Codex CLI could not be started. Check it is installed and set up in Settings → Providers, then use Retry stage.",
+                        message: "The Codex CLI could not be started. Check it is installed and set up in Settings → Providers, then use Try again.",
                     });
                 }
                 let completed = false;
@@ -198,17 +238,30 @@ export function codexImage(deps) {
                         if (threadId !== undefined)
                             throw providerError({
                                 kind: "unavailable",
-                                message: "The Codex CLI started more than one image job for one image, so Slopify cannot tell which result is right (both may have used your quota). Use Retry stage to make the image again.",
+                                message: "The Codex CLI started more than one image job for one image, so Slopify cannot tell which result is right (both may have used your quota). Use Try again to make the image again.",
                             });
                         threadId = cliShaped(binary, z.object({ thread_id: z.string() }), event.value).thread_id;
                     }
-                    else if (event.type === "turn.completed")
+                    else if (event.type === "turn.completed") {
                         completed = true;
+                        const counted = turnUsage.safeParse(event.value);
+                        if (counted.success && counted.data.usage)
+                            usage = {
+                                inputTokens: counted.data.usage.input_tokens,
+                                outputTokens: counted.data.usage.output_tokens,
+                                ...(counted.data.usage.cached_input_tokens
+                                    ? { cachedInputTokens: counted.data.usage.cached_input_tokens }
+                                    : {}),
+                            };
+                    }
                     else if (event.type === "turn.failed") {
                         const message = cliShaped(binary, failure, event.value).error.message;
                         const login = cliLoginError("codex", message);
                         if (login)
                             throw login;
+                        const planLimit = codexPlanLimit(message, new Date());
+                        if (planLimit !== undefined)
+                            throw codexLimitError(message, planLimit);
                         throw providerError({
                             kind: /refus|content.policy|safety/i.test(message) ? "refusal" : "other",
                             message: /refus|content.policy|safety/i.test(message)
@@ -221,6 +274,9 @@ export function codexImage(deps) {
                         const login = cliLoginError("codex", message);
                         if (login)
                             throw login;
+                        const planLimit = codexPlanLimit(message, new Date());
+                        if (planLimit !== undefined)
+                            throw codexLimitError(message, planLimit);
                         throw providerError({
                             kind: /image.generation|image tool|feature.*unavailable/i.test(message)
                                 ? "unsupported"
@@ -243,12 +299,15 @@ export function codexImage(deps) {
                 if (ended.error !== null)
                     throw providerError({
                         kind: "unsupported",
-                        message: "The Codex CLI could not be started. Check it is installed and set up in Settings → Providers, then use Retry stage.",
+                        message: "The Codex CLI could not be started. Check it is installed and set up in Settings → Providers, then use Try again.",
                     });
+                const stderrLimit = codexPlanLimit(run.stderr(), new Date());
+                if ((ended.code !== 0 || !completed) && stderrLimit !== undefined)
+                    throw codexLimitError(run.stderr().trim(), stderrLimit);
                 if (ended.code !== 0 || !completed)
                     throw (cliLoginError("codex", run.stderr()) ??
                         providerError({
-                            kind: unavailable ? "unsupported" : "other",
+                            kind: unavailable ? "unsupported" : endedKind(ended),
                             message: endedWithout(binary, ended, run.stderr()),
                         }));
                 if (unavailable)
@@ -256,7 +315,13 @@ export function codexImage(deps) {
                         kind: "unsupported",
                         message: `The Codex CLI cannot make images. ${cannotDraw}`,
                     });
-                return codexGeneratedImage(env, threadId, startedAt);
+                const image = codexGeneratedImage(env, threadId, startedAt);
+                const limits = await readingOf(before, deps.readLimits);
+                return {
+                    ...image,
+                    ...(usage === undefined ? {} : { usage }),
+                    ...(limits === undefined ? {} : { limits }),
+                };
             }
             catch (error) {
                 req.signal.throwIfAborted();
@@ -281,12 +346,12 @@ async function* bounded(source, maximum) {
         if (size > maximum)
             throw providerError({
                 kind: "other",
-                message: "The Codex CLI sent far more output than an image job should, so Slopify stopped it. Use Retry stage; if it keeps happening, update the Codex CLI to the latest version.",
+                message: "The Codex CLI sent far more output than an image job should, so Slopify stopped it. Use Try again; if it keeps happening, update the Codex CLI to the latest version.",
             });
         yield chunk;
     }
 }
-const imageNext = "Use Retry stage; if it keeps failing, run codex in a terminal to check it works and is signed in, or choose another image provider in the Providers section of Edit project.";
+const imageNext = "Use Try again; if it keeps failing, run codex in a terminal to check it works and is signed in, or choose another image provider in the Providers section of Edit project.";
 const cannotDraw = "Update the Codex CLI and check your ChatGPT plan includes image generation, or choose another image provider in the Providers section of Edit project.";
 function imageEnvironment(directory, source) {
     const env = { PWD: directory };

package/dist/adapters/image/fal.js

@@ -4,7 +4,7 @@ import { providerError } from "../../kernel/ports/model.js";
 import { httpFailure, internalError, missingKey, noImage, providerSaid, unreadable, } from "../explain.js";
 import { retryAfter } from "../retry-after.js";
 import { downloadImage } from "./bytes.js";
-import { withReferenceNote } from "./reference.js";
+import { referencePictures, withReferences } from "./reference.js";
 import { dataUri, downloadVideo } from "./video.js";
 // The HTTP gateway adapter for fal.ai: `fetch` and the downloader beside this file, no SDK.
 // `@fal-ai/client` would buy queue polling, which only the video clips need and which is three
@@ -102,7 +102,10 @@ export function falImage(deps) {
         generate: async (req) => {
             // An establishing image goes to the model's edit endpoint, which takes input images as
             // `image_urls`; only the models that have one are marked as taking a reference.
-            const edit = req.reference === undefined ? undefined : editEndpoint(req.model);
+            // Cast pictures ride the same list; a model without an edit endpoint gets the cast in
+            // words instead, since only the establishing image is something the user turned on.
+            const pictures = referencePictures(req);
+            const edit = pictures.length === 0 ? undefined : editEndpoint(req.model);
             if (req.reference !== undefined && edit === undefined)
                 throw providerError({
                     kind: "unsupported",
@@ -113,8 +116,10 @@ export function falImage(deps) {
                 signal: req.signal,
                 headers: { Authorization: `Key ${keyOf(deps)}`, "Content-Type": "application/json" },
                 body: JSON.stringify({
-                    prompt: withReferenceNote(req.prompt, req.reference),
-                    ...(req.reference === undefined ? {} : { image_urls: [dataUri(req.reference)] }),
+                    prompt: withReferences(req.prompt, req, edit === undefined ? 0 : pictures.length),
+                    ...(edit === undefined
+                        ? {}
+                        : { image_urls: pictures.map((picture) => dataUri(picture.image)) }),
                     ...aspectOf(req.model, req.aspect),
                     // The stage sends Number as that many independent calls, one piece each.
                     num_images: 1,
@@ -167,7 +172,7 @@ export function falImage(deps) {
                 if (current.error)
                     throw providerError({
                         kind: "other",
-                        message: providerSaid("fal.ai", "could not make the video clip", redact(current.error), "Use Retry stage; if it keeps happening, choose another image-to-video model under Animate images in Edit project → Inputs → Look."),
+                        message: providerSaid("fal.ai", "could not make the video clip", redact(current.error), "Use Try again; if it keeps happening, choose another image-to-video model under Animate images in Edit project → Inputs → Look."),
                     });
                 if (current.status === "COMPLETED")
                     break;
@@ -223,6 +228,9 @@ function kindOf(status) {
     // ceiling: everything else is `other` and is retried, so a 422 naming an input this model
     // does not take 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, subject = "image request") {

package/dist/adapters/image/google.js

@@ -5,7 +5,7 @@ import { httpFailure, missingKey, noImage, quoted, refusedImage, unreadable } fr
 import { retryAfter } from "../retry-after.js";
 import { describeBytes, sniffImage } from "./bytes.js";
 import { discoverGoogleImages } from "./models.js";
-import { withReferenceNote } from "./reference.js";
+import { referencePictures, withReferences } from "./reference.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.
@@ -65,15 +65,15 @@ export function googleImage(deps) {
                     model: req.model,
                     // With an establishing image the input is two parts, the image first; the Gemini
                     // image models draw with an input image as their reference.
-                    input: req.reference === undefined
+                    input: referencePictures(req).length === 0
                         ? req.prompt
                         : [
-                            {
+                            ...referencePictures(req).map(({ image }) => ({
                                 type: "image",
-                                mime_type: req.reference.mime,
-                                data: Buffer.from(req.reference.bytes).toString("base64"),
-                            },
-                            { type: "text", text: withReferenceNote(req.prompt, req.reference) },
+                                mime_type: image.mime,
+                                data: Buffer.from(image.bytes).toString("base64"),
+                            })),
+                            { type: "text", text: withReferences(req.prompt, req) },
                         ],
                     // 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
@@ -117,7 +117,7 @@ function decode(part) {
         const claimed = part.mime_type ?? "nothing";
         throw providerError({
             kind: "other",
-            message: `Google sent back something that is not a PNG or JPEG image (labelled ${claimed}, but ${describeBytes(bytes)}). Use Retry stage; if it keeps happening, choose another image model in the Providers section of Edit project.`,
+            message: `Google sent back something that is not a PNG or JPEG image (labelled ${claimed}, but ${describeBytes(bytes)}). Use Try again; if it keeps happening, choose another image model in the Providers section of Edit project.`,
         });
     }
     return { bytes, mime };
@@ -155,6 +155,9 @@ function kindOf(status, named, message) {
     // ceiling: everything else is `other` and is retried, so a prompt past the model's 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) {

package/dist/adapters/image/openai.js

@@ -5,7 +5,7 @@ import { httpFailure, missingKey, noImage, refusedImage, unreadable } from "../e
 import { retryAfter } from "../retry-after.js";
 import { describeBytes, sniffImage } from "./bytes.js";
 import { discoverOpenAiImages } from "./models.js";
-import { withReferenceNote } from "./reference.js";
+import { referencePictures, withReferences } from "./reference.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 -
@@ -54,7 +54,8 @@ export function openAiImage(deps) {
         id: "openai-image",
         models: () => discoverOpenAiImages(deps),
         generate: async (req) => {
-            const response = req.reference === undefined
+            const pictures = referencePictures(req);
+            const response = pictures.length === 0
                 ? await deps.fetch(`${openAiImagesBase}/images/generations`, {
                     method: "POST",
                     signal: req.signal,
@@ -79,7 +80,7 @@ export function openAiImage(deps) {
                         method: "POST",
                         signal: req.signal,
                         headers: { Authorization: `Bearer ${keyOf(deps)}` },
-                        body: editForm(req, req.reference),
+                        body: editForm(req, pictures),
                     });
             if (!response.ok) {
                 throw await failure(response);
@@ -92,13 +93,16 @@ export function openAiImage(deps) {
         },
     };
 }
-function editForm(req, reference) {
+// The edits endpoint takes several input images as repeated `image[]` parts: the establishing
+// image first, then the cast pictures.
+function editForm(req, pictures) {
     const form = new FormData();
     form.set("model", req.model);
-    form.set("prompt", withReferenceNote(req.prompt, reference));
+    form.set("prompt", withReferences(req.prompt, req));
     form.set("n", "1");
     form.set("size", sizeFor(req.model, req.aspect));
-    form.append("image[]", new Blob([Uint8Array.from(reference.bytes)], { type: reference.mime }), reference.mime === "image/jpeg" ? "reference.jpg" : "reference.png");
+    for (const [index, { image }] of pictures.entries())
+        form.append("image[]", new Blob([Uint8Array.from(image.bytes)], { type: image.mime }), `${index === 0 ? "reference" : `reference-${String(index + 1)}`}${image.mime === "image/jpeg" ? ".jpg" : ".png"}`);
     return form;
 }
 // A GPT image model always answers with base64, so the bytes arrive with the call and
@@ -110,7 +114,7 @@ function decode(b64) {
     if (mime === undefined) {
         throw providerError({
             kind: "other",
-            message: `OpenAI sent back something that is not a PNG or JPEG image (${describeBytes(bytes)}). Use Retry stage; if it keeps happening, choose another image model in the Providers section of Edit project.`,
+            message: `OpenAI sent back something that is not a PNG or JPEG image (${describeBytes(bytes)}). Use Try again; if it keeps happening, choose another image model in the Providers section of Edit project.`,
         });
     }
     return { bytes, mime };
@@ -137,6 +141,9 @@ function kindOf(status, code) {
     // ceiling: everything else is `other` and is retried, so a prompt past the model's length
     // 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) {

package/dist/adapters/image/reference.js

@@ -5,3 +5,37 @@ export const referenceNote = "The attached image is a visual reference only: kee
 export function withReferenceNote(prompt, reference) {
     return reference === undefined ? prompt : `${referenceNote}\n\n${prompt}`;
 }
+// Every picture a request carries, in the order they are attached: the establishing image,
+// then each mentioned cast member's pictures.
+export function referencePictures(req) {
+    return [
+        ...(req.reference === undefined ? [] : [{ image: req.reference }]),
+        ...(req.cast ?? []).flatMap((member) => member.images.map((image) => ({ image, member: member.name }))),
+    ];
+}
+// The prompt a provider sends with the first `limit` of `referencePictures(req)` attached. A
+// request without cast keeps exactly the wording it always had. Cast members whose pictures
+// did not fit (a provider that takes fewer input images, or none) are described in words.
+export function withReferences(prompt, req, limit = Number.POSITIVE_INFINITY) {
+    if (req.cast === undefined || req.cast.length === 0)
+        return limit === 0 ? prompt : withReferenceNote(prompt, req.reference);
+    const sent = referencePictures(req).slice(0, limit);
+    const lines = [];
+    if (sent.length > 0)
+        lines.push("The attached images are visual references only: do not copy their composition, pose or framing.");
+    for (const [index, picture] of sent.entries()) {
+        const member = req.cast.find((row) => row.name === picture.member);
+        lines.push(member === undefined
+            ? `Image ${String(index + 1)} is the establishing image: keep its characters, rendering style and colour palette.`
+            : `Image ${String(index + 1)} shows ${member.name}${describe(member.description)}: draw ${member.name} to look exactly like this.`);
+    }
+    const shown = new Set(sent.flatMap((picture) => picture.member ?? []));
+    for (const member of req.cast)
+        if (!shown.has(member.name))
+            lines.push(`${member.name} appears in this image${describe(member.description)}.`);
+    lines.push("Compose a new image from this brief:");
+    return `${lines.join("\n")}\n\n${prompt}`;
+}
+function describe(description) {
+    return description.trim() === "" ? "" : ` (${description.trim()})`;
+}

package/dist/adapters/image/replicate.js

@@ -4,6 +4,7 @@ import { providerError } from "../../kernel/ports/model.js";
 import { httpFailure, missingKey, noImage, providerSaid, refusedImage, unreadable, } from "../explain.js";
 import { retryAfter } from "../retry-after.js";
 import { downloadImage } from "./bytes.js";
+import { withReferences } from "./reference.js";
 import { dataUri, downloadVideo } from "./video.js";
 // The HTTP gateway adapter for Replicate: `fetch`, the injected clock and the downloader
 // beside this file, no SDK. The `replicate` package wraps exactly the two requests below, so
@@ -58,7 +59,8 @@ export function replicateImage(deps) {
                 },
                 body: JSON.stringify({
                     input: {
-                        prompt: req.prompt,
+                        // These models take no input image, so the cast is described in words.
+                        prompt: withReferences(req.prompt, req, 0),
                         // Replicate takes the aspect, so the closest size is exact.
                         aspect_ratio: req.aspect,
                         // The port stores PNG or JPEG and these models default to WebP. Nothing else
@@ -166,7 +168,7 @@ function declined(current) {
         kind: refusal ? "refusal" : "other",
         message: refusal
             ? refusedImage("Replicate", message)
-            : providerSaid("Replicate", "could not make the image", message, "Use Retry stage; if it keeps happening, reword the image prompt in the Images section of Edit project or choose another image model in its Providers section."),
+            : providerSaid("Replicate", "could not make the image", message, "Use Try again; if it keeps happening, reword the image prompt in the Images section of Edit project or choose another image model in its Providers section."),
     });
 }
 function auth(deps) {
@@ -188,6 +190,9 @@ function kindOf(status) {
     // ceiling: everything else is `other` and is retried, so a 402 with no credit left 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, subject = "image request") {

package/dist/adapters/image/video.js

@@ -16,13 +16,13 @@ export async function downloadVideo(download) {
         // The link is not quoted back: a delivery link carries its own signature.
         throw providerError({
             kind: "other",
-            message: `${download.provider} made the video clip, but Slopify could not download it (error ${String(response.status)}). Check your internet connection, then use Retry stage.`,
+            message: `${download.provider} made the video clip, but Slopify could not download it (error ${String(response.status)}). Check your internet connection, then use Try again.`,
         });
     const bytes = new Uint8Array(await response.arrayBuffer());
     if (!sniffVideo(bytes))
         throw providerError({
             kind: "other",
-            message: `${download.provider} sent back something that is not an MP4 video clip (${describeBytes(bytes)}). Use Retry stage; if it keeps happening, choose another image-to-video model under Animate images in Edit project → Inputs → Look.`,
+            message: `${download.provider} sent back something that is not an MP4 video clip (${describeBytes(bytes)}). Use Try again; if it keeps happening, choose another image-to-video model under Animate images in Edit project → Inputs → Look.`,
         });
     return { bytes, mime: "video/mp4" };
 }

package/dist/adapters/key-probes.js

@@ -0,0 +1,85 @@
+import { cartesiaVersion } from "./tts/cartesia.js";
+// Settings → Providers' Test button, per provider. Some answer a key they do not recognise
+// with something other than 401: Google with 400 API_KEY_INVALID, ElevenLabs with 400
+// invalid_api_key, Inworld with 403 "does not exist". Observed on 2026-09-27; their
+// documentation says 401.
+const bearer = (key) => ({ Authorization: `Bearer ${key}` });
+// Health check → "Model reachable": one read per chosen model, or one of the list. A model's
+// own page answers 404 when the key can't use it.
+const openAiModel = {
+    url: (model) => `https://api.openai.com/v1/models/${encodeURIComponent(model)}`,
+};
+function listed(ids) {
+    return (body, model) => {
+        try {
+            const found = ids(JSON.parse(body));
+            return found.length === 0 ? undefined : found.includes(model);
+        }
+        catch {
+            return undefined;
+        }
+    };
+}
+const field = (value, key) => typeof value === "object" && value !== null ? value[key] : undefined;
+const google = {
+    url: "https://generativelanguage.googleapis.com/v1beta/models?pageSize=1",
+    headers: (key) => ({ "x-goog-api-key": key }),
+    badKey: (status, body) => status === 400 && body.includes("API_KEY_INVALID"),
+    model: {
+        url: (model) => `https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(model.replace(/^models\//, ""))}`,
+    },
+};
+export const keyProbes = {
+    openrouter: {
+        url: "https://openrouter.ai/api/v1/key",
+        headers: bearer,
+        model: {
+            url: () => "https://openrouter.ai/api/v1/models",
+            lists: listed((body) => {
+                const data = field(body, "data");
+                return Array.isArray(data) ? data.map((one) => field(one, "id")) : [];
+            }),
+        },
+    },
+    "openai-tts": { url: "https://api.openai.com/v1/models", headers: bearer, model: openAiModel },
+    "openai-image": { url: "https://api.openai.com/v1/models", headers: bearer, model: openAiModel },
+    "google-image": google,
+    "google-tts": google,
+    // fal.ai's model list answers without a key; its price lookup requires one.
+    fal: {
+        url: "https://api.fal.ai/v1/models/pricing?endpoint_id=fal-ai/flux/dev",
+        headers: (key) => ({ Authorization: `Key ${key}` }),
+        model: {
+            url: (model) => `https://api.fal.ai/v1/models/pricing?endpoint_id=${encodeURIComponent(model)}`,
+        },
+    },
+    replicate: {
+        url: "https://api.replicate.com/v1/account",
+        headers: bearer,
+        // "owner/name", without a ":version".
+        model: {
+            url: (model) => `https://api.replicate.com/v1/models/${(model.split(":")[0] ?? model)
+                .split("/")
+                .map(encodeURIComponent)
+                .join("/")}`,
+        },
+    },
+    elevenlabs: {
+        url: "https://api.elevenlabs.io/v1/models",
+        headers: (key) => ({ "xi-api-key": key }),
+        badKey: (status, body) => status === 400 && body.includes("invalid_api_key"),
+        model: {
+            url: () => "https://api.elevenlabs.io/v1/models",
+            lists: listed((body) => Array.isArray(body) ? body.map((one) => field(one, "model_id")) : []),
+        },
+    },
+    cartesia: {
+        url: "https://api.cartesia.ai/voices?limit=1",
+        headers: (key) => ({ "X-API-Key": key, "Cartesia-Version": cartesiaVersion }),
+    },
+    inworld: {
+        url: "https://api.inworld.ai/voices/v1/voices?pageSize=1",
+        headers: (key) => ({ Authorization: `Basic ${key}` }),
+        badKey: (status, body) => status === 403 && /does not exist|was deleted/i.test(body),
+    },
+};