@mlx-node/lm 0.0.7 → 0.0.9

package/dist/stream.js

@@ -1,48 +1,29 @@
-import { Gemma4Model as Gemma4ModelNative, Lfm2Model as Lfm2ModelNative, Qwen3Model as Qwen3ModelNative, Qwen35Model as Qwen35ModelNative, Qwen35MoeModel as Qwen35MoeModelNative, } from '@mlx-node/core';
-// Save references to the native callback-based session streaming methods
-// before we override them. The legacy `chatStream` surface was removed in
-// the chat-session refactor; the remaining session entry points below
-// drive all streaming via the `ChatSession` API.
-//
-// Each wrapper class re-declares these three methods as
-// `AsyncGenerator<ChatStreamEvent>` overrides that delegate through the
-// shared `_runChatStream` bridge, so the wrapper structurally satisfies
-// `SessionCapableModel` and can be passed to `ChatSession<M>`.
-// Dense
-// oxlint-disable-next-line @typescript-eslint/unbound-method
-const _nativeDenseChatStreamSessionStart = Qwen35ModelNative.prototype.chatStreamSessionStart;
-// oxlint-disable-next-line @typescript-eslint/unbound-method
-const _nativeDenseChatStreamSessionContinue = Qwen35ModelNative.prototype.chatStreamSessionContinue;
-// oxlint-disable-next-line @typescript-eslint/unbound-method
-const _nativeDenseChatStreamSessionContinueTool = Qwen35ModelNative.prototype.chatStreamSessionContinueTool;
-// MoE
-// oxlint-disable-next-line @typescript-eslint/unbound-method
-const _nativeMoeChatStreamSessionStart = Qwen35MoeModelNative.prototype.chatStreamSessionStart;
-// oxlint-disable-next-line @typescript-eslint/unbound-method
-const _nativeMoeChatStreamSessionContinue = Qwen35MoeModelNative.prototype.chatStreamSessionContinue;
-// oxlint-disable-next-line @typescript-eslint/unbound-method
-const _nativeMoeChatStreamSessionContinueTool = Qwen35MoeModelNative.prototype.chatStreamSessionContinueTool;
-// LFM2
-// oxlint-disable-next-line @typescript-eslint/unbound-method
-const _nativeLfm2ChatStreamSessionStart = Lfm2ModelNative.prototype.chatStreamSessionStart;
-// oxlint-disable-next-line @typescript-eslint/unbound-method
-const _nativeLfm2ChatStreamSessionContinue = Lfm2ModelNative.prototype.chatStreamSessionContinue;
-// oxlint-disable-next-line @typescript-eslint/unbound-method
-const _nativeLfm2ChatStreamSessionContinueTool = Lfm2ModelNative.prototype.chatStreamSessionContinueTool;
-// Gemma4
-// oxlint-disable-next-line @typescript-eslint/unbound-method
-const _nativeGemma4ChatStreamSessionStart = Gemma4ModelNative.prototype.chatStreamSessionStart;
-// oxlint-disable-next-line @typescript-eslint/unbound-method
-const _nativeGemma4ChatStreamSessionContinue = Gemma4ModelNative.prototype.chatStreamSessionContinue;
-// oxlint-disable-next-line @typescript-eslint/unbound-method
-const _nativeGemma4ChatStreamSessionContinueTool = Gemma4ModelNative.prototype.chatStreamSessionContinueTool;
-// Qwen3 (legacy, text-only)
-// oxlint-disable-next-line @typescript-eslint/unbound-method
-const _nativeQwen3ChatStreamSessionStart = Qwen3ModelNative.prototype.chatStreamSessionStart;
-// oxlint-disable-next-line @typescript-eslint/unbound-method
-const _nativeQwen3ChatStreamSessionContinue = Qwen3ModelNative.prototype.chatStreamSessionContinue;
-// oxlint-disable-next-line @typescript-eslint/unbound-method
-const _nativeQwen3ChatStreamSessionContinueTool = Qwen3ModelNative.prototype.chatStreamSessionContinueTool;
+import { join } from "node:path";
+import { Gemma4Model as Gemma4ModelNative, Lfm2Model as Lfm2ModelNative, Qwen3Tokenizer, Qwen3Model as Qwen3ModelNative, Qwen35Model as Qwen35ModelNative, Qwen35MoeModel as Qwen35MoeModelNative, } from "@mlx-node/core";
+const modelPathsForTokenizers = new WeakMap();
+const tokenizerPromises = new WeakMap();
+function getNativeIsReasoning(chunk) {
+    return typeof chunk.isReasoning === "boolean" ? chunk.isReasoning : undefined;
+}
+function rememberModelPath(model, modelPath) {
+    modelPathsForTokenizers.set(model, modelPath);
+}
+async function applyChatTemplateFromModelPath(model, messages, addGenerationPrompt, tools, enableThinking, contentPolicy) {
+    const modelPath = modelPathsForTokenizers.get(model);
+    if (modelPath == null) {
+        throw new Error("applyChatTemplate unavailable: model path was not recorded when this model was loaded");
+    }
+    let tokenizerPromise = tokenizerPromises.get(model);
+    if (tokenizerPromise == null) {
+        tokenizerPromise = Qwen3Tokenizer.fromPretrained(join(modelPath, "tokenizer.json"));
+        tokenizerPromises.set(model, tokenizerPromise);
+    }
+    const tokenizer = await tokenizerPromise;
+    if (contentPolicy == null) {
+        return tokenizer.applyChatTemplate(messages, addGenerationPrompt, tools, enableThinking);
+    }
+    return tokenizer.applyChatTemplate(messages, addGenerationPrompt, tools, enableThinking, contentPolicy.order, contentPolicy.existingImagePlaceholder);
+}
 /**
  * Shared AsyncGenerator adapter for callback-based native streaming methods.
  *
@@ -149,7 +130,7 @@ export async function* _runChatStream(startCall, signal) {
         }
         else {
             onAbort = triggerAbort;
-            signal.addEventListener('abort', onAbort, { once: true });
+            signal.addEventListener("abort", onAbort, { once: true });
         }
     }
     try {
@@ -171,28 +152,56 @@ export async function* _runChatStream(startCall, signal) {
                     throw item.error;
                 const chunk = item.chunk;
                 if (chunk.done) {
-                    yield {
+                    if (typeof chunk.thinkingEnabled !== "boolean") {
+                        throw new Error("Native terminal chat stream chunk is missing thinkingEnabled");
+                    }
+                    // The native `ChatStreamChunk` carries `cachedTokens` on the
+                    // terminal (`done == true`) chunk for every streaming entry
+                    // point. Emit it on the final event verbatim — undefined means
+                    // the native dispatch did not populate it (e.g. a bridge-level
+                    // mock or an in-process driver), in which case downstream
+                    // consumers treat the absence as "unknown / not plumbed" and
+                    // skip emitting e.g. `X-Cached-Tokens` rather than reporting a
+                    // fabricated `0`.
+                    const chunkWithCached = chunk;
+                    const finalEvent = {
                         text: chunk.text,
                         done: true,
                         finishReason: chunk.finishReason,
                         toolCalls: chunk.toolCalls ?? [],
                         thinking: chunk.thinking ?? null,
+                        thinkingEnabled: chunk.thinkingEnabled,
                         numTokens: chunk.numTokens,
                         promptTokens: chunk.promptTokens ?? 0,
                         reasoningTokens: chunk.reasoningTokens ?? 0,
                         rawText: chunk.rawText,
                         performance: chunk.performance ?? undefined,
                     };
+                    if (typeof chunkWithCached.cachedTokens === "number") {
+                        finalEvent.cachedTokens = chunkWithCached.cachedTokens;
+                    }
+                    if (typeof chunkWithCached.publicRawText === "string") {
+                        finalEvent.publicRawText = chunkWithCached.publicRawText;
+                    }
+                    if (typeof chunkWithCached.textAuthoritative === "boolean") {
+                        finalEvent.textAuthoritative = chunkWithCached.textAuthoritative;
+                    }
+                    yield finalEvent;
                     return;
                 }
-                yield { text: chunk.text, done: false, isReasoning: chunk.isReasoning ?? undefined };
+                const delta = { text: chunk.text, done: false };
+                const isReasoning = getNativeIsReasoning(chunk);
+                if (isReasoning !== undefined) {
+                    delta.isReasoning = isReasoning;
+                }
+                yield delta;
             }
         }
     }
     finally {
         if (signal != null && onAbort != null) {
             try {
-                signal.removeEventListener('abort', onAbort);
+                signal.removeEventListener("abort", onAbort);
             }
             catch {
                 // removeEventListener shouldn't throw, but stay defensive —
@@ -203,205 +212,133 @@ export async function* _runChatStream(startCall, signal) {
     }
 }
 /**
- * Qwen3.5 dense model with AsyncGenerator-based session streaming.
+ * Build the streaming-model subclass for a native chat model class.
  *
- * Streaming is driven through the session API — `chatStreamSessionStart`,
- * `chatStreamSessionContinue`, and `chatStreamSessionContinueTool` below —
- * which adapt the callback-based native methods to
- * `AsyncGenerator<ChatStreamEvent>` so the wrapper structurally satisfies
- * `SessionCapableModel` and can be passed to `ChatSession<Qwen35Model>`.
- */
-export class Qwen35Model extends Qwen35ModelNative {
-    static async load(modelPath) {
-        const instance = await Qwen35ModelNative.load(modelPath);
-        Object.setPrototypeOf(instance, Qwen35Model.prototype);
-        return instance;
-    }
-    /**
-     * Streaming variant of {@link Qwen35Model#chatSessionStart}.
-     *
-     * Resets the KV caches, runs the jinja chat template, prefills on
-     * top of the fresh caches, and streams the decoded reply token-by-
-     * token. Stops on `<|im_end|>` so the cached history ends on a
-     * clean ChatML boundary that subsequent `chatStreamSessionContinue`
-     * deltas can append to. Text-only.
-     *
-     * The optional `signal` parameter wires an AbortSignal into the
-     * `_runChatStream` adapter's fast-abort path. Callers that need
-     * client-disconnect-aware cancellation (e.g. HTTP endpoints) pass
-     * one here and the native decode winds down at the next safepoint.
-     */
-    // @ts-expect-error — override callback-based native method with AsyncGenerator
-    async *chatStreamSessionStart(messages, config, signal) {
-        yield* _runChatStream((callback) => _nativeDenseChatStreamSessionStart.call(this, messages, config ?? null, callback), signal);
-    }
-    /**
-     * Streaming variant of {@link Qwen35Model#chatSessionContinue}.
-     *
-     * Builds a raw ChatML delta on top of the live session caches,
-     * tokenizes it, prefills the delta, and streams the decoded reply.
-     * Requires a live session started via `chatSessionStart` or
-     * `chatStreamSessionStart`. Stops on `<|im_end|>`.
-     *
-     * `images` is the native opt-in guard parameter — callers that
-     * attach a new image set must restart the session via
-     * `chatStreamSessionStart` with the full history. The high-level
-     * `ChatSession` wrapper handles that routing; callers that drive
-     * the wrapper directly should pass `null` for text-only continues.
-     */
-    // @ts-expect-error — override callback-based native method with AsyncGenerator
-    async *chatStreamSessionContinue(userMessage, images, config, signal) {
-        yield* _runChatStream((callback) => _nativeDenseChatStreamSessionContinue.call(this, userMessage, images, config ?? null, callback), signal);
-    }
-    /**
-     * Streaming variant of {@link Qwen35Model#chatSessionContinueTool}.
-     *
-     * Builds a ChatML `<tool_response>` delta on top of the live
-     * session caches and streams the decoded assistant reply. Requires
-     * a live session started via `chatSessionStart` /
-     * `chatStreamSessionStart`.
-     */
-    // @ts-expect-error — override callback-based native method with AsyncGenerator
-    async *chatStreamSessionContinueTool(toolCallId, content, config, signal) {
-        yield* _runChatStream((callback) => _nativeDenseChatStreamSessionContinueTool.call(this, toolCallId, content, config ?? null, callback), signal);
-    }
-}
-/**
- * Qwen3.5 MoE model wrapper.
+ * The returned class:
+ *   - captures the three native callback-based session-streaming methods
+ *     from `NativeClass.prototype`,
+ *   - overrides them as `async *` generators delegating to
+ *     {@link _runChatStream} with identical argument plumbing (including
+ *     `config ?? null`, `images`, `isError ?? null`, and the `signal`),
+ *   - overrides `static load` to re-prototype the native instance onto
+ *     the concrete subclass (`this`) and optionally record the path,
+ *   - installs a path-backed `applyChatTemplate` when `opts.applyTemplate`
+ *     (defaulting to `opts.recordModelPath`).
  *
- * Streaming is driven through the `ChatSession` API — overrides below
- * adapt the callback-based native methods to
- * `AsyncGenerator<ChatStreamEvent>` so the wrapper structurally
- * satisfies `SessionCapableModel`.
+ * @internal Exported so the VLM wrapper (`@mlx-node/vlm`) builds its
+ * `QianfanOCRModel` from the same factory. Not part of the public API.
  */
-export class Qwen35MoeModel extends Qwen35MoeModelNative {
-    static async load(modelPath) {
-        const instance = await Qwen35MoeModelNative.load(modelPath);
-        Object.setPrototypeOf(instance, Qwen35MoeModel.prototype);
-        return instance;
-    }
-    /** Streaming variant of {@link Qwen35MoeModel#chatSessionStart}. */
-    // @ts-expect-error — override callback-based native method with AsyncGenerator
-    async *chatStreamSessionStart(messages, config, signal) {
-        yield* _runChatStream((callback) => _nativeMoeChatStreamSessionStart.call(this, messages, config ?? null, callback), signal);
-    }
-    /** Streaming variant of {@link Qwen35MoeModel#chatSessionContinue}. */
-    // @ts-expect-error — override callback-based native method with AsyncGenerator
-    async *chatStreamSessionContinue(userMessage, images, config, signal) {
-        yield* _runChatStream((callback) => _nativeMoeChatStreamSessionContinue.call(this, userMessage, images, config ?? null, callback), signal);
+export function makeStreamingModel(NativeClass, opts) {
+    const recordPath = opts.recordModelPath;
+    const applyTemplate = opts.applyTemplate ?? recordPath;
+    const templateContentPolicy = opts.templateContentPolicy;
+    const replayAssistantRawText = opts.replayAssistantRawText ?? false;
+    // Capture the native callback-based methods before the subclass
+    // overrides below shadow them on the prototype.
+    const nativeStart = NativeClass.prototype.chatStreamSessionStart;
+    const nativeContinue = NativeClass.prototype.chatStreamSessionContinue;
+    const nativeContinueTool = NativeClass.prototype.chatStreamSessionContinueTool;
+    // `NativeClass` is structurally a constructor; cast to a concrete
+    // constructor type so `class extends` accepts it. Runtime behavior is
+    // unchanged — we extend the real native class.
+    const Base = NativeClass;
+    class StreamingModelImpl extends Base {
+        supportsReplayReasoningCapture() {
+            return true;
+        }
+        replaysAssistantRawText() {
+            return replayAssistantRawText;
+        }
+        static async load(modelPath, ...rest) {
+            // Forward any trailing family-specific load options verbatim (e.g.
+            // Gemma4's `Gemma4LoadOptions` with `draftModelPath`); families whose
+            // native `load` takes only the path receive no extras. The public
+            // signature is re-narrowed per family via `Parameters<C['load']>` in
+            // the factory return type below.
+            const instance = await NativeClass.load(modelPath, ...rest);
+            // Use `this.prototype` (not `StreamingModelImpl.prototype`) so the
+            // concrete subclass declared per family supplies the prototype and
+            // `instanceof ConcreteSubclass` holds.
+            Object.setPrototypeOf(instance, this.prototype);
+            if (recordPath)
+                rememberModelPath(instance, modelPath);
+            return instance;
+        }
+        // The native methods are callback-based, but `Base` is typed as a
+        // `SessionCapableModel` constructor (whose streaming methods already
+        // return `AsyncGenerator<ChatStreamEvent>`), so these overrides are
+        // type-compatible and need no `@ts-expect-error` suppression. The
+        // callback bridging happens at runtime via the captured natives.
+        async *chatStreamSessionStart(messages, config, signal) {
+            yield* _runChatStream((callback) => nativeStart.call(this, messages, (config ?? null), callback), signal);
+        }
+        async *chatStreamSessionContinue(messages, config, signal) {
+            yield* _runChatStream((callback) => nativeContinue.call(this, messages, (config ?? null), callback), signal);
+        }
+        async *chatStreamSessionContinueTool(messages, config, signal) {
+            yield* _runChatStream((callback) => nativeContinueTool.call(this, messages, (config ?? null), callback), signal);
+        }
     }
-    /** Streaming variant of {@link Qwen35MoeModel#chatSessionContinueTool}. */
-    // @ts-expect-error — override callback-based native method with AsyncGenerator
-    async *chatStreamSessionContinueTool(toolCallId, content, config, signal) {
-        yield* _runChatStream((callback) => _nativeMoeChatStreamSessionContinueTool.call(this, toolCallId, content, config ?? null, callback), signal);
+    if (applyTemplate) {
+        Object.defineProperty(StreamingModelImpl.prototype, "applyChatTemplate", {
+            configurable: true,
+            writable: true,
+            value(messages, addGenerationPrompt, tools, enableThinking) {
+                return applyChatTemplateFromModelPath(this, messages, addGenerationPrompt, tools, enableThinking, templateContentPolicy);
+            },
+        });
     }
+    return StreamingModelImpl;
 }
 /**
- * LFM2 model wrapper.
+ * Qwen3.5 dense model with AsyncGenerator-based session streaming.
  *
- * Streaming is driven through the `ChatSession` API — overrides below
- * adapt the callback-based native methods to
- * `AsyncGenerator<ChatStreamEvent>` so the wrapper structurally
- * satisfies `SessionCapableModel`. LFM2 is text-only; the native
- * `images` guard rejects non-empty image sets with an
- * `IMAGE_CHANGE_REQUIRES_SESSION_RESTART:` prefix.
+ * The empty `extends` inherits the factory's streaming overrides,
+ * `static load`, and `applyChatTemplate`, and supplies the concrete
+ * `.name === 'Qwen35Model'` and a working `instanceof`. Records its
+ * model path so `applyChatTemplate` can serve a lazily built tokenizer.
  */
-export class Lfm2Model extends Lfm2ModelNative {
-    static async load(modelPath) {
-        const instance = await Lfm2ModelNative.load(modelPath);
-        Object.setPrototypeOf(instance, Lfm2Model.prototype);
-        return instance;
-    }
-    /** Streaming variant of {@link Lfm2Model#chatSessionStart}. */
-    // @ts-expect-error — override callback-based native method with AsyncGenerator
-    async *chatStreamSessionStart(messages, config, signal) {
-        yield* _runChatStream((callback) => _nativeLfm2ChatStreamSessionStart.call(this, messages, config ?? null, callback), signal);
-    }
-    /** Streaming variant of {@link Lfm2Model#chatSessionContinue}. */
-    // @ts-expect-error — override callback-based native method with AsyncGenerator
-    async *chatStreamSessionContinue(userMessage, images, config, signal) {
-        yield* _runChatStream((callback) => _nativeLfm2ChatStreamSessionContinue.call(this, userMessage, images, config ?? null, callback), signal);
-    }
-    /** Streaming variant of {@link Lfm2Model#chatSessionContinueTool}. */
-    // @ts-expect-error — override callback-based native method with AsyncGenerator
-    async *chatStreamSessionContinueTool(toolCallId, content, config, signal) {
-        yield* _runChatStream((callback) => _nativeLfm2ChatStreamSessionContinueTool.call(this, toolCallId, content, config ?? null, callback), signal);
-    }
+export class Qwen35Model extends makeStreamingModel(Qwen35ModelNative, {
+    recordModelPath: true,
+}) {
 }
-/**
- * Gemma4 model wrapper.
- *
- * Streaming is driven through the `ChatSession` API — overrides below
- * adapt the callback-based native methods to
- * `AsyncGenerator<ChatStreamEvent>` so the wrapper structurally
- * satisfies `SessionCapableModel`. Gemma4 is text-only in the
- * current refactor scope; the native `images` guard rejects non-empty
- * image sets with an `IMAGE_CHANGE_REQUIRES_SESSION_RESTART:` prefix.
- */
-export class Gemma4Model extends Gemma4ModelNative {
-    static async load(modelPath) {
-        const instance = await Gemma4ModelNative.load(modelPath);
-        Object.setPrototypeOf(instance, Gemma4Model.prototype);
-        return instance;
-    }
-    /** Streaming variant of {@link Gemma4Model#chatSessionStart}. */
-    // @ts-expect-error — override callback-based native method with AsyncGenerator
-    async *chatStreamSessionStart(messages, config, signal) {
-        yield* _runChatStream((callback) => _nativeGemma4ChatStreamSessionStart.call(this, messages, config ?? null, callback), signal);
-    }
-    /** Streaming variant of {@link Gemma4Model#chatSessionContinue}. */
-    // @ts-expect-error — override callback-based native method with AsyncGenerator
-    async *chatStreamSessionContinue(userMessage, images, config, signal) {
-        yield* _runChatStream((callback) => _nativeGemma4ChatStreamSessionContinue.call(this, userMessage, images, config ?? null, callback), signal);
-    }
-    /** Streaming variant of {@link Gemma4Model#chatSessionContinueTool}. */
-    // @ts-expect-error — override callback-based native method with AsyncGenerator
-    async *chatStreamSessionContinueTool(toolCallId, content, config, signal) {
-        yield* _runChatStream((callback) => _nativeGemma4ChatStreamSessionContinueTool.call(this, toolCallId, content, config ?? null, callback), signal);
-    }
+/** Qwen3.5 MoE model — see {@link Qwen35Model} for the wrapper shape. */
+export class Qwen35MoeModel extends makeStreamingModel(Qwen35MoeModelNative, {
+    recordModelPath: true,
+}) {
+}
+/** LFM2 model (text-only) — see {@link Qwen35Model} for the wrapper shape. */
+export class Lfm2Model extends makeStreamingModel(Lfm2ModelNative, {
+    recordModelPath: true,
+    replayAssistantRawText: true,
+}) {
+}
+/** Gemma4 model (text-only) — see {@link Qwen35Model} for the wrapper shape. */
+export class Gemma4Model extends makeStreamingModel(Gemma4ModelNative, {
+    recordModelPath: true,
+}) {
 }
 /**
- * Qwen3 (legacy) model wrapper.
+ * Qwen3 (first-gen, text-only) model.
  *
- * Streaming is driven through the `ChatSession` API — overrides below
- * adapt the callback-based native methods to
- * `AsyncGenerator<ChatStreamEvent>` so the wrapper structurally
- * satisfies `SessionCapableModel`. Qwen3 legacy is text-only; the
- * native `images` guard rejects non-empty image sets with an
- * `IMAGE_CHANGE_REQUIRES_SESSION_RESTART:` prefix.
+ * Records its model path (so prototype-set + path-recording match the
+ * other families) but does not install the factory's path-backed
+ * `applyChatTemplate`; it retains the native tokenizer-backed method.
  */
-export class Qwen3Model extends Qwen3ModelNative {
-    static async load(modelPath) {
-        const instance = await Qwen3ModelNative.load(modelPath);
-        Object.setPrototypeOf(instance, Qwen3Model.prototype);
-        return instance;
-    }
-    /** Streaming variant of {@link Qwen3Model#chatSessionStart}. */
-    // @ts-expect-error — override callback-based native method with AsyncGenerator
-    async *chatStreamSessionStart(messages, config, signal) {
-        yield* _runChatStream((callback) => _nativeQwen3ChatStreamSessionStart.call(this, messages, config ?? null, callback), signal);
-    }
-    /** Streaming variant of {@link Qwen3Model#chatSessionContinue}. */
-    // @ts-expect-error — override callback-based native method with AsyncGenerator
-    async *chatStreamSessionContinue(userMessage, images, config, signal) {
-        yield* _runChatStream((callback) => _nativeQwen3ChatStreamSessionContinue.call(this, userMessage, images, config ?? null, callback), signal);
-    }
-    /** Streaming variant of {@link Qwen3Model#chatSessionContinueTool}. */
-    // @ts-expect-error — override callback-based native method with AsyncGenerator
-    async *chatStreamSessionContinueTool(toolCallId, content, config, signal) {
-        yield* _runChatStream((callback) => _nativeQwen3ChatStreamSessionContinueTool.call(this, toolCallId, content, config ?? null, callback), signal);
-    }
+export class Qwen3Model extends makeStreamingModel(Qwen3ModelNative, {
+    recordModelPath: true,
+    applyTemplate: false,
+}) {
 }
 // -------------------------------------------------------------------
 // Compile-time conformance check
 // -------------------------------------------------------------------
 //
-// Ensures each wrapper class structurally satisfies
-// `SessionCapableModel` so `ChatSession<XxxModel>` will type-check in
-// downstream code. The assignments are compile-only — the
-// `null as unknown as T` placeholder never runs. If a wrapper's
-// override signature drifts away from the interface, TypeScript will
-// fail to compile this block, surfacing the regression at build time.
+// Ensures each family class structurally satisfies
+// `SessionCapableModel` so `ChatSession<XxxModel>` type-checks in
+// downstream code. Compile-only — the `null as unknown as T`
+// placeholder never runs. If a factory override signature drifts away
+// from the interface, this block fails to compile.
 function _assertSessionCapable() {
     const _qwen35 = null;
     const _moe = null;
@@ -415,3 +352,29 @@ function _assertSessionCapable() {
     void _qwen3;
 }
 void _assertSessionCapable;
+/** Compile-time guard that both Qwen3.5 native classes and wrappers retain the exact media planner. */
+function _assertExpandedPromptPlannerSurfaces() {
+    const _nativeDense = null;
+    const _nativeMoe = null;
+    const _wrappedDense = null;
+    const _wrappedMoe = null;
+    void _nativeDense;
+    void _nativeMoe;
+    void _wrappedDense;
+    void _wrappedMoe;
+}
+void _assertExpandedPromptPlannerSurfaces;
+/** Compile-time guard that the factory preserves every non-streaming native member. */
+function _assertPreservedNativeSurfaces() {
+    const _qwen3 = null;
+    const _qwen35 = null;
+    const _moe = null;
+    const _lfm2 = null;
+    const _gemma4 = null;
+    void _qwen3;
+    void _qwen35;
+    void _moe;
+    void _lfm2;
+    void _gemma4;
+}
+void _assertPreservedNativeSurfaces;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mlx-node/lm",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "homepage": "https://github.com/mlx-node/mlx-node",
   "bugs": {
     "url": "https://github.com/mlx-node/mlx-node/issues"
@@ -28,9 +28,9 @@
     "test": "vite test run"
   },
   "dependencies": {
-    "@mlx-node/core": "0.0.7"
+    "@mlx-node/core": "0.0.9"
   },
   "devDependencies": {
-    "@types/node": "^25.6.0"
+    "@types/node": "^26.0.0"
   }
 }