@giovannijecha/jecode 0.7.4 → 0.8.1

package/README.md

@@ -22,18 +22,21 @@
 
 <p align="center">
   <a href="https://github.com/giovannijecha/jecode/blob/main/CHANGELOG.md">Changelog</a> &middot;
+  <a href="https://github.com/giovannijecha/jecode/blob/main/docs/compatibility.md">Compatibility</a> &middot;
   <a href="https://github.com/giovannijecha/jecode/releases">Releases</a>
 </p>
 
 > Jecode is currently pre-1.0. The core loop is usable today, but commands and
-> terminal interactions may still evolve before 1.0.
+> terminal interactions may still evolve before 1.0. The release-candidate
+> surface is now frozen in the [compatibility contract](https://github.com/giovannijecha/jecode/blob/main/docs/compatibility.md).
 
 ## Why Jecode
 
 - **One visible loop.** One controller talks to the model, runs tools, and
-  returns control to you. Independent reads may overlap inside a step; writes
-  and commands stay ordered. There are no delegated agents or hidden model
-  workers.
+  returns control to you. Independent reads may overlap within one model
+  response; writes and commands stay ordered. You can steer an active turn
+  without starting a second loop. There are no delegated agents or hidden
+  model workers.
 - **Terminal-native today.** The transcript, composer, searchable menus, tool
   output, diffs, approvals, reasoning, and status share one full-screen TUI.
 - **Permission-aware.** Tool use is visible. Dangerous actions ask first, and
@@ -245,7 +248,8 @@ Useful controls:
 - **Backspace/Delete** removes one character;
   **Ctrl+Backspace/Delete** removes one word.
 - **Home/End** moves to the beginning or end of the composer.
-- **Tab** completes a slash command without running it; **Enter** sends.
+- **Tab** completes a slash command without running it; **Enter** sends. During
+  an active model turn, **Enter** queues guidance for its next safe boundary.
 - **Alt+Enter** inserts a newline.
 - **Esc** closes the active menu or interrupts foreground work.
 - **Ctrl+C** interrupts, or exits while idle. **Ctrl+D** requests a clean exit.
@@ -253,9 +257,11 @@ Useful controls:
 - **Ctrl+O** expands or compacts the latest reasoning or tool-detail block.
 
 The footer keeps the active model, effort, and workspace visible. During work,
-it adds the current state, elapsed time, and interrupt hint. Operational
-feedback uses the same replaceable status area instead of adding noise to the
-conversation or its Markdown export.
+it adds the current state, elapsed time, steering availability or queue count,
+and interrupt hint. Queued guidance joins the same conversation turn after the
+provider response or complete tool batch already in progress; `Esc` remains an
+immediate interruption. Operational feedback uses the same replaceable status
+area instead of adding noise to the conversation or its Markdown export.
 
 ## Sessions and context
 
@@ -316,19 +322,23 @@ settings, then built-in defaults.
 | `--root` | - | Current directory |
 | `--effort` | `JECODE_EFFORT` | `high` |
 | `--max-tokens` | `JECODE_MAX_TOKENS` | `64000` ceiling, clamped to the usable request budget; not sent by `openai-codex` |
-| `--max-steps` | `JECODE_MAX_STEPS` | `40` |
+| `--max-steps` | `JECODE_MAX_STEPS` | No limit |
 | `--compaction-percent` | `JECODE_COMPACTION_PERCENT` | `85`; accepts `50` through `95` |
 | `--reduced-motion` | `JECODE_REDUCED_MOTION=1` | Off |
 | `--auto-approve` | `JECODE_AUTO_APPROVE=1` | Off |
 | `--ephemeral` | `JECODE_EPHEMERAL=1` | Off |
 
+`--max-steps` is an opt-in, process-only budget for deterministic automation
+and diagnostics. Interactive work has no arbitrary model-loop ceiling, and the
+budget is neither shown nor saved by `/settings`.
+
 Non-secret preferences live in `~/.jecode/settings.json`. Explicitly saved API
 keys live in `~/.jecode/credentials.json`, while ChatGPT OAuth accounts live in
 `~/.jecode/accounts.json`. Environment credentials always take precedence.
 Secret stores use owner-only permissions where the operating system supports
 them.
 
-Jecode has one current interface theme, Dark Steel. `NO_COLOR` is supported for
+Jecode has one current interface theme, Slate. `NO_COLOR` is supported for
 terminals and pipelines that disable colour.
 
 ## Safety model
@@ -409,15 +419,17 @@ fixtures. `npm run bench:transcript` and `npm run bench:search` provide manual
 probes for long-session rendering and workspace search. Architecture and
 security boundaries are documented in
 [docs/architecture.md](docs/architecture.md); brand assets and usage rules live
-in [docs/brand.md](docs/brand.md). The maintainer release procedure lives in
-[docs/releasing.md](docs/releasing.md).
+in [docs/brand.md](docs/brand.md). The public 1.0 contract lives in
+[docs/compatibility.md](docs/compatibility.md), and the maintainer release
+procedure lives in [docs/releasing.md](docs/releasing.md).
 
 ## Community
 
 - Ask questions, share workflows, and explore early ideas in
   [GitHub Discussions](https://github.com/giovannijecha/jecode/discussions).
 - Report reproducible bugs and focused feature requests through
-  [GitHub Issues](https://github.com/giovannijecha/jecode/issues).
+  [GitHub Issues](https://github.com/giovannijecha/jecode/issues). New
+  capabilities are deferred until the 1.0 stabilization cycle is complete.
 - Report security concerns privately through the repository Security tab.
 
 Public pull requests are not accepted at this stage. Code changes remain a

package/dist/batch.js

@@ -126,7 +126,7 @@ function options(session, contextPolicy) {
         maxTokens: session.config.maxTokens,
         contextPolicy,
         effort: session.config.effort,
-        maxSteps: session.config.maxSteps,
+        maxModelRequests: session.config.maxModelRequests,
         toolContext: { root: session.config.root },
     };
 }

package/dist/cli-info.js

@@ -15,7 +15,7 @@ Options:
   --ollama-host <url>    Ollama Cloud, local, or custom endpoint
   --effort <level>       low, medium, high, xhigh, or max
   --max-tokens <number>  output-token ceiling
-  --max-steps <number>   tool-loop ceiling
+  --max-steps <number>   optional per-turn model-request budget
   --compaction-percent <${MIN_COMPACTION_PERCENT}-${MAX_COMPACTION_PERCENT}>
                           context usage that triggers compaction (default: ${DEFAULT_COMPACTION_PERCENT})
   --reduced-motion       use a steady terminal cursor

package/dist/config.js

@@ -27,6 +27,7 @@ export function loadConfig(argv, saved = readSettings()) {
     if (!EFFORTS.includes(effort)) {
         throw new Error(`unknown effort "${effort}" (expected one of: ${EFFORTS.join(", ")})`);
     }
+    const maxModelRequests = optional(flags["max-steps"], process.env.JECODE_MAX_STEPS, undefined);
     return {
         providerId,
         model: pick(flags.model, process.env.JECODE_MODEL, saved.models?.[providerId] ?? ""),
@@ -37,7 +38,9 @@ export function loadConfig(argv, saved = readSettings()) {
         effort,
         // Every request streams, so a large ceiling costs nothing in timeout risk.
         maxTokens: toInt(pick(flags["max-tokens"], process.env.JECODE_MAX_TOKENS, String(saved.maxTokens ?? 64000)), "max-tokens"),
-        maxSteps: toInt(pick(flags["max-steps"], process.env.JECODE_MAX_STEPS, String(saved.maxSteps ?? 40)), "max-steps"),
+        ...(maxModelRequests === undefined
+            ? {}
+            : { maxModelRequests: toInt(maxModelRequests, "max-steps") }),
         compactionPercent: toPercent(pick(flags["compaction-percent"], process.env.JECODE_COMPACTION_PERCENT, String(saved.compactionPercent ?? DEFAULT_COMPACTION_PERCENT))),
         root: path.resolve(pick(flags.root, undefined, process.cwd())),
         autoApprove: flags["auto-approve"] === "true" ||

package/dist/controller.js

@@ -6,7 +6,7 @@
 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;
+export const MAX_TOOL_CALLS_PER_RESPONSE = 32;
 /** Independent read calls share one bounded execution wave. */
 export const MAX_CONCURRENT_TOOL_CALLS = 4;
 /**
@@ -28,9 +28,25 @@ export async function runTurn(history, options, events, signal, modelHistory = h
         if (projected !== undefined)
             context = clone([...projected]);
     };
-    for (let step = 0; step < options.maxSteps; step++) {
+    const appendSteering = (messages) => {
+        for (const text of messages) {
+            append({ role: "user", content: [{ kind: "text", text }] });
+        }
+        for (const text of messages) {
+            events.onSteering?.(text);
+        }
+        return messages.length > 0;
+    };
+    let requests = 0;
+    while (true) {
         throwIfAborted(signal);
-        events.onStep?.(step + 1, options.maxSteps);
+        if (options.maxModelRequests !== undefined &&
+            requests >= options.maxModelRequests) {
+            const requestLabel = options.maxModelRequests === 1 ? "request" : "requests";
+            throw new Error(`stopped after ${options.maxModelRequests} model ${requestLabel} (--max-steps limit reached)`);
+        }
+        appendSteering(options.steering?.drain() ?? []);
+        requests++;
         // The message is displayed as it streams; what comes back here is the
         // assembled version, which exists to be appended to the history.
         const response = await requestAssistant(history, context, specs, options, events, signal);
@@ -41,8 +57,8 @@ export async function runTurn(history, options, events, signal, modelHistory = h
         if (assistant.content.length === 0) {
             throw new Error(`${options.provider.id} completed without an answer or tool call`);
         }
-        if (calls.length > MAX_TOOL_CALLS_PER_STEP) {
-            throw new Error(`provider returned ${calls.length} tool calls in one step (maximum ${MAX_TOOL_CALLS_PER_STEP})`);
+        if (calls.length > MAX_TOOL_CALLS_PER_RESPONSE) {
+            throw new Error(`provider returned ${calls.length} tool calls in one response (maximum ${MAX_TOOL_CALLS_PER_RESPONSE})`);
         }
         assertToolCallIds(calls);
         if (assistant.usage !== undefined)
@@ -52,6 +68,11 @@ export async function runTurn(history, options, events, signal, modelHistory = h
             : response.inputTokens);
         append(assistant);
         if (calls.length === 0) {
+            const steering = options.steering?.drainOrClose();
+            if (steering !== undefined && appendSteering(steering.messages)) {
+                await checkpoint("checkpointed");
+                continue;
+            }
             await checkpoint("completed");
             return; // the model is done — hand back to the user
         }
@@ -68,14 +89,15 @@ export async function runTurn(history, options, events, signal, modelHistory = h
                 for (let offset = 0; offset < batch.length; offset++) {
                     throwIfAborted(signal);
                     const call = batch[offset];
-                    events.onToolProgress?.(start + offset + 1, calls.length);
+                    const current = start + offset + 1;
+                    events.onToolPreparing?.(call, current, calls.length);
                     const preview = await look(call, options, signal);
                     throwIfAborted(signal);
                     announced.add(call.id);
                     events.onToolCall(call, preview);
-                    prepared.push({ call, preview });
+                    prepared.push({ call, current, preview });
                 }
-                const runs = await Promise.all(prepared.map(({ call, preview }) => settle(call, options, events, signal, preview)));
+                const runs = await Promise.all(prepared.map(({ call, current, preview }) => settle(call, current, calls.length, options, events, signal, preview)));
                 for (let offset = 0; offset < runs.length; offset++) {
                     const call = prepared[offset]?.call;
                     const run = runs[offset];
@@ -113,9 +135,9 @@ export async function runTurn(history, options, events, signal, modelHistory = h
             throw error;
         }
         append({ role: "user", content: results });
+        appendSteering(options.steering?.drain() ?? []);
         await checkpoint("checkpointed");
     }
-    throw new Error(`gave up after ${options.maxSteps} steps without finishing (raise --max-steps)`);
 }
 function nextBatch(calls, start, tools) {
     const first = calls[start];
@@ -141,12 +163,12 @@ function assertToolCallIds(calls) {
         if (call.id.trim() === "")
             throw new Error("provider returned a tool call without an id");
         if (seen.has(call.id)) {
-            throw new Error("provider returned duplicate tool call ids in one step");
+            throw new Error("provider returned duplicate tool call ids in one response");
         }
         seen.add(call.id);
     }
 }
-async function settle(call, options, events, signal, preview) {
+async function settle(call, current, total, options, events, signal, preview) {
     const tool = findTool(options.tools, call.name);
     if (tool === undefined) {
         return refuse(call, `no such tool: ${call.name}`, "unknown tool");
@@ -158,6 +180,7 @@ async function settle(call, options, events, signal, preview) {
         return refuse(call, "the user declined this call — ask them how to proceed", "declined");
     }
     throwIfAborted(signal);
+    events.onToolStart?.(call, current, total);
     return runTool(tool, call, {
         ...options.toolContext,
         signal,

package/dist/duration.js

@@ -0,0 +1,8 @@
+// One compact duration grammar shared by terminal and exported tool evidence.
+export function toolDuration(durationMs, live = false) {
+    const bounded = Number.isFinite(durationMs) ? Math.max(0, durationMs) : 0;
+    if (!live && bounded < 1_000)
+        return `${Math.round(bounded)}ms`;
+    const seconds = bounded / 1_000;
+    return `${seconds < 10 ? seconds.toFixed(1) : Math.round(seconds)}s`;
+}

package/dist/openai-account.js

@@ -30,29 +30,27 @@ export async function removeOpenAIAccount(signal) {
     }
     return { removed: true, revokeFailed };
 }
-export async function openAIAuthorization(forceToken, signal, onStatus) {
+export async function openAIAuthorization(rejectedToken, signal, onStatus) {
     const account = openAICodexAccount();
     if (account === undefined)
         throw new Error("ChatGPT account is not connected");
-    const mustRefresh = forceToken !== undefined || expiresSoon(account);
+    const mustRefresh = rejectedToken !== undefined || expiresSoon(account);
     const ready = mustRefresh
-        ? await refreshAccount(forceToken, signal, onStatus)
+        ? await refreshAccount(rejectedToken, signal, onStatus)
         : account;
     return { accessToken: ready.accessToken, accountId: ready.accountId };
 }
-async function refreshAccount(forceToken, signal, onStatus) {
+async function refreshAccount(rejectedToken, signal, onStatus) {
     if (refreshing !== undefined)
         return abortable(refreshing, signal);
     if (signal?.aborted === true)
         throw abortReason(signal);
-    onStatus?.("Refreshing ChatGPT sign-in");
     const task = updateOpenAICodexAccount(async (current) => {
         if (current === undefined)
             throw new Error("ChatGPT account is not connected");
-        if (forceToken !== undefined && current.accessToken !== forceToken)
-            return current;
-        if (forceToken === undefined && !expiresSoon(current))
+        if (!requiresAuthorityRefresh(current, rejectedToken))
             return current;
+        onStatus?.("Refreshing ChatGPT sign-in");
         return refreshOpenAITokens(current);
     }).then((account) => {
         if (account === undefined)
@@ -72,6 +70,12 @@ async function refreshAccount(forceToken, signal, onStatus) {
 function expiresSoon(account) {
     return account.expiresAt - Date.now() <= REFRESH_EARLY_MS;
 }
+function requiresAuthorityRefresh(account, rejectedToken) {
+    // A different fresh token means another process already recovered. An
+    // expiring replacement still needs rotation, while a rejected current token
+    // must be rotated regardless of its advertised expiry.
+    return expiresSoon(account) || account.accessToken === rejectedToken;
+}
 function abortable(promise, signal) {
     if (signal === undefined)
         return promise;

package/dist/providers/anthropic-stream.js

@@ -9,6 +9,7 @@ import { addBounded, MAX_TOOL_ARGUMENT_CHARS } from "./stream-limits.js";
 export async function assembleAnthropic(events, onStream) {
     const blocks = new Map();
     const partialJson = new Map();
+    const announcedTools = new Set();
     const sizes = { toolArguments: 0 };
     let stopReason;
     let stopDetails;
@@ -23,6 +24,13 @@ export async function assembleAnthropic(events, onStream) {
             case "content_block_start": {
                 if (typeof event.index === "number" && event.content_block !== undefined) {
                     blocks.set(event.index, { ...event.content_block });
+                    if (event.content_block["type"] === "tool_use" &&
+                        !announcedTools.has(event.index)) {
+                        announcedTools.add(event.index);
+                        const rawName = event.content_block["name"];
+                        const name = typeof rawName === "string" && rawName !== "" ? rawName : undefined;
+                        onStream?.({ kind: "tool", ...(name === undefined ? {} : { name }) });
+                    }
                 }
                 break;
             }

package/dist/providers/anthropic-wire.js

@@ -44,27 +44,39 @@ export function stopNotice(data) {
 export function fromWireResponse(data) {
     const raw = Array.isArray(data.content) ? data.content : [];
     const content = [];
+    let suppressedToolCall = false;
     for (const item of raw) {
         const block = item;
         if (block.type === "text" && typeof block.text === "string") {
             content.push({ kind: "text", text: block.text });
         }
-        else if (block.type === "tool_use" &&
-            typeof block.id === "string" &&
-            typeof block.name === "string") {
-            content.push({
-                kind: "tool_call",
-                id: block.id,
-                name: block.name,
-                input: (block.input ?? {}),
-            });
+        else if (block.type === "tool_use") {
+            if (data.stop_reason === "tool_use" &&
+                typeof block.id === "string" &&
+                typeof block.name === "string") {
+                content.push({
+                    kind: "tool_call",
+                    id: block.id,
+                    name: block.name,
+                    input: (block.input ?? {}),
+                });
+            }
+            else {
+                suppressedToolCall = true;
+            }
         }
         // thinking / redacted_thinking and anything future: carried in `raw` only.
     }
     const notice = stopNotice(data);
     if (notice !== undefined)
         content.push({ kind: "text", text: notice });
-    return { role: "assistant", content, raw, rawFrom: "anthropic", usage: normalizeUsage(data) };
+    const retainRaw = data.stop_reason !== "max_tokens" && !suppressedToolCall;
+    return {
+        role: "assistant",
+        content,
+        ...(retainRaw ? { raw, rawFrom: "anthropic" } : {}),
+        usage: normalizeUsage(data),
+    };
 }
 function normalizeUsage(data) {
     const usage = data.usage;

package/dist/providers/ollama-stream.js

@@ -6,6 +6,7 @@
 import { addBounded, MAX_TOOL_ARGUMENT_CHARS } from "./stream-limits.js";
 export async function assembleOllama(events, onStream) {
     const calls = new Map();
+    const announcedTools = new Map();
     let toolArgumentChars = 0;
     let content = "";
     let reasoning = "";
@@ -53,6 +54,12 @@ export async function assembleOllama(events, onStream) {
                 call.args += part.function.arguments;
             }
             calls.set(index, call);
+            const name = call.name === "" ? undefined : call.name;
+            if (!announcedTools.has(index) ||
+                (announcedTools.get(index) === undefined && name !== undefined)) {
+                announcedTools.set(index, name);
+                onStream?.({ kind: "tool", ...(name === undefined ? {} : { name }) });
+            }
         }
     }
     if (finishReason === undefined) {

package/dist/providers/ollama-wire.js

@@ -60,10 +60,18 @@ export function fromWireReply(reply) {
     const content = [];
     if (reply.content !== "")
         content.push({ kind: "text", text: reply.content });
-    for (const call of reply.toolCalls) {
-        content.push({ kind: "tool_call", id: call.id, name: call.name, input: parseArgs(call.args) });
+    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) });
+        }
     }
-    const raw = reply.reasoning === "" ? undefined : { reasoning: reply.reasoning };
+    const notice = stopNotice(reply);
+    if (notice !== undefined)
+        content.push({ kind: "text", text: notice });
+    const suppressedToolCall = reply.toolCalls.length > 0 && !acceptsToolCalls;
+    const retainRaw = reply.finishReason !== "length" && !suppressedToolCall;
+    const raw = !retainRaw || reply.reasoning === "" ? undefined : { reasoning: reply.reasoning };
     return {
         role: "assistant",
         content,

package/dist/providers/openai-stream.js

@@ -6,6 +6,7 @@
 // those streamed items remain the fallback when the final envelope is empty.
 export async function assembleOpenAI(events, onStream) {
     const items = [];
+    const announcedTools = { identities: new Set(), anonymous: false };
     let refusal = false;
     for await (const raw of events) {
         const event = raw;
@@ -24,14 +25,31 @@ export async function assembleOpenAI(events, onStream) {
                 if (typeof event.delta === "string")
                     onStream?.({ kind: "thinking", text: event.delta });
                 break;
+            case "response.output_item.added":
+                if (isFunctionCall(event.item)) {
+                    announceTool(event, event.item, announcedTools, onStream);
+                }
+                break;
+            case "response.function_call_arguments.delta":
+            case "response.function_call_arguments.done":
+                announceTool(event, undefined, announcedTools, onStream);
+                break;
             case "response.output_item.done":
-                if (event.item !== undefined)
+                if (event.item !== undefined) {
+                    if (isFunctionCall(event.item)) {
+                        announceTool(event, event.item, announcedTools, onStream);
+                    }
                     items.push(event.item);
+                }
                 break;
             case "response.done":
             case "response.completed":
+                return withDefaultStatus(reconcileOutput(event.response, items), "completed");
             case "response.incomplete":
-                return reconcileOutput(event.response, items);
+                return {
+                    ...reconcileOutput(event.response, items),
+                    status: "incomplete",
+                };
             case "response.failed": {
                 const response = event.response;
                 throw new Error(`openai stream error: ${response?.error?.message ?? "unspecified"}`);
@@ -44,9 +62,46 @@ export async function assembleOpenAI(events, onStream) {
     }
     throw new Error("openai stream ended before a terminal response event");
 }
+function isFunctionCall(item) {
+    return typeof item === "object" && item !== null &&
+        item["type"] === "function_call";
+}
+function announceTool(event, item, announced, onStream) {
+    const identities = toolIdentities(event, item);
+    if (identities.length === 0) {
+        if (announced.anonymous)
+            return;
+        announced.anonymous = true;
+    }
+    else {
+        const duplicate = identities.some((identity) => announced.identities.has(identity));
+        for (const identity of identities)
+            announced.identities.add(identity);
+        if (duplicate)
+            return;
+    }
+    const rawName = item?.name ?? event.name;
+    const name = typeof rawName === "string" && rawName !== "" ? rawName : undefined;
+    onStream?.({ kind: "tool", ...(name === undefined ? {} : { name }) });
+}
+function toolIdentities(event, item) {
+    const identities = [];
+    const itemId = event.item_id ?? item?.id;
+    if (typeof itemId === "string" && itemId !== "")
+        identities.push(`item:${itemId}`);
+    if (typeof event.output_index === "number")
+        identities.push(`output:${event.output_index}`);
+    if (typeof item?.call_id === "string" && item.call_id !== "") {
+        identities.push(`call:${item.call_id}`);
+    }
+    return identities;
+}
 function reconcileOutput(completed, items) {
     if (completed === undefined)
         return { output: items };
     const finalCount = Array.isArray(completed.output) ? completed.output.length : 0;
     return items.length > finalCount ? { ...completed, output: items } : completed;
 }
+function withDefaultStatus(response, status) {
+    return response.status === undefined ? { ...response, status } : response;
+}

package/dist/providers/openai-wire.js

@@ -40,8 +40,9 @@ export function toWireItems(message, providerId = "openai") {
 }
 export function stopNotice(data) {
     const reason = data.incomplete_details?.reason;
-    if (reason === undefined)
-        return undefined;
+    if (reason === undefined) {
+        return data.status === "incomplete" ? "[incomplete response]" : undefined;
+    }
     return reason === "max_output_tokens"
         ? "[truncated: hit max_output_tokens — raise --max-tokens]"
         : `[incomplete: ${reason}]`;
@@ -49,6 +50,7 @@ export function stopNotice(data) {
 export function fromWireResponse(data, providerId = "openai") {
     const raw = Array.isArray(data.output) ? data.output : [];
     const content = [];
+    let suppressedFunctionCall = false;
     for (const entry of raw) {
         const item = entry;
         if (item.type === "message" && Array.isArray(item.content)) {
@@ -62,22 +64,35 @@ export function fromWireResponse(data, providerId = "openai") {
                 }
             }
         }
-        else if (item.type === "function_call" &&
-            typeof item.call_id === "string" &&
-            typeof item.name === "string") {
-            content.push({
-                kind: "tool_call",
-                id: item.call_id,
-                name: item.name,
-                input: parseArguments(item.arguments),
-            });
+        else if (item.type === "function_call") {
+            if (data.status === "completed" &&
+                (item.status === undefined || item.status === "completed") &&
+                typeof item.call_id === "string" &&
+                typeof item.name === "string") {
+                content.push({
+                    kind: "tool_call",
+                    id: item.call_id,
+                    name: item.name,
+                    input: parseArguments(item.arguments),
+                });
+            }
+            else {
+                suppressedFunctionCall = true;
+            }
         }
         // reasoning items and anything future: carried in `raw` only.
     }
     const notice = stopNotice(data);
     if (notice !== undefined)
         content.push({ kind: "text", text: notice });
-    return { role: "assistant", content, raw, rawFrom: providerId, usage: normalizeUsage(data) };
+    return {
+        role: "assistant",
+        content,
+        ...(data.status === "completed" && !suppressedFunctionCall
+            ? { raw, rawFrom: providerId }
+            : {}),
+        usage: normalizeUsage(data),
+    };
 }
 function normalizeUsage(data) {
     const usage = data.usage;

package/dist/sessions/codec.js

@@ -3,7 +3,7 @@
 // can become conversation or provider input.
 import { Buffer } from "node:buffer";
 import { CONTEXT_LIMITS } from "../context/projection.js";
-export const SESSION_SCHEMA = 3;
+export const SESSION_SCHEMA = 4;
 export const SESSION_FILE_LIMITS = Object.freeze({
     text: 1_048_576,
     metadataBytes: 64 * 1_024,
@@ -135,7 +135,7 @@ export function decodeNode(value) {
             effort: identity["effort"],
         }),
         messages: Object.freeze(messages.map(messageFromRecord)),
-        blocks: Object.freeze(blocks.map(blockFromRecord)),
+        blocks: Object.freeze(blocks.map((block) => blockFromRecord(block, version))),
         ...(context === undefined ? {} : { context: Object.freeze(context) }),
         ...(failure === undefined ? {} : { failure: Object.freeze(failure) }),
     });
@@ -266,18 +266,23 @@ function blockRecord(block) {
             right: block.right,
             tone: block.tone,
             body: block.body?.map(detailRecord) ?? null,
+            durationMs: block.durationMs ?? null,
         }];
 }
-function blockFromRecord(value) {
+function blockFromRecord(value, version) {
     if (!record(value) || typeof value["kind"] !== "string")
         throw invalid();
     if ((value["kind"] === "user" || value["kind"] === "answer" || value["kind"] === "reasoning") &&
         keys(value, "kind,text") && boundedText(value["text"]))
         return { kind: value["kind"], text: value["text"] };
-    if (value["kind"] === "tool" && keys(value, "body,kind,name,right,target,tone") &&
+    const toolKeys = version >= 4
+        ? "body,durationMs,kind,name,right,target,tone"
+        : "body,kind,name,right,target,tone";
+    if (value["kind"] === "tool" && keys(value, toolKeys) &&
         bounded(value["name"], 256) && boundedText(value["target"]) &&
         boundedText(value["right"], 1_024) &&
         (value["tone"] === "ok" || value["tone"] === "fail" || value["tone"] === "deny") &&
+        (version < 4 || nullableInteger(value["durationMs"], 0)) &&
         (value["body"] === null ||
             (Array.isArray(value["body"]) && value["body"].length <= SESSION_FILE_LIMITS.details))) {
         const body = value["body"] === null
@@ -290,6 +295,9 @@ function blockFromRecord(value) {
             right: value["right"],
             tone: value["tone"],
             ...(body === undefined ? {} : { body }),
+            ...(version < 4 || value["durationMs"] === null
+                ? {}
+                : { durationMs: value["durationMs"] }),
         };
     }
     throw invalid();
@@ -398,7 +406,7 @@ function integer(value, minimum) {
     return typeof value === "number" && Number.isSafeInteger(value) && value >= minimum;
 }
 function schema(value) {
-    return value === 1 || value === 2 || value === SESSION_SCHEMA;
+    return value === 1 || value === 2 || value === 3 || value === SESSION_SCHEMA;
 }
 function settlement(value, version) {
     return value === "checkpointed" || value === "completed" ||