@gentbajko/slopify 3.25.9 → 4.1.0

package/dist/adapters/image/fal.js

@@ -1,10 +1,13 @@
 import { z } from "zod";
+import { internalError } from "../../kernel/errors.js";
 import { redact } from "../../kernel/log.js";
 import { providerError } from "../../kernel/ports/model.js";
-import { httpFailure, internalError, missingKey, noImage, providerSaid, unreadable, } from "../explain.js";
-import { retryAfter } from "../retry-after.js";
+import { createRows, editSettings } from "../../kernel/ports/settings-places.js";
+import { httpFailure, noImage, providerSaid, unreadable } from "../explain.js";
+import { failureText, httpProviderError, kindOfStatus, requireKey, safeJson, } from "../http-failure.js";
+import { modelAccessOf } from "../model-access.js";
 import { downloadImage } from "./bytes.js";
-import { referencePictures, withReferences } from "./reference.js";
+import { attachedPictures, promptFor } 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
@@ -60,6 +63,7 @@ const editModels = [
 function editEndpoint(model) {
     return editModels.includes(model) ? `${model}/edit` : undefined;
 }
+export const falEditRefusal = "This fal.ai model can't edit a picture. Choose FLUX.2 or Nano Banana 2 on fal.ai, or Codex CLI, OpenAI or Google, under Made with … · change.";
 // Image-to-video runs on fal's queue, not the synchronous host: a clip takes one to five
 // minutes, and fal documents the queue as the way to call anything that slow. A request is
 // submitted, its status polled until it completes, and its answer fetched from the links the
@@ -104,19 +108,21 @@ export function falImage(deps) {
             // `image_urls`; only the models that have one are marked as taking a reference.
             // 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 pictures = attachedPictures(req);
             const edit = pictures.length === 0 ? undefined : editEndpoint(req.model);
+            if (req.edit !== undefined && edit === undefined)
+                throw providerError({ kind: "unsupported", message: falEditRefusal });
             if (req.reference !== undefined && edit === undefined)
                 throw providerError({
                     kind: "unsupported",
-                    message: "This fal.ai model can't use an establishing image as a reference. Choose FLUX.2 or Nano Banana 2 under Images → Model on Play or in Edit project → Providers, or set Establishing image to Off in the Images section.",
+                    message: `This fal.ai model can't use an establishing image as a reference. Choose FLUX.2 or Nano Banana 2 as the image model in ${createRows.images} or ${editSettings.images}, or set Establishing image to Off there.`,
                 });
             const response = await deps.fetch(`${falBase}/${edit ?? req.model}`, {
                 method: "POST",
                 signal: req.signal,
                 headers: { Authorization: `Key ${keyOf(deps)}`, "Content-Type": "application/json" },
                 body: JSON.stringify({
-                    prompt: withReferences(req.prompt, req, edit === undefined ? 0 : pictures.length),
+                    prompt: promptFor(req.prompt, req, edit === undefined ? 0 : pictures.length),
                     ...(edit === undefined
                         ? {}
                         : { image_urls: pictures.map((picture) => dataUri(picture.image)) }),
@@ -129,7 +135,7 @@ export function falImage(deps) {
                 }),
             });
             if (!response.ok) {
-                throw await failure(response);
+                throw await failure(response, "image request", true);
             }
             const answer = parse(await response.text());
             refused(answer, req.prompt);
@@ -162,7 +168,7 @@ export function falImage(deps) {
                 }),
             });
             if (!submitted.ok)
-                throw await failure(submitted, "video clip request");
+                throw await failure(submitted, "video clip request", true);
             const links = read(queued, await submitted.text());
             for (;;) {
                 const status = await deps.fetch(links.status_url, { signal: req.signal, headers });
@@ -172,7 +178,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 Try again; 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 ${editSettings.look}.`),
                     });
                 if (current.status === "COMPLETED")
                     break;
@@ -198,12 +204,7 @@ function read(schema, text) {
     return parsed.data;
 }
 function keyOf(deps) {
-    // `missing_key`, not `auth`, because that rule makes it terminal.
-    const key = deps.key();
-    if (key === undefined || key === "") {
-        throw providerError({ kind: "missing_key", message: missingKey("fal.ai") });
-    }
-    return key;
+    return requireKey(deps.key(), "fal.ai");
 }
 // A content-policy refusal is final, named here and made terminal by the wrapper. fal declines
 // inside a 200 - the safety checker flags the image and hands back a blank one. With no
@@ -213,41 +214,16 @@ function refused(answer, prompt) {
     if (flags.length > 0 && flags.every((flagged) => flagged)) {
         throw providerError({
             kind: "refusal",
-            message: `fal.ai's safety checker blocked the image for this prompt: "${redact(prompt)}". Reword the image prompt in the Images section of Edit project, or choose another image provider in its Providers section.`,
+            message: `fal.ai's safety checker blocked the image for this prompt: "${redact(prompt)}". Reword the image prompt in ${editSettings.images}, or choose another image service there.`,
         });
     }
 }
-// Only the adapter sees the vendor's status code, so only the adapter names the kind.
-function kindOf(status) {
-    if (status === 401 || status === 403) {
-        return "auth";
-    }
-    if (status === 429) {
-        return "rate_limit";
-    }
-    // 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") {
-    const text = await response.text().catch(() => "");
+// `atModel`: the request went to the model's own address, so a 404 or 403 is about the model.
+async function failure(response, subject = "image request", atModel = false) {
+    const text = await failureText(response);
     // The provider's own words, through the redactor - an error body may quote the key back.
     const message = redact(detailOf(text) || response.statusText);
-    const retryAfterMs = retryAfter(response.headers.get("retry-after"));
-    return providerError({
-        kind: kindOf(response.status),
-        message: httpFailure({
-            provider: "fal.ai",
-            status: response.status,
-            detail: message,
-            subject,
-        }),
-        ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
-    });
+    return httpProviderError(response, kindOfStatus(response.status), httpFailure({ provider: "fal.ai", status: response.status, detail: message, subject }), undefined, modelAccessOf(response.status, text, atModel));
 }
 function detailOf(text) {
     const parsed = errorBody.safeParse(safeJson(text));
@@ -270,11 +246,3 @@ function parse(text) {
     }
     return parsed.data;
 }
-function safeJson(text) {
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return undefined;
-    }
-}

package/dist/adapters/image/google.js

@@ -1,11 +1,13 @@
 import { z } from "zod";
 import { redact } from "../../kernel/log.js";
 import { providerError } from "../../kernel/ports/model.js";
-import { httpFailure, missingKey, noImage, quoted, refusedImage, unreadable } from "../explain.js";
-import { retryAfter } from "../retry-after.js";
+import { editSettings } from "../../kernel/ports/settings-places.js";
+import { httpFailure, noImage, quoted, refusedImage, unreadable } from "../explain.js";
+import { failureText, httpProviderError, kindOfStatus, requireKey, safeJson, } from "../http-failure.js";
+import { modelAccessOf } from "../model-access.js";
 import { describeBytes, sniffImage } from "./bytes.js";
 import { discoverGoogleImages } from "./models.js";
-import { referencePictures, withReferences } from "./reference.js";
+import { attachedPictures, promptFor } 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 +67,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: referencePictures(req).length === 0
+                    input: attachedPictures(req).length === 0
                         ? req.prompt
                         : [
-                            ...referencePictures(req).map(({ image }) => ({
+                            ...attachedPictures(req).map(({ image }) => ({
                                 type: "image",
                                 mime_type: image.mime,
                                 data: Buffer.from(image.bytes).toString("base64"),
                             })),
-                            { type: "text", text: withReferences(req.prompt, req) },
+                            { type: "text", text: promptFor(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,18 +119,13 @@ 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 Try again; 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 ${editSettings.images}.`,
         });
     }
     return { bytes, mime };
 }
 function keyOf(deps) {
-    // `missing_key`, not `auth`, because that rule makes it terminal.
-    const key = deps.key();
-    if (key === undefined || key === "") {
-        throw providerError({ kind: "missing_key", message: missingKey("Google") });
-    }
-    return key;
+    return requireKey(deps.key(), "Google");
 }
 // Only the adapter sees the vendor's status code, so only the adapter names the kind.
 function kindOf(status, named, message) {
@@ -141,27 +138,16 @@ function kindOf(status, named, message) {
     if (status === 400 && refusalWords.test(message)) {
         return "refusal";
     }
-    if (status === 401 || status === 403) {
-        return "auth";
-    }
-    if (status === 429) {
-        // Interactions wraps quota failures in a string-coded error and exposes the limit
-        // in the message. Zero allocated capacity cannot be fixed by waiting and retrying.
-        if (/quota exceeded for metric:[^\r\n]*?\blimit:\s*0\s*(?:,|$)/im.test(message)) {
-            return "unsupported";
-        }
-        return "rate_limit";
+    // Interactions wraps quota failures in a string-coded error and exposes the limit
+    // in the message. Zero allocated capacity cannot be fixed by waiting and retrying.
+    if (status === 429 &&
+        /quota exceeded for metric:[^\r\n]*?\blimit:\s*0\s*(?:,|$)/im.test(message)) {
+        return "unsupported";
     }
-    // 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";
+    return kindOfStatus(status);
 }
 async function failure(response) {
-    const text = await response.text().catch(() => "");
+    const text = await failureText(response);
     const parsed = errorBody.safeParse(safeJson(text));
     // The provider's own words, through the redactor - an error body may quote the key back.
     const named = parsed.success ? parsed.data.error.status : undefined;
@@ -170,24 +156,23 @@ async function failure(response) {
     const delay = parsed.success
         ? parsed.data.error.details?.find((one) => one["@type"] === "type.googleapis.com/google.rpc.RetryInfo")?.retryDelay
         : undefined;
-    const retryAfterMs = retryAfter(response.headers.get("retry-after")) ?? googleRetryDelay(delay, message);
     const detail = message || response.statusText;
-    return providerError({
-        kind,
-        message: kind === "unsupported"
-            ? `Google gives this API key no image quota for this model${quoted(`error ${String(response.status)}`, detail)}. Retrying will not help: turn on billing for the key's project in Google AI Studio, or choose another image provider in the Providers section of Edit project.`
-            : // PERMISSION_DENIED and FAILED_PRECONDITION also cover keys without access, billing
-                // and region limits, so they read as a content refusal only when Google says so.
-                kind === "refusal" && refusalWords.test(message)
-                    ? refusedImage("Google", detail)
-                    : httpFailure({
-                        provider: "Google",
-                        status: response.status,
-                        detail,
-                        subject: "image request",
-                    }),
-        ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
-    });
+    const refused = kind === "refusal" && refusalWords.test(message);
+    return httpProviderError(response, kind, kind === "unsupported"
+        ? `Google gives this API key no image quota for this model${quoted(`error ${String(response.status)}`, detail)}. Retrying will not help: turn on billing for the key's project in Google AI Studio, or choose another image service in ${editSettings.images}.`
+        : // PERMISSION_DENIED and FAILED_PRECONDITION also cover keys without access, billing
+            // and region limits, so they read as a content refusal only when Google says so.
+            refused
+                ? refusedImage("Google", detail)
+                : httpFailure({
+                    provider: "Google",
+                    status: response.status,
+                    detail,
+                    subject: "image request",
+                }), googleRetryDelay(delay, message), 
+    // A key that reads the model list but is denied or told "not found" here is denied the
+    // model the request names: Google answers a bad key with 400 API_KEY_INVALID.
+    refused ? undefined : modelAccessOf(response.status, `${named ?? ""} ${message}`, true));
 }
 function googleRetryDelay(delay, message) {
     const seconds = delay?.match(/^(\d+(?:\.\d+)?)s$/)?.[1] ??
@@ -207,11 +192,3 @@ function parse(text) {
     }
     return parsed.data;
 }
-function safeJson(text) {
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return undefined;
-    }
-}

package/dist/adapters/image/models.js

@@ -66,13 +66,13 @@ function requireKey(deps) {
     if (key === undefined || key === "")
         throw providerError({
             kind: "missing_key",
-            message: "Save this provider's API key in Settings → Providers to load its models.",
+            message: "Save this provider's API key in Settings → Keys & services to load its models.",
         });
     return key;
 }
 function unavailable() {
     return providerError({
         kind: "other",
-        message: "Slopify could not load this provider's model list. Check the API key in Settings → Providers and your internet connection, then refresh the list.",
+        message: "Slopify could not load this provider's model list. Check the API key in Settings → Keys & services and your internet connection, then refresh the list.",
     });
 }

package/dist/adapters/image/openai.js

@@ -1,11 +1,13 @@
 import { z } from "zod";
 import { redact } from "../../kernel/log.js";
 import { providerError } from "../../kernel/ports/model.js";
-import { httpFailure, missingKey, noImage, refusedImage, unreadable } from "../explain.js";
-import { retryAfter } from "../retry-after.js";
+import { editSettings } from "../../kernel/ports/settings-places.js";
+import { httpFailure, noImage, refusedImage, unreadable } from "../explain.js";
+import { failureText, httpProviderError, kindOfStatus, requireKey, safeJson, } from "../http-failure.js";
+import { modelAccessOf } from "../model-access.js";
 import { describeBytes, sniffImage } from "./bytes.js";
 import { discoverOpenAiImages } from "./models.js";
-import { referencePictures, withReferences } from "./reference.js";
+import { attachedPictures, promptFor } 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 -
@@ -56,7 +58,7 @@ export function openAiImage(deps) {
         id: "openai-image",
         models: () => discoverOpenAiImages(deps),
         generate: async (req) => {
-            const pictures = referencePictures(req);
+            const pictures = attachedPictures(req);
             const response = pictures.length === 0
                 ? await deps.fetch(`${openAiImagesBase}/images/generations`, {
                     method: "POST",
@@ -96,11 +98,11 @@ export function openAiImage(deps) {
     };
 }
 // The edits endpoint takes several input images as repeated `image[]` parts: the establishing
-// image first, then the cast pictures.
+// image (or, for a design's edit, the picture to change) first, then the cast pictures.
 function editForm(req, pictures) {
     const form = new FormData();
     form.set("model", req.model);
-    form.set("prompt", withReferences(req.prompt, req));
+    form.set("prompt", promptFor(req.prompt, req));
     form.set("n", "1");
     form.set("size", sizeFor(req.model, req.aspect));
     for (const [index, { image }] of pictures.entries())
@@ -116,57 +118,37 @@ 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 Try again; 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 ${editSettings.images}.`,
         });
     }
     return { bytes, mime };
 }
 function keyOf(deps) {
-    // `missing_key`, not `auth`, because that rule makes it terminal.
-    const key = deps.key();
-    if (key === undefined || key === "") {
-        throw providerError({ kind: "missing_key", message: missingKey("OpenAI") });
-    }
-    return key;
+    return requireKey(deps.key(), "OpenAI");
 }
 // Only the adapter sees the vendor's status code, so only the adapter names the kind.
 function kindOf(status, code) {
     if (code !== undefined && code !== null && refusalCodes.includes(code)) {
         return "refusal";
     }
-    if (status === 401 || status === 403) {
-        return "auth";
-    }
-    if (status === 429) {
-        return "rate_limit";
-    }
-    // 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";
+    return kindOfStatus(status);
 }
 async function failure(response) {
-    const text = await response.text().catch(() => "");
+    const text = await failureText(response);
     const parsed = errorBody.safeParse(safeJson(text));
     // The provider's own words, through the redactor - an error body may quote the key back.
     const message = redact(parsed.success ? parsed.data.error.message : text.trim() || response.statusText);
-    const retryAfterMs = retryAfter(response.headers.get("retry-after"));
     const kind = kindOf(response.status, parsed.success ? parsed.data.error.code : undefined);
-    return providerError({
-        kind,
-        message: kind === "refusal"
-            ? refusedImage("OpenAI", message)
-            : httpFailure({
-                provider: "OpenAI",
-                status: response.status,
-                detail: message,
-                subject: "image request",
-            }),
-        ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
-    });
+    return httpProviderError(response, kind, kind === "refusal"
+        ? refusedImage("OpenAI", message)
+        : httpFailure({
+            provider: "OpenAI",
+            status: response.status,
+            detail: message,
+            subject: "image request",
+        }), undefined, kind === "refusal"
+        ? undefined
+        : modelAccessOf(response.status, `${parsed.success ? (parsed.data.error.code ?? "") : ""} ${message}`));
 }
 function parse(text) {
     const parsed = generated.safeParse(safeJson(text));
@@ -178,11 +160,3 @@ function parse(text) {
     }
     return parsed.data;
 }
-function safeJson(text) {
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return undefined;
-    }
-}

package/dist/adapters/image/reference.js

@@ -39,3 +39,39 @@ export function withReferences(prompt, req, limit = Number.POSITIVE_INFINITY) {
 function describe(description) {
     return description.trim() === "" ? "" : ` (${description.trim()})`;
 }
+// What an edit model is told about the first attached picture: it is the canvas to change,
+// the opposite of a reference.
+export const editNote = "Change the first attached image as follows. Keep everything the instruction does not mention exactly as it is: people, faces, composition and framing.";
+// The pictures an edit request attaches: the picture to change, then each cast member's
+// pictures. An edit never sends an establishing image.
+export function editPictures(req) {
+    return [
+        ...(req.edit === undefined ? [] : [{ image: req.edit.source }]),
+        ...(req.cast ?? []).flatMap((member) => member.images.map((image) => ({ image, member: member.name }))),
+    ];
+}
+// The prompt an edit request sends with the first `limit` of `editPictures(req)` attached.
+export function withEditInstruction(instruction, req, limit = Number.POSITIVE_INFINITY) {
+    const sent = editPictures(req).slice(0, limit);
+    const lines = [editNote];
+    for (const [index, picture] of sent.entries()) {
+        const member = req.cast?.find((row) => row.name === picture.member);
+        if (member !== undefined)
+            lines.push(`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)}.`);
+    return `${lines.join("\n")}\n\n${instruction}`;
+}
+// What an adapter attaches and says: an edit's pictures and instruction, or, for every other
+// request, exactly what it always attached and said.
+export function attachedPictures(req) {
+    return req.edit === undefined ? referencePictures(req) : editPictures(req);
+}
+export function promptFor(prompt, req, limit = Number.POSITIVE_INFINITY) {
+    return req.edit === undefined
+        ? withReferences(prompt, req, limit)
+        : withEditInstruction(prompt, req, limit);
+}

package/dist/adapters/image/replicate.js

@@ -1,8 +1,10 @@
 import { z } from "zod";
 import { redact } from "../../kernel/log.js";
 import { providerError } from "../../kernel/ports/model.js";
-import { httpFailure, missingKey, noImage, providerSaid, refusedImage, unreadable, } from "../explain.js";
-import { retryAfter } from "../retry-after.js";
+import { createRows, editSettings } from "../../kernel/ports/settings-places.js";
+import { httpFailure, noImage, providerSaid, refusedImage, unreadable } from "../explain.js";
+import { failureText, httpProviderError, kindOfStatus, requireKey, safeJson, } from "../http-failure.js";
+import { modelAccessOf } from "../model-access.js";
 import { downloadImage } from "./bytes.js";
 import { withReferences } from "./reference.js";
 import { dataUri, downloadVideo } from "./video.js";
@@ -37,6 +39,7 @@ const errorBody = z.object({ detail: z.string().optional(), title: z.string().op
 // `canceled` cannot happen here - nothing cancels a prediction this app made - but reading
 // it as terminal beats polling forever.
 const settled = ["succeeded", "failed", "canceled"];
+export const replicateEditRefusal = "Replicate's image models can't edit a picture. Choose Codex CLI, OpenAI, Google, or FLUX.2 or Nano Banana 2 on fal.ai under Made with … · change.";
 export function replicateImage(deps) {
     return {
         id: "replicate",
@@ -44,10 +47,12 @@ export function replicateImage(deps) {
         generate: async (req) => {
             // The Replicate models listed take no input image to draw from (the FLUX image inputs
             // copy the picture's composition), so an establishing image is refused, not dropped.
+            if (req.edit !== undefined)
+                throw providerError({ kind: "unsupported", message: replicateEditRefusal });
             if (req.reference !== undefined)
                 throw providerError({
                     kind: "unsupported",
-                    message: "Replicate's image models can't use an establishing image as a reference. Choose Codex CLI, OpenAI, Google or fal.ai under Images → Provider on Play or in Edit project → Providers, or set Establishing image to Off in the Images section.",
+                    message: `Replicate's image models can't use an establishing image as a reference. Choose Codex CLI, OpenAI, Google or fal.ai as the image service in ${createRows.images} or ${editSettings.images}, or set Establishing image to Off there.`,
                 });
             const response = await deps.fetch(`${replicateBase}/models/${req.model}/predictions`, {
                 method: "POST",
@@ -70,7 +75,7 @@ export function replicateImage(deps) {
                 }),
             });
             if (!response.ok) {
-                throw await failure(response);
+                throw await failure(response, "image request", true);
             }
             const url = await settle(deps, parse(await response.text()), req.signal);
             // The download rides inside the attempt: a link that 404s is a failed attempt.
@@ -100,7 +105,7 @@ export function replicateImage(deps) {
                 }),
             });
             if (!response.ok)
-                throw await failure(response, "video clip request");
+                throw await failure(response, "video clip request", true);
             const url = await settle(deps, parse(await response.text()), req.signal);
             return await downloadVideo({
                 fetch: deps.fetch,
@@ -168,50 +173,25 @@ function declined(current) {
         kind: refusal ? "refusal" : "other",
         message: refusal
             ? refusedImage("Replicate", message)
-            : 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."),
+            : providerSaid("Replicate", "could not make the image", message, `Use Try again; if it keeps happening, reword the image prompt in ${editSettings.images} or choose another image model there.`),
     });
 }
 function auth(deps) {
-    // `missing_key`, not `auth`, because that rule makes it terminal.
-    const key = deps.key();
-    if (key === undefined || key === "") {
-        throw providerError({ kind: "missing_key", message: missingKey("Replicate") });
-    }
-    return { Authorization: `Bearer ${key}` };
+    return { Authorization: `Bearer ${requireKey(deps.key(), "Replicate")}` };
 }
-// Only the adapter sees the vendor's status code, so only the adapter names the kind.
-function kindOf(status) {
-    if (status === 401 || status === 403) {
-        return "auth";
-    }
-    if (status === 429) {
-        return "rate_limit";
-    }
-    // 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") {
-    const text = await response.text().catch(() => "");
+// `atModel`: the request went to the model's own address, so a 404 or 403 is about the model.
+async function failure(response, subject = "image request", atModel = false) {
+    const text = await failureText(response);
     const parsed = errorBody.safeParse(safeJson(text));
     // The provider's own words, through the redactor - an error body may quote the key back.
     const detail = parsed.success ? (parsed.data.detail ?? parsed.data.title) : undefined;
     const message = redact(detail ?? text.trim());
-    const retryAfterMs = retryAfter(response.headers.get("retry-after"));
-    return providerError({
-        kind: kindOf(response.status),
-        message: httpFailure({
-            provider: "Replicate",
-            status: response.status,
-            detail: message || response.statusText,
-            subject,
-        }),
-        ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
-    });
+    return httpProviderError(response, kindOfStatus(response.status), httpFailure({
+        provider: "Replicate",
+        status: response.status,
+        detail: message || response.statusText,
+        subject,
+    }), undefined, modelAccessOf(response.status, text, atModel));
 }
 function parse(text) {
     const parsed = prediction.safeParse(safeJson(text));
@@ -223,11 +203,3 @@ function parse(text) {
     }
     return parsed.data;
 }
-function safeJson(text) {
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return undefined;
-    }
-}

package/dist/adapters/image/video.js

@@ -1,4 +1,5 @@
 import { providerError } from "../../kernel/ports/model.js";
+import { editSettings } from "../../kernel/ports/settings-places.js";
 import { describeBytes } from "./bytes.js";
 // What the two image-to-video adapters share: the still goes up inline as a data URI (the
 // render sends a small JPEG, `slices/rebuild/runtime-animate.ts`), and the clip comes back
@@ -22,7 +23,7 @@ export async function downloadVideo(download) {
     if (!sniffVideo(bytes))
         throw providerError({
             kind: "other",
-            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.`,
+            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 ${editSettings.look}.`,
         });
     return { bytes, mime: "video/mp4" };
 }