@giovannijecha/jecode 0.8.3 → 0.8.5

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,12 +60,17 @@ 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) {
@@ -70,6 +82,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 +95,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`);

package/dist/providers/failure.js

@@ -0,0 +1,181 @@
+// Provider failures normalized at adapter boundaries. The controller and TUI
+// never need to understand a vendor response shape in order to make a safe
+// retry decision or show an actionable error.
+import { leadingText } from "../text-boundary.js";
+const MAX_WIRE_ERROR_CHARS = 2_000;
+/** One stable error contract for every provider adapter. */
+export class ProviderRequestError extends Error {
+    providerId;
+    kind;
+    status;
+    code;
+    retryAfterMs;
+    requestId;
+    body;
+    constructor(providerId, source, details) {
+        super(source.message, { cause: source });
+        this.name = "ProviderRequestError";
+        this.providerId = providerId;
+        this.kind = details.kind;
+        this.status = details.status;
+        this.code = details.code;
+        this.retryAfterMs = details.retryAfterMs;
+        this.requestId = details.requestId;
+        this.body = source.body;
+    }
+}
+/** Preserve structured fields carried by an error event inside a live stream. */
+export function providerWireError(prefix, message, metadata = {}) {
+    const detail = message === undefined ? "unspecified" : leadingText(message, MAX_WIRE_ERROR_CHARS);
+    const error = new Error(`${prefix}: ${detail}`);
+    const code = safeIdentifier(metadata.code);
+    const type = safeIdentifier(metadata.type);
+    if (code !== undefined)
+        error.code = code;
+    if (type !== undefined)
+        error.type = type;
+    return error;
+}
+export function normalizeProviderError(providerId, error) {
+    if (error instanceof ProviderRequestError)
+        return error;
+    const source = error instanceof Error ? error : new Error(String(error));
+    return new ProviderRequestError(providerId, source, providerFailureDetails(providerId, source));
+}
+/** Keep caller cancellation intact; normalize every other adapter failure. */
+export function throwProviderError(providerId, signal, error) {
+    if (signal?.aborted === true)
+        throw error;
+    throw normalizeProviderError(providerId, error);
+}
+export function providerFailureDetails(providerId, error) {
+    if (error instanceof ProviderRequestError) {
+        return compact({
+            kind: error.kind,
+            status: error.status,
+            code: error.code,
+            retryAfterMs: error.retryAfterMs,
+            requestId: error.requestId,
+        });
+    }
+    const http = error;
+    const wire = error;
+    const body = bodyError(http.body);
+    const code = firstIdentifier(wire.code, body.code);
+    const type = firstIdentifier(wire.type, body.type);
+    const evidence = [code, type, leadingText(error.message, 4_000), body.message]
+        .filter((value) => value !== undefined)
+        .join(" ")
+        .toLocaleLowerCase();
+    const status = number(http.status);
+    const kind = classify(providerId, status, evidence);
+    return compact({
+        kind,
+        status,
+        code,
+        retryAfterMs: number(http.retryAfterMs),
+        requestId: safeRequestId(http.requestId),
+    });
+}
+/** Generation replay is allowed only for a definite transient rate rejection. */
+export function isRetryableGenerationFailure(providerId, error) {
+    return providerFailureDetails(providerId, error).kind === "rate-limit";
+}
+/** Idempotent reads may retry transient pressure, never account hard stops. */
+export function isRetryableReadFailure(providerId, error) {
+    const kind = providerFailureDetails(providerId, error).kind;
+    return kind === "rate-limit" || kind === "overload" || kind === "network" || kind === "unknown";
+}
+function classify(providerId, status, evidence) {
+    if (providerId === "anthropic" &&
+        /enforced[_ -]?spend[_ -]?limit[_ -]?reached/u.test(evidence))
+        return "billing";
+    if ((providerId === "openai" || providerId === "openai-codex") &&
+        /billing[_ -]?hard[_ -]?limit[_ -]?reached/u.test(evidence))
+        return "billing";
+    if (providerId === "openai-codex" &&
+        /usage[_ -]?limit[_ -]?reached|plan limit/u.test(evidence))
+        return "quota";
+    if (/insufficient[_ -]?quota|usage quota|quota (?:exceeded|exhausted)/u.test(evidence)) {
+        return "quota";
+    }
+    if (status === 402 ||
+        /\b(?:no|zero) credits? remaining\b|\bcredits? exhausted\b|billing|payment required|(?:hard|spend)[_ -]?limit/u
+            .test(evidence))
+        return "billing";
+    if (status === 401 ||
+        /invalid[_ -]?(?:api[_ -]?)?key|authentication|unauthorized|invalid[_ -]?token|oauth/u
+            .test(evidence))
+        return "authentication";
+    if (/context[_ -]?(?:length|window)|maximum context|too many input tokens|prompt (?:is )?too long/u
+        .test(evidence))
+        return "context";
+    if (status === 429 ||
+        /rate[_ -]?limit|too many requests|tokens per min|requests per min|\btpm\b|\brpm\b/u
+            .test(evidence))
+        return "rate-limit";
+    if (status === 408 ||
+        status === 409 ||
+        status === 500 ||
+        status === 502 ||
+        status === 503 ||
+        status === 504 ||
+        status === 529 ||
+        /overload|temporarily unavailable|server is busy/u.test(evidence))
+        return "overload";
+    if (status === undefined &&
+        /network error calling|timed out waiting|response body was idle|stream was idle|fetch failed|socket/u
+            .test(evidence))
+        return "network";
+    return "unknown";
+}
+function bodyError(body) {
+    if (body === undefined || body.trim() === "")
+        return {};
+    let parsed;
+    try {
+        parsed = JSON.parse(body);
+    }
+    catch {
+        return { message: body };
+    }
+    if (!record(parsed))
+        return {};
+    const nested = record(parsed["error"]) ? parsed["error"] : undefined;
+    const detail = record(parsed["detail"]) ? parsed["detail"] : undefined;
+    return compact({
+        code: firstText(nested?.["code"], detail?.["code"], parsed["code"]),
+        type: firstText(nested?.["type"], detail?.["type"], parsed["type"]),
+        message: firstText(nested?.["message"], typeof parsed["error"] === "string" ? parsed["error"] : undefined, detail?.["message"], typeof parsed["detail"] === "string" ? parsed["detail"] : undefined, parsed["message"]),
+    });
+}
+function firstText(...values) {
+    return values.find((value) => typeof value === "string" && value !== "");
+}
+function firstIdentifier(...values) {
+    for (const value of values) {
+        const identifier = safeIdentifier(value);
+        if (identifier !== undefined)
+            return identifier;
+    }
+    return undefined;
+}
+function safeIdentifier(value) {
+    return typeof value === "string" && /^[A-Za-z0-9._:-]{1,128}$/u.test(value)
+        ? value
+        : undefined;
+}
+function number(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function safeRequestId(value) {
+    return typeof value === "string" && /^[A-Za-z0-9._:-]{1,256}$/u.test(value)
+        ? value
+        : undefined;
+}
+function compact(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
+}
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/providers/http.js

@@ -1,6 +1,8 @@
 // The entire HTTP layer: one bounded request, then either a JSON body or an
-// event stream. Only idempotent reads retry. Once a POST starts or response
-// bytes flow, a failure is surfaced rather than silently replayed.
+// event stream. Idempotent reads retry transient failures. A generation POST
+// gets one retry only when its provider adapter classifies an explicit,
+// delayed rejection as transient, before a stream exists. Ambiguous POST
+// failures and failures after response bytes flow are surfaced.
 import { leadingText } from "../text-boundary.js";
 import { readSseJson } from "./sse.js";
 import { sseStreamCharacterLimit } from "./stream-limits.js";
@@ -9,19 +11,26 @@ const MAX_JSON_CHARS = 5_000_000;
 const MAX_ERROR_CHARS = 2_000;
 const HANDSHAKE_TIMEOUT_MS = 60_000;
 const BODY_IDLE_TIMEOUT_MS = 120_000;
+const MODEL_PROGRESS_TIMEOUT_MS = 300_000;
 const GET_RETRIES = 3;
-function httpError(message, status, body) {
+const GENERATION_RATE_LIMIT_RETRIES = 1;
+const MAX_RETRY_DELAY_MS = 60_000;
+function httpError(message, status, body, metadata = {}) {
     const error = new Error(message);
     error.status = status;
     error.body = body;
+    if (metadata.retryAfterMs !== undefined)
+        error.retryAfterMs = metadata.retryAfterMs;
+    if (metadata.requestId !== undefined)
+        error.requestId = metadata.requestId;
     return error;
 }
 export async function postJson(url, headers, body, signal, onStatus) {
     return asJson(url, await request(url, headers, body, signal, onStatus));
 }
 /** A plain read. The only thing jecode asks for without sending anything. */
-export async function getJson(url, headers, signal, onStatus) {
-    return asJson(url, await request(url, headers, undefined, signal, onStatus));
+export async function getJson(url, headers, signal, onStatus, retry) {
+    return asJson(url, await request(url, headers, undefined, signal, onStatus, 0, undefined, retry));
 }
 async function asJson(url, res) {
     const { text, truncated } = await boundedText(url, res, MAX_JSON_CHARS);
@@ -35,20 +44,39 @@ async function asJson(url, res) {
         throw httpError(`${url} returned non-JSON`, res.status, leadingText(text, 500));
     }
 }
-export async function postSse(url, headers, body, maxOutputTokens, signal, onStatus) {
+export async function postSse(url, headers, body, maxOutputTokens, signal, onStatus, progress, retry) {
     const maximumChars = sseStreamCharacterLimit(maxOutputTokens);
-    const res = await request(url, { accept: "text/event-stream", ...headers }, body, signal, onStatus);
+    onStatus?.("Connecting");
+    const res = await request(url, { accept: "text/event-stream", ...headers }, body, signal, onStatus, GENERATION_RATE_LIMIT_RETRIES, retry);
     if (res.body === null)
         throw httpError(`${url} returned no body`, res.status);
-    return readSseJson(withIdleTimeout(url, res.body), maximumChars);
+    onStatus?.("Waiting for model");
+    return readSseJson(res.body, maximumChars, {
+        milliseconds: BODY_IDLE_TIMEOUT_MS,
+        error: () => httpError(`${url} SSE stream was idle for ${BODY_IDLE_TIMEOUT_MS}ms without an event`, res.status),
+        ...(progress === undefined
+            ? {}
+            : {
+                progress: {
+                    milliseconds: MODEL_PROGRESS_TIMEOUT_MS,
+                    observed: progress,
+                    error: () => httpError(`${url} SSE stream made no model progress for ${MODEL_PROGRESS_TIMEOUT_MS}ms`, res.status),
+                },
+            }),
+    });
 }
-async function request(url, headers, body, signal, onStatus) {
-    const maxRetries = body === undefined ? GET_RETRIES : 0;
+async function request(url, headers, body, signal, onStatus, generationRetries = 0, generationRetry, readRetry) {
+    const read = body === undefined;
+    const maxRetries = read ? GET_RETRIES : generationRetries;
     let lastError;
     let waitMs = 0;
     for (let attempt = 0; attempt <= maxRetries; attempt++) {
-        if (waitMs > 0)
-            await sleep(waitMs, signal);
+        if (attempt > 0) {
+            if (waitMs > 0)
+                await sleep(waitMs, signal);
+            if (!read)
+                onStatus?.("Connecting");
+        }
         let res;
         const handshake = handshakeSignal(url, signal);
         try {
@@ -70,9 +98,10 @@ async function request(url, headers, body, signal, onStatus) {
                 throw cause;
             const detail = cause instanceof Error ? cause.message : String(cause);
             lastError = httpError(`network error calling ${url}: ${detail}`);
+            if (!read || attempt >= maxRetries)
+                throw lastError;
             waitMs = backoff(attempt);
-            if (attempt < maxRetries)
-                onStatus?.(`Network error · retrying in ${waitLabel(waitMs)}`);
+            onStatus?.(`Network error · retrying in ${waitLabel(waitMs)}`);
             continue;
         }
         finally {
@@ -85,14 +114,22 @@ async function request(url, headers, body, signal, onStatus) {
         if (res.ok)
             return res;
         const { text } = await boundedText(url, res, MAX_ERROR_CHARS);
-        lastError = httpError(`${url} -> ${res.status} ${res.statusText}`, res.status, text);
-        if (!RETRYABLE.has(res.status))
+        const providerDelay = retryAfter(res) ?? retryAfterMessage(text);
+        const requestId = responseRequestId(res);
+        lastError = httpError(`${url} -> ${res.status} ${res.statusText}`, res.status, text, {
+            ...(providerDelay === undefined ? {} : { retryAfterMs: providerDelay }),
+            ...(requestId === undefined ? {} : { requestId }),
+        });
+        const retryable = read
+            ? RETRYABLE.has(res.status) && (readRetry?.(lastError) ?? true)
+            : generationRetries > 0 &&
+                providerDelay !== undefined &&
+                generationRetry?.(lastError) === true;
+        if (!retryable || attempt >= maxRetries)
             throw lastError;
-        waitMs = retryAfter(res) ?? backoff(attempt);
-        if (attempt < maxRetries) {
-            const reason = res.status === 429 ? "Rate limited" : `HTTP ${res.status}`;
-            onStatus?.(`${reason} · retrying in ${waitLabel(waitMs)}`);
-        }
+        waitMs = providerDelay ?? backoff(attempt);
+        const reason = res.status === 429 ? "Rate limited" : `HTTP ${res.status}`;
+        onStatus?.(`${reason} · retrying in ${waitLabel(waitMs)}`);
     }
     throw lastError ?? httpError(`${url} failed`);
 }
@@ -154,39 +191,6 @@ async function timedRead(url, reader) {
             clearTimeout(timer);
     }
 }
-function withIdleTimeout(url, body) {
-    const reader = body.getReader();
-    let released = false;
-    const release = () => {
-        if (released)
-            return;
-        released = true;
-        reader.releaseLock();
-    };
-    return new ReadableStream({
-        async pull(controller) {
-            try {
-                const { done, value } = await timedRead(url, reader);
-                if (done) {
-                    release();
-                    controller.close();
-                }
-                else {
-                    controller.enqueue(value);
-                }
-            }
-            catch (error) {
-                await reader.cancel(error).catch(() => undefined);
-                release();
-                controller.error(error);
-            }
-        },
-        async cancel(reason) {
-            await reader.cancel(reason).catch(() => undefined);
-            release();
-        },
-    });
-}
 function waitLabel(ms) {
     return ms < 1_000 ? `${ms}ms` : `${Math.ceil(ms / 1_000)}s`;
 }
@@ -198,10 +202,35 @@ function retryAfter(res) {
     if (header === null)
         return undefined;
     const seconds = Number(header);
-    if (Number.isFinite(seconds) && seconds >= 0)
-        return Math.min(60_000, seconds * 1_000);
+    if (Number.isFinite(seconds) && seconds >= 0) {
+        return Math.min(MAX_RETRY_DELAY_MS, seconds * 1_000);
+    }
     const at = Date.parse(header);
-    return Number.isNaN(at) ? undefined : Math.max(0, Math.min(60_000, at - Date.now()));
+    return Number.isNaN(at)
+        ? undefined
+        : Math.max(0, Math.min(MAX_RETRY_DELAY_MS, at - Date.now()));
+}
+function retryAfterMessage(body) {
+    const match = /\btry again in\s+(\d+(?:\.\d+)?)\s*(milliseconds?|ms|seconds?|secs?|s)\b/iu
+        .exec(body);
+    if (match === null)
+        return undefined;
+    const amount = Number(match[1]);
+    if (!Number.isFinite(amount) || amount < 0)
+        return undefined;
+    const unit = match[2]?.toLowerCase();
+    const milliseconds = unit === "ms" || unit?.startsWith("millisecond") === true
+        ? amount
+        : amount * 1_000;
+    return Math.min(MAX_RETRY_DELAY_MS, Math.ceil(milliseconds));
+}
+function responseRequestId(res) {
+    for (const name of ["x-request-id", "request-id"]) {
+        const value = res.headers.get(name)?.trim();
+        if (value !== undefined && /^[A-Za-z0-9._:-]{1,256}$/u.test(value))
+            return value;
+    }
+    return undefined;
 }
 function sleep(ms, signal) {
     return new Promise((resolve, reject) => {

package/dist/providers/ollama-stream.js

@@ -3,6 +3,7 @@
 // Nothing arrives finished here: text accumulates, and each tool call is
 // spread across chunks keyed by `index` — id and name usually in the first,
 // arguments as JSON fragments after it.
+import { providerWireError } from "./failure.js";
 import { addBounded, MAX_TOOL_ARGUMENT_CHARS } from "./stream-limits.js";
 export async function assembleOllama(events, onStream) {
     const calls = new Map();
@@ -16,7 +17,10 @@ export async function assembleOllama(events, onStream) {
         const event = raw;
         if (event.error !== undefined) {
             const message = typeof event.error === "string" ? event.error : event.error.message;
-            throw new Error(`ollama stream error: ${message ?? "unspecified"}`);
+            throw providerWireError("ollama stream error", message, {
+                code: typeof event.error === "string" ? undefined : event.error.code,
+                type: typeof event.error === "string" ? undefined : event.error.type,
+            });
         }
         if (event.usage !== undefined)
             usage = event.usage;

package/dist/providers/ollama.js

@@ -10,9 +10,11 @@ import { getJson, postJson, postSse } from "./http.js";
 import { listModels } from "./catalog.js";
 import { keyFor } from "../credentials.js";
 import { assembleOllama } from "./ollama-stream.js";
+import { isRetryableGenerationFailure, isRetryableReadFailure, throwProviderError, } from "./failure.js";
 import { OLLAMA_CLOUD_HOST, OLLAMA_LOCAL_HOST, ollamaConnectionKind, parseOllamaEndpoint, } from "./ollama-endpoint.js";
 import { fromWireReply, stopNotice, toWireMessages, toWireTool } from "./ollama-wire.js";
 const KEY = "OLLAMA_API_KEY";
+const ID = "ollama";
 // Ollama also accepts `none`; Jecode's product-wide reasoning floor is `low`.
 const OLLAMA_EFFORTS = ["low", "medium", "high"];
 let configuredHost;
@@ -29,7 +31,7 @@ export function ollamaConnection() {
     return { ...endpoint, kind: ollamaConnectionKind(endpoint), inferred };
 }
 export const ollama = {
-    id: "ollama",
+    id: ID,
     defaultModel: "",
     auth: { kind: "api-key", keyVar: KEY },
     // The only provider whose key is conditional: a daemon on this machine is
@@ -47,9 +49,14 @@ export const ollama = {
         }
     },
     // Whatever the daemon has pulled, or whatever the subscription grants.
-    models(signal, onStatus) {
-        const at = endpoint();
-        return listModels(`${at.baseUrl}/v1/models`, headers(at), signal, onStatus);
+    async models(signal, onStatus) {
+        try {
+            const at = endpoint();
+            return await listModels(`${at.baseUrl}/v1/models`, headers(at), signal, onStatus, (error) => isRetryableReadFailure(ID, error));
+        }
+        catch (error) {
+            throwProviderError(ID, signal, error);
+        }
     },
     async efforts() {
         return OLLAMA_EFFORTS;
@@ -83,25 +90,30 @@ export const ollama = {
         const effort = requireSupportedEffort(req.model, req.effort, OLLAMA_EFFORTS);
         // The OpenAI-compatible endpoint accepts this vocabulary for thinking
         // models. Invalid levels are rejected locally instead of being rewritten.
-        const events = await postSse(`${at.baseUrl}/v1/chat/completions`, headers(at), {
-            model: req.model,
-            messages: toWireMessages(req.system, req.messages),
-            tools: req.tools.map(toWireTool),
-            max_tokens: req.maxTokens,
-            reasoning_effort: effort,
-            stream: true,
-            stream_options: { include_usage: true },
-        }, req.maxTokens, req.signal, req.onStatus);
-        const reply = await assembleOllama(events, req.onStream);
-        const notice = stopNotice(reply);
-        if (notice !== undefined)
-            req.onStream?.({ kind: "text", text: `\n${notice}` });
-        return fromWireReply(reply);
+        try {
+            const events = await postSse(`${at.baseUrl}/v1/chat/completions`, headers(at), {
+                model: req.model,
+                messages: toWireMessages(req.system, req.messages),
+                tools: req.tools.map(toWireTool),
+                max_tokens: req.maxTokens,
+                reasoning_effort: effort,
+                stream: true,
+                stream_options: { include_usage: true },
+            }, req.maxTokens, req.signal, req.onStatus, undefined, (error) => isRetryableGenerationFailure(ID, error));
+            const reply = await assembleOllama(events, req.onStream);
+            const notice = stopNotice(reply);
+            if (notice !== undefined)
+                req.onStream?.({ kind: "text", text: `\n${notice}` });
+            return fromWireReply(reply);
+        }
+        catch (error) {
+            throwProviderError(ID, req.signal, error);
+        }
     },
 };
 async function nativeContextWindow(at, model, fallback, signal, onStatus) {
     try {
-        const running = await getJson(`${at.baseUrl}/api/ps`, headers(at), signal, onStatus);
+        const running = await getJson(`${at.baseUrl}/api/ps`, headers(at), signal, onStatus, (error) => isRetryableReadFailure(ID, error));
         const allocated = runningContext(running, model);
         if (allocated !== undefined)
             return { value: usableContext(allocated), runtime: true };