@giovannijecha/jecode 0.8.4 → 0.8.6

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,23 +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);
+    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 {
@@ -73,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 {
@@ -88,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`);
 }
@@ -168,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/index.js

@@ -1,7 +1,7 @@
 import { anthropic } from "./anthropic.js";
 import { openai } from "./openai.js";
 import { openaiCodex } from "./openai-codex.js";
-import { configureOllama, ollama } from "./ollama.js";
+import { ollama } from "./ollama.js";
 export const PROVIDERS = [anthropic, openai, openaiCodex, ollama];
 export function providerNames() {
     return PROVIDERS.map((provider) => provider.id);
@@ -13,7 +13,3 @@ export function selectProvider(id) {
     }
     return found;
 }
-/** Apply provider-specific process state after startup precedence is resolved. */
-export function configureProviders(config) {
-    configureOllama(config.ollamaHost);
-}

package/dist/providers/ollama-context.js

@@ -0,0 +1,42 @@
+// Cloud model capacity, with bounded metadata and conservative safety headroom.
+import { postJson } from "./http.js";
+import { OLLAMA_CLOUD_HOST } from "./ollama-endpoint.js";
+const CACHE_MS = 30_000;
+const capacities = new Map();
+export async function ollamaContextWindow(model, headers, signal, onStatus) {
+    signal?.throwIfAborted();
+    const cached = capacities.get(model);
+    if (cached !== undefined && cached.expiresAt > Date.now())
+        return cached.value;
+    capacities.delete(model);
+    try {
+        const details = await postJson(`${OLLAMA_CLOUD_HOST}/api/show`, headers, { model }, signal, onStatus);
+        const tokens = modelCapacity(details);
+        if (tokens === undefined)
+            return undefined;
+        const value = Object.freeze({ tokens: Math.floor(tokens * 95 / 100) });
+        capacities.set(model, { value, expiresAt: Date.now() + CACHE_MS });
+        return value;
+    }
+    catch (error) {
+        if (signal?.aborted)
+            throw error;
+        // Missing metadata leaves budgeting to the controller's safe fallback.
+        return undefined;
+    }
+}
+function modelCapacity(value) {
+    if (!record(value) || !record(value["model_info"]))
+        return undefined;
+    const counts = Object.entries(value["model_info"])
+        .filter(([name, count]) => name.endsWith(".context_length") && validTokenCount(count))
+        .map(([, count]) => count);
+    return counts.length === 0 ? undefined : Math.max(...counts);
+}
+function validTokenCount(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) &&
+        value >= 4_096 && value <= 10_000_000;
+}
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/providers/ollama-endpoint.js

@@ -1,40 +1,13 @@
-// Turning an Ollama host into one safe, normalized endpoint.
-export const OLLAMA_LOCAL_HOST = "http://127.0.0.1:11434";
+// The fixed API endpoint and recognition of its retired saved setting.
 export const OLLAMA_CLOUD_HOST = "https://ollama.com";
-export function parseOllamaEndpoint(value) {
-    let url;
+/** Recognize old official-cloud values without making endpoints configurable. */
+export function isLegacyOllamaCloudHost(value) {
+    if (typeof value !== "string")
+        return false;
     try {
-        url = new URL(value.trim());
+        return new URL(value.trim()).href.replace(/\/+$/, "") === OLLAMA_CLOUD_HOST;
     }
     catch {
-        throw new Error("Ollama endpoint must be an absolute HTTP(S) URL");
+        return false;
     }
-    if (url.protocol !== "http:" && url.protocol !== "https:") {
-        throw new Error("Ollama endpoint must use HTTP or HTTPS");
-    }
-    if (url.username !== "" || url.password !== "") {
-        throw new Error("Ollama endpoint must not contain credentials");
-    }
-    if (url.search !== "" || url.hash !== "") {
-        throw new Error("Ollama endpoint must not contain a query or fragment");
-    }
-    const loopback = isExactLoopback(url.hostname);
-    if (url.protocol === "http:" && !loopback) {
-        throw new Error("Ollama endpoint must use HTTPS unless it is an exact loopback address");
-    }
-    const pathname = url.pathname.replace(/\/+$/, "");
-    return {
-        baseUrl: `${url.origin}${pathname === "" ? "" : pathname}`,
-        loopback,
-    };
-}
-export function ollamaConnectionKind(endpoint) {
-    if (endpoint.baseUrl === OLLAMA_CLOUD_HOST)
-        return "cloud";
-    if (endpoint.baseUrl === OLLAMA_LOCAL_HOST)
-        return "local";
-    return "custom";
-}
-function isExactLoopback(hostname) {
-    return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]";
 }

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;