@mlx-node/lm 0.0.7 → 0.0.8

package/README.md

@@ -153,10 +153,10 @@ Or set `MLX_PROFILE_DECODE=1` to auto-enable and write a report on exit.
 | `loadModel()`    | Auto-detect and load any supported model from disk                                |
 | `loadSession()`  | `loadModel()` + `new ChatSession(model)` in one step                              |
 | `ChatSession<M>` | Multi-turn chat wrapper — `send()`, `sendStream()`, `sendToolResult()`, `reset()` |
-| `Qwen3Model`     | Qwen3 inference — `generate()`, paged attention, speculative decoding             |
-| `Qwen35Model`    | Qwen3.5 Dense — `generate()` with compiled C++ forward                            |
-| `Qwen35MoeModel` | Qwen3.5 MoE — `generate()` with compiled C++ forward and expert routing           |
-| `Gemma4Model`    | Gemma4 inference — `generate()`                                                   |
+| `Qwen3Model`     | Qwen3 inference — `generate()` and paged attention                                |
+| `Qwen35Model`    | Qwen3.5 Dense — compiled forward, VLM, paged attention, native MTP                |
+| `Qwen35MoeModel` | Qwen3.5 MoE — compiled forward, expert routing, paged attention, native MTP       |
+| `Gemma4Model`    | Gemma4 inference — multimodal generation and optional external-draft speculation  |
 | `Lfm2Model`      | LFM2.5 hybrid conv+attention inference — `generate()`                             |
 
 ### Streaming Types
@@ -218,13 +218,13 @@ function createToolDefinition(
 
 Every generative model wrapper exposes the same `ChatSession<M>` surface — `send()`, `sendStream()`, and `sendToolResult()` all work against any of the models below.
 
-| Model         | `generate()` | `ChatSession` | Training | Notes                                 |
-| ------------- | :----------: | :-----------: | :------: | ------------------------------------- |
-| Qwen3         |     Yes      |      Yes      | GRPO/SFT | Paged attention, speculative decoding |
-| Qwen3.5 Dense |     Yes      |      Yes      | GRPO/SFT | Compiled C++ forward, VLM variant     |
-| Qwen3.5 MoE   |     Yes      |      Yes      | GRPO/SFT | Compiled C++ forward, expert routing  |
-| Gemma4        |     Yes      |      Yes      |    No    | Streaming chat via session            |
-| LFM2.5        |     Yes      |      Yes      |    No    | Hybrid conv + attention architecture  |
+| Model         | `generate()` | `ChatSession` | Training | Notes                                |
+| ------------- | :----------: | :-----------: | :------: | ------------------------------------ |
+| Qwen3         |     Yes      |      Yes      | GRPO/SFT | Paged attention                      |
+| Qwen3.5 Dense |     Yes      |      Yes      | GRPO/SFT | Compiled forward, VLM, native MTP    |
+| Qwen3.5 MoE   |     Yes      |      Yes      | GRPO/SFT | Expert routing, paged cache, MTP     |
+| Gemma4        |     Yes      |      Yes      |    No    | Multimodal, optional external draft  |
+| LFM2.5        |     Yes      |      Yes      |    No    | Hybrid conv + attention architecture |
 
 ## Performance
 

package/dist/chat-session.d.ts

@@ -1,90 +1,28 @@
+import type { ChatConfig, ChatMessage, ChatResult, ToolDefinition } from '@mlx-node/core';
+import type { ChatStreamEvent } from './stream.js';
 /**
- * Generic server-side chat session wrapper.
- *
- * `ChatSession<M>` is the cross-model chat-session wrapper. It works
- * against any model that exposes the uniform chat-session NAPI
- * surface — `chatSessionStart`,
- * `chatSessionContinue`, `chatSessionContinueTool`, and their
- * streaming variants plus `resetCaches`. See `SessionCapableModel`
- * below.
- *
- * 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.
- *
- *   - An image hash (`lastImagesKey`) tracks the images bound to the
- *     current cache. A `send()` call whose image set has changed
- *     (different bytes or different ordering) triggers a full
- *     restart: `resetCaches()` → push the new user message (with
- *     images) to history → `chatSessionStart(history)`.
- *
- *   - Text-only `send()` on turn >= 1 takes the cheap delta path.
- *
- *   - `sendToolResult` always dispatches `chatSessionContinueTool`,
- *     since tool turns never change image state. The session enforces
- *     a strict unresolved-ok-tool-call contract at runtime, driven by
- *     `unresolvedOkToolCallCount` (derived from `ChatResult.toolCalls`
- *     after each turn via `countOkToolCalls` /
- *     `computeTrailingAssistantUnresolvedToolCallCount`):
- *
- *       * `null` — the trailing assistant turn has no outstanding ok
- *         tool call. Plain `send()` / `sendStream()` are the only
- *         valid entry points; `sendToolResult*()` throws because
- *         there is nothing for the result to resolve.
- *       * `1` — exactly one outstanding ok tool call. Plain `send()` /
- *         `sendStream()` throw (they would orphan the call);
- *         `sendToolResult*()` is the sole valid forward step and
- *         dispatches the tool result through the native session.
- *       * `>1` — a multi-tool-call fan-out that the chat-session API
- *         cannot progress incrementally (each `sendToolResult*` would
- *         re-open the assistant turn and weave new replies between
- *         the sibling results). Both `send()` / `sendStream()` and
- *         `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.
- *
- *   - `sawFinal` gates `turnCount` advance on the streaming path, so
- *     the session refuses to advance when the stream throws
- *     mid-decode or yields a final chunk with
- *     `finishReason: 'error'`.
- *
- *   - The `inFlight` guard rejects concurrent `send()` /
- *     `sendStream()` calls at the class level. The native side
- *     serializes cache mutation on a single worker thread, so a
- *     second in-flight call would race the first's cache-save step.
- *
- *   - **Cold-restart primitives.** `primeHistory()` plus
- *     `startFromHistory()` / `startFromHistoryStream()` let a caller
- *     seed a fresh session with an externally-reconstructed history
- *     (e.g. a server `ResponseStore` chain) and replay it through the
- *     native `chatSessionStart` path without going through `send()`.
- *     These are intended for server-side `SessionRegistry` cache-miss
- *     cold-start; normal usage stays on `send` / `sendStream` /
- *     `sendToolResult` / `reset`.
- *
- * ## Typical usage
- *
- * ```typescript
- * import { Qwen35Model, ChatSession } from '@mlx-node/lm';
- *
- * const model = await Qwen35Model.load('./models/qwen3.5-0.8b');
- * const session = new ChatSession(model, { system: 'Be concise.' });
- * const r1 = await session.send('Say hi in one word.');
- * const r2 = await session.send('Another word?');
- * await session.reset();
- * ```
+ * Stable, provider-neutral error raised before native inference when a
+ * rendered prompt cannot fit in the model's physically available hot KV
+ * window. The marker is intentionally the canonical string recognized by
+ * pi's overflow recovery, so managed agent sessions compact and retry while
+ * stateless HTTP callers receive a clean request error instead of a native
+ * `BlockAllocator exhausted` failure.
  */
-import type { ChatConfig, ChatMessage, ChatResult } from '@mlx-node/core';
-import type { ChatStreamEvent } from './stream.js';
+export declare class ContextCapacityError extends Error {
+    readonly promptTokens: number;
+    readonly effectiveWindowTokens: number;
+    readonly code = "context_length_exceeded";
+    constructor(promptTokens: number, effectiveWindowTokens: number);
+}
+/** Recognize both the typed JS preflight and the native hard backstop. */
+export declare function isContextCapacityError(error: unknown): boolean;
+/** Physical and trained context limits captured by a native model at load. */
+export interface SessionContextLimits {
+    trainedWindowTokens: number;
+    effectiveWindowTokens: number;
+    pagedBlockCapacity: number;
+    pagedBlockSize: number;
+}
 /**
  * Structural interface matched by every generative model wrapper
  * (`Qwen35Model`, `Qwen35MoeModel`, `Lfm2Model`, `Gemma4Model`,
@@ -95,9 +33,38 @@ import type { ChatStreamEvent } from './stream.js';
  * fully structural.
  */
 export interface SessionCapableModel {
+    /**
+     * Optional non-generating chat-template tokenizer. Exposed by
+     * wrappers that can count prompt tokens without running inference
+     * (used by Anthropic `/v1/messages/count_tokens`).
+     */
+    applyChatTemplate?(messages: ChatMessage[], addGenerationPrompt?: boolean | null, tools?: ToolDefinition[] | null, enableThinking?: boolean | null): Promise<Uint32Array> | Uint32Array;
+    /**
+     * Optional model-native planner for prompt formats whose media placeholders
+     * expand after chat-template rendering. It returns the exact token length
+     * that inference will prefill, without mutating model/session state.
+     *
+     * Qwen3.5 dense/MoE implement this with their loaded image processor. Models
+     * without post-template expansion omit it and retain raw template counting.
+     */
+    expandedPromptTokenCount?(promptTokens: Uint32Array, messages: ChatMessage[]): Promise<number> | number;
+    /**
+     * Optional synchronous load-time snapshot of the model's usable context.
+     * Qwen3.5 dense/MoE expose this when adaptive paged-cache sizing is active.
+     */
+    contextLimits?(): SessionContextLimits;
+    /**
+     * Whether this loaded model instance has a complete image-input path.
+     *
+     * Optional so text-only and older wrappers continue to satisfy the
+     * structural contract. Supporting native wrappers snapshot this value after
+     * load, once the vision encoder/processor and any required cache backend are
+     * known to be available.
+     */
+    supportsImages?(): boolean;
     chatSessionStart(messages: ChatMessage[], config?: ChatConfig | null): Promise<ChatResult>;
-    chatSessionContinue(userMessage: string, images: Uint8Array[] | null, config?: ChatConfig | null): Promise<ChatResult>;
-    chatSessionContinueTool(toolCallId: string, content: string, config?: ChatConfig | null): Promise<ChatResult>;
+    chatSessionContinue(userMessage: string, images: Uint8Array[] | null, audio: Uint8Array[] | null, config?: ChatConfig | null): Promise<ChatResult>;
+    chatSessionContinueTool(toolCallId: string, content: string, config?: ChatConfig | null, isError?: boolean | null): Promise<ChatResult>;
     /**
      * The optional `signal` parameter on every streaming entry point is
      * plumbed into the `_runChatStream` fast-abort path in the wrapper
@@ -108,9 +75,128 @@ export interface SessionCapableModel {
      * callers (the common direct-use path) just omit it.
      */
     chatStreamSessionStart(messages: ChatMessage[], config?: ChatConfig | null, signal?: AbortSignal): AsyncGenerator<ChatStreamEvent>;
-    chatStreamSessionContinue(userMessage: string, images: Uint8Array[] | null, config?: ChatConfig | null, signal?: AbortSignal): AsyncGenerator<ChatStreamEvent>;
-    chatStreamSessionContinueTool(toolCallId: string, content: string, config?: ChatConfig | null, signal?: AbortSignal): AsyncGenerator<ChatStreamEvent>;
+    chatStreamSessionContinue(userMessage: string, images: Uint8Array[] | null, audio: Uint8Array[] | null, config?: ChatConfig | null, signal?: AbortSignal): AsyncGenerator<ChatStreamEvent>;
+    chatStreamSessionContinueTool(toolCallId: string, content: string, config?: ChatConfig | null, signal?: AbortSignal, isError?: boolean | null): AsyncGenerator<ChatStreamEvent>;
     resetCaches(): void;
+    /**
+     * Whether the underlying native model has the block-paged KV cache
+     * adapter (`PagedKVCacheAdapter` + `BlockAllocator` + `LayerKVPool`)
+     * active.
+     *
+     * `true` iff the adapter was successfully constructed at load time
+     * (driven by the per-model `use_block_paged_cache` config flag, which
+     * defaults to ON for Qwen3 + LFM2 after parity verification and OFF
+     * for Gemma4 + Qwen3.5 + Qwen3.5 MoE pending parity validation; also
+     * always `false` on Qwen3.5 VLM checkpoints where
+     * `set_vision_encoder` rejects when the adapter is populated).
+     *
+     * When `true`, the native cache reuses SYS blocks across requests via
+     * content-addressing in the `BlockAllocator`'s prefix-hash table —
+     * the JS-side warm slot in
+     * `SessionRegistry.getOrCreateWarmAny(requestedSystem)` becomes
+     * redundant for stateless `/v1/messages` traffic. The server
+     * endpoint reads this getter to decide whether to allocate a fresh
+     * `ChatSession` per request (paged-active) or to lease the warm slot
+     * (non-paged); see `packages/server/src/endpoints/messages.ts`.
+     *
+     * Optional on the structural interface so models that pre-date the
+     * NAPI getter (notably `QianfanOCRModel` from `@mlx-node/vlm`, which
+     * has no paged-adapter wiring) still satisfy the type contract — a
+     * missing getter is treated as `false` (not paged) by callers.
+     * Surfaced as a synchronous method on every native wrapper that DOES
+     * support paged so the routing decision in the server doesn't need a
+     * model-thread roundtrip per request — the value is captured at load
+     * time and never changes for a given model instance.
+     */
+    hasBlockPagedCache?(): boolean;
+    /**
+     * MTP: whether the underlying native model can run speculative
+     * decoding. Surfaced by `Qwen3_5Model` / `Qwen3_5MoeModel` (an MTP
+     * head shipped in the checkpoint and loaded by persistence) and by
+     * `Gemma4Model` (an external draft model — DSpark or Google gemma-4
+     * assistant, auto-detected from the draft's config.json — attached
+     * via `loadModel` / `loadSession` `draftModelPath`; NOT in-checkpoint
+     * MTP heads); all other native wrappers omit the method, in
+     * which case callers treat a missing getter as `false` (no MTP).
+     *
+     * When `true`, {@link ChatSession#mergeConfig} auto-defaults the
+     * per-request `enableMtp` flag to `true` — the speculative-decode
+     * path takes over unless the caller explicitly opts out by passing
+     * `enableMtp: false` in their `ChatConfig` overlay. When `false`
+     * (or the method is missing), `enableMtp` is left untouched.
+     *
+     * Synchronous on every supporting wrapper so the auto-default check
+     * doesn't need a model-thread roundtrip per call — the value is
+     * captured at load time and never changes for a given model
+     * instance.
+     *
+     * ## Companion `ChatConfig` knobs (only meaningful when `enableMtp` is on)
+     *
+     * Two related `ChatConfig` fields tune the speculative-decode loop.
+     * They are forwarded verbatim to the native side via
+     * {@link SendOptions.config} (per-call overlay) or
+     * {@link ChatSessionOptions.defaultConfig} (session default), and
+     * `mergeConfig` shallow-merges per-call over per-session so an
+     * explicit per-send value always wins over the session default for
+     * the same field.
+     *
+     * - **`mtpDepth`** — pins the MTP draft depth per speculative cycle.
+     *   On Qwen3.5 native MTP heads it is clamped to `[1, 5]` by the
+     *   verify FFI contract, and when unset native code currently pins
+     *   depth 1. Setting `mtpDepth` explicitly pins that value unless
+     *   the caller also passes `mtpAdaptiveDepth: true` to opt into
+     *   adaptive depth with the supplied maximum/seed. Gemma4 external
+     *   drafts resolve the field per draft variant instead — see the
+     *   Gemma4 section below.
+     * - **`mtpAdaptiveDepth`** — toggles the adaptive depth policy.
+     *   Defaults to OFF for native MTP and assistants (Gemma4 DSpark has the
+     *   family override documented below). When ON, the native-MTP default
+     *   mode runs a 5-state machine
+     *   (`Explore` → `Full` → {`NeighborProbe` | `Reduced` → `Probe`})
+     *   with per-depth EMA tracking of
+     *   `accepted_tokens / cycle_wall_ns` and picks the depth that
+     *   maximizes that rate (DFlash-style, EMA decay α=0.3, drop-back
+     *   threshold 0.75). `MLX_MTP_ADAPTIVE_DEPTH_MODE=expected-value`
+     *   instead uses the MTPLX-style intra-cycle expected-value gate; by
+     *   default it stops at its base depth, with deeper expansion kept
+     *   research-only behind `MLX_MTP_EV_ALLOW_DEEPEN=1`.
+     *   An explicit `false` always wins, pinning the chosen `mtpDepth` for
+     *   every cycle. When `enableMtp` is false (or the model has no MTP
+     *   head) the field is ignored.
+     *
+     * The defaults for both `mtpDepth` and `mtpAdaptiveDepth` are
+     * applied on the native side (see
+     * `crates/mlx-core/src/models/qwen3_5/chat_common.rs` MTP runtime
+     * flag inventory), so omitting them from `defaultConfig` /
+     * `SendOptions.config` is the recommended path for callers that
+     * just want speculative decoding "on with sensible defaults".
+     *
+     * ## Gemma4 external drafts (`draftModelPath`)
+     *
+     * Gemma4 reinterprets the knobs per draft variant (resolved in
+     * `gemma4/model.rs` `resolve_params`, always from the RAW config
+     * value — the engine's central `[1, 5]` clamp is an MTP-head
+     * contract that does not apply to external drafts):
+     *
+     * - **DSpark**: with both knobs unset, full draft blocks (the
+     *   checkpoint's block size — 7 tokens on
+     *   `dspark_gemma4_12b_block7`) run behind a short per-turn measurement
+     *   against target-only AR. If DSpark loses on the current host/context,
+     *   that turn permanently falls back to exact target-only decoding. An
+     *   insufficiently long generation budget preserves the fixed-block path.
+     *   An explicit `mtpDepth` acts as a CAP on the block (clamped to
+     *   `[1, blockSize]`) and pins it unless `mtpAdaptiveDepth: true` opts the
+     *   guard back in. Explicit `mtpAdaptiveDepth: false` disables the guard.
+     * - **Assistant** (Google `gemma-4-*-it-assistant`): chained AR
+     *   drafting has no checkpoint-pinned block size — an unset
+     *   `mtpDepth` drafts 3 tokens per cycle (`ASSISTANT_DEFAULT_DEPTH`,
+     *   a quality/latency tradeoff, not a checkpoint contract), and an
+     *   explicit `mtpDepth` clamps to `[1, 8]` (`ASSISTANT_MAX_DEPTH`).
+     *
+     * `mtpAdaptiveDepth` remains ignored for the assistant variant. Qwen3.5
+     * native-MTP semantics above are unchanged.
+     */
+    hasMtpWeights?(): boolean;
 }
 /** Per-call options for {@link ChatSession#send} / `sendStream`. */
 export interface SendOptions {
@@ -120,10 +206,22 @@ export interface SendOptions {
      * session forcibly restarts via `chatSessionStart`.
      */
     images?: Uint8Array[];
+    /**
+     * Optional audio bytes (encoded WAV) attached to this user turn. When
+     * the audio set differs from the session's current `lastAudioKey`, the
+     * session forcibly restarts via `chatSessionStart` (mirrors `images`).
+     * Only the unified Gemma 4 audio checkpoint consumes this.
+     */
+    audio?: Uint8Array[];
     /**
      * Per-call `ChatConfig` overlay applied on top of the session's
      * `defaultConfig`. `reuseCache` is always forced on regardless of
-     * what the caller passes.
+     * what the caller passes. The overlay is shallow-merged on top of
+     * the session default, so per-call values always win over per-session
+     * values for the same field — including the speculative-decode
+     * knobs `enableMtp`, `mtpDepth`, and `mtpAdaptiveDepth`. See
+     * {@link SessionCapableModel.hasMtpWeights} for the full MTP knob
+     * surface and default-resolution rules.
      */
     config?: ChatConfig;
     /**
@@ -155,7 +253,12 @@ export interface ChatSessionOptions {
     /**
      * Default `ChatConfig` applied to every `send()` / `sendStream()`
      * / `sendToolResult()` call. Per-call config is shallow-merged on
-     * top of this, and `reuseCache` is forced on.
+     * top of this, and `reuseCache` is forced on. Speculative-decode
+     * knobs (`enableMtp`, `mtpDepth`, `mtpAdaptiveDepth`) can be parked
+     * here as session-wide defaults and overridden per call via
+     * {@link SendOptions.config}; see
+     * {@link SessionCapableModel.hasMtpWeights} for the MTP knob surface
+     * and default-resolution rules.
      */
     defaultConfig?: ChatConfig;
 }
@@ -180,13 +283,22 @@ export declare class ChatSession<M extends SessionCapableModel = SessionCapableM
     private history;
     /**
      * Hex-encoded byte-identity key of the image set currently bound
-     * to the server's KV cache (FNV-1a 64-bit; see `computeImagesKey`).
+     * to the server's KV cache (SHA-256; see `computeImagesKey`).
      * `null` when no images are cached. A `send()` whose new key
      * differs triggers a full `chatSessionStart` restart.
      */
     private lastImagesKey;
+    /**
+     * Hex-encoded byte-identity key of the audio set currently bound to the
+     * server's KV cache (see {@link computeAudioKey}). `null` when no audio is
+     * cached. A `send()` whose new key differs triggers a full
+     * `chatSessionStart` restart — the audio counterpart of `lastImagesKey`.
+     */
+    private lastAudioKey;
     private turnCount;
     private inFlight;
+    /** A failed/abandoned native delta must be followed by a full replay. */
+    private needsFullReplay;
     /**
      * Count of `ok` tool calls emitted by the prior assistant turn, or
      * `null` when the prior turn produced none. Gates every continuation
@@ -216,6 +328,32 @@ export declare class ChatSession<M extends SessionCapableModel = SessionCapableM
     get turns(): number;
     /** Whether the session currently has images bound to its cache. */
     get hasImages(): boolean;
+    /** Load-time physical context snapshot, when exposed by the model. */
+    contextLimits(): SessionContextLimits | undefined;
+    /** Authoritative image-input capability of the loaded native model. */
+    supportsImages(): boolean;
+    /**
+     * Render and validate a complete message list against the model's physical
+     * context window without starting inference or mutating session/native cache
+     * state.
+     *
+     * HTTP streaming callers use this before committing SSE headers so an
+     * oversized prompt can still receive a protocol-shaped 400 response without
+     * delaying those headers until image processing, prefill, or the first
+     * generated token. The returned config carries the same output-budget clamp
+     * applied by the send entry points; those entry points intentionally repeat
+     * the check against their own authoritative history before native dispatch.
+     */
+    preflightContextCapacity(messages: readonly ChatMessage[], config?: ChatConfig): Promise<ChatConfig>;
+    /**
+     * Capacity-preflight one pending user/tool message against this session's
+     * preserved history without starting inference or mutating cache state.
+     *
+     * This is the exact counterpart of the delta `send*` paths. It matters for
+     * server-side prompt-cache hits where the HTTP request contains only the new
+     * message while the leased ChatSession owns the earlier conversation.
+     */
+    preflightPendingContextCapacity(pending: ChatMessage, config?: ChatConfig): Promise<ChatConfig>;
     /**
      * Count of `ok` tool calls from the most recent assistant turn, or
      * `null` when the trailing turn produced none. Non-null means the
@@ -268,16 +406,61 @@ export declare class ChatSession<M extends SessionCapableModel = SessionCapableM
      * hit this must tighten the prompt / tool spec or reset the
      * session.
      *
+     * `isError` is the structured tool-error signal. When `true`, the
+     * native renderer prepends a short, model-facing error marker to
+     * `content` inside the wire-format tool block so the model
+     * receives a clear text-level cue that the tool result represents
+     * a failure. The structured field is stored verbatim on the
+     * appended `{ role: 'tool', ... }` history entry so cold-replay
+     * (image-change restart, `startFromHistory*`, server-side
+     * `SessionRegistry` cache-miss rebuild) re-renders the marker
+     * consistently with the live turn. Defaults to `undefined` (no
+     * marker). Pass through verbatim — we do NOT infer error from
+     * `content`.
+     *
      * Appends a `{ role: 'tool', ... }` message to history on success.
      */
     sendToolResult(toolCallId: string, content: string, opts?: {
+        isError?: boolean;
         config?: ChatConfig;
     }): Promise<ChatResult>;
-    /** Streaming variant of {@link ChatSession#sendToolResult}. */
+    /**
+     * Cold-replay a tool result through the start path: re-render the
+     * full preserved history (including the prior media turn and the
+     * unresolved tool-call assistant turn) plus this tool message. Used
+     * when the native session is cold (turnCount===0 — e.g. after an
+     * interrupted media-held replay rolled the cache back) and by the
+     * media-held rejection catch. `mediaChanged=true` forces a
+     * resetCaches so the prefill always starts from a guaranteed-clean
+     * cache; `isFirstTurn=false` because a tool result always follows a
+     * prior tool-call turn.
+     */
+    private replayToolResultThroughStartPath;
+    /**
+     * Streaming variant of {@link ChatSession#sendToolResult}.
+     *
+     * `isError` mirrors the non-streaming entry point — when `true`,
+     * the native renderer prepends a short, model-facing error marker
+     * to `content` inside the wire-format tool block. The structured
+     * field is stored verbatim on the appended `{ role: 'tool', ... }`
+     * history entry so cold-replay re-renders the marker consistently
+     * with the live streaming turn.
+     */
     sendToolResultStream(toolCallId: string, content: string, opts?: {
+        isError?: boolean;
         config?: ChatConfig;
         signal?: AbortSignal;
     }): AsyncGenerator<ChatStreamEvent>;
+    /**
+     * Streaming counterpart of {@link replayToolResultThroughStartPath}:
+     * cold-replay a tool result through the start stream. Used by the
+     * turn-0 precheck and the media-held rejection catch in
+     * {@link sendToolResultStream}. The start stream owns the history
+     * push, turnCount increment, and media-key rehydration; callers keep
+     * `delegated`/early-return semantics so the commit `finally` stays
+     * off.
+     */
+    private replayToolResultThroughStartStreamPath;
     /**
      * Reset the session state.
      *
@@ -285,6 +468,23 @@ export declare class ChatSession<M extends SessionCapableModel = SessionCapableM
      * image key, and turn counter so the next `send()` goes through
      * `chatSessionStart` again.
      *
+     * This is a full wipe — safe default for public callers. It always
+     * calls `model.resetCaches()`, which is the ONLY behavior exposed
+     * on the public API because the underlying `SessionCapableModel`
+     * is shared across every `ChatSession` lifetime via the native
+     * `ModelRegistry`: a partial wipe that leaves the shared native
+     * KV cache intact would leak a previous (unrelated) request's
+     * cached prefix into the next `chat_session_start_sync` call. The
+     * server-side warm-lease replay path (where preserving the native
+     * cache is correct) uses its own server-private helper gated by
+     * the `SessionRegistry` HIT signal — the only authoritative proof
+     * that the native cache genuinely belongs to this chain. That
+     * helper lives inside `@mlx-node/server`, never touches the
+     * `@mlx-node/lm` export map, and is not reachable from downstream
+     * consumers. Public consumers of `@mlx-node/lm` have no such HIT
+     * signal, so the public API intentionally offers only the full-wipe
+     * option.
+     *
      * Returns `Promise<void>` for an async-friendly signature even
      * though `resetCaches()` is currently synchronous.
      */
@@ -390,8 +590,31 @@ export declare class ChatSession<M extends SessionCapableModel = SessionCapableM
      * 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.
+     *
+     * MTP auto-default: if neither `defaultConfig` nor `overlay`
+     * sets `enableMtp` AND the underlying model exposes
+     * `hasMtpWeights()` returning `true`, set `enableMtp = true` so the
+     * speculative-decode path runs out of the box on MTP-capable
+     * checkpoints. An explicit `false` from either source wins (the
+     * undefined-check below preserves it). This duck-typed check also
+     * covers Gemma4 with an external draft attached — DSpark or Google
+     * assistant (`hasMtpWeights()` reports the external draft there,
+     * not in-checkpoint MTP heads).
      */
     private mergeConfig;
+    /**
+     * Render the exact full prompt and constrain generation to the physical KV
+     * window before native code allocates a block. Models that do not expose
+     * both the tokenizer seam and a load-time context snapshot retain their
+     * existing behavior.
+     *
+     * The returned config is a copy only when `maxNewTokens` needs clamping.
+     * An omitted output budget stays omitted when the native default fits; it is
+     * made explicit only when the remaining window is smaller than that default.
+     */
+    private constrainToContextCapacity;
+    /** Full history that a pending user/tool turn would render, without mutation. */
+    private historyWithPending;
     /**
      * Shared start-path logic for `send()`. Handles both the turn-0
      * first-ever-send case and the image-change mid-session restart
@@ -400,8 +623,24 @@ export declare class ChatSession<M extends SessionCapableModel = SessionCapableM
      * image set.
      */
     private runStartPath;
+    /**
+     * Core of {@link runStartPath} that takes a PRE-BUILT pending
+     * `ChatMessage` (user or tool) instead of building a user message
+     * itself. The cold-restart catch in `sendToolResult()` replays the
+     * conversation through this core with a pending `{ role: 'tool', ... }`
+     * message so the tool-result turn is re-rendered against the full
+     * history without duplicating the start-path bookkeeping.
+     */
+    private runStartPathWithMessage;
     /** Streaming counterpart to {@link runStartPath}. */
     private runStartStreamPath;
+    /**
+     * Streaming counterpart to {@link runStartPathWithMessage}: replays
+     * through the cold start stream from a PRE-BUILT pending
+     * `ChatMessage`. The cold-restart catch in `sendToolResultStream()`
+     * delegates here with a pending `{ role: 'tool', ... }` message.
+     */
+    private runStartStreamPathWithMessage;
     /**
      * Shared pre-start bookkeeping for both `send()` and `sendStream()`:
      *
@@ -418,16 +657,22 @@ export declare class ChatSession<M extends SessionCapableModel = SessionCapableM
      *   - On a fresh / reset history, re-inject the system prompt.
      */
     private prepareStartPath;
-    /** Build a user `ChatMessage` with or without attached images. */
+    /** Build a user `ChatMessage` with or without attached images/audio. */
     private buildUserMessage;
     /**
      * Walk the history backward to find the most recent user message
-     * with images and return its FNV-1a key. Used by
+     * with images and return its SHA-256 key. Used by
      * {@link startFromHistory} and {@link startFromHistoryStream} to
      * hydrate `lastImagesKey` after a cold replay, so subsequent delta
      * continues correctly detect image changes.
      */
     private computeTrailingImagesKey;
+    /**
+     * Audio counterpart of {@link computeTrailingImagesKey}: walk history
+     * backward to the most recent user message carrying audio and return its
+     * SHA-256 key, so a cold replay hydrates `lastAudioKey` correctly.
+     */
+    private computeTrailingAudioKey;
     /**
      * Derive the post-prime value of `unresolvedOkToolCallCount` from
      * the primed history. Walks backward to the most recent assistant

package/dist/chat-session.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chat-session.d.ts","sourceRoot":"","sources":["../src/chat-session.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"chat-session.d.ts","sourceRoot":"","sources":["../src/chat-session.ts"],"names":[],"mappings":"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"}