@giovannijecha/jecode 0.8.4 → 0.8.6

package/dist/process-lease.js

@@ -0,0 +1,329 @@
+// ABA-safe process ownership built from an atomic directory and one unique
+// generation entry. No cleanup operation ever unlinks a shared fixed owner.
+import { randomUUID } from "node:crypto";
+import { lstat, mkdir, open, opendir, rmdir, unlink } from "node:fs/promises";
+import * as path from "node:path";
+import { fileIdentity, sameFileIdentity } from "./file-identity.js";
+const OWNER_NAME = /^owner-([1-9]\d*)-([a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12})$/;
+const TOKEN = /^([1-9]\d*):([a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12})$/;
+export class ProcessLeaseError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ProcessLeaseError";
+    }
+}
+class ProcessLeaseChangedError extends ProcessLeaseError {
+}
+export function processLeaseToken() {
+    return `${process.pid}:${randomUUID()}`;
+}
+/** Create a new generation in a directory that must not already exist. */
+export async function createProcessLeaseDirectory(directory, token, mode = 0o700, hooks = {}) {
+    const entry = entryForToken(token);
+    await mkdir(directory, { mode });
+    const directoryIdentity = await requireDirectoryIdentity(directory);
+    let generation;
+    try {
+        await assertDirectoryIdentity(directory, directoryIdentity);
+        await hooks.beforeOwnerOpen?.();
+        const ownerFile = path.join(directory, entry);
+        const handle = await open(ownerFile, "wx", 0o600);
+        try {
+            const opened = await handle.stat({ bigint: true });
+            if (!opened.isFile() || opened.size !== 0n) {
+                throw new ProcessLeaseError("process lease owner is unsafe");
+            }
+            const linked = await lstat(ownerFile, { bigint: true });
+            const entryIdentity = fileIdentity(opened);
+            if (linked.isSymbolicLink() || !linked.isFile() || linked.size !== 0n ||
+                !sameFileIdentity(entryIdentity, fileIdentity(linked)))
+                throw new ProcessLeaseError("process lease owner changed while starting");
+            generation = Object.freeze({ token, entry, directoryIdentity, entryIdentity });
+        }
+        finally {
+            await handle.close();
+        }
+        await assertDirectoryIdentity(directory, directoryIdentity);
+        const owner = await inspectProcessLease(directory);
+        if (owner === undefined || owner.entry !== entry || owner.token !== token ||
+            !sameFileIdentity(owner.directoryIdentity, directoryIdentity) ||
+            generation === undefined ||
+            !sameFileIdentity(owner.entryIdentity, generation.entryIdentity))
+            throw new ProcessLeaseError("process lease generation lost ownership while starting");
+        return generation;
+    }
+    catch (error) {
+        if (generation !== undefined) {
+            await unlinkCreatedEntry(directory, generation).catch(() => undefined);
+        }
+        await removeEmptyDirectory(directory, directoryIdentity).catch(() => undefined);
+        throw error;
+    }
+}
+/** Acquire once, recovering only an observed dead generation. */
+export async function tryAcquireProcessLease(directory, token, options = {}) {
+    const staleMs = boundedDelay(options.staleMs ?? 0);
+    const setupGraceMs = boundedDelay(options.setupGraceMs ?? 1_000);
+    for (let attempt = 0; attempt < 4; attempt++) {
+        try {
+            const generation = await createProcessLeaseDirectory(directory, token);
+            return processLease(directory, generation);
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+        }
+        const observation = await inspectDirectory(directory);
+        if (observation.kind === "changed")
+            continue;
+        if (observation.kind === "missing")
+            continue;
+        if (observation.kind === "empty") {
+            if (Date.now() - observation.modifiedAt < Math.max(staleMs, setupGraceMs)) {
+                return undefined;
+            }
+            await removeEmptyDirectory(directory, observation.directoryIdentity);
+            continue;
+        }
+        if (Date.now() - observation.owner.modifiedAt < staleMs ||
+            pidIsAlive(observation.owner.pid))
+            return undefined;
+        await removeObservedProcessLease(directory, observation.owner);
+    }
+    return undefined;
+}
+export function processLease(directory, generation) {
+    let released = false;
+    return Object.freeze({
+        token: generation.token,
+        assertOwned: async () => {
+            if (released)
+                throw new ProcessLeaseError("process lease is closed");
+            const owner = await inspectProcessLease(directory);
+            if (owner === undefined || owner.entry !== generation.entry ||
+                owner.token !== generation.token ||
+                !sameFileIdentity(owner.directoryIdentity, generation.directoryIdentity) ||
+                !sameFileIdentity(owner.entryIdentity, generation.entryIdentity))
+                throw new ProcessLeaseError("process lease is no longer owned by this process");
+        },
+        release: async () => {
+            if (released)
+                return true;
+            const removed = await removeObservedProcessLease(directory, generation);
+            if (removed)
+                released = true;
+            return removed;
+        },
+    });
+}
+export async function inspectProcessLease(directory, hooks = {}) {
+    for (let attempt = 0; attempt < 4; attempt++) {
+        const observation = await inspectDirectory(directory, hooks);
+        if (observation.kind === "changed")
+            continue;
+        if (observation.kind === "missing" || observation.kind === "empty")
+            return undefined;
+        return observation.owner;
+    }
+    throw new ProcessLeaseError("process lease kept changing during inspection");
+}
+/** Remove only this unique generation, never a later owner's entry. */
+export async function removeProcessLease(directory, token) {
+    const entry = entryForToken(token);
+    let owner;
+    try {
+        owner = await inspectProcessLease(directory);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return true;
+        throw error;
+    }
+    if (owner === undefined)
+        return false;
+    if (owner.entry !== entry || owner.token !== token)
+        return false;
+    return removeObservedProcessLease(directory, owner);
+}
+export async function removeObservedProcessLease(directory, generation) {
+    try {
+        await assertDirectoryIdentity(directory, generation.directoryIdentity);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return true;
+        if (error instanceof ProcessLeaseError)
+            return false;
+        throw error;
+    }
+    const removed = await unlinkObserved(directory, generation);
+    if (!removed)
+        return false;
+    try {
+        await rmdir(directory);
+        return true;
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT")
+            return true;
+        // Our unique generation is already gone. A delayed or newer generation
+        // now owns any remaining entry and must clean up its own directory.
+        if (code === "ENOTEMPTY" || code === "EEXIST")
+            return true;
+        throw error;
+    }
+}
+export function pidIsAlive(pid) {
+    if (!Number.isSafeInteger(pid) || pid < 1 || pid > 0x7fff_ffff)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code !== "ESRCH";
+    }
+}
+async function inspectDirectory(directory, hooks = {}) {
+    let details;
+    try {
+        details = await lstat(directory, { bigint: true });
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return { kind: "missing" };
+        throw error;
+    }
+    if (details.isSymbolicLink() || !details.isDirectory()) {
+        throw new ProcessLeaseError("process lease path is not a direct directory");
+    }
+    const directoryIdentity = fileIdentity(details);
+    try {
+        const names = [];
+        const handle = await opendir(directory);
+        for await (const entry of handle) {
+            names.push(entry.name);
+            if (names.length > 1)
+                break;
+        }
+        await assertDirectoryIdentity(directory, directoryIdentity);
+        if (names.length === 0) {
+            return { kind: "empty", directoryIdentity, modifiedAt: Number(details.mtimeMs) };
+        }
+        if (names.length !== 1)
+            throw new ProcessLeaseError("process lease has multiple owners");
+        await hooks.afterEntries?.();
+        const name = names[0];
+        const parsed = OWNER_NAME.exec(name);
+        if (parsed === null)
+            throw new ProcessLeaseError("process lease owner is invalid");
+        const pid = Number(parsed[1]);
+        if (!Number.isSafeInteger(pid) || pid > 0x7fff_ffff) {
+            throw new ProcessLeaseError("process lease owner is invalid");
+        }
+        const ownerFile = path.join(directory, name);
+        const owner = await lstat(ownerFile, { bigint: true });
+        if (owner.isSymbolicLink() || !owner.isFile() || owner.size !== 0n) {
+            throw new ProcessLeaseError("process lease owner is unsafe");
+        }
+        await assertDirectoryIdentity(directory, directoryIdentity);
+        return {
+            kind: "owned",
+            owner: Object.freeze({
+                pid,
+                token: `${parsed[1]}:${parsed[2]}`,
+                entry: name,
+                directoryIdentity,
+                entryIdentity: fileIdentity(owner),
+                modifiedAt: Number(owner.mtimeMs),
+            }),
+        };
+    }
+    catch (error) {
+        if (inspectionChanged(error))
+            return { kind: "changed" };
+        throw error;
+    }
+}
+async function unlinkObserved(directory, generation) {
+    try {
+        await assertDirectoryIdentity(directory, generation.directoryIdentity);
+        const ownerFile = path.join(directory, generation.entry);
+        const owner = await lstat(ownerFile, { bigint: true });
+        if (owner.isSymbolicLink() || !owner.isFile() || owner.size !== 0n ||
+            !sameFileIdentity(fileIdentity(owner), generation.entryIdentity))
+            return false;
+        await unlink(ownerFile);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        if (error instanceof ProcessLeaseError)
+            return false;
+        throw error;
+    }
+}
+/** Clean up only the unique entry this failed creator actually opened. */
+async function unlinkCreatedEntry(directory, generation) {
+    try {
+        const ownerFile = path.join(directory, generation.entry);
+        const owner = await lstat(ownerFile, { bigint: true });
+        if (owner.isSymbolicLink() || !owner.isFile() || owner.size !== 0n ||
+            !sameFileIdentity(fileIdentity(owner), generation.entryIdentity))
+            return false;
+        await unlink(ownerFile);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return true;
+        throw error;
+    }
+}
+async function removeEmptyDirectory(directory, identity) {
+    try {
+        await assertDirectoryIdentity(directory, identity);
+        await rmdir(directory);
+        return true;
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT")
+            return true;
+        if (code === "ENOTEMPTY" || code === "EEXIST" || error instanceof ProcessLeaseError) {
+            return false;
+        }
+        throw error;
+    }
+}
+async function requireDirectoryIdentity(directory) {
+    const details = await lstat(directory, { bigint: true });
+    if (details.isSymbolicLink() || !details.isDirectory()) {
+        throw new ProcessLeaseError("process lease path is not a direct directory");
+    }
+    return fileIdentity(details);
+}
+async function assertDirectoryIdentity(directory, expected) {
+    const current = await requireDirectoryIdentity(directory);
+    if (!sameFileIdentity(current, expected)) {
+        throw new ProcessLeaseChangedError("process lease directory changed during acquisition");
+    }
+}
+function inspectionChanged(error) {
+    const code = error.code;
+    return code === "ENOENT" || code === "ENOTDIR" || error instanceof ProcessLeaseChangedError;
+}
+function entryForToken(token) {
+    const parsed = TOKEN.exec(token);
+    if (parsed === null)
+        throw new ProcessLeaseError("process lease token is invalid");
+    return `owner-${parsed[1]}-${parsed[2]}`;
+}
+function boundedDelay(value) {
+    if (!Number.isSafeInteger(value) || value < 0 || value > 24 * 60 * 60 * 1_000) {
+        throw new RangeError("process lease delay is invalid");
+    }
+    return value;
+}

package/dist/provider-commands.js

@@ -1,16 +1,12 @@
 // Provider access and connection management. Runtime selection lives in /models.
-import { saveCommandSettings } from "./command-settings.js";
 import { apiKeyCommand } from "./credential-commands.js";
 import { credentialSource } from "./credentials.js";
-import { ollamaConnectionHint, ollamaConnectionSetting, } from "./ollama-settings-command.js";
 import { openAIAccountHint } from "./openai-account.js";
 import { openAIAccountCommand } from "./openai-account-command.js";
-import { providerLabel } from "./provider-label.js";
+import { providerLabel, providerRouteLabel } from "./provider-label.js";
 import { PROVIDERS } from "./providers/index.js";
-import { ollamaConnection } from "./providers/ollama.js";
 import { heading } from "./tui/picker.js";
-const OLLAMA_KEY = "OLLAMA_API_KEY";
-/** The single control plane for API keys, OAuth accounts, and Ollama endpoints. */
+/** The single control plane for API keys and OAuth accounts. */
 export async function providersCommand(session, host) {
     const choose = chooser(host);
     if (choose === undefined)
@@ -20,9 +16,10 @@ export async function providersCommand(session, host) {
     while (true) {
         const index = await choose({
             title: [],
+            description: `Current route: ${providerRouteLabel(session.provider)} · access changes do not switch it; use /models`,
             options: groups.map((group) => ({
                 label: group.label,
-                value: providerCount(group.providers.length),
+                value: providerGroupHint(group, session.provider.id),
             })),
             index: selected,
         });
@@ -53,7 +50,7 @@ async function providerGroupCommand(group, session, host) {
             title: heading(group.label, "provider access", session.palette),
             options: group.providers.map((provider) => ({
                 label: providerLabel(provider.id),
-                value: providerAccessHint(provider),
+                value: `${provider.id === session.provider.id ? "current · " : ""}${providerAccessHint(provider)}`,
             })),
             index: selected,
         });
@@ -74,45 +71,22 @@ async function providerGroupCommand(group, session, host) {
 function providerCount(count) {
     return `${count} ${count === 1 ? "provider" : "providers"}`;
 }
+function providerGroupHint(group, activeId) {
+    const active = group.providers.find((provider) => provider.id === activeId);
+    const count = providerCount(group.providers.length);
+    return active === undefined ? count : `${count} · current ${providerRouteLabel(active)}`;
+}
 export function providerAccessHint(provider) {
-    if (provider.id === "ollama") {
-        const connection = ollamaConnection();
-        if (connection.loopback)
-            return `${ollamaConnectionHint()} · no key needed`;
-        return `${ollamaConnectionHint()} · API key ${credentialSource(OLLAMA_KEY) ?? "missing"}`;
-    }
     if (provider.auth.kind === "oauth")
         return openAIAccountHint();
     return `API key · ${credentialSource(provider.auth.keyVar) ?? "missing"}`;
 }
 async function manageProvider(provider, session, host) {
-    if (provider.id === "ollama") {
-        await ollamaProviderCommand(session, host);
-        return;
-    }
     if (provider.auth.kind === "oauth") {
         await openAIAccountCommand(session, host);
         return;
     }
-    await apiKeyCommand(provider.auth.keyVar, providerLabel(provider.id), session, host);
-}
-async function ollamaProviderCommand(session, host) {
-    if (host.choose === undefined)
-        return;
-    const index = await host.choose({
-        title: heading("Ollama", "access and connection", session.palette),
-        options: [
-            { label: "connection", hint: ollamaConnectionHint() },
-            { label: "API key", hint: credentialSource(OLLAMA_KEY) ?? "missing" },
-        ],
-        index: 0,
-    });
-    if (index === 0) {
-        await ollamaConnectionSetting(session, host, (patch) => saveCommandSettings(host, patch));
-    }
-    else if (index === 1) {
-        await apiKeyCommand(OLLAMA_KEY, "Ollama", session, host);
-    }
+    await apiKeyCommand(provider.auth.keyVar, providerLabel(provider.id), session, host, provider.id);
 }
 function chooser(host) {
     if (host.choose === undefined) {

package/dist/provider-errors.js

@@ -3,23 +3,47 @@ import { redactCredentials } from "./credential-safety.js";
 import { providerLabel } from "./provider-label.js";
 import { leadingText } from "./text-boundary.js";
 import { terminalText } from "./ui/terminal-text.js";
-const CONNECTION_FAILURE = /network error calling|timed out waiting for response headers|response body was idle/i;
+import { providerFailureDetails, } from "./providers/failure.js";
 const MAX_MESSAGE_CHARS = 1_000;
 const MAX_REASON_CHARS = 500;
 const HTML = /<!doctype\s|<\/?[a-z][^>]*>/i;
 export function providerFailure(provider, error, labelProvider = false) {
-    if (provider.id === "ollama" && CONNECTION_FAILURE.test(error.message)) {
-        return provider.location?.() === "local"
-            ? "Ollama is not reachable on this computer · start Ollama or choose cloud in /providers"
-            : "Ollama is not reachable · check its connection in /providers";
+    const details = providerFailureDetails(provider.id, error);
+    let failure = actionableFailure(provider.id, details.kind) ?? rawFailure(error);
+    if (details.requestId !== undefined)
+        failure += ` · request ${details.requestId}`;
+    const label = providerLabel(provider.id);
+    return labelProvider && !failure.startsWith(`${label} `) ? `${label}: ${failure}` : failure;
+}
+function actionableFailure(providerId, kind) {
+    switch (kind) {
+        case "authentication":
+            return "authentication failed";
+        case "billing":
+            return providerId === "openai"
+                ? "credits exhausted · add credits or choose another provider in /models"
+                : "billing limit reached · check provider billing or choose another provider in /models";
+        case "quota":
+            return "usage quota exhausted · check provider limits or choose another provider in /models";
+        case "rate-limit":
+            return "rate limit reached · retry later";
+        case "overload":
+            return "temporarily unavailable · retry later";
+        case "context":
+            return "context limit reached · compact the conversation or choose a larger-context model";
+        case "network":
+            return "network request failed · check the connection and retry";
+        case "unknown":
+            return undefined;
     }
+}
+function rawFailure(error) {
     const message = safeText(error.message, MAX_MESSAGE_CHARS) || "provider request failed";
     const reason = providerReason(error);
     const detail = reason !== undefined && !message.toLocaleLowerCase().includes(reason.toLocaleLowerCase())
         ? ` · ${reason}`
         : "";
-    const failure = `${message}${detail}`;
-    return labelProvider ? `${providerLabel(provider.id)}: ${failure}` : failure;
+    return `${message}${detail}`;
 }
 function providerReason(error) {
     const body = error.body;

package/dist/provider-label.js

@@ -1,10 +1,16 @@
 // Stable human-facing names for provider identifiers.
 export function providerLabel(id) {
     switch (id) {
-        case "anthropic": return "Anthropic";
+        case "anthropic": return "Anthropic API";
         case "openai": return "OpenAI API";
-        case "openai-codex": return "ChatGPT";
-        case "ollama": return "Ollama";
+        case "openai-codex": return "OpenAI Account";
+        case "ollama": return "Ollama API";
         default: return id === "" ? "Provider" : `${id[0]?.toUpperCase() ?? ""}${id.slice(1)}`;
     }
 }
+/** Name the actual connection a model request will use. */
+export function providerRouteLabel(provider) {
+    if (provider.id === "openai")
+        return "OpenAI API · billed usage";
+    return providerLabel(provider.id);
+}

package/dist/providers/anthropic-stream.js

@@ -5,6 +5,7 @@
 // exactly the array a non-streamed response would have returned. That matters
 // beyond display: thinking blocks carry a signature and must be echoed back
 // byte-for-byte on the next request.
+import { providerWireError } from "./failure.js";
 import { addBounded, MAX_TOOL_ARGUMENT_CHARS } from "./stream-limits.js";
 import { toolInputFromJson } from "./tool-input.js";
 export async function assembleAnthropic(events, onStream) {
@@ -63,7 +64,9 @@ export async function assembleAnthropic(events, onStream) {
                 break;
             }
             case "error": {
-                throw new Error(`anthropic stream error: ${event.error?.message ?? "unspecified"}`);
+                throw providerWireError("anthropic stream error", event.error?.message, {
+                    type: event.error?.type,
+                });
             }
             case "message_stop":
                 complete = true;

package/dist/providers/anthropic-wire.js

@@ -87,11 +87,16 @@ function normalizeUsage(data) {
     const usage = data.usage;
     if (usage === undefined)
         return undefined;
+    const uncached = wireTokenCount(usage.input_tokens);
+    const cached = wireTokenCount(usage.cache_read_input_tokens);
+    const cacheWrite = wireTokenCount(usage.cache_creation_input_tokens);
     return {
-        inputTokens: wireTokenCount(usage.input_tokens),
+        // Anthropic reports these as disjoint buckets. Jecode's provider-neutral
+        // input count represents the complete request context, as OpenAI's does.
+        inputTokens: uncached + cached + cacheWrite,
         outputTokens: wireTokenCount(usage.output_tokens),
-        cachedInputTokens: wireTokenCount(usage.cache_read_input_tokens),
-        cacheWriteInputTokens: wireTokenCount(usage.cache_creation_input_tokens),
+        cachedInputTokens: cached,
+        cacheWriteInputTokens: cacheWrite,
         reasoningTokens: 0,
     };
 }

package/dist/providers/anthropic.js

@@ -11,11 +11,13 @@ import { modelCatalog } from "./catalog.js";
 import { keyFor } from "../credentials.js";
 import { EFFORTS, requireSupportedEffort } from "../effort.js";
 import { assembleAnthropic } from "./anthropic-stream.js";
+import { isRetryableGenerationFailure, isRetryableReadFailure, throwProviderError, } from "./failure.js";
 import { fromWireResponse, stopNotice, toWireMessage, toWireTool } from "./anthropic-wire.js";
 const ENDPOINT = "https://api.anthropic.com/v1/messages";
 const MODELS = "https://api.anthropic.com/v1/models?limit=100";
 const API_VERSION = "2023-06-01";
 const KEY = "ANTHROPIC_API_KEY";
+const ID = "anthropic";
 const ADAPTIVE = /^claude-(?:fable-5|mythos-(?:5|preview)|opus-(?:5|4-[678])|sonnet-(?:5|4-6))(?:-|$)/;
 const MAX_WITHOUT_XHIGH = ["low", "medium", "high", "max"];
 const ANTHROPIC_45_EFFORTS = ["low", "medium", "high"];
@@ -32,7 +34,7 @@ export function anthropicEfforts(model) {
     return supportsAdaptiveThinking(model) ? EFFORTS : [];
 }
 export const anthropic = {
-    id: "anthropic",
+    id: ID,
     // Sonnet is the default because it is the one that can be left running.
     // Opus via `--model claude-opus-5`, Haiku via `--model claude-haiku-4-5`.
     defaultModel: "claude-sonnet-5",
@@ -43,9 +45,14 @@ export const anthropic = {
     // Newest first is how the endpoint already answers, so the order is left
     // exactly as it arrives rather than re-sorted into something less useful.
     async models(signal, onStatus) {
-        const catalog = await loadModels(signal, onStatus);
-        contextByModel = catalog.contexts;
-        return catalog.ids;
+        try {
+            const catalog = await loadModels(signal, onStatus);
+            contextByModel = catalog.contexts;
+            return catalog.ids;
+        }
+        catch (error) {
+            throwProviderError(ID, signal, error);
+        }
     },
     async efforts(model) {
         return anthropicEfforts(model);
@@ -53,14 +60,18 @@ export const anthropic = {
     async contextWindow(model, signal, onStatus) {
         if (contextByModel.has(model))
             return contextByModel.get(model);
-        const catalog = await loadModels(signal, onStatus);
-        contextByModel = catalog.contexts;
-        const context = contextByModel.get(model);
-        if (!contextByModel.has(model))
-            contextByModel.set(model, undefined);
-        return context;
+        try {
+            const catalog = await loadModels(signal, onStatus);
+            contextByModel = catalog.contexts;
+            const context = contextByModel.get(model);
+            if (!contextByModel.has(model))
+                contextByModel.set(model, undefined);
+            return context;
+        }
+        catch (error) {
+            throwProviderError(ID, signal, error);
+        }
     },
-    location: () => "cloud",
     async send(req) {
         const key = requireKey();
         const body = {
@@ -70,6 +81,9 @@ export const anthropic = {
             messages: req.messages.map(toWireMessage),
             tools: req.tools.map(toWireTool),
             stream: true,
+            ...(req.identity?.purpose === "compaction"
+                ? {}
+                : { cache_control: { type: "ephemeral" } }),
         };
         if (supportsAdaptiveThinking(req.model)) {
             body["thinking"] = { type: "adaptive", display: "summarized" };
@@ -80,18 +94,23 @@ export const anthropic = {
                 effort: requireSupportedEffort(req.model, req.effort, efforts),
             };
         }
-        const events = await postSse(ENDPOINT, headers(key), body, req.maxTokens, req.signal, req.onStatus);
-        const data = await assembleAnthropic(events, req.onStream);
-        // A refusal or a truncation never arrives as streamed text, so it has to
-        // be announced separately or the user watches the turn end in silence.
-        const notice = stopNotice(data);
-        if (notice !== undefined)
-            req.onStream?.({ kind: "text", text: `\n${notice}` });
-        return fromWireResponse(data);
+        try {
+            const events = await postSse(ENDPOINT, headers(key), body, req.maxTokens, req.signal, req.onStatus, undefined, (error) => isRetryableGenerationFailure(ID, error));
+            const data = await assembleAnthropic(events, req.onStream);
+            // A refusal or a truncation never arrives as streamed text, so it has to
+            // be announced separately or the user watches the turn end in silence.
+            const notice = stopNotice(data);
+            if (notice !== undefined)
+                req.onStream?.({ kind: "text", text: `\n${notice}` });
+            return fromWireResponse(data);
+        }
+        catch (error) {
+            throwProviderError(ID, req.signal, error);
+        }
     },
 };
 async function loadModels(signal, onStatus) {
-    const entries = await modelCatalog(MODELS, headers(requireKey()), signal, onStatus);
+    const entries = await modelCatalog(MODELS, headers(requireKey()), signal, onStatus, (error) => isRetryableReadFailure(ID, error));
     return {
         ids: entries.map((entry) => entry.id),
         contexts: new Map(entries.map((entry) => [

package/dist/providers/catalog.js

@@ -12,11 +12,11 @@ import { getJson } from "./http.js";
 export const MAX_MODEL_CATALOG_ENTRIES = 1_000;
 export const MAX_MODEL_CATALOG_ITEMS = 4_000;
 export const MAX_MODEL_ID_CHARS = 256;
-export async function listModels(url, headers, signal, onStatus) {
-    return (await modelCatalog(url, headers, signal, onStatus)).map((entry) => entry.id);
+export async function listModels(url, headers, signal, onStatus, retry) {
+    return (await modelCatalog(url, headers, signal, onStatus, retry)).map((entry) => entry.id);
 }
-export async function modelCatalog(url, headers, signal, onStatus) {
-    const body = await getJson(url, headers, signal, onStatus);
+export async function modelCatalog(url, headers, signal, onStatus, retry) {
+    const body = await getJson(url, headers, signal, onStatus, retry);
     const data = body.data;
     if (!Array.isArray(data))
         throw new Error(`${url} did not return a model list`);