@gentbajko/slopify 3.25.8 → 4.0.0

package/dist/adapters/image/google.js

@@ -1,11 +1,12 @@
 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 { 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 +66,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
@@ -123,12 +124,7 @@ function decode(part) {
     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 +137,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 +155,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 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.
+            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 +191,3 @@ function parse(text) {
     }
     return parsed.data;
 }
-function safeJson(text) {
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return undefined;
-    }
-}

package/dist/adapters/image/openai.js

@@ -1,11 +1,12 @@
 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 { 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 +57,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 +97,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())
@@ -122,51 +123,31 @@ function decode(b64) {
     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 +159,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,9 @@
 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 { 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 +38,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,6 +46,8 @@ 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",
@@ -70,7 +74,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 +104,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,
@@ -172,46 +176,21 @@ function declined(current) {
     });
 }
 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 +202,3 @@ function parse(text) {
     }
     return parsed.data;
 }
-function safeJson(text) {
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return undefined;
-    }
-}

package/dist/adapters/interest/search-interest.js

@@ -0,0 +1,113 @@
+import { z } from "zod";
+// Public search interest without a key: Google's search suggestions (DuckDuckGo's when Google
+// doesn't answer) and the Wikipedia article's views last month. Checked keyless on 2026-10-18;
+// Google Trends answers 429/404 to such calls, so it isn't asked.
+// ceiling: one service that hangs costs a topic this long at most.
+export const interestRequestMs = 4000;
+const suggestAnswer = z.tuple([z.string(), z.array(z.string())]).rest(z.unknown());
+const openSearchAnswer = z.tuple([z.string(), z.array(z.string())]).rest(z.unknown());
+const pageviewsAnswer = z.object({ items: z.array(z.object({ views: z.number() }).loose()) });
+class Unanswered extends Error {
+    reason;
+    constructor(reason) {
+        super(reason);
+        this.reason = reason;
+    }
+}
+// "en" from "en-GB"; a language Wikipedia names by its two letters.
+function languageOf(language) {
+    const code = language.trim().toLowerCase().slice(0, 2);
+    return /^[a-z]{2}$/.test(code) ? code : "en";
+}
+// The last whole month before `now`, as the pageviews API names its days.
+export function lastMonth(now) {
+    const first = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth() - 1, 1));
+    const last = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 0));
+    const day = (date) => `${String(date.getUTCFullYear())}${String(date.getUTCMonth() + 1).padStart(2, "0")}${String(date.getUTCDate()).padStart(2, "0")}00`;
+    return { start: day(first), end: day(last) };
+}
+export function createSearchInterest(deps) {
+    const headers = {
+        "User-Agent": `Slopify/${deps.version} (https://github.com/gentbajko/slopify)`,
+        Accept: "application/json",
+    };
+    const json = async (url, signal) => {
+        const timeout = AbortSignal.timeout(interestRequestMs);
+        let response;
+        try {
+            response = await deps.fetch(url, { headers, signal: AbortSignal.any([signal, timeout]) });
+        }
+        catch {
+            throw new Unanswered(timeout.aborted ? "timeout" : "offline");
+        }
+        if (!response.ok)
+            throw new Unanswered("refused");
+        try {
+            return await response.json();
+        }
+        catch {
+            throw new Unanswered("refused");
+        }
+    };
+    const reasonOf = (error) => error instanceof Unanswered ? error.reason : "offline";
+    const suggestions = async (topic, language, signal) => {
+        const q = encodeURIComponent(topic);
+        let failure = "offline";
+        for (const url of [
+            `https://suggestqueries.google.com/complete/search?client=firefox&hl=${language}&q=${q}`,
+            `https://duckduckgo.com/ac/?q=${q}&type=list&kl=wt-wt`,
+        ]) {
+            try {
+                const parsed = suggestAnswer.safeParse(await json(url, signal));
+                if (parsed.success)
+                    return parsed.data[1].slice(0, 10);
+                failure = "refused";
+            }
+            catch (error) {
+                failure = reasonOf(error);
+            }
+        }
+        return failure;
+    };
+    const wikiViews = async (topic, language, signal) => {
+        try {
+            const found = openSearchAnswer.safeParse(await json(`https://${language}.wikipedia.org/w/api.php?action=opensearch&format=json&namespace=0&limit=1&search=${encodeURIComponent(topic)}`, signal));
+            if (!found.success)
+                return "refused";
+            const title = found.data[1][0];
+            if (title === undefined)
+                return null;
+            const { start, end } = lastMonth(deps.now());
+            let answer;
+            try {
+                answer = await json(`https://wikimedia.org/api/rest_v1/metrics/pageviews/per-article/${language}.wikipedia/all-access/user/${encodeURIComponent(title.replaceAll(" ", "_"))}/monthly/${start}/${end}`, signal);
+            }
+            catch (error) {
+                // An article too new to have a month of views answers 404.
+                if (reasonOf(error) === "refused")
+                    return null;
+                throw error;
+            }
+            const views = pageviewsAnswer.safeParse(answer);
+            return views.success ? views.data.items.reduce((sum, item) => sum + item.views, 0) : null;
+        }
+        catch (error) {
+            return reasonOf(error);
+        }
+    };
+    return async (topic, rawLanguage, signal) => {
+        const language = languageOf(rawLanguage);
+        const [offered, views] = await Promise.all([
+            suggestions(topic, language, signal),
+            wikiViews(topic, language, signal),
+        ]);
+        const failed = (value) => typeof value === "string";
+        if (failed(offered) && failed(views))
+            return { ok: false, reason: offered };
+        return {
+            ok: true,
+            suggestions: failed(offered) ? null : offered,
+            wikiViews: failed(views) ? null : views,
+        };
+    };
+}

package/dist/adapters/key-probes.js

@@ -1,3 +1,4 @@
+import { safeJson } from "./http-failure.js";
 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
@@ -21,6 +22,37 @@ function listed(ids) {
     };
 }
 const field = (value, key) => typeof value === "object" && value !== null ? value[key] : undefined;
+function idsOf(rows, key, strip) {
+    if (!Array.isArray(rows))
+        return undefined;
+    return rows.flatMap((row) => {
+        const id = field(row, key);
+        return typeof id === "string" && id !== "" ? [strip ? id.replace(strip, "") : id] : [];
+    });
+}
+// `{ data: [{ id }] }`: OpenAI's and OpenRouter's lists.
+function dataList(url) {
+    return {
+        url: () => url,
+        read: (body) => {
+            const ids = idsOf(field(safeJson(body), "data"), "id");
+            return ids === undefined ? undefined : { ids };
+        },
+    };
+}
+const googleBase = "https://generativelanguage.googleapis.com/v1beta/models?pageSize=1000";
+const googleList = {
+    url: (page) => page === undefined ? googleBase : `${googleBase}&pageToken=${encodeURIComponent(page)}`,
+    read: (body) => {
+        const value = safeJson(body);
+        const ids = idsOf(field(value, "models"), "name", /^models\//);
+        if (ids === undefined)
+            return undefined;
+        const next = field(value, "nextPageToken");
+        return typeof next === "string" && next !== "" ? { ids, next } : { ids };
+    },
+};
+const openAiList = dataList("https://api.openai.com/v1/models");
 const google = {
     url: "https://generativelanguage.googleapis.com/v1beta/models?pageSize=1",
     headers: (key) => ({ "x-goog-api-key": key }),
@@ -28,6 +60,7 @@ const google = {
     model: {
         url: (model) => `https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(model.replace(/^models\//, ""))}`,
     },
+    list: googleList,
 };
 export const keyProbes = {
     openrouter: {
@@ -40,9 +73,20 @@ export const keyProbes = {
                 return Array.isArray(data) ? data.map((one) => field(one, "id")) : [];
             }),
         },
+        list: dataList("https://openrouter.ai/api/v1/models"),
+    },
+    "openai-tts": {
+        url: "https://api.openai.com/v1/models",
+        headers: bearer,
+        model: openAiModel,
+        list: openAiList,
+    },
+    "openai-image": {
+        url: "https://api.openai.com/v1/models",
+        headers: bearer,
+        model: openAiModel,
+        list: openAiList,
     },
-    "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.
@@ -72,6 +116,13 @@ export const keyProbes = {
             url: () => "https://api.elevenlabs.io/v1/models",
             lists: listed((body) => Array.isArray(body) ? body.map((one) => field(one, "model_id")) : []),
         },
+        list: {
+            url: () => "https://api.elevenlabs.io/v1/models",
+            read: (body) => {
+                const ids = idsOf(safeJson(body), "model_id");
+                return ids === undefined ? undefined : { ids };
+            },
+        },
     },
     cartesia: {
         url: "https://api.cartesia.ai/voices?limit=1",

package/dist/adapters/llm/antigravity.js

@@ -6,6 +6,7 @@ import { redact } from "../../kernel/log.js";
 import { documentMessages } from "../../kernel/ports/llm-documents.js";
 import { providerError } from "../../kernel/ports/model.js";
 import { cliCheck, cliName, cliReported, commandOf } from "../explain.js";
+import { accessField } from "../model-access.js";
 import { nodeAntigravityModels } from "./antigravity-models.js";
 import { imageWorkspace, readFileName, unseenImages } from "./image-workspace.js";
 import { cliInput, cliShaped, deliveredInput, endedWithout, promptOf, stopCliRun, stuckCli, } from "./run-cli.js";
@@ -205,6 +206,8 @@ function failure(binary, model, message, sentence, now = Date.now) {
     if (/invalid model selection/i.test(message))
         return providerError({
             kind: "unsupported",
+            // agy lists models a plan can't run and refuses them with this sentence.
+            access: "no-access",
             message: `The ${cliName(binary)} does not offer the model "${model}". Run "agy models" in a terminal to see the ones it has, pick one in the Edit tab (Edit project → Providers), then use Continue the run.`,
         });
     if (/quota|resource.?exhausted|capacity/i.test(message) &&
@@ -233,6 +236,7 @@ function failure(binary, model, message, sentence, now = Date.now) {
     }
     return providerError({
         kind: "other",
+        ...accessField(null, message),
         message: sentence ?? cliReported(binary, redact(message), cliCheck(binary)),
     });
 }