@giovannijecha/jecode 0.8.1 → 0.8.3

package/dist/credential-safety.js

@@ -1,8 +1,11 @@
 // The shell needs a useful process environment, not the application's secrets.
 import { credentialValues } from "./credentials.js";
 import { accountValues } from "./accounts.js";
+import { USER_STORE_LIMITS } from "./user-store.js";
 const REDACTED = "[credential redacted]";
 const MIN_HEURISTIC_SECRET_CHARS = 8;
+export const MAX_REDACTION_SECRETS = USER_STORE_LIMITS.credentialEntries;
+const MAX_REDACTION_SECRET_CODE_UNITS = USER_STORE_LIMITS.accountToken;
 const EXPLICIT_CREDENTIAL_ENVIRONMENT_NAMES = new Set([
     "ANTHROPIC_API_KEY",
     "OLLAMA_API_KEY",
@@ -27,11 +30,24 @@ export function shellEnvironment(source = process.env) {
 }
 /** Remove values Jecode recognizes as credentials before tool output leaves the shell boundary. */
 export function redactCredentials(text, source = process.env) {
-    return redact(text, secrets(source));
+    const known = secrets(source);
+    return known.saturated ? (text === "" ? "" : REDACTED) : redact(text, known.values);
 }
 /** Redact before bounded capture, retaining enough raw overlap for split values. */
 export function credentialRedactor(source = process.env) {
-    const values = secrets(source);
+    const known = secrets(source);
+    if (known.saturated)
+        return closedRedactor();
+    const values = known.values;
+    const candidates = new Map();
+    for (const value of values) {
+        const first = value[0];
+        const bucket = candidates.get(first);
+        if (bucket === undefined)
+            candidates.set(first, [value]);
+        else
+            bucket.push(value);
+    }
     const longest = Math.max(0, ...values.map((value) => value.length));
     let pending = "";
     return {
@@ -40,16 +56,17 @@ export function credentialRedactor(source = process.env) {
             const ready = [];
             let at = 0;
             while (at < combined.length) {
-                const rest = combined.slice(at);
+                const matching = candidates.get(combined[at]) ?? [];
+                const rest = matching.length === 0 ? "" : combined.slice(at);
                 // A complete shorter credential can also be the prefix of a longer
                 // one. Hold that ambiguous suffix until the next chunk proves which
                 // value arrived, otherwise the longer credential leaks its tail.
                 if (rest.length < longest &&
-                    values.some((value) => value.length > rest.length && value.startsWith(rest))) {
+                    matching.some((value) => value.length > rest.length && value.startsWith(rest))) {
                     pending = rest;
                     return ready.join("");
                 }
-                const complete = values.find((value) => combined.startsWith(value, at));
+                const complete = matching.find((value) => combined.startsWith(value, at));
                 if (complete !== undefined) {
                     ready.push(REDACTED);
                     at += complete.length;
@@ -68,6 +85,20 @@ export function credentialRedactor(source = process.env) {
         },
     };
 }
+function closedRedactor() {
+    let emitted = false;
+    return {
+        write(chunk) {
+            if (chunk === "" || emitted)
+                return "";
+            emitted = true;
+            return REDACTED;
+        },
+        end() {
+            return "";
+        },
+    };
+}
 function sensitiveEnvironmentName(name) {
     const normalized = name
         .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
@@ -79,16 +110,32 @@ function sensitiveEnvironmentName(name) {
         COMPACT_SENSITIVE_ENVIRONMENT_NAME.test(normalized));
 }
 function secrets(source) {
-    const values = new Set([...credentialValues(), ...accountValues()]);
+    const values = new Set();
+    let saturated = false;
+    const add = (value) => {
+        if (value === "" || values.has(value) || saturated)
+            return;
+        if (value.length > MAX_REDACTION_SECRET_CODE_UNITS ||
+            values.size >= MAX_REDACTION_SECRETS) {
+            saturated = true;
+            return;
+        }
+        values.add(value);
+    };
+    for (const value of [...credentialValues(), ...accountValues()])
+        add(value);
     for (const [name, value] of Object.entries(source)) {
-        if (value === undefined || value === "")
+        if (saturated || value === undefined || value === "")
             continue;
         const explicit = EXPLICIT_CREDENTIAL_ENVIRONMENT_NAMES.has(name.toUpperCase());
         if (explicit || (value.length >= MIN_HEURISTIC_SECRET_CHARS && sensitiveEnvironment(name, value))) {
-            values.add(value);
+            add(value);
         }
     }
-    return [...values].filter((value) => value !== "").sort((left, right) => right.length - left.length);
+    return {
+        values: [...values].sort((left, right) => right.length - left.length),
+        saturated,
+    };
 }
 function redact(text, values) {
     let redacted = text;

package/dist/credentials.js

@@ -10,11 +10,11 @@
 // secret in the working tree is one `git add -A` from being published, which
 // is why "not in the repo" is a rule and not a preference.
 import { chmod, mkdir } from "node:fs/promises";
-import { readFileSync } from "node:fs";
 import * as path from "node:path";
 import { atomicWrite } from "./atomic.js";
 import { withStoreLock } from "./store-lock.js";
 import { legacyUserDataPath, userDataLabel, userDataPath } from "./user-data.js";
+import { assertStoreText, readBoundedJsonSync, USER_STORE_LIMITS } from "./user-store.js";
 /** Keys this session was given but not asked to keep. Dies with the window. */
 const held = new Map();
 /** The saved file, read once. `undefined` until the first look at it. */
@@ -58,6 +58,10 @@ export function hasSaved(name) {
 }
 /** Take a key for this session only. Nothing is written anywhere. */
 export function hold(name, value) {
+    assertCredential(name, value);
+    if (!held.has(name) && held.size >= USER_STORE_LIMITS.credentialEntries) {
+        throw new Error("too many session credentials");
+    }
     held.set(name, value);
 }
 /** Remove only the value held by this process. Saved and environment values remain. */
@@ -73,10 +77,14 @@ export function forgetSession(name) {
  * Windows ignores the mode and relies on the profile directory's own ACL.
  */
 export async function keep(name, value) {
+    assertCredential(name, value);
     const file = storePath();
     await prepare(file);
     return withStoreLock(file, async () => {
         const all = { ...readSavedStore(), [name]: value };
+        if (Object.keys(all).length > USER_STORE_LIMITS.credentialEntries) {
+            throw new Error("too many saved credentials");
+        }
         await persist(file, all);
         saved = all;
         // A newly saved replacement must become active immediately. Otherwise an
@@ -131,9 +139,14 @@ function readSavedStore() {
 }
 function readStore(file) {
     try {
-        const parsed = JSON.parse(readFileSync(file, "utf8"));
+        const parsed = readBoundedJsonSync(file, USER_STORE_LIMITS.credentialsBytes);
+        if (!record(parsed))
+            return {};
         // Anything that is not a string is not a key, whatever the file says.
-        return Object.fromEntries(Object.entries(parsed).filter((entry) => typeof entry[1] === "string"));
+        const entries = Object.entries(parsed);
+        if (entries.length > USER_STORE_LIMITS.credentialEntries)
+            return {};
+        return Object.fromEntries(entries.filter((entry) => credential(entry[0], entry[1])));
     }
     catch (error) {
         // Only a missing canonical file falls through to the legacy location. A
@@ -148,7 +161,22 @@ async function prepare(file) {
         await chmod(directory, 0o700);
 }
 async function persist(file, values) {
-    await atomicWrite(file, `${JSON.stringify(values, null, 2)}\n`, { mode: 0o600 });
+    const text = `${JSON.stringify(values, null, 2)}\n`;
+    assertStoreText(text, USER_STORE_LIMITS.credentialsBytes);
+    await atomicWrite(file, text, { mode: 0o600 });
+}
+function assertCredential(name, value) {
+    if (!credential(name, value))
+        throw new Error("invalid credential name or value");
+}
+function credential(name, value) {
+    return name.length > 0 && name.length <= USER_STORE_LIMITS.credentialName &&
+        /^[A-Za-z_][A-Za-z0-9_]*$/.test(name) &&
+        typeof value === "string" && value.length > 0 &&
+        value.length <= USER_STORE_LIMITS.credentialValue;
+}
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 /** An empty variable is an unset variable — an exported "" is not a key. */
 function use(value) {

package/dist/input-boundary.js

@@ -0,0 +1,80 @@
+// One bounded ingress for text that can become a user prompt.
+import { Buffer } from "node:buffer";
+import { StringDecoder } from "node:string_decoder";
+import { MAX_TEXT_CODE_UNITS } from "./text-boundary.js";
+export const MAX_PROMPT_CODE_UNITS = MAX_TEXT_CODE_UNITS;
+export const PROMPT_LIMIT_MESSAGE = `Prompt cannot exceed ${MAX_PROMPT_CODE_UNITS.toLocaleString("en-US")} UTF-16 code units`;
+export class PromptLimitError extends Error {
+    constructor() {
+        super(PROMPT_LIMIT_MESSAGE);
+        this.name = "PromptLimitError";
+    }
+}
+export function assertPromptLength(length) {
+    if (length > MAX_PROMPT_CODE_UNITS)
+        throw new PromptLimitError();
+}
+export function assertPromptAppend(current, added) {
+    if (added > MAX_PROMPT_CODE_UNITS - current)
+        throw new PromptLimitError();
+}
+/**
+ * Split raw UTF-8 input without letting one unterminated line grow past the
+ * prompt boundary. Newline, CRLF, and a final line without a newline match the
+ * line semantics used by batch mode.
+ */
+export async function* boundedInputLines(source) {
+    const decoder = new StringDecoder("utf8");
+    let line = "";
+    let pendingCr = false;
+    const append = (text, from, to) => {
+        const length = to - from;
+        assertPromptAppend(line.length, length);
+        if (length > 0)
+            line += text.slice(from, to);
+    };
+    const consume = function* (text) {
+        if (text === "")
+            return;
+        let from = 0;
+        if (pendingCr) {
+            if (text.startsWith("\n"))
+                from = 1;
+            pendingCr = false;
+            yield line;
+            line = "";
+        }
+        while (from < text.length) {
+            const cr = text.indexOf("\r", from);
+            const lf = text.indexOf("\n", from);
+            const newline = cr === -1 ? lf : lf === -1 ? cr : Math.min(cr, lf);
+            if (newline === -1) {
+                append(text, from, text.length);
+                return;
+            }
+            append(text, from, newline);
+            if (text[newline] === "\r" && newline + 1 === text.length) {
+                pendingCr = true;
+                return;
+            }
+            yield line;
+            line = "";
+            from = text[newline] === "\r" && text[newline + 1] === "\n"
+                ? newline + 2
+                : newline + 1;
+        }
+    };
+    for await (const chunk of source) {
+        const text = typeof chunk === "string" ? chunk : decoder.write(Buffer.from(chunk));
+        yield* consume(text);
+    }
+    const tail = decoder.end();
+    if (tail !== "")
+        yield* consume(tail);
+    if (pendingCr) {
+        yield line;
+        line = "";
+    }
+    if (line !== "")
+        yield line;
+}

package/dist/main.js

@@ -1,7 +1,10 @@
 // Process entry point. The testable bootstrap lives in start.ts.
 import { start } from "./start.js";
+import { isProcessSignalError, withProcessShutdown } from "./process-shutdown.js";
 import { terminalText } from "./ui/terminal-text.js";
-start().catch((error) => {
+withProcessShutdown((signal) => start(process.argv.slice(2), { signal })).catch((error) => {
+    if (isProcessSignalError(error))
+        return;
     process.stderr.write(`jecode: ${terminalText(error.message)}\n`);
     process.exitCode = 1;
 });

package/dist/openai-oauth-callback.js

@@ -173,7 +173,7 @@ function resultPage(success) {
 let mascot;
 function mascotDataUri() {
     if (mascot === undefined) {
-        const file = new URL("../docs/assets/brand/jeco-256.png", import.meta.url);
+        const file = new URL("../assets/jeco-256.png", import.meta.url);
         mascot = `data:image/png;base64,${readFileSync(file).toString("base64")}`;
     }
     return mascot;

package/dist/openai-oauth.js

@@ -17,6 +17,8 @@ const DEVICE_POLL = `${AUTHORITY}/api/accounts/deviceauth/token`;
 const DEVICE_VERIFY = `${AUTHORITY}/codex/device`;
 const DEVICE_REDIRECT = `${AUTHORITY}/deviceauth/callback`;
 const LOGIN_LIMIT_MS = 15 * 60_000;
+/** RFC 8628 increases the polling interval by five seconds after `slow_down`. */
+const SLOW_DOWN_INCREMENT_MS = 5_000;
 export async function beginBrowserLogin() {
     const verifier = randomBytes(64).toString("base64url");
     const challenge = createHash("sha256").update(verifier).digest("base64url");
@@ -121,23 +123,65 @@ async function exchange(code, signal) {
     return openAITokenReply(response.value);
 }
 async function pollDevice(deviceAuthId, userCode, interval, signal) {
-    const started = Date.now();
-    while (Date.now() - started < LOGIN_LIMIT_MS) {
-        const response = await oauthRequest(DEVICE_POLL, {
-            contentType: "application/json",
-            value: { device_auth_id: deviceAuthId, user_code: userCode },
-        }, signal, [200, 403, 404]);
-        if (response.status === 200) {
-            const value = record(response.value) ? response.value : {};
-            return {
-                authorizationCode: required(value["authorization_code"], "authorization code"),
-                verifier: required(value["code_verifier"], "code verifier"),
-                redirectUri: DEVICE_REDIRECT,
-            };
+    const deadline = new AbortController();
+    const timer = setTimeout(() => {
+        deadline.abort(new Error("ChatGPT device sign-in timed out after 15 minutes"));
+    }, LOGIN_LIMIT_MS);
+    const combined = signal === undefined
+        ? deadline.signal
+        : AbortSignal.any([signal, deadline.signal]);
+    let intervalMs = interval * 1_000;
+    try {
+        while (true) {
+            const response = await oauthRequest(DEVICE_POLL, {
+                contentType: "application/json",
+                value: { device_auth_id: deviceAuthId, user_code: userCode },
+            }, combined, [200, 400, 403, 404, 429]);
+            if (combined.aborted)
+                throw abortReason(combined);
+            if (response.status === 200) {
+                const value = record(response.value) ? response.value : {};
+                return {
+                    authorizationCode: required(value["authorization_code"], "authorization code"),
+                    verifier: required(value["code_verifier"], "code verifier"),
+                    redirectUri: DEVICE_REDIRECT,
+                };
+            }
+            const errorCode = deviceErrorCode(response.value);
+            if (errorCode === "access_denied") {
+                throw new Error("ChatGPT device sign-in was denied");
+            }
+            if (errorCode === "expired_token") {
+                throw new Error("ChatGPT device sign-in code expired");
+            }
+            const pending = errorCode === "authorization_pending" ||
+                errorCode === "deviceauth_authorization_pending" ||
+                ((response.status === 403 || response.status === 404) && errorCode === undefined);
+            const slowDown = errorCode === "slow_down" ||
+                (response.status === 429 && errorCode === undefined);
+            if (!pending && !slowDown) {
+                throw new Error(`ChatGPT device sign-in failed (${response.status})`);
+            }
+            if (slowDown)
+                intervalMs += SLOW_DOWN_INCREMENT_MS;
+            await sleep(intervalMs, combined);
         }
-        await sleep(interval * 1_000, signal);
     }
-    throw new Error("ChatGPT device sign-in timed out after 15 minutes");
+    finally {
+        clearTimeout(timer);
+    }
+}
+function deviceErrorCode(value) {
+    if (!record(value))
+        return undefined;
+    const error = value["error"];
+    const nested = typeof error === "string"
+        ? error
+        : record(error)
+            ? optional(error["code"])
+            : undefined;
+    const code = nested ?? optional(value["code"]);
+    return code?.trim().toLowerCase();
 }
 function intervalSeconds(value) {
     const parsed = typeof value === "string" ? Number(value.trim()) : value;

package/dist/process-shutdown.js

@@ -0,0 +1,52 @@
+// One process-wide cancellation boundary for operating-system signals.
+const SHUTDOWN_GRACE_MS = 2_000;
+const SIGNALS = [
+    ["SIGINT", 2],
+    ["SIGHUP", 1],
+    ["SIGTERM", 15],
+];
+export class ProcessSignalError extends Error {
+    signal;
+    exitCode;
+    constructor(signal, exitCode) {
+        super(`received ${signal}`);
+        this.name = "ProcessSignalError";
+        this.signal = signal;
+        this.exitCode = exitCode;
+    }
+}
+export function isProcessSignalError(error) {
+    return error instanceof ProcessSignalError;
+}
+/**
+ * Abort foreground work on the first fatal signal and reserve a bounded hard
+ * exit for work that ignores cancellation. A second signal exits immediately.
+ */
+export async function withProcessShutdown(work) {
+    const control = new AbortController();
+    let exitCode;
+    let forceTimer;
+    const listeners = [];
+    for (const [name, number] of SIGNALS) {
+        const listener = () => {
+            if (control.signal.aborted) {
+                process.exit(exitCode ?? 128 + number);
+            }
+            exitCode = 128 + number;
+            process.exitCode = exitCode;
+            control.abort(new ProcessSignalError(name, exitCode));
+            forceTimer = setTimeout(() => process.exit(exitCode), SHUTDOWN_GRACE_MS);
+        };
+        listeners.push([name, listener]);
+        process.on(name, listener);
+    }
+    try {
+        return await work(control.signal);
+    }
+    finally {
+        if (forceTimer !== undefined)
+            clearTimeout(forceTimer);
+        for (const [name, listener] of listeners)
+            process.off(name, listener);
+    }
+}

package/dist/providers/anthropic-stream.js

@@ -6,11 +6,13 @@
 // beyond display: thinking blocks carry a signature and must be echoed back
 // byte-for-byte on the next request.
 import { addBounded, MAX_TOOL_ARGUMENT_CHARS } from "./stream-limits.js";
+import { toolInputFromJson } from "./tool-input.js";
 export async function assembleAnthropic(events, onStream) {
     const blocks = new Map();
     const partialJson = new Map();
     const announcedTools = new Set();
     const sizes = { toolArguments: 0 };
+    const toolInputErrors = {};
     let stopReason;
     let stopDetails;
     let usage;
@@ -46,7 +48,10 @@ export async function assembleAnthropic(events, onStream) {
                 const pending = partialJson.get(event.index);
                 const block = blocks.get(event.index);
                 if (pending !== undefined && block !== undefined) {
-                    block.input = parseJsonObject(pending);
+                    const parsed = toolInputFromJson(pending);
+                    block.input = parsed.input;
+                    if (parsed.inputError !== undefined)
+                        toolInputErrors[event.index] = parsed.inputError;
                     partialJson.delete(event.index);
                 }
                 break;
@@ -69,10 +74,24 @@ export async function assembleAnthropic(events, onStream) {
     }
     if (!complete)
         throw new Error("anthropic stream ended before message_stop");
-    const content = [...blocks.entries()]
-        .sort(([a], [b]) => a - b)
-        .map(([, block]) => block);
-    return { content, stop_reason: stopReason, stop_details: stopDetails, usage };
+    const ordered = [...blocks.entries()].sort(([a], [b]) => a - b);
+    const content = ordered.map(([, block]) => block);
+    const orderedInputErrors = {};
+    for (let index = 0; index < ordered.length; index++) {
+        const sourceIndex = ordered[index]?.[0];
+        if (sourceIndex === undefined || toolInputErrors[sourceIndex] === undefined)
+            continue;
+        orderedInputErrors[index] = toolInputErrors[sourceIndex];
+    }
+    return {
+        content,
+        stop_reason: stopReason,
+        stop_details: stopDetails,
+        usage,
+        ...(Object.keys(orderedInputErrors).length === 0
+            ? {}
+            : { toolInputErrors: orderedInputErrors }),
+    };
 }
 function mergeUsage(before, after) {
     return after === undefined ? before : { ...before, ...after };
@@ -108,18 +127,3 @@ function applyDelta(blocks, partialJson, sizes, index, delta, onStream) {
             return;
     }
 }
-// Tool arguments arrive as a stream of JSON fragments. An empty accumulation
-// is a call with no arguments, not a malformed one.
-function parseJsonObject(text) {
-    if (text.trim() === "")
-        return {};
-    try {
-        const parsed = JSON.parse(text);
-        return typeof parsed === "object" && parsed !== null
-            ? parsed
-            : {};
-    }
-    catch {
-        return {};
-    }
-}

package/dist/providers/anthropic-wire.js

@@ -1,5 +1,6 @@
 // Translation between the normalized vocabulary and the Anthropic wire shape.
 // Pure functions, no I/O — which is what makes them testable without a key.
+import { toolInputFromValue } from "./tool-input.js";
 import { wireTokenCount } from "./wire-usage.js";
 export function toWireTool(tool) {
     return { name: tool.name, description: tool.description, input_schema: tool.input };
@@ -45,7 +46,8 @@ export function fromWireResponse(data) {
     const raw = Array.isArray(data.content) ? data.content : [];
     const content = [];
     let suppressedToolCall = false;
-    for (const item of raw) {
+    for (let index = 0; index < raw.length; index++) {
+        const item = raw[index];
         const block = item;
         if (block.type === "text" && typeof block.text === "string") {
             content.push({ kind: "text", text: block.text });
@@ -54,11 +56,14 @@ export function fromWireResponse(data) {
             if (data.stop_reason === "tool_use" &&
                 typeof block.id === "string" &&
                 typeof block.name === "string") {
+                const parsed = toolInputFromValue(block.input ?? {});
+                const inputError = data.toolInputErrors?.[index] ?? parsed.inputError;
                 content.push({
                     kind: "tool_call",
                     id: block.id,
                     name: block.name,
-                    input: (block.input ?? {}),
+                    input: parsed.input,
+                    ...(inputError === undefined ? {} : { inputError }),
                 });
             }
             else {

package/dist/providers/ollama-wire.js

@@ -6,6 +6,7 @@
 // Chat Completions differs on two points that matter here — a tool result is a
 // message of its own with role "tool", not a block inside a user turn, and tool
 // arguments travel as a JSON string rather than an object.
+import { toolInputFromJson } from "./tool-input.js";
 import { wireTokenCount } from "./wire-usage.js";
 export function toWireTool(tool) {
     return {
@@ -63,7 +64,12 @@ export function fromWireReply(reply) {
     const acceptsToolCalls = reply.finishReason === "tool_calls";
     if (acceptsToolCalls) {
         for (const call of reply.toolCalls) {
-            content.push({ kind: "tool_call", id: call.id, name: call.name, input: parseArgs(call.args) });
+            content.push({
+                kind: "tool_call",
+                id: call.id,
+                name: call.name,
+                ...toolInputFromJson(call.args),
+            });
         }
     }
     const notice = stopNotice(reply);
@@ -104,17 +110,3 @@ export function stopNotice(reply) {
         ? "[truncated: hit the output limit — raise --max-tokens]"
         : undefined;
 }
-// A model that emits malformed JSON gets the empty object, which fails
-// validation in tools/args.ts with a message written for it to read. That is a
-// recoverable turn; throwing here would end the whole thing instead.
-function parseArgs(args) {
-    if (args.trim() === "")
-        return {};
-    try {
-        const parsed = JSON.parse(args);
-        return typeof parsed === "object" && parsed !== null ? parsed : {};
-    }
-    catch {
-        return {};
-    }
-}

package/dist/providers/ollama.js

@@ -17,7 +17,8 @@ const KEY = "OLLAMA_API_KEY";
 const OLLAMA_EFFORTS = ["low", "medium", "high"];
 let configuredHost;
 const CONTEXT_CACHE_MS = 30_000;
-const contextByEndpoint = new Map();
+const runtimeContextByEndpoint = new Map();
+const modelContextByEndpoint = new Map();
 /** Set the endpoint selected for this process. Undefined restores key-aware inference. */
 export function configureOllama(host) {
     configuredHost = host === undefined ? undefined : parseOllamaEndpoint(host).baseUrl;
@@ -56,15 +57,16 @@ export const ollama = {
     async contextWindow(model, signal, onStatus) {
         const at = endpoint();
         const cacheKey = `${at.baseUrl}\u0000${model}`;
-        const cached = contextByEndpoint.get(cacheKey);
-        if (cached !== undefined && cached.expiresAt > Date.now())
-            return cached.value;
-        const observed = await nativeContextWindow(at, model, signal, onStatus);
+        const runtime = cachedContext(runtimeContextByEndpoint, cacheKey);
+        if (runtime !== undefined)
+            return runtime;
+        const modelCapacity = cachedContext(modelContextByEndpoint, cacheKey);
+        const observed = await nativeContextWindow(at, model, modelCapacity, signal, onStatus);
         if (observed?.runtime === true) {
-            contextByEndpoint.set(cacheKey, {
-                value: observed.value,
-                expiresAt: Date.now() + CONTEXT_CACHE_MS,
-            });
+            rememberContext(runtimeContextByEndpoint, cacheKey, observed.value);
+        }
+        else if (observed !== undefined && modelCapacity === undefined) {
+            rememberContext(modelContextByEndpoint, cacheKey, observed.value);
         }
         return observed?.value;
     },
@@ -88,6 +90,7 @@ export const ollama = {
             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);
@@ -96,7 +99,7 @@ export const ollama = {
         return fromWireReply(reply);
     },
 };
-async function nativeContextWindow(at, model, signal, onStatus) {
+async function nativeContextWindow(at, model, fallback, signal, onStatus) {
     try {
         const running = await getJson(`${at.baseUrl}/api/ps`, headers(at), signal, onStatus);
         const allocated = runningContext(running, model);
@@ -106,6 +109,8 @@ async function nativeContextWindow(at, model, signal, onStatus) {
     catch (error) {
         throwIfAborted(signal, error);
     }
+    if (fallback !== undefined)
+        return { value: fallback, runtime: false };
     try {
         const details = await postJson(`${at.baseUrl}/api/show`, headers(at), { model }, signal, onStatus);
         const capacity = modelCapacity(details);
@@ -118,6 +123,18 @@ async function nativeContextWindow(at, model, signal, onStatus) {
         return undefined;
     }
 }
+function cachedContext(cache, key) {
+    const cached = cache.get(key);
+    if (cached === undefined)
+        return undefined;
+    if (cached.expiresAt > Date.now())
+        return cached.value;
+    cache.delete(key);
+    return undefined;
+}
+function rememberContext(cache, key, value) {
+    cache.set(key, { value, expiresAt: Date.now() + CONTEXT_CACHE_MS });
+}
 function runningContext(value, model) {
     if (!record(value) || !Array.isArray(value["models"]))
         return undefined;