@gentbajko/slopify 0.1.0

package/dist/adapters/image/replicate.js

@@ -0,0 +1,183 @@
+import { z } from "zod";
+import { redact } from "../../kernel/log.js";
+import { providerError } from "../../kernel/ports/model.js";
+import { retryAfter } from "../retry-after.js";
+import { downloadImage } from "./bytes.js";
+// The HTTP gateway adapter for Replicate (01-architecture Module boundaries). `fetch`,
+// the injected clock, and the downloader beside this file; no SDK. `replicate` the package
+// exists and wraps exactly the two requests below, so 05-dependencies' rung 3 covers it.
+export const replicateBase = "https://api.replicate.com/v1";
+// `Prefer: wait` holds the connection open while the model runs, up to the 60 s ceiling
+// Replicate documents. A model slower than that answers `starting` instead, and the
+// prediction has to be polled - which is why this adapter takes a clock. The attempt
+// wrapper's 300 s (`logic/09` §Q77) is what ends the polling, through the request signal.
+export const replicateWaitSeconds = 60;
+export const replicatePollMs = 2000;
+// `logic/02` §Q15: the model dropdown is filled from what the provider offers. Replicate's
+// model index lists every model on the platform, text and video among them, so the
+// text-to-image shortlist is this adapter's own data and adding one is a line here.
+// ceiling: each entry has to take `prompt`, `aspect_ratio` and `output_format`, which is
+// the convention across Replicate's official image models but not a guarantee; a model
+// that spells its inputs differently needs a per-model input map first.
+export const replicateModels = [
+    { id: "black-forest-labs/flux-1.1-pro", name: "FLUX 1.1 [pro]" },
+    { id: "black-forest-labs/flux-dev", name: "FLUX.1 [dev]" },
+    { id: "black-forest-labs/flux-schnell", name: "FLUX.1 [schnell]" },
+];
+// A wire payload is narrowed, never cast (01-architecture §Q10, §Q33). `output` is one
+// URL on the models that make a single image and an array on the ones that can make
+// several, so both shapes are read and the first is taken.
+const prediction = z.object({
+    status: z.string(),
+    output: z.union([z.string(), z.array(z.string())]).nullish(),
+    error: z.string().nullish(),
+    urls: z.object({ get: z.string().optional() }).nullish(),
+});
+const errorBody = z.object({ detail: z.string().optional(), title: z.string().optional() });
+// The two terminal states that are not success. `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 function replicateImage(deps) {
+    return {
+        id: "replicate",
+        models: () => Promise.resolve(replicateModels),
+        generate: async (req) => {
+            const response = await deps.fetch(`${replicateBase}/models/${req.model}/predictions`, {
+                method: "POST",
+                signal: req.signal,
+                headers: {
+                    ...auth(deps),
+                    "Content-Type": "application/json",
+                    Prefer: `wait=${String(replicateWaitSeconds)}`,
+                },
+                body: JSON.stringify({
+                    input: {
+                        prompt: req.prompt,
+                        // `logic/09` step 1: Replicate takes the aspect itself, so the closest
+                        // supported size is the exact one.
+                        aspect_ratio: req.aspect,
+                        // The port stores a PNG or a JPEG and these models default to WebP.
+                        // Nothing else is set: step 2 asks for the provider's own quality and style.
+                        output_format: "png",
+                    },
+                }),
+            });
+            if (!response.ok) {
+                throw await failure(response);
+            }
+            const url = await settle(deps, parse(await response.text()), req.signal);
+            // The download is inside the attempt with the call that produced the link, so a
+            // link that 404s is a failed attempt rather than a broken file on the project.
+            return await downloadImage({
+                fetch: deps.fetch,
+                provider: "Replicate",
+                url,
+                signal: req.signal,
+            });
+        },
+    };
+}
+// `Prefer: wait` answers `starting` when the model outlived its 60 s, and Replicate's own
+// guidance is to poll `urls.get` until the prediction settles.
+async function settle(deps, first, signal) {
+    let current = first;
+    while (!settled.includes(current.status)) {
+        const next = current.urls?.get;
+        if (next === undefined) {
+            throw providerError({
+                kind: "other",
+                message: `Replicate left the prediction ${current.status} and named no address to read it from`,
+            });
+        }
+        await deps.clock.sleep(replicatePollMs, signal);
+        const response = await deps.fetch(next, { signal, headers: auth(deps) });
+        if (!response.ok) {
+            throw await failure(response);
+        }
+        current = parse(await response.text());
+    }
+    return outputOf(current);
+}
+function outputOf(current) {
+    if (current.status !== "succeeded") {
+        throw declined(current);
+    }
+    const output = current.output;
+    const url = typeof output === "string" ? output : output?.[0];
+    if (url === undefined || url === "") {
+        throw providerError({ kind: "other", message: "Replicate succeeded with no image" });
+    }
+    return url;
+}
+// `logic/09` §Q74: a content-policy refusal is the provider's final answer and is never
+// retried. Replicate reports one as a settled prediction whose `error` says so, with the
+// same 201 the successful call had, so the text is what tells them apart.
+const refusalWords = /\b(nsfw|sensitive|safety|content polic|flagged|moderat)/i;
+function declined(current) {
+    // The provider's own words, verbatim, through the same redactor the wrapper uses.
+    const message = redact(current.error ?? `the prediction ended ${current.status}`);
+    // ceiling: read off the sentence, because Replicate carries no machine-readable reason
+    // on a failed prediction. A phrase the list does not know is retried three more times
+    // and costs the user three more images; a structured field would settle it, and the
+    // upgrade is to read one when Replicate ships it.
+    return providerError({
+        kind: refusalWords.test(message) ? "refusal" : "other",
+        message: `Replicate answered: ${message}`,
+    });
+}
+function auth(deps) {
+    // `logic/02` §Q13: an attempt that finds no key fails rather than calling anonymously.
+    // `missing_key` rather than `auth` because the same rule makes it terminal.
+    const key = deps.key();
+    if (key === undefined || key === "") {
+        throw providerError({ kind: "missing_key", message: "no Replicate key is stored" });
+    }
+    return { Authorization: `Bearer ${key}` };
+}
+// Only the adapter can read a vendor's status code, so only the adapter names the kind;
+// the attempt wrapper maps it and nothing downstream classifies again (03-conventions).
+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 kind for "this request will never
+    // work" would have to be added to the port's error contract first, which is not this
+    // adapter's to widen.
+    return "other";
+}
+async function failure(response) {
+    const text = await response.text().catch(() => "");
+    const parsed = errorBody.safeParse(safeJson(text));
+    // The provider's own words, verbatim, through the same redactor the wrapper uses: an
+    // error body is free to quote the key back and this is the first place it is held.
+    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: `Replicate answered ${String(response.status)}: ${message || response.statusText}`,
+        ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
+    });
+}
+function parse(text) {
+    const parsed = prediction.safeParse(safeJson(text));
+    if (!parsed.success) {
+        throw providerError({
+            kind: "other",
+            message: "Replicate's answer was not in the shape this app can read",
+        });
+    }
+    return parsed.data;
+}
+function safeJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/adapters/llm/claude-code.js

@@ -0,0 +1,158 @@
+import { z } from "zod";
+import { redact } from "../../kernel/log.js";
+import { providerError } from "../../kernel/ports/model.js";
+import { cliEvent, cliShaped, endedWithout, promptOf } from "./run-cli.js";
+import { lines } from "./sse-lines.js";
+// The local-agent adapter for Claude Code (01-architecture Module boundaries): spawned
+// non-interactively, authenticated by the CLI's own login, no key anywhere in this file.
+// Readiness is not computed here - `adapters/**` may not import `slices/**`, and
+// `slices/settings/cli-status.ts` already probes the binary per request (`logic/02`
+// §Q135). The registry `main.ts` builds is where this adapter and that probe meet.
+export const claudeCodeBinary = "claude";
+// The CLI takes an alias for the latest model of a family (`claude --help`, 2.1.258).
+// ceiling: a fixed list, because the CLI has no offline command that prints the models an
+// account may use. A user whose plan carries a model not listed here cannot pick it;
+// reading the list off the CLI is the upgrade when it can print one.
+export const claudeCodeModels = [
+    { id: "fable", name: "Claude Fable (latest)" },
+    { id: "opus", name: "Claude Opus (latest)" },
+    { id: "sonnet", name: "Claude Sonnet (latest)" },
+    { id: "haiku", name: "Claude Haiku (latest)" },
+];
+// Measured on 2.1.258, not assumed: with the built-in tools left alone, a `-p` run of this
+// CLI still reached for ToolSearch and WebFetch, and the machine's MCP servers were loaded
+// into the session. Neither belongs in a content pipeline - the article stage must not
+// quietly ground itself on the web, since `logic/06` §Q47 makes grounding an explicit ask,
+// and no stage should be able to touch the disk. `--tools ""` empties the built-in set and
+// `--strict-mcp-config` drops the user's MCP servers; the init event of a run with both
+// reports `"tools":[]` and `"mcp_servers":[]`.
+export function claudeCodeArgs(req) {
+    return [
+        "-p",
+        "--output-format",
+        "stream-json",
+        // stream-json output is refused without it.
+        "--verbose",
+        "--strict-mcp-config",
+        ...(req.webSearch === true
+            ? ["--tools", "WebSearch", "--allowedTools", "WebSearch"]
+            : ["--tools", ""]),
+        ...(req.model === "" ? [] : ["--model", req.model]),
+        // Everything after `--` is the prompt, so a prompt opening with a dash is text and not
+        // a flag. It is one argv element: no shell sees it and nothing in it is expanded.
+        "--",
+        promptOf(req.messages),
+    ];
+}
+const assistantEvent = z.object({
+    message: z.object({
+        content: z.array(z.object({ type: z.string(), text: z.string().optional() })),
+    }),
+});
+// The result event as 2.1.258 writes it. `subtype` stays "success" even for a failed run -
+// a bad model name answers `{"subtype":"success","is_error":true,"api_error_status":404}` -
+// so `is_error` is what decides, with `subtype` checked as well for a run that never
+// reached the model at all.
+const resultEvent = z.object({
+    subtype: z.string(),
+    is_error: z.boolean().optional(),
+    result: z.string().optional(),
+    stop_reason: z.string().nullish(),
+    api_error_status: z.number().nullish(),
+    modelUsage: z
+        .record(z.string(), z.object({ inputTokens: z.number(), outputTokens: z.number() }))
+        .optional(),
+});
+export function claudeCodeLlm(deps) {
+    const binary = deps.binary ?? claudeCodeBinary;
+    async function* complete(req) {
+        const run = deps.run(binary, claudeCodeArgs(req), req.signal);
+        try {
+            for await (const line of lines(run.stdout, req.signal)) {
+                if (line.trim() === "") {
+                    continue;
+                }
+                const event = cliEvent(binary, line);
+                if (event.type === "assistant") {
+                    for (const block of cliShaped(binary, assistantEvent, event.value).message.content) {
+                        // A turn also carries `thinking` and `tool_use` blocks; only the prose is the
+                        // stage's output.
+                        if (block.type === "text" && block.text !== undefined && block.text !== "") {
+                            yield { type: "delta", text: block.text };
+                        }
+                    }
+                    continue;
+                }
+                if (event.type !== "result") {
+                    continue;
+                }
+                const result = cliShaped(binary, resultEvent, event.value);
+                if (result.is_error === true || result.subtype !== "success") {
+                    throw providerError({
+                        kind: kindOf(result.api_error_status ?? null),
+                        message: redact(result.result ?? result.subtype),
+                    });
+                }
+                yield {
+                    type: "done",
+                    usage: usageOf(result.modelUsage),
+                    finishReason: result.stop_reason ?? null,
+                };
+                return;
+            }
+        }
+        catch (error) {
+            // A cancelled stage killed the child; the reason the user's cancel carried is what
+            // the runner expects back, not whatever the half-closed pipe threw (`logic/13`).
+            req.signal.throwIfAborted();
+            throw error;
+        }
+        finally {
+            // The consumer can also abandon the generator - a retry, a timeout - and an agent
+            // session left running would keep spending the user's subscription.
+            run.kill();
+        }
+        // A cancelled run ends its stream the same way an exhausted one does: the child was
+        // killed, so stdout simply stopped. `logic/13` §Q112 says an aborted call counts
+        // nothing, so it must not be reported as the provider failing.
+        req.signal.throwIfAborted();
+        // The stream ended with no result event at all.
+        throw providerError({
+            kind: "other",
+            message: endedWithout(binary, await run.ended, run.stderr()),
+        });
+    }
+    return {
+        id: "claude-code",
+        // The CLI emits whole assistant turns rather than token deltas, which is still enough
+        // for the idle timeout of `logic/01` §Q62 to see life on the stream.
+        // ceiling: `--include-partial-messages` would give per-token deltas for the streamed
+        // article of `logic/07` step 2; it is the upgrade when the page needs finer text.
+        capabilities: { streams: true, reportsUsage: true, webSearch: true },
+        models: () => Promise.resolve(claudeCodeModels),
+        complete,
+    };
+}
+// The CLI reports the upstream status on the result event; nothing else about a local
+// process says which failure this was.
+function kindOf(status) {
+    if (status === 401 || status === 403) {
+        return "auth";
+    }
+    if (status === 429) {
+        return "rate_limit";
+    }
+    return "other";
+}
+// `modelUsage` is keyed by model id and a run may touch more than one - a fallback model,
+// a sub-agent - so the counts are summed. An empty object means the CLI reported none.
+function usageOf(usage) {
+    const entries = Object.values(usage ?? {});
+    if (entries.length === 0) {
+        return null;
+    }
+    return {
+        inputTokens: entries.reduce((total, one) => total + one.inputTokens, 0),
+        outputTokens: entries.reduce((total, one) => total + one.outputTokens, 0),
+    };
+}

package/dist/adapters/llm/codex.js

@@ -0,0 +1,126 @@
+import { z } from "zod";
+import { redact } from "../../kernel/log.js";
+import { providerError } from "../../kernel/ports/model.js";
+import { cliEvent, cliShaped, endedWithout, promptOf } from "./run-cli.js";
+import { lines } from "./sse-lines.js";
+// The local-agent adapter for the Codex CLI. Same shape as Claude Code's and a different
+// vocabulary: Codex writes a JSONL thread of `thread.started`, `item.*` and `turn.*`
+// events. No key here either - the CLI's own login authenticates it (`logic/02` §Q135).
+export const codexBinary = "codex";
+// ceiling: a fixed list. `codex` has no offline command that prints the models an account
+// may use - `codex doctor` reports the install, not the catalogue, and the model refresh
+// it does at start needs the login this list is meant to be readable without. These two
+// are the ids this machine's `~/.codex/config.toml` names; reading the real catalogue is
+// the upgrade when the CLI grows a command that prints it.
+export const codexModels = [
+    { id: "gpt-5.1-codex-max", name: "GPT-5.1 Codex Max" },
+    { id: "gpt-5.6-sol", name: "GPT-5.6 Sol" },
+];
+// `codex exec --help` (0.149.1) for the flags. `-c web_search=<mode>` is a TOML override,
+// and the binary's own error names the modes: "unknown variant `bogus`, expected one of
+// `disabled`, `cached`, `indexed`, `live`". `live` is the grounded mode `logic/06` asks
+// for and `disabled` is what every other stage runs under, so no stage grounds itself by
+// accident. `--ephemeral` keeps no session file, `--skip-git-repo-check` lets it run in
+// the data directory, and the quotes in the value are part of the argv element because
+// the override is parsed as TOML, where a bare `live` is not a string.
+export function codexArgs(req) {
+    return [
+        "exec",
+        "--json",
+        "--ephemeral",
+        "--skip-git-repo-check",
+        "-c",
+        `web_search="${req.webSearch === true ? "live" : "disabled"}"`,
+        ...(req.model === "" ? [] : ["-m", req.model]),
+        // The prompt is one argv element after `--`, so a leading dash is text, not a flag.
+        "--",
+        promptOf(req.messages),
+    ];
+}
+const itemCompleted = z.object({
+    item: z.object({ type: z.string(), text: z.string().optional() }),
+});
+// The field names are the shipped binary's own: `TurnCompletedEvent` carries `usage`, and
+// its counts are `input_tokens`, `cached_input_tokens`, `cache_write_input_tokens`,
+// `output_tokens`, `reasoning_output_tokens`. Only the two the port has a home for are read.
+const turnCompleted = z.object({
+    usage: z.object({ input_tokens: z.number(), output_tokens: z.number() }).nullish(),
+});
+const turnFailed = z.object({ error: z.object({ message: z.string() }) });
+// The top-level `error` event carries its text in `message`, not in `error.message`.
+const errorEvent = z.object({ message: z.string() });
+export function codexLlm(deps) {
+    const binary = deps.binary ?? codexBinary;
+    async function* complete(req) {
+        const run = deps.run(binary, codexArgs(req), req.signal);
+        try {
+            for await (const line of lines(run.stdout, req.signal)) {
+                if (line.trim() === "") {
+                    continue;
+                }
+                const event = cliEvent(binary, line);
+                if (event.type === "item.completed") {
+                    const { item } = cliShaped(binary, itemCompleted, event.value);
+                    // A turn also completes `reasoning`, `web_search`, `command_execution` and
+                    // `error` items. The last of those is a warning, not a failure: this machine's
+                    // codex opens every run with an `error` item saying it has no metadata for the
+                    // configured model, then answers normally. Only `turn.failed` ends a turn.
+                    if (item.type === "agent_message" && item.text !== undefined && item.text !== "") {
+                        yield { type: "delta", text: item.text };
+                    }
+                    continue;
+                }
+                if (event.type === "turn.completed") {
+                    const { usage } = cliShaped(binary, turnCompleted, event.value);
+                    // ceiling: Codex reports no stop reason, so the continuation loop of
+                    // `logic/07` §Q59 cannot tell a finished answer from one cut at the output
+                    // limit for this provider. A `--output-schema` run would, at the cost of
+                    // constraining every stage's answer.
+                    yield { type: "done", usage: usageOf(usage), finishReason: null };
+                    return;
+                }
+                if (event.type === "turn.failed") {
+                    throw providerError({
+                        kind: "other",
+                        message: redact(cliShaped(binary, turnFailed, event.value).error.message),
+                    });
+                }
+                if (event.type === "error") {
+                    throw providerError({
+                        kind: "other",
+                        message: redact(cliShaped(binary, errorEvent, event.value).message),
+                    });
+                }
+            }
+        }
+        catch (error) {
+            req.signal.throwIfAborted();
+            throw error;
+        }
+        finally {
+            run.kill();
+        }
+        // A cancelled run ends its stream the same way an exhausted one does: the child was
+        // killed, so stdout simply stopped. `logic/13` §Q112 says an aborted call counts
+        // nothing, so it must not be reported as the provider failing.
+        req.signal.throwIfAborted();
+        // The stream ended with neither a completed turn nor a failure.
+        throw providerError({
+            kind: "other",
+            message: endedWithout(binary, await run.ended, run.stderr()),
+        });
+    }
+    return {
+        id: "codex",
+        // ceiling: one `item.completed` per whole message rather than per token, same as the
+        // other CLI. Enough for the idle timeout of `logic/01` §Q62 to see life on the stream.
+        capabilities: { streams: true, reportsUsage: true, webSearch: true },
+        models: () => Promise.resolve(codexModels),
+        complete,
+    };
+}
+function usageOf(usage) {
+    return usage === null || usage === undefined
+        ? null
+        : { inputTokens: usage.input_tokens, outputTokens: usage.output_tokens };
+}

package/dist/adapters/llm/openrouter.js

@@ -0,0 +1,193 @@
+import { z } from "zod";
+import { redact } from "../../kernel/log.js";
+import { providerError } from "../../kernel/ports/model.js";
+import { retryAfter } from "../retry-after.js";
+import { sseData } from "./sse-lines.js";
+// The HTTP gateway adapter (01-architecture Module boundaries). `fetch` plus the line
+// reader beside this file, no SDK: 05-dependencies records global `fetch` at rung 3 and
+// the reader at rung 6, so nothing here is worth a dependency.
+export const openRouterBase = "https://openrouter.ai/api/v1";
+// OpenRouter ranks apps by these two headers; they carry no user data.
+const appHeaders = {
+    "HTTP-Referer": "https://slopify.stream",
+    "X-Title": "Slopify",
+};
+// A wire payload is narrowed, never cast: everything unlisted is dropped at the seam so
+// no vendor shape can leak past this file (01-architecture §Q10, §Q33).
+const modelList = z.object({
+    data: z.array(z.object({ id: z.string(), name: z.string().optional() })),
+});
+const errorBody = z.object({
+    error: z.object({ message: z.string(), code: z.union([z.number(), z.string()]).optional() }),
+});
+const streamChunk = z.object({
+    choices: z
+        .array(z.object({
+        delta: z.object({ content: z.string().nullish() }).optional(),
+        finish_reason: z.string().nullish(),
+    }))
+        .optional(),
+    usage: z.object({ prompt_tokens: z.number(), completion_tokens: z.number() }).nullish(),
+    error: z
+        .object({ message: z.string(), code: z.union([z.number(), z.string()]).optional() })
+        .optional(),
+});
+export function openRouterLlm(deps) {
+    async function* complete(req) {
+        const response = await deps.fetch(`${openRouterBase}/chat/completions`, {
+            method: "POST",
+            signal: req.signal,
+            headers: { ...headers(deps.key()), "Content-Type": "application/json" },
+            body: JSON.stringify({
+                model: req.model,
+                messages: req.messages.map((message) => ({
+                    role: message.role,
+                    content: message.content,
+                })),
+                stream: true,
+                // The usage-accounting flag: without it the final chunk carries no token counts
+                // and the Usage page would have nothing to count (`logic/16`).
+                usage: { include: true },
+                // `logic/06` §Q47: web grounding is asked for explicitly. OpenRouter runs the
+                // search itself, so the plugin works whatever model was picked.
+                ...(req.webSearch === true ? { plugins: [{ id: "web" }] } : {}),
+            }),
+        });
+        if (!response.ok) {
+            throw await failure(response);
+        }
+        if (response.body === null) {
+            throw providerError({ kind: "other", message: "OpenRouter answered with no body" });
+        }
+        let usage = null;
+        let finishReason = null;
+        let complete = false;
+        for await (const data of sseData(response.body, req.signal)) {
+            if (data === "") {
+                continue;
+            }
+            if (data === "[DONE]") {
+                complete = true;
+                break;
+            }
+            const chunk = parseChunk(data);
+            if (chunk.error !== undefined) {
+                // A stream that has already answered 200 reports a mid-flight failure in a data
+                // frame; without this the stage would store half an article as a success.
+                throw providerError({
+                    kind: kindOf(statusOf(chunk.error.code)),
+                    message: redact(chunk.error.message),
+                });
+            }
+            const choice = chunk.choices?.[0];
+            const text = choice?.delta?.content;
+            if (text !== undefined && text !== null && text !== "") {
+                yield { type: "delta", text };
+            }
+            if (choice?.finish_reason !== undefined && choice.finish_reason !== null) {
+                // It arrives on the last choice chunk, one frame before the usage frame, so it is
+                // held rather than read off whichever chunk happens to be last (`logic/07` §Q59
+                // reads it to tell a finished article from a truncated one).
+                finishReason = choice.finish_reason;
+            }
+            if (chunk.usage !== undefined && chunk.usage !== null) {
+                usage = {
+                    inputTokens: chunk.usage.prompt_tokens,
+                    outputTokens: chunk.usage.completion_tokens,
+                };
+                complete = true;
+            }
+        }
+        if (!complete) {
+            // Neither `[DONE]` nor the usage frame arrived, so the connection dropped part-way.
+            // Saying so is what stops a truncated answer being stored as a whole one.
+            throw providerError({
+                kind: "other",
+                message: "OpenRouter's stream ended before the response was complete",
+            });
+        }
+        yield { type: "done", usage, finishReason };
+    }
+    return {
+        id: "openrouter",
+        capabilities: { streams: true, reportsUsage: true, webSearch: true },
+        models: async () => {
+            const response = await deps.fetch(`${openRouterBase}/models`, {
+                headers: headers(deps.key()),
+            });
+            if (!response.ok) {
+                throw await failure(response);
+            }
+            const parsed = modelList.safeParse(await response.json());
+            if (!parsed.success) {
+                throw providerError({
+                    kind: "other",
+                    message: "OpenRouter's model list was not in the shape this app can read",
+                });
+            }
+            return parsed.data.data.map((model) => ({ id: model.id, name: model.name ?? model.id }));
+        },
+        complete,
+    };
+}
+function headers(key) {
+    // `logic/02` §Q13: an attempt that finds no key fails rather than calling anonymously
+    // and being told off by the provider in words the user cannot act on. `missing_key`
+    // rather than `auth` because the same rule makes it terminal: there is nothing to
+    // retry until the user saves a key, and the wrapper is where that is decided.
+    if (key === undefined || key === "") {
+        throw providerError({ kind: "missing_key", message: "no OpenRouter key is stored" });
+    }
+    return { Authorization: `Bearer ${key}`, ...appHeaders };
+}
+// Only the adapter can read a vendor's status code, so only the adapter names the kind;
+// the attempt wrapper maps it and nothing downstream classifies again (03-conventions).
+function kindOf(status) {
+    if (status === 401 || status === 403) {
+        return "auth";
+    }
+    if (status === 429) {
+        return "rate_limit";
+    }
+    // ceiling: everything else is `other` and is retried. 400 and 402 will fail the same
+    // way four times over; a terminal kind for "this request will never work" would have to
+    // be added to the port's error contract first, which is not this adapter's to widen.
+    return "other";
+}
+async function failure(response) {
+    const text = await response.text().catch(() => "");
+    const parsed = errorBody.safeParse(safeJson(text));
+    // The provider's own words, verbatim, through the same redactor the wrapper uses: an
+    // error body is free to quote the key back and this is the first place it is held.
+    const message = redact(parsed.success ? parsed.data.error.message : text.trim() || response.statusText);
+    const retryAfterMs = retryAfter(response.headers.get("retry-after"));
+    return providerError({
+        kind: kindOf(response.status),
+        message: `OpenRouter answered ${response.status}: ${message}`,
+        ...(retryAfterMs === undefined ? {} : { retryAfterMs }),
+    });
+}
+function statusOf(code) {
+    return typeof code === "number" ? code : Number(code ?? 0);
+}
+function parseChunk(data) {
+    const parsed = streamChunk.safeParse(safeJson(data));
+    if (!parsed.success) {
+        // A frame that will not parse is a stream cut mid-line or a payload this app does not
+        // understand. Either way the answer is incomplete, and the text is not echoed back:
+        // a half-written frame is noise, and the wrapper stores whatever is thrown.
+        throw providerError({
+            kind: "other",
+            message: "OpenRouter sent a stream frame this app could not read",
+        });
+    }
+    return parsed.data;
+}
+function safeJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}