@giovannijecha/jecode 0.8.3 → 0.8.5

package/dist/model-command.js

@@ -2,7 +2,7 @@
 import { saveCommandSettings } from "./command-settings.js";
 import { compatibleEffort } from "./effort.js";
 import { providerFailure } from "./provider-errors.js";
-import { providerLabel } from "./provider-label.js";
+import { providerLabel, providerRouteLabel } from "./provider-label.js";
 import { PROVIDERS } from "./providers/index.js";
 import { readSettings } from "./settings.js";
 /** Build one searchable catalogue from every provider that is usable now. */
@@ -76,7 +76,7 @@ export async function modelsCommand(session, host, behavior = {}, providers = PR
             label: choice.model,
             // Provider identity is part of the choice, not optional help: keep it
             // visible even when the terminal is only at the supported minimum.
-            value: providerLabel(choice.provider.id),
+            value: providerRouteLabel(choice.provider),
         })),
         searchable: true,
         query: "",
@@ -111,7 +111,7 @@ export async function modelsCommand(session, host, behavior = {}, providers = PR
     if (behavior.announce !== false) {
         host.emit({
             kind: "notice",
-            text: `model · ${providerLabel(chosen.provider.id)} · ${chosen.model}`,
+            text: `model · ${providerRouteLabel(chosen.provider)} · ${chosen.model}`,
             tone: "info",
         });
     }
@@ -138,6 +138,7 @@ async function alignEffort(provider, model, effort, host) {
 }
 function catalogDescription(disconnected, failed) {
     const parts = [
+        "The connection on the right will run this model; API and account usage stay separate",
         disconnected.length === 0
             ? undefined
             : `Not connected: ${disconnected.map((provider) => providerLabel(provider.id)).join(", ")}`,
@@ -145,7 +146,7 @@ function catalogDescription(disconnected, failed) {
             ? undefined
             : `Unavailable: ${failed.map((entry) => providerLabel(entry.provider.id)).join(", ")}`,
     ].filter((part) => part !== undefined);
-    return parts.length === 0 ? undefined : `${parts.join(" · ")} · manage in /providers`;
+    return `${parts.join(" · ")} · manage access in /providers`;
 }
 function emptyCatalogMessage(connected, failed) {
     if (failed.length === 1 && connected.length === 1) {

package/dist/openai-account-command.js

@@ -29,9 +29,14 @@ export async function openAIAccountCommand(session, host, dependencies = DEFAULT
         return false;
     if (connected && actions[action]?.key === "s") {
         const result = await removeOpenAIAccount(host.signal);
+        const route = session.provider.id === "openai-codex"
+            ? " · choose another provider in /models"
+            : "";
         host.emit({
             kind: "notice",
-            text: result.revokeFailed ? "ChatGPT disconnected · remote sign-out could not be confirmed" : "ChatGPT disconnected",
+            text: result.revokeFailed
+                ? `ChatGPT disconnected · remote sign-out could not be confirmed${route}`
+                : `ChatGPT disconnected${route}`,
             tone: result.revokeFailed ? "warn" : "info",
         });
         return result.removed;
@@ -89,7 +94,13 @@ async function waitForLogin(login, session, host, openUrl) {
             if (outcome.kind === "account") {
                 host.dismiss?.();
                 await saveOpenAIAccount(outcome.account, host.signal);
-                host.emit({ kind: "notice", text: "ChatGPT connected", tone: "info" });
+                host.emit({
+                    kind: "notice",
+                    text: session.provider.id === "openai-codex"
+                        ? "ChatGPT connected · current provider route"
+                        : "ChatGPT connected · choose a ChatGPT model in /models to use this account",
+                    tone: "info",
+                });
                 return true;
             }
             if (outcome.kind === "error") {

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

@@ -5,7 +5,7 @@ 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";
@@ -15,28 +15,71 @@ export async function providersCommand(session, host) {
     const choose = chooser(host);
     if (choose === undefined)
         return;
-    let selected = Math.max(0, PROVIDERS.findIndex((provider) => provider.id === session.provider.id));
+    const groups = providerGroups();
+    let selected = Math.max(0, groups.findIndex((group) => group.providers.some((provider) => provider.id === session.provider.id)));
     while (true) {
         const index = await choose({
             title: [],
-            options: PROVIDERS.map((provider) => ({
+            description: `Current route: ${providerRouteLabel(session.provider)} · access changes do not switch it; use /models`,
+            options: groups.map((group) => ({
+                label: group.label,
+                value: providerGroupHint(group, session.provider.id),
+            })),
+            index: selected,
+        });
+        if (index === undefined) {
+            throwIfAborted(host.signal);
+            return;
+        }
+        const group = groups[index];
+        if (group === undefined)
+            return;
+        selected = index;
+        await providerGroupCommand(group, session, host);
+        throwIfAborted(host.signal);
+    }
+}
+function providerGroups() {
+    return [
+        { label: "Account", providers: PROVIDERS.filter((provider) => provider.auth.kind === "oauth") },
+        { label: "API", providers: PROVIDERS.filter((provider) => provider.auth.kind !== "oauth") },
+    ];
+}
+async function providerGroupCommand(group, session, host) {
+    if (host.choose === undefined)
+        return;
+    let selected = Math.max(0, group.providers.findIndex((provider) => provider.id === session.provider.id));
+    while (true) {
+        const index = await host.choose({
+            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,
         });
-        if (index === undefined)
+        if (index === undefined) {
+            throwIfAborted(host.signal);
             return;
-        const provider = PROVIDERS[index];
+        }
+        const provider = group.providers[index];
         if (provider === undefined)
             return;
         selected = index;
         await manageProvider(provider, session, host);
-        // Esc closes only the nested provider flow. Ctrl+C also settles that
-        // picker, but aborts the command signal and must not reopen the parent.
+        // Esc closes only the provider-specific flow. Ctrl+C also settles that
+        // interaction, but aborts the command signal and must not reopen a menu.
         throwIfAborted(host.signal);
     }
 }
+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();
@@ -57,7 +100,7 @@ async function manageProvider(provider, session, host) {
         await openAIAccountCommand(session, host);
         return;
     }
-    await apiKeyCommand(provider.auth.keyVar, providerLabel(provider.id), session, host);
+    await apiKeyCommand(provider.auth.keyVar, providerLabel(provider.id), session, host, provider.id);
 }
 async function ollamaProviderCommand(session, host) {
     if (host.choose === undefined)
@@ -74,7 +117,7 @@ async function ollamaProviderCommand(session, host) {
         await ollamaConnectionSetting(session, host, (patch) => saveCommandSettings(host, patch));
     }
     else if (index === 1) {
-        await apiKeyCommand(OLLAMA_KEY, "Ollama", session, host);
+        await apiKeyCommand(OLLAMA_KEY, "Ollama", session, host, "ollama");
     }
 }
 function chooser(host) {

package/dist/provider-errors.js

@@ -1,11 +1,102 @@
 // Actionable provider failures for user-facing command and turn surfaces.
+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";
+import { providerFailureDetails, } from "./providers/failure.js";
 const CONNECTION_FAILURE = /network error calling|timed out waiting for response headers|response body was idle/i;
+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"
+    const details = providerFailureDetails(provider.id, error);
+    let failure;
+    if (provider.id === "ollama" && details.kind === "network" && CONNECTION_FAILURE.test(error.message)) {
+        failure = 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";
     }
-    return labelProvider ? `${providerLabel(provider.id)}: ${error.message}` : error.message;
+    else {
+        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}`
+        : "";
+    return `${message}${detail}`;
+}
+function providerReason(error) {
+    const body = error.body;
+    if (typeof body !== "string" || body.trim() === "")
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(body);
+    }
+    catch {
+        const raw = body.trim();
+        if (raw.startsWith("{") || raw.startsWith("[") || HTML.test(raw))
+            return undefined;
+        return safeReason(raw);
+    }
+    for (const candidate of reasonCandidates(parsed)) {
+        const reason = safeReason(candidate);
+        if (reason !== undefined)
+            return reason;
+    }
+    return undefined;
+}
+function reasonCandidates(value) {
+    if (typeof value === "string")
+        return [value];
+    if (!record(value))
+        return [];
+    const error = value["error"];
+    return [
+        record(error) ? error["message"] : undefined,
+        typeof error === "string" ? error : undefined,
+        value["message"],
+        value["detail"],
+    ].filter((candidate) => typeof candidate === "string");
+}
+function safeReason(text) {
+    if (HTML.test(text))
+        return undefined;
+    return safeText(text, MAX_REASON_CHARS) || undefined;
+}
+function safeText(text, max) {
+    const redacted = redactCredentials(text).trim().replace(/\s+/gu, " ");
+    return leadingText(terminalText(redacted), max);
+}
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
 }

package/dist/provider-label.js

@@ -8,3 +8,16 @@ export function providerLabel(id) {
         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.auth.kind === "oauth")
+        return `${providerLabel(provider.id)} account`;
+    if (provider.id === "openai")
+        return "OpenAI API · billed usage";
+    if (provider.id === "anthropic")
+        return "Anthropic API";
+    if (provider.id === "ollama") {
+        return provider.location?.() === "local" ? "Ollama · local" : "Ollama API";
+    }
+    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,
     };
 }