@mlx-node/lm 0.0.8 → 0.0.10

package/dist/chat-session.js

@@ -11,12 +11,12 @@
  * Design notes:
  *
  *   - The session tracks its own `ChatMessage[]` history on the
- *     TypeScript side. In the common text-continue case the history
- *     is only appended to and never read back — each `send()` on
- *     turn >= 1 issues a cheap `chatSessionContinue` delta against
- *     the live KV cache. The history is kept purely so the
- *     image-change mid-session path can call `chatSessionStart` with
- *     the full rebuilt history for a clean re-prefill.
+ *     TypeScript side and passes the complete structured transcript
+ *     on every turn. Native code renders that transcript with the
+ *     checkpoint-provided chat template, verifies the completed history
+ *     against the committed cache, and appends the template-authored suffix
+ *     to the exact cached token IDs. Incompatible or edited history cold
+ *     replays the complete render.
  *
  *   - An image hash (`lastImagesKey`) tracks the images bound to the
  *     current cache. A `send()` call whose image set has changed
@@ -24,7 +24,9 @@
  *     restart: `resetCaches()` → push the new user message (with
  *     images) to history → `chatSessionStart(history)`.
  *
- *   - Text-only `send()` on turn >= 1 takes the cheap delta path.
+ *   - Text-only `send()` on turn >= 1 still gets incremental prefill
+ *     on a token-prefix hit. Prompt structure is never reconstructed
+ *     from Rust string literals.
  *
  *   - `sendToolResult` always dispatches `chatSessionContinueTool`,
  *     since tool turns never change image state. The session enforces
@@ -48,9 +50,7 @@
  *         `sendToolResult*()` throw. The only valid recovery is
  *         `reset()` or `primeHistory()` + `startFromHistory*()` with
  *         a fully-resolved conversation — there is no "advance past
- *         the broken turn" path. This mirrors the native ChatML delta
- *         format which would otherwise silently corrupt multi-call
- *         conversations.
+ *         the broken turn" path.
  *
  *   - `sawFinal` gates `turnCount` advance on the streaming path, so
  *     the session refuses to advance when the stream throws
@@ -85,21 +85,17 @@
  */
 import { createHash } from 'node:crypto';
 /**
- * Typed prefix the native delta path uses to reject a text-only
- * continuation while the session still holds image/audio KV state
- * (gemma4 raises this after a media turn). The native session refuses
- * to advance the cheap delta on top of media KV, so the session layer
- * recognizes this exact prefix and transparently replays the whole
- * conversation through the cold start path instead of surfacing the
- * raw error to the caller.
+ * Typed prefix native media guards use when a history cannot be continued
+ * from the held image/audio state. The session layer recognizes this exact
+ * prefix and transparently replays the complete structured conversation.
  *
  * MUST stay byte-for-byte identical to the Rust constant
  * `IMAGE_CHANGE_RESTART_PREFIX` in
  * `crates/mlx-core/src/engine/cache.rs` — it is not exported across the
  * NAPI boundary, so the two literals are kept in sync by hand. The
  * native message starts with this prefix and is delivered as the
- * `Error.message`: on the sync delta path as a rejected promise, and on
- * the streaming delta path as a thrown error on the generator's first
+ * `Error.message`: on the sync path as a rejected promise, and on
+ * the streaming path as a thrown error on the generator's first
  * iteration (the native worker-thread sink error is re-thrown by the
  * `packages/lm/src/stream.ts` bridge before any chunk is yielded).
  */
@@ -192,23 +188,40 @@ function toAssistantToolCalls(toolCalls) {
 }
 /**
  * Build an assistant `ChatMessage` from a just-completed turn's
- * decoded text + tool-call list. The assistant entry is appended to
- * `this.history` after every successful turn and is later read back
- * by the native `chatSessionStart` cold-replay path (image-change
- * mid-session restart, `startFromHistory*`, server-side
- * `SessionRegistry` cache-miss rebuild). Dropping the `toolCalls`
- * field here would orphan any subsequent `{role: 'tool', ...}`
- * entries on replay — the jinja template would render a
- * `<tool_response>` for a call that was never declared on the
- * preceding assistant turn, corrupting the conversation structure
- * and changing model behavior after a restart.
+ * decoded text, exact raw text, tool-call list, reasoning body, and resolved
+ * thinking mode. LFM2 replays the exact raw content because its checkpoint
+ * template does not consume structured reasoning; Qwen/Gemma retain their
+ * structured fields. The assistant entry is appended to `this.history` after every
+ * successful turn and is later read back by the native
+ * `chatSessionStart` cold-replay path (image-change mid-session
+ * restart, `startFromHistory*`, server-side `SessionRegistry`
+ * cache-miss rebuild). Dropping `toolCalls`, `reasoningContent`, or
+ * `thinkingEnabled` changes the rendered assistant bytes on replay:
+ * tool responses lose their declaring call, reasoning disappears, or
+ * an empty disabled-thinking channel is reinterpreted under the
+ * current turn's mode.
  */
-function buildAssistantMessage(text, toolCalls) {
+function buildAssistantMessage(text, toolCalls, thinking, thinkingEnabled, rawText, replayRawText) {
+    if (replayRawText) {
+        return {
+            role: 'assistant',
+            content: rawText ?? text,
+            thinkingEnabled,
+        };
+    }
     const calls = toAssistantToolCalls(toolCalls);
+    const message = {
+        role: 'assistant',
+        content: text,
+        thinkingEnabled,
+    };
     if (calls) {
-        return { role: 'assistant', content: text, toolCalls: calls };
+        message.toolCalls = calls;
+    }
+    if (thinking != null) {
+        message.reasoningContent = thinking;
     }
-    return { role: 'assistant', content: text };
+    return message;
 }
 /**
  * Count the `ok`-status tool calls in a `ChatResult.toolCalls` /
@@ -230,6 +243,63 @@ function countOkToolCalls(toolCalls) {
     }
     return n;
 }
+/**
+ * Select the assistant text committed after a successful stream.
+ *
+ * Default emitters expose parsed text on the terminal event, so an empty
+ * value is authoritative for a tool-only turn and must not fall back to raw
+ * streamed tool markup. Gemma's channel-aware emitter instead sends visible
+ * text as deltas and an empty terminal value for ordinary no-tool replies, so
+ * retain the accumulated visible text in that distinct shape.
+ */
+function selectCommittedStreamText(finalText, accumulatedVisible, terminalTextAuthoritative) {
+    if (finalText == null)
+        return accumulatedVisible;
+    if (terminalTextAuthoritative === true)
+        return finalText;
+    if (terminalTextAuthoritative === false)
+        return accumulatedVisible;
+    if (finalText !== '')
+        return finalText;
+    return accumulatedVisible;
+}
+/** Mirror the native default used by `resolve_include_reasoning`. */
+function includesReasoning(config) {
+    return config.includeReasoning ?? config.reasoningEffort !== 'none';
+}
+/**
+ * Session history must retain reasoning even when the caller hides it. Ask
+ * native finalization for the full parsed turn without mutating the committed
+ * request config; the public view is redacted again below.
+ */
+function withReplayReasoning(config, model) {
+    if (includesReasoning(config))
+        return config;
+    if (model.supportsReplayReasoningCapture?.() !== true)
+        return config;
+    // A zero-budget "none" turn cannot produce a reasoning body worth
+    // replaying. Preserve the caller's native suppression flag for this common
+    // short-generation path (for example title generation).
+    if (config.reasoningEffort === 'none' && (config.thinkingTokenBudget ?? 0) <= 0) {
+        return config;
+    }
+    return { ...config, includeReasoning: true };
+}
+function publicChatResult(result, config) {
+    if (includesReasoning(config))
+        return result;
+    const safeRaw = result.publicRawText;
+    return { ...result, thinking: undefined, rawText: safeRaw ?? result.text };
+}
+function publicStreamEvent(event, config) {
+    if (includesReasoning(config))
+        return event;
+    if (!event.done) {
+        return event.isReasoning === true ? null : event;
+    }
+    const safeRaw = event.publicRawText;
+    return { ...event, thinking: null, rawText: safeRaw ?? event.text };
+}
 /**
  * Compute a stable hex-encoded identity key for a list of image
  * byte buffers.
@@ -306,11 +376,12 @@ export class ChatSession {
     model;
     system;
     defaultConfig;
+    /** Tool definitions are conversation state for deterministic template replay. */
+    activeTools;
     /**
      * Full conversation history tracked on the TS side. Appended to on
-     * every successful turn. Only read back when the image-change path
-     * triggers a restart — normal text continues use the server-side
-     * cache, not this array.
+     * every successful turn and sent on every role-aware native turn so
+     * the model-provided template remains the sole prompt authority.
      */
     history = [];
     /**
@@ -329,7 +400,7 @@ export class ChatSession {
     lastAudioKey = null;
     turnCount = 0;
     inFlight = false;
-    /** A failed/abandoned native delta must be followed by a full replay. */
+    /** A failed/abandoned native turn must be followed by a full replay. */
     needsFullReplay = false;
     /**
      * Count of `ok` tool calls emitted by the prior assistant turn, or
@@ -356,6 +427,7 @@ export class ChatSession {
         this.model = model;
         this.system = options.system;
         this.defaultConfig = options.defaultConfig ?? {};
+        this.activeTools = this.defaultConfig.tools;
     }
     /**
      * Number of completed turns. Increments only after a successful
@@ -440,9 +512,10 @@ export class ChatSession {
     /**
      * Send a user message and resolve with the assistant reply.
      *
-     * Turn 0 and any turn whose image set has changed dispatch through
-     * `chatSessionStart` with the full history. All other turns use
-     * the cheap `chatSessionContinue` delta path.
+     * Turn 0 and any turn whose image set changed dispatch through
+     * `chatSessionStart`. Later turns pass the same complete structured
+     * history through `chatSessionContinue`; native code renders the
+     * model template and reuses KV on an exact token-prefix match.
      */
     async send(userMessage, opts = {}) {
         if (this.inFlight) {
@@ -454,11 +527,11 @@ export class ChatSession {
             const mergedConfig = this.mergeConfig(opts.config);
             const newImagesKey = computeImagesKey(opts.images);
             const newAudioKey = computeAudioKey(opts.audio);
-            // Only an explicit NEW image/audio set can trigger a restart. Omitting
+            // Only an explicit NEW image/audio set can trigger a forced restart. Omitting
             // `images`/`audio` (key === null) is interpreted as "keep the current
             // media cache state" — the server-side cache already holds any prior
             // media context, so a text-only follow-up like "what about the
-            // top-right?" can stay on the cheap delta path even after a media turn.
+            // top-right?" can ask native code to verify/reuse the templated history.
             const imageChanged = newImagesKey !== null && newImagesKey !== this.lastImagesKey;
             const audioChanged = newAudioKey !== null && newAudioKey !== this.lastAudioKey;
             const isFirstTurn = this.turnCount === 0;
@@ -466,14 +539,15 @@ export class ChatSession {
             if (isFirstTurn || imageChanged || audioChanged || replayRequired) {
                 return await this.runStartPath(userMessage, opts.images, opts.audio, imageChanged || audioChanged || replayRequired, isFirstTurn, mergedConfig);
             }
-            // Delta continue: text-only, images/audio always null. The server
-            // cache already holds all prior turns (including any media from an
-            // earlier restart), so we only need to ship the new user string.
+            // Role-aware continuation: pass the complete structured transcript.
+            // Native code renders it with the checkpoint template and only reuses
+            // the live cache when the resulting tokens exactly extend that cache.
             const pendingUser = { role: 'user', content: userMessage };
-            const constrainedConfig = await this.constrainToContextCapacity(this.historyWithPending(pendingUser), mergedConfig);
+            const pendingHistory = this.historyWithPending(pendingUser);
+            const constrainedConfig = await this.constrainToContextCapacity(pendingHistory, mergedConfig);
             let result;
             try {
-                result = await this.model.chatSessionContinue(userMessage, null, null, constrainedConfig);
+                result = await this.model.chatSessionContinue(pendingHistory, withReplayReasoning(constrainedConfig, this.model));
             }
             catch (err) {
                 if (!isMediaHeldRestartError(err)) {
@@ -481,19 +555,20 @@ export class ChatSession {
                     throw err;
                 }
                 // The native session holds media KV (gemma4 after an image/audio
-                // turn) and refused the text delta. Transparently replay the full
+                // turn) and refused the continuation. Transparently replay the full
                 // conversation through the cold start path. The earlier media turn
                 // already lives in `this.history`, so the start path re-renders it;
                 // the trailing-media keys keep `lastImagesKey`/`lastAudioKey`
-                // consistent across the replay. The delta path has NOT pushed
+                // consistent across the replay. The continuation path has NOT pushed
                 // `userMessage` yet, so `runStartPath` pushing it adds no duplicate.
                 return await this.runStartPath(userMessage, undefined, undefined, true, false, constrainedConfig);
             }
             this.history.push(pendingUser);
-            this.history.push(buildAssistantMessage(result.text, result.toolCalls));
+            this.history.push(buildAssistantMessage(result.text, result.toolCalls, result.thinking, result.thinkingEnabled, result.rawText, this.model.replaysAssistantRawText?.() === true));
             this.turnCount++;
+            this.commitActiveTools(constrainedConfig);
             this.recordToolCallFanout(result.toolCalls);
-            return result;
+            return publicChatResult(result, constrainedConfig);
         }
         finally {
             this.inFlight = false;
@@ -535,12 +610,17 @@ export class ChatSession {
             }
             // Delta continue stream: text-only.
             const pendingUser = { role: 'user', content: userMessage };
-            const constrainedConfig = await this.constrainToContextCapacity(this.historyWithPending(pendingUser), mergedConfig);
+            const pendingHistory = this.historyWithPending(pendingUser);
+            const constrainedConfig = await this.constrainToContextCapacity(pendingHistory, mergedConfig);
             let sawFinal = false;
             let accumulated = '';
             let accumulatedVisible = '';
             let finalRaw = null;
+            let finalReplayRaw = null;
+            let finalTextAuthoritative;
             let finalToolCalls;
+            let finalThinking = null;
+            let finalThinkingEnabled = false;
             // Set when the media-held rejection re-routes this turn through the
             // cold start stream. The replay path owns the history push, turnCount
             // increment, and media-key rehydration, so the commit `finally` below
@@ -548,12 +628,16 @@ export class ChatSession {
             let delegated = false;
             try {
                 try {
-                    for await (const event of this.model.chatStreamSessionContinue(userMessage, null, null, constrainedConfig, opts.signal)) {
+                    for await (const event of this.model.chatStreamSessionContinue(pendingHistory, withReplayReasoning(constrainedConfig, this.model), opts.signal)) {
                         if (event.done) {
                             if (event.finishReason !== 'error') {
                                 sawFinal = true;
                                 finalRaw = event.text;
+                                finalReplayRaw = event.rawText;
+                                finalTextAuthoritative = event.textAuthoritative;
                                 finalToolCalls = event.toolCalls;
+                                finalThinking = event.thinking;
+                                finalThinkingEnabled = event.thinkingEnabled;
                             }
                         }
                         else {
@@ -562,7 +646,9 @@ export class ChatSession {
                                 accumulatedVisible += event.text;
                             }
                         }
-                        yield event;
+                        const publicEvent = publicStreamEvent(event, constrainedConfig);
+                        if (publicEvent !== null)
+                            yield publicEvent;
                     }
                 }
                 catch (err) {
@@ -594,8 +680,9 @@ export class ChatSession {
                 // committed (or rolled back) — so this commit must stay off.
                 if (sawFinal && !delegated) {
                     this.history.push(pendingUser);
-                    this.history.push(buildAssistantMessage(finalRaw || accumulatedVisible, finalToolCalls));
+                    this.history.push(buildAssistantMessage(selectCommittedStreamText(finalRaw, accumulatedVisible, finalTextAuthoritative), finalToolCalls, finalThinking, finalThinkingEnabled, finalReplayRaw, this.model.replaysAssistantRawText?.() === true));
                     this.turnCount++;
+                    this.commitActiveTools(constrainedConfig);
                     this.recordToolCallFanout(finalToolCalls);
                 }
                 else if (!delegated) {
@@ -611,9 +698,9 @@ export class ChatSession {
         }
     }
     /**
-     * Send a tool-result turn. Always dispatches
-     * `chatSessionContinueTool` — tool turns never change image state,
-     * so there is no restart path here.
+     * Send a tool-result turn. The declaring assistant tool call and the
+     * pending result are both included in the full history passed to
+     * `chatSessionContinueTool`.
      *
      * Rejects if the prior assistant turn emitted more than one `ok`
      * tool call: the chat-session API only supports exactly one tool
@@ -647,8 +734,14 @@ export class ChatSession {
         try {
             const { isError, config } = opts;
             const mergedConfig = this.mergeConfig(config);
-            const toolMsg = { role: 'tool', content, toolCallId, isError };
-            const constrainedConfig = await this.constrainToContextCapacity(this.historyWithPending(toolMsg), mergedConfig);
+            const toolMsg = {
+                role: 'tool',
+                content,
+                toolCallId,
+                isError,
+            };
+            const pendingHistory = this.historyWithPending(toolMsg);
+            const constrainedConfig = await this.constrainToContextCapacity(pendingHistory, mergedConfig);
             // A cold native session (turnCount===0) has no live KV to delta
             // against — the typical cause is an interrupted media-held replay
             // whose rollback wiped the cache and reset the counter while
@@ -663,12 +756,13 @@ export class ChatSession {
                 return await this.replayToolResultThroughStartPath(toolMsg, constrainedConfig);
             }
             try {
-                const result = await this.model.chatSessionContinueTool(toolCallId, content, constrainedConfig, isError ?? null);
+                const result = await this.model.chatSessionContinueTool(pendingHistory, withReplayReasoning(constrainedConfig, this.model));
                 this.history.push({ role: 'tool', content, toolCallId, isError });
-                this.history.push(buildAssistantMessage(result.text, result.toolCalls));
+                this.history.push(buildAssistantMessage(result.text, result.toolCalls, result.thinking, result.thinkingEnabled, result.rawText, this.model.replaysAssistantRawText?.() === true));
                 this.turnCount++;
+                this.commitActiveTools(constrainedConfig);
                 this.recordToolCallFanout(result.toolCalls);
-                return result;
+                return publicChatResult(result, constrainedConfig);
             }
             catch (err) {
                 if (!isMediaHeldRestartError(err)) {
@@ -725,8 +819,14 @@ export class ChatSession {
         try {
             const { isError, config, signal } = opts;
             const mergedConfig = this.mergeConfig(config);
-            const toolMsg = { role: 'tool', content, toolCallId, isError };
-            const constrainedConfig = await this.constrainToContextCapacity(this.historyWithPending(toolMsg), mergedConfig);
+            const toolMsg = {
+                role: 'tool',
+                content,
+                toolCallId,
+                isError,
+            };
+            const pendingHistory = this.historyWithPending(toolMsg);
+            const constrainedConfig = await this.constrainToContextCapacity(pendingHistory, mergedConfig);
             // A cold native session (turnCount===0) has no live KV to delta
             // against — typically the residue of an interrupted media-held
             // replay whose rollback wiped the cache and reset the counter
@@ -745,7 +845,11 @@ export class ChatSession {
             let accumulated = '';
             let accumulatedVisible = '';
             let finalRaw = null;
+            let finalReplayRaw = null;
+            let finalTextAuthoritative;
             let finalToolCalls;
+            let finalThinking = null;
+            let finalThinkingEnabled = false;
             // Set when the media-held rejection re-routes this tool turn
             // through the cold start stream. The replay path owns the history
             // push, turnCount increment, and media-key rehydration, so the
@@ -753,12 +857,16 @@ export class ChatSession {
             let delegated = false;
             try {
                 try {
-                    for await (const event of this.model.chatStreamSessionContinueTool(toolCallId, content, constrainedConfig, signal, isError ?? null)) {
+                    for await (const event of this.model.chatStreamSessionContinueTool(pendingHistory, withReplayReasoning(constrainedConfig, this.model), signal)) {
                         if (event.done) {
                             if (event.finishReason !== 'error') {
                                 sawFinal = true;
                                 finalRaw = event.text;
+                                finalReplayRaw = event.rawText;
+                                finalTextAuthoritative = event.textAuthoritative;
                                 finalToolCalls = event.toolCalls;
+                                finalThinking = event.thinking;
+                                finalThinkingEnabled = event.thinkingEnabled;
                             }
                         }
                         else {
@@ -767,7 +875,9 @@ export class ChatSession {
                                 accumulatedVisible += event.text;
                             }
                         }
-                        yield event;
+                        const publicEvent = publicStreamEvent(event, constrainedConfig);
+                        if (publicEvent !== null)
+                            yield publicEvent;
                     }
                 }
                 catch (err) {
@@ -799,8 +909,9 @@ export class ChatSession {
                 // off.
                 if (sawFinal && !delegated) {
                     this.history.push({ role: 'tool', content, toolCallId, isError });
-                    this.history.push(buildAssistantMessage(finalRaw || accumulatedVisible, finalToolCalls));
+                    this.history.push(buildAssistantMessage(selectCommittedStreamText(finalRaw, accumulatedVisible, finalTextAuthoritative), finalToolCalls, finalThinking, finalThinkingEnabled, finalReplayRaw, this.model.replaysAssistantRawText?.() === true));
                     this.turnCount++;
+                    this.commitActiveTools(constrainedConfig);
                     this.recordToolCallFanout(finalToolCalls);
                 }
                 else if (!delegated) {
@@ -862,6 +973,7 @@ export class ChatSession {
         this.turnCount = 0;
         this.unresolvedOkToolCallCount = null;
         this.needsFullReplay = false;
+        this.activeTools = this.defaultConfig.tools;
     }
     /**
      * Prime the session history without running inference.
@@ -929,14 +1041,15 @@ export class ChatSession {
             const mergedConfig = this.mergeConfig(config);
             const historySnapshot = this.history.slice();
             const constrainedConfig = await this.constrainToContextCapacity(historySnapshot, mergedConfig);
-            const result = await this.model.chatSessionStart(historySnapshot, constrainedConfig);
-            this.history.push(buildAssistantMessage(result.text, result.toolCalls));
+            const result = await this.model.chatSessionStart(historySnapshot, withReplayReasoning(constrainedConfig, this.model));
+            this.history.push(buildAssistantMessage(result.text, result.toolCalls, result.thinking, result.thinkingEnabled, result.rawText, this.model.replaysAssistantRawText?.() === true));
             this.turnCount++;
             this.needsFullReplay = false;
             this.lastImagesKey = this.computeTrailingImagesKey();
             this.lastAudioKey = this.computeTrailingAudioKey();
+            this.commitActiveTools(constrainedConfig);
             this.recordToolCallFanout(result.toolCalls);
-            return result;
+            return publicChatResult(result, constrainedConfig);
         }
         finally {
             this.inFlight = false;
@@ -971,14 +1084,22 @@ export class ChatSession {
             let accumulated = '';
             let accumulatedVisible = '';
             let finalRaw = null;
+            let finalReplayRaw = null;
+            let finalTextAuthoritative;
             let finalToolCalls;
+            let finalThinking = null;
+            let finalThinkingEnabled = false;
             try {
-                for await (const event of this.model.chatStreamSessionStart(historySnapshot, constrainedConfig, signal)) {
+                for await (const event of this.model.chatStreamSessionStart(historySnapshot, withReplayReasoning(constrainedConfig, this.model), signal)) {
                     if (event.done) {
                         if (event.finishReason !== 'error') {
                             sawFinal = true;
                             finalRaw = event.text;
+                            finalReplayRaw = event.rawText;
+                            finalTextAuthoritative = event.textAuthoritative;
                             finalToolCalls = event.toolCalls;
+                            finalThinking = event.thinking;
+                            finalThinkingEnabled = event.thinkingEnabled;
                         }
                     }
                     else {
@@ -987,7 +1108,9 @@ export class ChatSession {
                             accumulatedVisible += event.text;
                         }
                     }
-                    yield event;
+                    const publicEvent = publicStreamEvent(event, constrainedConfig);
+                    if (publicEvent !== null)
+                        yield publicEvent;
                 }
             }
             finally {
@@ -997,11 +1120,12 @@ export class ChatSession {
                 // mutated on a successful commit — on any non-success exit,
                 // the primed state is left intact so the caller can retry.
                 if (sawFinal) {
-                    this.history.push(buildAssistantMessage(finalRaw || accumulatedVisible, finalToolCalls));
+                    this.history.push(buildAssistantMessage(selectCommittedStreamText(finalRaw, accumulatedVisible, finalTextAuthoritative), finalToolCalls, finalThinking, finalThinkingEnabled, finalReplayRaw, this.model.replaysAssistantRawText?.() === true));
                     this.turnCount++;
                     this.needsFullReplay = false;
                     this.lastImagesKey = this.computeTrailingImagesKey();
                     this.lastAudioKey = this.computeTrailingAudioKey();
+                    this.commitActiveTools(constrainedConfig);
                     this.recordToolCallFanout(finalToolCalls);
                 }
             }
@@ -1102,12 +1226,25 @@ export class ChatSession {
         const n = countOkToolCalls(toolCalls);
         this.unresolvedOkToolCallCount = n > 0 ? n : null;
     }
+    /**
+     * Persist the effective tools only when their turn commits successfully.
+     * Preflights and failed/abandoned turns intentionally never call this.
+     */
+    commitActiveTools(config) {
+        if (config.tools !== undefined) {
+            this.activeTools = config.tools;
+        }
+    }
     /**
      * Merge default + per-call config and force `reuseCache: true`.
      * The session path is a session-reuse operation by construction —
      * `reuseCache: false` on the continue path would wipe the very
      * cache the delta depends on.
      *
+     * Tool resolution here is side-effect free because public capacity
+     * preflights use this same merge path. Successful turn commit sites call
+     * {@link commitActiveTools} after native inference finishes.
+     *
      * MTP auto-default: if neither `defaultConfig` nor `overlay`
      * sets `enableMtp` AND the underlying model exposes
      * `hasMtpWeights()` returning `true`, set `enableMtp = true` so the
@@ -1124,6 +1261,14 @@ export class ChatSession {
             ...overlay,
             reuseCache: true,
         };
+        // Tools are part of the committed conversation state. Constructor
+        // defaults seed that state, but must not overwrite a tool set committed by
+        // a later successful turn. A current-call overlay is the only higher
+        // precedence source; it remains provisional until a success site calls
+        // commitActiveTools().
+        if (overlay?.tools === undefined && this.activeTools !== undefined) {
+            merged.tools = this.activeTools;
+        }
         if (merged.enableMtp === undefined &&
             typeof this.model.hasMtpWeights === 'function' &&
             this.model.hasMtpWeights()) {
@@ -1223,8 +1368,8 @@ export class ChatSession {
             // (e.g. the assistant reply below) don't retroactively mutate
             // what the native side / any mock observed as its `messages`
             // argument.
-            const result = await this.model.chatSessionStart(this.history.slice(), constrainedConfig);
-            this.history.push(buildAssistantMessage(result.text, result.toolCalls));
+            const result = await this.model.chatSessionStart(this.history.slice(), withReplayReasoning(constrainedConfig, this.model));
+            this.history.push(buildAssistantMessage(result.text, result.toolCalls, result.thinking, result.thinkingEnabled, result.rawText, this.model.replaysAssistantRawText?.() === true));
             this.turnCount++;
             this.needsFullReplay = false;
             // The start path always re-renders the FULL preserved history, so the
@@ -1236,8 +1381,9 @@ export class ChatSession {
             // turn to be mis-detected as a change and replayed twice.
             this.lastImagesKey = this.computeTrailingImagesKey();
             this.lastAudioKey = this.computeTrailingAudioKey();
+            this.commitActiveTools(constrainedConfig);
             this.recordToolCallFanout(result.toolCalls);
-            return result;
+            return publicChatResult(result, constrainedConfig);
         }
         catch (err) {
             // Roll back: drop the tentative user push so history stays
@@ -1282,17 +1428,25 @@ export class ChatSession {
         let accumulated = '';
         let accumulatedVisible = '';
         let finalRaw = null;
+        let finalReplayRaw = null;
+        let finalTextAuthoritative;
         let finalToolCalls;
+        let finalThinking = null;
+        let finalThinkingEnabled = false;
         // Snapshot the history before dispatch — see `runStartPath` for
         // the rationale.
         const historySnapshot = this.history.slice();
         try {
-            for await (const event of this.model.chatStreamSessionStart(historySnapshot, constrainedConfig, signal)) {
+            for await (const event of this.model.chatStreamSessionStart(historySnapshot, withReplayReasoning(constrainedConfig, this.model), signal)) {
                 if (event.done) {
                     if (event.finishReason !== 'error') {
                         sawFinal = true;
                         finalRaw = event.text;
+                        finalReplayRaw = event.rawText;
+                        finalTextAuthoritative = event.textAuthoritative;
                         finalToolCalls = event.toolCalls;
+                        finalThinking = event.thinking;
+                        finalThinkingEnabled = event.thinkingEnabled;
                     }
                 }
                 else {
@@ -1301,7 +1455,9 @@ export class ChatSession {
                         accumulatedVisible += event.text;
                     }
                 }
-                yield event;
+                const publicEvent = publicStreamEvent(event, constrainedConfig);
+                if (publicEvent !== null)
+                    yield publicEvent;
             }
         }
         finally {
@@ -1314,7 +1470,7 @@ export class ChatSession {
             // generator was wound down. Mid-stream throws still propagate
             // naturally — finally runs first, then the error continues up.
             if (sawFinal) {
-                this.history.push(buildAssistantMessage(finalRaw || accumulatedVisible, finalToolCalls));
+                this.history.push(buildAssistantMessage(selectCommittedStreamText(finalRaw, accumulatedVisible, finalTextAuthoritative), finalToolCalls, finalThinking, finalThinkingEnabled, finalReplayRaw, this.model.replaysAssistantRawText?.() === true));
                 this.turnCount++;
                 this.needsFullReplay = false;
                 // The start path always re-renders the FULL preserved history, so the
@@ -1326,6 +1482,7 @@ export class ChatSession {
                 // turn to be mis-detected as a change and replayed twice.
                 this.lastImagesKey = this.computeTrailingImagesKey();
                 this.lastAudioKey = this.computeTrailingAudioKey();
+                this.commitActiveTools(constrainedConfig);
                 this.recordToolCallFanout(finalToolCalls);
             }
             else {