@giovannijecha/jecode 0.4.0 → 0.6.0

package/dist/controller.js

@@ -5,6 +5,7 @@
 // loop iterates. That constraint is implemented here, not left as a product claim.
 import { isToolCall } from "./types.js";
 import { findTool, runTool, toolSpecs } from "./tools/index.js";
+import { requestAssistant } from "./controller-request.js";
 export const MAX_TOOL_CALLS_PER_STEP = 32;
 /** Independent read calls share one bounded execution wave. */
 export const MAX_CONCURRENT_TOOL_CALLS = 4;
@@ -13,24 +14,27 @@ export const MAX_CONCURRENT_TOOL_CALLS = 4;
  * stops asking for tools. `history` is mutated in place, so an aborted turn
  * still leaves the conversation in a consistent state.
  */
-export async function runTurn(history, options, events, signal) {
+export async function runTurn(history, options, events, signal, modelHistory = history) {
     const specs = toolSpecs(options.tools);
+    let context = modelHistory;
+    const append = (message) => {
+        history.push(message);
+        if (context !== history)
+            context.push(message);
+    };
+    const checkpoint = async (settlement) => {
+        const projected = await events.onCheckpoint?.(history, settlement, context);
+        if (projected !== undefined)
+            context = clone([...projected]);
+    };
     for (let step = 0; step < options.maxSteps; step++) {
         throwIfAborted(signal);
         events.onStep?.(step + 1, options.maxSteps);
         // The message is displayed as it streams; what comes back here is the
         // assembled version, which exists to be appended to the history.
-        const assistant = await options.provider.send({
-            model: options.model,
-            system: options.system,
-            messages: history,
-            tools: specs,
-            maxTokens: options.maxTokens,
-            effort: options.effort,
-            signal,
-            onStream: (event) => events.onStream(event),
-            onStatus: (status) => events.onStatus?.(status),
-        });
+        const response = await requestAssistant(history, context, specs, options, events, signal);
+        const assistant = response.message;
+        context = response.context;
         throwIfAborted(signal);
         const calls = assistant.content.filter(isToolCall);
         if (assistant.content.length === 0) {
@@ -40,10 +44,11 @@ export async function runTurn(history, options, events, signal) {
             throw new Error(`provider returned ${calls.length} tool calls in one step (maximum ${MAX_TOOL_CALLS_PER_STEP})`);
         }
         assertToolCallIds(calls);
-        history.push(assistant);
+        append(assistant);
         if (calls.length === 0) {
             if (assistant.usage !== undefined)
                 events.onUsage?.(assistant.usage);
+            await checkpoint("completed");
             return; // the model is done — hand back to the user
         }
         // Consecutive shared reads run together. An exclusive call is an ordered
@@ -87,7 +92,7 @@ export async function runTurn(history, options, events, signal) {
                 repairs.push({ call, run });
                 results.push(run.result);
             }
-            history.push({ role: "user", content: results });
+            append({ role: "user", content: results });
             // History repair is the invariant. UI recovery is best-effort and must
             // never replace the original exception or leave the conversation open.
             for (const { call, run } of repairs) {
@@ -100,11 +105,13 @@ export async function runTurn(history, options, events, signal) {
                     // The surface is already failing; the next turn can still proceed.
                 }
             }
+            await checkpoint("checkpointed");
             if (interrupted)
                 throw abortReason(signal);
             throw error;
         }
-        history.push({ role: "user", content: results });
+        append({ role: "user", content: results });
+        await checkpoint("checkpointed");
     }
     throw new Error(`gave up after ${options.maxSteps} steps without finishing (raise --max-steps)`);
 }
@@ -187,3 +194,6 @@ function throwIfAborted(signal) {
 function abortReason(signal) {
     return signal.reason instanceof Error ? signal.reason : new Error("interrupted");
 }
+function clone(value) {
+    return structuredClone(value);
+}

package/dist/conversation.js

@@ -0,0 +1,236 @@
+// Canonical settled conversation state.
+//
+// A node owns one complete user-turn delta. The selected root-to-node path is
+// the durable source for the transcript and full history; context anchors can
+// project an older prefix before it is sent to a provider. Provider traffic
+// and live screen blocks remain prospective until a consistent checkpoint.
+import { projectContext, validContextAnchor } from "./context/projection.js";
+export const CONVERSATION_LIMITS = Object.freeze({
+    nodes: 1_024,
+    messageCodeUnits: 8_388_608,
+    transcriptCodeUnits: 8_388_608,
+    contextCodeUnits: 8_388_608,
+});
+/** Immutable tree with one selected model/transcript path. */
+export class ConversationTree {
+    #nodes;
+    #activeNodeId;
+    constructor(nodes, activeNodeId) {
+        this.#nodes = Object.freeze([...nodes]);
+        this.#activeNodeId = activeNodeId;
+        Object.freeze(this);
+    }
+    static empty() {
+        return new ConversationTree([], 0);
+    }
+    static restore(nodes, activeNodeId) {
+        let tree = ConversationTree.empty();
+        for (let index = 0; index < nodes.length; index++) {
+            const node = nodes[index];
+            if (node === undefined || node.id !== index + 1) {
+                throw new Error("session contains a non-sequential conversation node");
+            }
+            tree = tree.select(node.parentId).commit({
+                parentId: node.parentId,
+                createdAt: node.createdAt,
+                identity: node.identity,
+                messages: node.messages,
+                blocks: node.blocks,
+                ...(node.context === undefined ? {} : { context: node.context }),
+            }, node.settlement);
+            const restored = tree.activeNode;
+            if (restored === undefined || restored.id !== node.id) {
+                throw new Error("session conversation could not be restored");
+            }
+            if (node.revision > 1) {
+                const copy = [...tree.#nodes];
+                copy[node.id - 1] = ownedNode({ ...restored, revision: node.revision });
+                tree = new ConversationTree(copy, node.id);
+            }
+        }
+        return tree.select(activeNodeId);
+    }
+    /** Commit or extend the one prospective leaf turn. */
+    commit(draft, settlement) {
+        if (draft.parentId !== (draft.nodeId === undefined
+            ? this.#activeNodeId
+            : this.node(draft.nodeId)?.parentId)) {
+            throw new Error("turn parent no longer matches the selected conversation");
+        }
+        if (draft.nodeId === undefined)
+            return this.#append(draft, settlement);
+        return this.#replace(draft, settlement);
+    }
+    select(nodeId) {
+        if (!validNodeId(nodeId) || (nodeId !== 0 && this.#nodes[nodeId - 1]?.id !== nodeId)) {
+            throw new Error("conversation node does not exist");
+        }
+        return new ConversationTree(this.#nodes, nodeId);
+    }
+    node(nodeId) {
+        return nodeId === 0 ? undefined : this.#nodes[nodeId - 1];
+    }
+    get nodes() {
+        return this.#nodes;
+    }
+    get activeNodeId() {
+        return this.#activeNodeId;
+    }
+    get activeNode() {
+        return this.node(this.#activeNodeId);
+    }
+    /** Select the newest completed turn on the active path, if one exists. */
+    latestCompleted() {
+        let id = this.#activeNodeId;
+        while (id !== 0) {
+            const node = this.node(id);
+            if (node === undefined)
+                throw new Error("conversation path is incomplete");
+            if (node.settlement === "completed")
+                return this.select(id);
+            id = node.parentId;
+        }
+        return undefined;
+    }
+    get history() {
+        return this.#path().flatMap((node) => clone(node.messages));
+    }
+    get contextHistory() {
+        return projectContext(this.#path());
+    }
+    get transcript() {
+        return this.#path().flatMap((node) => clone(node.blocks));
+    }
+    #append(draft, settlement) {
+        if (this.#nodes.length >= CONVERSATION_LIMITS.nodes) {
+            throw new Error("conversation reached its session limit — start /new");
+        }
+        const node = ownedNode({
+            id: this.#nodes.length + 1,
+            parentId: draft.parentId,
+            revision: 1,
+            createdAt: draft.createdAt,
+            settlement,
+            identity: draft.identity,
+            messages: draft.messages,
+            blocks: settledBlocks(draft.blocks),
+            ...(draft.context === undefined ? {} : { context: draft.context }),
+        });
+        assertTurn(node);
+        const nodes = [...this.#nodes, node];
+        assertBounds(nodes);
+        return new ConversationTree(nodes, node.id);
+    }
+    #replace(draft, settlement) {
+        const id = draft.nodeId;
+        const current = this.node(id);
+        if (current === undefined || id !== this.#activeNodeId || this.#nodes.some((node) => node.parentId === id)) {
+            throw new Error("only the active leaf turn can be checkpointed");
+        }
+        const node = ownedNode({
+            ...current,
+            revision: current.revision + 1,
+            settlement,
+            identity: draft.identity,
+            messages: draft.messages,
+            blocks: settledBlocks(draft.blocks),
+            context: draft.context ?? current.context,
+        });
+        assertTurn(node);
+        const nodes = [...this.#nodes];
+        nodes[id - 1] = node;
+        assertBounds(nodes);
+        return new ConversationTree(nodes, id);
+    }
+    #path() {
+        const path = [];
+        let id = this.#activeNodeId;
+        while (id !== 0) {
+            const node = this.node(id);
+            if (node === undefined)
+                throw new Error("conversation path is incomplete");
+            path.push(node);
+            id = node.parentId;
+        }
+        path.reverse();
+        return path;
+    }
+}
+function ownedNode(node) {
+    return Object.freeze({
+        ...node,
+        identity: Object.freeze({ ...node.identity }),
+        messages: Object.freeze(clone(node.messages)),
+        blocks: Object.freeze(clone(node.blocks)),
+        ...(node.context === undefined ? {} : { context: Object.freeze({ ...node.context }) }),
+    });
+}
+function settledBlocks(blocks) {
+    return clone(blocks).flatMap((block) => {
+        if (block.kind === "notice")
+            return [];
+        if (block.kind === "reasoning") {
+            const { live: _live, expanded: _expanded, ...settled } = block;
+            return [settled];
+        }
+        if (block.kind === "tool") {
+            const { startedAt: _startedAt, expanded: _expanded, ...settled } = block;
+            return [settled];
+        }
+        return [block];
+    });
+}
+function assertTurn(node) {
+    if (!validNodeId(node.id) || node.id === 0 ||
+        !validNodeId(node.parentId) || node.parentId >= node.id ||
+        !Number.isSafeInteger(node.revision) || node.revision < 1 ||
+        node.createdAt.length === 0 || node.createdAt.length > 64 ||
+        (node.settlement !== "checkpointed" && node.settlement !== "completed") ||
+        node.messages.length < 2 || node.messages[0]?.role !== "user" ||
+        node.identity.providerId.length === 0 || node.identity.providerId.length > 128 ||
+        node.identity.model.length === 0 || node.identity.model.length > 512 ||
+        node.identity.effort.length === 0 || node.identity.effort.length > 32)
+        throw new Error("turn checkpoint is invalid");
+    if (node.settlement === "completed" && node.messages.at(-1)?.role !== "assistant") {
+        throw new Error("a completed turn must end with an assistant message");
+    }
+}
+function assertBounds(nodes) {
+    let messageCodeUnits = 0;
+    let transcriptCodeUnits = 0;
+    let contextCodeUnits = 0;
+    for (const node of nodes) {
+        messageCodeUnits += JSON.stringify(node.messages).length;
+        transcriptCodeUnits += JSON.stringify(node.blocks).length;
+        contextCodeUnits += node.context?.summary.length ?? 0;
+        if (node.context !== undefined)
+            assertContextPath(nodes, node);
+    }
+    if (messageCodeUnits > CONVERSATION_LIMITS.messageCodeUnits) {
+        throw new Error("conversation model history reached its session limit — start /new");
+    }
+    if (transcriptCodeUnits > CONVERSATION_LIMITS.transcriptCodeUnits) {
+        throw new Error("conversation transcript reached its session limit — start /new");
+    }
+    if (contextCodeUnits > CONVERSATION_LIMITS.contextCodeUnits) {
+        throw new Error("conversation context summaries reached their session limit — start /new");
+    }
+}
+function assertContextPath(nodes, owner) {
+    const context = owner.context;
+    const boundary = nodes[context.throughNodeId - 1];
+    if (boundary === undefined || !validContextAnchor(context, boundary.messages.length)) {
+        throw new Error("turn context checkpoint is invalid");
+    }
+    let id = owner.id;
+    while (id !== 0 && id !== boundary.id)
+        id = nodes[id - 1]?.parentId ?? 0;
+    if (id !== boundary.id)
+        throw new Error("turn context checkpoint is outside its branch");
+}
+function validNodeId(value) {
+    return Number.isSafeInteger(value) && value >= 0;
+}
+function clone(value) {
+    return structuredClone(value);
+}

package/dist/launch.js

@@ -0,0 +1,19 @@
+export function parseLaunch(argv) {
+    const first = argv[0];
+    if (first !== undefined && !first.startsWith("--") && first !== "-h" && first !== "-v") {
+        if (first !== "resume")
+            throw new Error(`unknown command ${first}`);
+        const rest = argv.slice(1);
+        const latest = rest.filter((value) => value === "--latest").length;
+        if (latest > 1)
+            throw new Error("--latest may be passed only once");
+        return {
+            kind: "resume",
+            latest: latest === 1,
+            configArgs: rest.filter((value) => value !== "--latest"),
+        };
+    }
+    if (argv.includes("--latest"))
+        throw new Error("--latest requires `jecode resume`");
+    return { kind: "new", latest: false, configArgs: [...argv] };
+}

package/dist/providers/anthropic.js

@@ -7,7 +7,7 @@
 // purpose: the default omits the reasoning text, which on a screen reads as a
 // long silence before anything appears.
 import { postSse } from "./http.js";
-import { listModels } from "./catalog.js";
+import { modelCatalog } from "./catalog.js";
 import { keyFor } from "../credentials.js";
 import { EFFORTS, requireSupportedEffort } from "../effort.js";
 import { assembleAnthropic } from "./anthropic-stream.js";
@@ -19,6 +19,7 @@ const KEY = "ANTHROPIC_API_KEY";
 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"];
+let contextByModel = new Map();
 export function supportsAdaptiveThinking(model) {
     return ADAPTIVE.test(model);
 }
@@ -41,12 +42,24 @@ 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.
-    models(signal, onStatus) {
-        return listModels(MODELS, headers(requireKey()), signal, onStatus);
+    async models(signal, onStatus) {
+        const catalog = await loadModels(signal, onStatus);
+        contextByModel = catalog.contexts;
+        return catalog.ids;
     },
     async efforts(model) {
         return anthropicEfforts(model);
     },
+    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;
+    },
     location: () => "cloud",
     async send(req) {
         const key = requireKey();
@@ -77,6 +90,23 @@ export const anthropic = {
         return fromWireResponse(data);
     },
 };
+async function loadModels(signal, onStatus) {
+    const entries = await modelCatalog(MODELS, headers(requireKey()), signal, onStatus);
+    return {
+        ids: entries.map((entry) => entry.id),
+        contexts: new Map(entries.map((entry) => [
+            entry.id,
+            contextWindow(entry.metadata["max_input_tokens"]),
+        ])),
+    };
+}
+function contextWindow(value) {
+    return validTokenCount(value) ? Object.freeze({ tokens: value }) : undefined;
+}
+function validTokenCount(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) &&
+        value >= 4_096 && value <= 10_000_000;
+}
 // Read at the moment it is used, never captured at import: a key typed into
 // the running window has to count, and so does one exported after startup.
 function apiKey() {

package/dist/providers/catalog.js

@@ -13,6 +13,9 @@ 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 modelCatalog(url, headers, signal, onStatus) {
     const body = await getJson(url, headers, signal, onStatus);
     const data = body.data;
     if (!Array.isArray(data))
@@ -22,16 +25,20 @@ export async function listModels(url, headers, signal, onStatus) {
     const inspected = Math.min(data.length, MAX_MODEL_CATALOG_ITEMS);
     for (let index = 0; index < inspected && models.length < MAX_MODEL_CATALOG_ENTRIES; index++) {
         const entry = data[index];
-        const id = typeof entry === "object" && entry !== null
-            ? entry.id
-            : undefined;
+        const metadata = record(entry) ? entry : undefined;
+        if (metadata === undefined)
+            continue;
+        const id = metadata["id"];
         if (typeof id !== "string" ||
             id === "" ||
             id.length > MAX_MODEL_ID_CHARS ||
             unique.has(id))
             continue;
         unique.add(id);
-        models.push(id);
+        models.push({ id, metadata });
     }
     return models;
 }
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/providers/ollama.js

@@ -5,14 +5,19 @@
 // daemon. There is no default model — the catalogue is whatever the host has
 // pulled or the subscription grants — so the model has to be named with
 // --model.
-import { postSse } from "./http.js";
+import { requireSupportedEffort } from "../effort.js";
+import { getJson, postJson, postSse } from "./http.js";
 import { listModels } from "./catalog.js";
 import { keyFor } from "../credentials.js";
 import { assembleOllama } from "./ollama-stream.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";
+// Ollama also accepts `none`; Jecode's product-wide reasoning floor is `low`.
+const OLLAMA_EFFORTS = ["low", "medium", "high"];
 let configuredHost;
+const CONTEXT_CACHE_MS = 30_000;
+const contextByEndpoint = 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;
@@ -46,7 +51,22 @@ export const ollama = {
         return listModels(`${at.baseUrl}/v1/models`, headers(at), signal, onStatus);
     },
     async efforts() {
-        return [];
+        return OLLAMA_EFFORTS;
+    },
+    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);
+        if (observed?.runtime === true) {
+            contextByEndpoint.set(cacheKey, {
+                value: observed.value,
+                expiresAt: Date.now() + CONTEXT_CACHE_MS,
+            });
+        }
+        return observed?.value;
     },
     location: () => {
         try {
@@ -58,13 +78,15 @@ export const ollama = {
     },
     async send(req) {
         const at = endpoint();
-        // `effort` has no equivalent in this shape and is dropped rather than
-        // guessed at — depth on these models is a property of the model chosen.
+        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,
         }, req.signal, req.onStatus);
         const reply = await assembleOllama(events, req.onStream);
@@ -74,6 +96,63 @@ export const ollama = {
         return fromWireReply(reply);
     },
 };
+async function nativeContextWindow(at, model, signal, onStatus) {
+    try {
+        const running = await getJson(`${at.baseUrl}/api/ps`, headers(at), signal, onStatus);
+        const allocated = runningContext(running, model);
+        if (allocated !== undefined)
+            return { value: usableContext(allocated), runtime: true };
+    }
+    catch (error) {
+        throwIfAborted(signal, error);
+    }
+    try {
+        const details = await postJson(`${at.baseUrl}/api/show`, headers(at), { model }, signal, onStatus);
+        const capacity = modelCapacity(details);
+        return capacity === undefined
+            ? undefined
+            : { value: usableContext(capacity), runtime: false };
+    }
+    catch (error) {
+        throwIfAborted(signal, error);
+        return undefined;
+    }
+}
+function runningContext(value, model) {
+    if (!record(value) || !Array.isArray(value["models"]))
+        return undefined;
+    for (const entry of value["models"]) {
+        if (!record(entry))
+            continue;
+        if (entry["name"] !== model && entry["model"] !== model)
+            continue;
+        if (validTokenCount(entry["context_length"]))
+            return entry["context_length"];
+    }
+    return undefined;
+}
+function modelCapacity(value) {
+    if (!record(value) || !record(value["model_info"]))
+        return undefined;
+    const capacities = Object.entries(value["model_info"])
+        .filter(([name, count]) => name.endsWith(".context_length") && validTokenCount(count))
+        .map(([, count]) => count);
+    return capacities.length === 0 ? undefined : Math.max(...capacities);
+}
+function validTokenCount(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) &&
+        value >= 4_096 && value <= 10_000_000;
+}
+function usableContext(tokens) {
+    return Object.freeze({ tokens: Math.floor(tokens * 95 / 100) });
+}
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function throwIfAborted(signal, error) {
+    if (signal?.aborted === true)
+        throw error;
+}
 function endpoint() {
     return ollamaConnection();
 }

package/dist/providers/openai-codex.js

@@ -19,6 +19,7 @@ const MAX_MODELS = 1_000;
 const MAX_MODEL_CHARS = 256;
 const XHIGH_EFFORTS = ["low", "medium", "high", "xhigh"];
 let effortByModel = new Map();
+let contextByModel = new Map();
 export const openaiCodex = {
     id: ID,
     defaultModel: "",
@@ -29,7 +30,7 @@ export const openaiCodex = {
     location: () => "cloud",
     async models(signal, onStatus) {
         const catalog = await loadCatalog(signal, onStatus);
-        effortByModel = catalog.efforts;
+        rememberCatalog(catalog);
         return catalog.ids;
     },
     async efforts(model, signal, onStatus) {
@@ -37,9 +38,19 @@ export const openaiCodex = {
         if (cached !== undefined)
             return cached;
         const catalog = await loadCatalog(signal, onStatus);
-        effortByModel = catalog.efforts;
+        rememberCatalog(catalog);
         return effortByModel.get(model) ?? fallbackEfforts(model);
     },
+    async contextWindow(model, signal, onStatus) {
+        if (contextByModel.has(model))
+            return contextByModel.get(model);
+        const catalog = await loadCatalog(signal, onStatus);
+        rememberCatalog(catalog);
+        const context = contextByModel.get(model);
+        if (!contextByModel.has(model))
+            contextByModel.set(model, undefined);
+        return context;
+    },
     async send(req) {
         const efforts = effortByModel.get(req.model) ?? fallbackEfforts(req.model);
         const effort = requireSupportedEffort(req.model, req.effort, efforts);
@@ -75,6 +86,10 @@ async function loadCatalog(signal, onStatus) {
         return modelCatalog(body);
     }, signal, onStatus);
 }
+function rememberCatalog(catalog) {
+    effortByModel = catalog.efforts;
+    contextByModel = catalog.contexts;
+}
 async function withAuthorization(operation, signal, onStatus) {
     let authorization = await openAIAuthorization(undefined, signal, onStatus);
     try {
@@ -120,6 +135,7 @@ function modelCatalog(value) {
                 id,
                 priority: typeof entry["priority"] === "number" ? entry["priority"] : 0,
                 efforts: reasoningLevels(entry, id),
+                context: modelContextWindow(entry),
             }];
     })
         .sort((left, right) => left.priority - right.priority)
@@ -127,8 +143,36 @@ function modelCatalog(value) {
     return {
         ids: models.map((entry) => entry.id),
         efforts: new Map(models.map((entry) => [entry.id, entry.efforts])),
+        contexts: new Map(models.map((entry) => [entry.id, entry.context])),
     };
 }
+function modelContextWindow(entry) {
+    const resolved = tokenCount(entry["context_window"]) ?? tokenCount(entry["max_context_window"]);
+    if (resolved === undefined)
+        return undefined;
+    const percent = percentage(entry["effective_context_window_percent"]) ?? 95;
+    const tokens = Math.floor(resolved * percent / 100);
+    if (!validTokenCount(tokens))
+        return undefined;
+    const automatic = Math.floor(resolved * 9 / 10);
+    const advertised = tokenCount(entry["auto_compact_token_limit"]);
+    return Object.freeze({
+        tokens,
+        compactAtTokens: Math.min(advertised ?? automatic, automatic, tokens),
+    });
+}
+function tokenCount(value) {
+    return validTokenCount(value) ? value : undefined;
+}
+function validTokenCount(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) &&
+        value >= 4_096 && value <= 10_000_000;
+}
+function percentage(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 1 && value <= 100
+        ? value
+        : undefined;
+}
 function reasoningLevels(entry, model) {
     const source = entry["supported_reasoning_levels"];
     if (!Array.isArray(source))