@mlx-node/lm 0.0.10 → 0.0.12

package/dist/chat-session.js

@@ -21,8 +21,10 @@
  *   - 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)`.
+ *     restart: release this session's native cache owner → push the new user
+ *     message (with images) to history → `chatSessionStart(history)`. Native
+ *     models without owner-scoped release retain the exclusive-model
+ *     `resetCaches()` fallback.
  *
  *   - Text-only `send()` on turn >= 1 still gets incremental prefill
  *     on a token-prefix hit. Prompt structure is never reconstructed
@@ -83,7 +85,7 @@
  * await session.reset();
  * ```
  */
-import { createHash } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 /**
  * Typed prefix native media guards use when a history cannot be continued
  * from the held image/audio state. The session layer recognizes this exact
@@ -106,6 +108,23 @@ const IMAGE_CHANGE_RESTART_PREFIX = 'IMAGE_CHANGE_REQUIRES_SESSION_RESTART:';
  * `crates/mlx-core/src/engine/params.rs`.
  */
 const NATIVE_DEFAULT_MAX_NEW_TOKENS = 2048;
+/**
+ * Model wrapper class names whose in-checkpoint MTP head must NOT be
+ * auto-enabled. Fallback only: {@link ChatSession#mtpAutoDefaultAllowed}
+ * prefers the native {@link SessionCapableModel.mtpAutoEnabled} getter in BOTH
+ * directions whenever the binding exposes it.
+ *
+ * NemotronH ships a complete MTP head on every checkpoint, so
+ * `hasMtpWeights()` is unconditionally `true`. Setting `enable_mtp` forces the
+ * turn into the exclusive/barrier scheduler lane, which takes the session OUT
+ * of continuous batching so concurrent sessions serialize; a streaming MTP turn
+ * additionally has no flat-core streaming arm and falls back to paged AR — no
+ * speculation and no batching. The BARRIER is the reason, not the head's speed:
+ * MTP is roughly perf-neutral on this family, so an explicit per-session
+ * `enableMtp: true` costs nothing. Drop the family from this set once an MTP
+ * turn can share the continuous-batching lane.
+ */
+const MTP_AUTO_DEFAULT_SUPPRESSED_MODELS = new Set(['NemotronHModel']);
 /**
  * Stable, provider-neutral error raised before native inference when a
  * rendered prompt cannot fit in the model's physically available hot KV
@@ -300,39 +319,6 @@ function publicStreamEvent(event, config) {
     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.
- *
- * Returns `null` when no images are provided so `send()` can
- * distinguish "no-images" from "image set changed". The key is
- * order-sensitive: `[A, B]` and `[B, A]` produce different keys,
- * matching the positional semantics of the underlying VLM chat
- * template.
- *
- * This is a byte-identity check — callers use the key solely to
- * decide whether to restart the server-side session, so any
- * collision-resistant digest is sufficient. We use SHA-256 (native
- * `node:crypto`) with a length-prefixed framing so different image
- * counts and different byte lengths cannot collide by accident.
- *
- * Implementation note: kept fully sync + self-contained so
- * `send()` can stay synchronous in its routing decision. `node:crypto`
- * is a Node built-in, so this adds no external runtime dependency
- * beyond `@mlx-node/core` and the existing stream bridge.
- */
-function computeImagesKey(images) {
-    return computeByteListKey(images);
-}
-/**
- * Audio counterpart of {@link computeImagesKey}: a stable, order-sensitive
- * byte-identity key for a list of encoded audio buffers. Used by `send()` /
- * `sendStream()` to decide whether a new audio set must cold-restart the
- * server-side session. Shares the exact SHA-256 framing as the image key.
- */
-function computeAudioKey(audio) {
-    return computeByteListKey(audio);
-}
 /**
  * SHA-256 byte-identity key for a length-framed list of byte buffers.
  * Returns `null` for an empty/absent list so callers can distinguish
@@ -345,6 +331,10 @@ function computeAudioKey(audio) {
  * before any `await` in `send()`/`sendStream()`, so the JS loop's cost
  * was a real head-of-line-blocking stall for every other request
  * handled by the same process.
+ *
+ * The key is order-sensitive: `[A, B]` and `[B, A]` produce different keys,
+ * matching the positional semantics of the underlying VLM chat template.
+ * Kept fully sync so `send()` can stay synchronous in its routing decision.
  */
 function computeByteListKey(buffers) {
     if (!buffers || buffers.length === 0)
@@ -376,6 +366,19 @@ export class ChatSession {
     model;
     system;
     defaultConfig;
+    /**
+     * Stable native cache/scheduler identity for this JS session.
+     *
+     * Direct HTTP callers do not carry the agent provider's cacheOwnerId. If
+     * they reach a paged model without an owner, native must conservatively use
+     * the legacy exclusive lane because sequence zero cannot represent two live
+     * requests. Give every ChatSession its own identity while still allowing an
+     * explicit provider identity to override it.
+     */
+    cacheOwnerId = null;
+    /** The native owner used by this session, retained as a set for retryable release. */
+    nativeCacheOwnerIds = new Set();
+    disposed = false;
     /** Tool definitions are conversation state for deterministic template replay. */
     activeTools;
     /**
@@ -386,14 +389,14 @@ export class ChatSession {
     history = [];
     /**
      * Hex-encoded byte-identity key of the image set currently bound
-     * to the server's KV cache (SHA-256; see `computeImagesKey`).
+     * to the server's KV cache (SHA-256; see `computeByteListKey`).
      * `null` when no images are cached. A `send()` whose new key
      * differs triggers a full `chatSessionStart` restart.
      */
     lastImagesKey = null;
     /**
      * 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
+     * server's KV cache (see {@link computeByteListKey}). `null` when no audio is
      * cached. A `send()` whose new key differs triggers a full
      * `chatSessionStart` restart — the audio counterpart of `lastImagesKey`.
      */
@@ -464,7 +467,7 @@ export class ChatSession {
         if (this.inFlight) {
             throw new Error('ChatSession: cannot preflight context capacity while a send() is in flight');
         }
-        return await this.constrainToContextCapacity(messages.slice(), this.mergeConfig(config));
+        return await this.constrainToContextCapacity(messages.slice(), this.mergeConfig(config, false));
     }
     /**
      * Capacity-preflight one pending user/tool message against this session's
@@ -487,7 +490,7 @@ export class ChatSession {
         else {
             throw new Error('ChatSession: pending context capacity preflight requires a user or tool message');
         }
-        return await this.constrainToContextCapacity(this.historyWithPending(pending), this.mergeConfig(config));
+        return await this.constrainToContextCapacity(this.historyWithPending(pending), this.mergeConfig(config, false));
     }
     /**
      * Count of `ok` tool calls from the most recent assistant turn, or
@@ -525,8 +528,8 @@ export class ChatSession {
         this.inFlight = true;
         try {
             const mergedConfig = this.mergeConfig(opts.config);
-            const newImagesKey = computeImagesKey(opts.images);
-            const newAudioKey = computeAudioKey(opts.audio);
+            const newImagesKey = computeByteListKey(opts.images);
+            const newAudioKey = computeByteListKey(opts.audio);
             // 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
@@ -537,7 +540,7 @@ export class ChatSession {
             const isFirstTurn = this.turnCount === 0;
             const replayRequired = this.needsFullReplay;
             if (isFirstTurn || imageChanged || audioChanged || replayRequired) {
-                return await this.runStartPath(userMessage, opts.images, opts.audio, imageChanged || audioChanged || replayRequired, isFirstTurn, mergedConfig);
+                return await this.runStartPath(userMessage, opts.images, opts.audio, imageChanged || audioChanged || replayRequired, isFirstTurn, mergedConfig, opts.signal);
             }
             // Role-aware continuation: pass the complete structured transcript.
             // Native code renders it with the checkpoint template and only reuses
@@ -547,7 +550,7 @@ export class ChatSession {
             const constrainedConfig = await this.constrainToContextCapacity(pendingHistory, mergedConfig);
             let result;
             try {
-                result = await this.model.chatSessionContinue(pendingHistory, withReplayReasoning(constrainedConfig, this.model));
+                result = await this.runNonStreamingNative('continue', pendingHistory, withReplayReasoning(constrainedConfig, this.model), opts.signal);
             }
             catch (err) {
                 if (!isMediaHeldRestartError(err)) {
@@ -561,7 +564,7 @@ export class ChatSession {
                 // the trailing-media keys keep `lastImagesKey`/`lastAudioKey`
                 // 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);
+                return await this.runStartPath(userMessage, undefined, undefined, true, false, constrainedConfig, opts.signal);
             }
             this.history.push(pendingUser);
             this.history.push(buildAssistantMessage(result.text, result.toolCalls, result.thinking, result.thinkingEnabled, result.rawText, this.model.replaysAssistantRawText?.() === true));
@@ -593,8 +596,8 @@ export class ChatSession {
         this.inFlight = true;
         try {
             const mergedConfig = this.mergeConfig(opts.config);
-            const newImagesKey = computeImagesKey(opts.images);
-            const newAudioKey = computeAudioKey(opts.audio);
+            const newImagesKey = computeByteListKey(opts.images);
+            const newAudioKey = computeByteListKey(opts.audio);
             // Only an explicit NEW image/audio set can trigger a restart. Omitting
             // `images`/`audio` (key === null) is interpreted as "keep the current
             // media cache state" — the server-side cache already holds any prior
@@ -732,7 +735,7 @@ export class ChatSession {
         this.assertCanSendToolResult('sendToolResult');
         this.inFlight = true;
         try {
-            const { isError, config } = opts;
+            const { isError, config, signal } = opts;
             const mergedConfig = this.mergeConfig(config);
             const toolMsg = {
                 role: 'tool',
@@ -753,10 +756,10 @@ export class ChatSession {
             // tool-call turn (turnCount>=1), so this never fires on the happy
             // path.
             if (this.turnCount === 0 || this.needsFullReplay) {
-                return await this.replayToolResultThroughStartPath(toolMsg, constrainedConfig);
+                return await this.replayToolResultThroughStartPath(toolMsg, constrainedConfig, signal);
             }
             try {
-                const result = await this.model.chatSessionContinueTool(pendingHistory, withReplayReasoning(constrainedConfig, this.model));
+                const result = await this.runNonStreamingNative('continueTool', pendingHistory, withReplayReasoning(constrainedConfig, this.model), signal);
                 this.history.push({ role: 'tool', content, toolCallId, isError });
                 this.history.push(buildAssistantMessage(result.text, result.toolCalls, result.thinking, result.thinkingEnabled, result.rawText, this.model.replaysAssistantRawText?.() === true));
                 this.turnCount++;
@@ -779,7 +782,7 @@ export class ChatSession {
                 // restart core pushes it — `isError` rides on that message so the
                 // wire-format error marker is re-rendered, and a tool result
                 // always follows >=1 prior turn so `isFirstTurn` is false.
-                return await this.replayToolResultThroughStartPath(toolMsg, constrainedConfig);
+                return await this.replayToolResultThroughStartPath(toolMsg, constrainedConfig, signal);
             }
         }
         finally {
@@ -793,12 +796,12 @@ export class ChatSession {
      * 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.
+     * native cache invalidation so the prefill starts from a guaranteed-clean
+     * owner; `isFirstTurn=false` because a tool result always follows a prior
+     * tool-call turn.
      */
-    async replayToolResultThroughStartPath(toolMsg, config) {
-        return await this.runStartPathWithMessage(toolMsg, true, false, config);
+    async replayToolResultThroughStartPath(toolMsg, config, signal) {
+        return await this.runStartPathWithMessage(toolMsg, true, false, config, signal);
     }
     /**
      * Streaming variant of {@link ChatSession#sendToolResult}.
@@ -938,42 +941,106 @@ export class ChatSession {
     /**
      * Reset the session state.
      *
-     * Clears the underlying model's KV caches and wipes local history,
-     * 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.
+     * Invalidates this session's native KV state and wipes local history,
+     * media keys, and turn counter so the next `send()` goes through
+     * `chatSessionStart` again. Block-paged models release only this stable
+     * session owner; clearing the model-wide scheduler would invalidate every
+     * other live `ChatSession`. Exclusive/flat models retain the model-wide
+     * `resetCaches()` barrier because they have no independently releasable
+     * owner state.
      *
-     * Returns `Promise<void>` for an async-friendly signature even
-     * though `resetCaches()` is currently synchronous.
+     * Native invalidation is async: the release/reset command is awaited so it
+     * has fully drained through the model thread before this promise resolves —
+     * callers that `await reset()` and
+     * then start a turn keep strict command-queue ordering. Because the
+     * await genuinely suspends, `reset()` RESERVES the same in-flight
+     * guard as the send entry points for its whole duration: any
+     * concurrent `send*()`, `reset()`, `primeHistory()`, or
+     * `startFromHistory*()` on this session rejects until the reset
+     * settles, so a racing turn can never commit against the pre-wipe
+     * history (or have its state erased mid-commit). If native invalidation
+     * rejects, no JS state is wiped and the guard is released.
      */
     async reset() {
+        if (this.disposed) {
+            throw new Error('ChatSession: session has been disposed');
+        }
         if (this.inFlight) {
             throw new Error('ChatSession: cannot reset() while a send() is in flight; await the previous call first');
         }
-        this.model.resetCaches();
-        this.history = [];
-        this.lastImagesKey = null;
-        this.lastAudioKey = null;
-        this.turnCount = 0;
-        this.unresolvedOkToolCallCount = null;
-        this.needsFullReplay = false;
-        this.activeTools = this.defaultConfig.tools;
+        this.inFlight = true;
+        try {
+            if (this.model.hasBlockPagedCache?.() === true && this.model.releaseCacheOwner) {
+                for (const ownerId of Array.from(this.nativeCacheOwnerIds)) {
+                    await this.model.releaseCacheOwner(ownerId);
+                    this.nativeCacheOwnerIds.delete(ownerId);
+                }
+            }
+            else {
+                await this.model.resetCaches();
+                this.nativeCacheOwnerIds.clear();
+            }
+            this.history = [];
+            this.lastImagesKey = null;
+            this.lastAudioKey = null;
+            this.turnCount = 0;
+            this.unresolvedOkToolCallCount = null;
+            this.needsFullReplay = false;
+            this.activeTools = this.defaultConfig.tools;
+        }
+        finally {
+            this.inFlight = false;
+        }
+    }
+    /**
+     * Permanently dispose this JS session and release its native scheduler
+     * owner. The operation is awaited and idempotent; it rejects while
+     * a turn is in flight so native state cannot be torn down mid-decode.
+     *
+     * A caller-supplied first `cacheOwnerId` becomes this session's stable owner
+     * just like the generated default. Do not share an explicit owner id between
+     * independently disposed sessions: disposing either session releases that
+     * owner's native scheduler state for both.
+     */
+    async dispose() {
+        if (this.disposed)
+            return;
+        if (this.inFlight) {
+            throw new Error('ChatSession: cannot dispose() while a send() is in flight; await the previous call first');
+        }
+        this.inFlight = true;
+        try {
+            let firstReleaseError;
+            let hadReleaseError = false;
+            if (this.model.releaseCacheOwner) {
+                for (const ownerId of Array.from(this.nativeCacheOwnerIds)) {
+                    try {
+                        await this.model.releaseCacheOwner(ownerId);
+                        this.nativeCacheOwnerIds.delete(ownerId);
+                    }
+                    catch (error) {
+                        if (!hadReleaseError)
+                            firstReleaseError = error;
+                        hadReleaseError = true;
+                    }
+                }
+            }
+            else {
+                this.nativeCacheOwnerIds.clear();
+            }
+            if (hadReleaseError)
+                throw firstReleaseError;
+            this.disposed = true;
+            this.history = [];
+            this.lastImagesKey = null;
+            this.lastAudioKey = null;
+            this.turnCount = 0;
+            this.unresolvedOkToolCallCount = null;
+            this.needsFullReplay = false;
+        }
+        finally {
+            this.inFlight = false;
+        }
     }
     /**
      * Prime the session history without running inference.
@@ -1026,7 +1093,7 @@ export class ChatSession {
      * stay on the delta path, and subsequent image turns correctly
      * trigger restart).
      */
-    async startFromHistory(config) {
+    async startFromHistory(config, opts = {}) {
         if (this.inFlight) {
             throw new Error('ChatSession: cannot startFromHistory() while a send() is in flight');
         }
@@ -1041,7 +1108,7 @@ 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, withReplayReasoning(constrainedConfig, this.model));
+            const result = await this.runNonStreamingNative('start', historySnapshot, withReplayReasoning(constrainedConfig, this.model), opts.signal);
             this.history.push(buildAssistantMessage(result.text, result.toolCalls, result.thinking, result.thinkingEnabled, result.rawText, this.model.replaysAssistantRawText?.() === true));
             this.turnCount++;
             this.needsFullReplay = false;
@@ -1137,6 +1204,34 @@ export class ChatSession {
     // -------------------------------------------------------------------
     // Internal helpers
     // -------------------------------------------------------------------
+    /**
+     * Dispatch one non-streaming native turn through the public AbortSignal
+     * surface (H2). The model wrapper owns the attach-race-safe translation
+     * from AbortSignal to the lower-level native operation handle; ChatSession
+     * never exposes that two-phase primitive to callers.
+     *
+     * Callers sit inside the entry points' existing try/finally blocks,
+     * so a rejection here releases `inFlight` and (on the delta paths)
+     * sets `needsFullReplay` exactly like any other native failure.
+     */
+    async runNonStreamingNative(kind, messages, config, signal) {
+        const model = this.model;
+        if (signal?.aborted === true)
+            throw new Error('chat session cancelled');
+        if (kind === 'start') {
+            return signal == null
+                ? await model.chatSessionStart(messages, config)
+                : await model.chatSessionStart(messages, config, signal);
+        }
+        if (kind === 'continue') {
+            return signal == null
+                ? await model.chatSessionContinue(messages, config)
+                : await model.chatSessionContinue(messages, config, signal);
+        }
+        return signal == null
+            ? await model.chatSessionContinueTool(messages, config)
+            : await model.chatSessionContinueTool(messages, config, signal);
+    }
     /**
      * Gate plain-text continuation entry points (`send`, `sendStream`)
      * on the tool-call resolution invariant. Any outstanding `ok` tool
@@ -1242,25 +1337,46 @@ export class ChatSession {
      * 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.
+     * preflights use this same merge path with owner establishment disabled.
+     * 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
-     * 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).
+     * `hasMtpWeights()` returning `true` AND
+     * {@link ChatSession#mtpAutoDefaultAllowed} agrees, 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).
      */
-    mergeConfig(overlay) {
+    mergeConfig(overlay, establishCacheOwner = true) {
+        if (this.disposed) {
+            throw new Error('ChatSession: session has been disposed');
+        }
         const merged = {
             ...this.defaultConfig,
             ...overlay,
             reuseCache: true,
         };
+        const requestedOwnerId = merged.cacheOwnerId;
+        if (this.cacheOwnerId === null) {
+            if (establishCacheOwner) {
+                this.cacheOwnerId = requestedOwnerId === undefined || requestedOwnerId === '' ? randomUUID() : requestedOwnerId;
+                merged.cacheOwnerId = this.cacheOwnerId;
+                this.nativeCacheOwnerIds.add(this.cacheOwnerId);
+            }
+        }
+        else if (requestedOwnerId !== undefined && requestedOwnerId !== '' && requestedOwnerId !== this.cacheOwnerId) {
+            throw new Error(`ChatSession: cacheOwnerId cannot change after the session owner is established; create a new ChatSession for owner ${requestedOwnerId}`);
+        }
+        else {
+            merged.cacheOwnerId = this.cacheOwnerId;
+            if (establishCacheOwner)
+                this.nativeCacheOwnerIds.add(this.cacheOwnerId);
+        }
         // 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
@@ -1271,11 +1387,32 @@ export class ChatSession {
         }
         if (merged.enableMtp === undefined &&
             typeof this.model.hasMtpWeights === 'function' &&
-            this.model.hasMtpWeights()) {
+            this.model.hasMtpWeights() &&
+            this.mtpAutoDefaultAllowed()) {
             merged.enableMtp = true;
         }
         return merged;
     }
+    /**
+     * Whether an MTP-capable model wants `enableMtp` on for a caller who set
+     * nothing. `mtpAutoEnabled()` is authoritative in both directions when
+     * present; otherwise {@link MTP_AUTO_DEFAULT_SUPPRESSED_MODELS} is matched
+     * along the prototype CHAIN rather than by a bare `constructor.name`, so it
+     * still fires through the `makeStreamingModel` wrapper subclass that
+     * `@mlx-node/lm` actually hands to `ChatSession`.
+     */
+    mtpAutoDefaultAllowed() {
+        if (typeof this.model.mtpAutoEnabled === 'function') {
+            return this.model.mtpAutoEnabled();
+        }
+        for (let proto = Object.getPrototypeOf(this.model); proto !== null; proto = Object.getPrototypeOf(proto)) {
+            const name = proto.constructor?.name;
+            if (name !== undefined && MTP_AUTO_DEFAULT_SUPPRESSED_MODELS.has(name)) {
+                return false;
+            }
+        }
+        return true;
+    }
     /**
      * Render the exact full prompt and constrain generation to the physical KV
      * window before native code allocates a block. Models that do not expose
@@ -1336,9 +1473,9 @@ export class ChatSession {
      * native side gets the full conversation re-rendered with the new
      * image set.
      */
-    async runStartPath(userMessage, images, audio, mediaChanged, isFirstTurn, config) {
+    async runStartPath(userMessage, images, audio, mediaChanged, isFirstTurn, config, signal) {
         const userMsg = this.buildUserMessage(userMessage, images, audio);
-        return await this.runStartPathWithMessage(userMsg, mediaChanged, isFirstTurn, config);
+        return await this.runStartPathWithMessage(userMsg, mediaChanged, isFirstTurn, config, signal);
     }
     /**
      * Core of {@link runStartPath} that takes a PRE-BUILT pending
@@ -1348,27 +1485,28 @@ export class ChatSession {
      * message so the tool-result turn is re-rendered against the full
      * history without duplicating the start-path bookkeeping.
      */
-    async runStartPathWithMessage(pendingMessage, mediaChanged, isFirstTurn, config) {
+    async runStartPathWithMessage(pendingMessage, mediaChanged, isFirstTurn, config, signal) {
         // Capture pre-state so the restart can be rolled back if the
-        // native call fails. The media-change branch resets caches BEFORE
-        // we know whether the new prefill will succeed, so on failure we
-        // also have to drop turnCount + lastImagesKey/lastAudioKey to force
-        // the next call to re-route through the start path (rather than a
-        // delta continue against wiped caches).
+        // native call fails. The media-change branch releases this owner's caches
+        // BEFORE we know whether the new prefill will succeed, so on failure we
+        // also have to drop turnCount + lastImagesKey/lastAudioKey to force the
+        // next call to re-route through the start path (rather than a delta
+        // continue against released caches).
         const wasMediaChangeRestart = mediaChanged && !isFirstTurn;
         const historyLenBefore = this.history.length;
         // Capacity validation must happen before `prepareStartPath()` because a
-        // media-change restart clears native caches. A rejected oversized prompt
-        // is a request error and must leave both JS history and native state intact.
+        // media-change restart releases native owner state. A rejected oversized
+        // prompt is a request error and must leave both JS history and native state
+        // intact.
         const constrainedConfig = await this.constrainToContextCapacity(this.historyWithPending(pendingMessage), config);
-        this.prepareStartPath(mediaChanged, isFirstTurn);
+        await this.prepareStartPath(mediaChanged, isFirstTurn, constrainedConfig.cacheOwnerId);
         this.history.push(pendingMessage);
         try {
             // Pass a shallow snapshot so later pushes to `this.history`
             // (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(), withReplayReasoning(constrainedConfig, this.model));
+            const result = await this.runNonStreamingNative('start', this.history.slice(), withReplayReasoning(constrainedConfig, this.model), signal);
             this.history.push(buildAssistantMessage(result.text, result.toolCalls, result.thinking, result.thinkingEnabled, result.rawText, this.model.replaysAssistantRawText?.() === true));
             this.turnCount++;
             this.needsFullReplay = false;
@@ -1390,7 +1528,7 @@ export class ChatSession {
             // consistent with turnCount.
             this.history.length = historyLenBefore;
             if (wasMediaChangeRestart) {
-                // Caches were wiped by prepareStartPath() but the new prefill
+                // This owner's caches were released by prepareStartPath() but the new prefill
                 // failed. Force the next call to re-route through the start
                 // path with the (preserved) prior history.
                 this.turnCount = 0;
@@ -1416,10 +1554,10 @@ export class ChatSession {
         // See `runStartPath` for the full rationale.
         const wasMediaChangeRestart = mediaChanged && !isFirstTurn;
         const historyLenBefore = this.history.length;
-        // See the sync start path: reject before a media restart can clear native
-        // state, and make the output budget explicit before allocating KV blocks.
+        // See the sync start path: reject before a media restart can release native
+        // owner state, and make the output budget explicit before allocating KV blocks.
         const constrainedConfig = await this.constrainToContextCapacity(this.historyWithPending(pendingMessage), config);
-        this.prepareStartPath(mediaChanged, isFirstTurn);
+        await this.prepareStartPath(mediaChanged, isFirstTurn, constrainedConfig.cacheOwnerId);
         // Stage the pending message on the pending history BEFORE the
         // stream starts — the native call reads it synchronously via
         // `model.chatStreamSessionStart(history, config)`.
@@ -1490,7 +1628,7 @@ export class ChatSession {
                 // consistent with turnCount.
                 this.history.length = historyLenBefore;
                 if (wasMediaChangeRestart) {
-                    // Caches were wiped by prepareStartPath() but the new
+                    // This owner's caches were released by prepareStartPath() but the new
                     // prefill never reached a successful done:true. Force the
                     // next call to re-route through the start path with the
                     // preserved prior history.
@@ -1504,8 +1642,9 @@ export class ChatSession {
     /**
      * Shared pre-start bookkeeping for both `send()` and `sendStream()`:
      *
-     *   - On an image-change restart (turn >= 1), reset the native KV
-     *     caches so the new image set gets a fresh prefill. History is
+     *   - On an image-change restart (turn >= 1), release this session's native
+     *     cache owner so the new image set gets a fresh prefill without wiping
+     *     concurrently live owners. History is
      *     intentionally preserved — `chatSessionStart` receives the full
      *     accumulated conversation plus the new user turn so the jinja
      *     render walks every prior turn and every prior image again
@@ -1516,9 +1655,19 @@ export class ChatSession {
      *     turn.
      *   - On a fresh / reset history, re-inject the system prompt.
      */
-    prepareStartPath(mediaChanged, isFirstTurn) {
+    async prepareStartPath(mediaChanged, isFirstTurn, cacheOwnerId) {
         if (mediaChanged && !isFirstTurn) {
-            this.model.resetCaches();
+            // Await owner release so it has drained through the model thread before
+            // the replacement start is enqueued. This is deliberately owner-scoped
+            // on continuously batched models: a model-wide reset would invalidate
+            // unrelated live ChatSessions. Third-party/exclusive models predating
+            // the owner lifecycle retain the full-reset fallback.
+            if (this.model.hasBlockPagedCache?.() === true && this.model.releaseCacheOwner && cacheOwnerId) {
+                await this.model.releaseCacheOwner(cacheOwnerId);
+            }
+            else {
+                await this.model.resetCaches();
+            }
         }
         if (this.history.length === 0 && this.system != null) {
             this.history.push({ role: 'system', content: this.system });
@@ -1544,7 +1693,7 @@ export class ChatSession {
         for (let i = this.history.length - 1; i >= 0; i--) {
             const msg = this.history[i];
             if (msg?.role === 'user' && msg.images && msg.images.length > 0) {
-                return computeImagesKey(msg.images);
+                return computeByteListKey(msg.images);
             }
         }
         return null;
@@ -1558,7 +1707,7 @@ export class ChatSession {
         for (let i = this.history.length - 1; i >= 0; i--) {
             const msg = this.history[i];
             if (msg?.role === 'user' && msg.audio && msg.audio.length > 0) {
-                return computeAudioKey(msg.audio);
+                return computeByteListKey(msg.audio);
             }
         }
         return null;