@mlx-node/lm 0.0.6 → 0.0.8

package/dist/stream.js

@@ -1,19 +1,64 @@
-import { Qwen35Model as Qwen35ModelNative, Qwen35MoeModel as Qwen35MoeModelNative } from '@mlx-node/core';
-// Save references to the native callback-based methods before we override them
-// oxlint-disable-next-line @typescript-eslint/unbound-method
-const _nativeDenseChatStream = Qwen35ModelNative.prototype.chatStream;
-// oxlint-disable-next-line @typescript-eslint/unbound-method
-const _nativeMoeChatStream = Qwen35MoeModelNative.prototype.chatStream;
+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) {
+    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;
+    return tokenizer.applyChatTemplate(messages, addGenerationPrompt, tools, enableThinking);
+}
 /**
- * Shared AsyncGenerator implementation that wraps a native callback-based
- * chatStream into a `for await...of`-compatible stream.
+ * Shared AsyncGenerator adapter for callback-based native streaming methods.
  *
- * Cancellation is automatic via the generator's `finally` block.
+ * Takes a `startCall` closure that, given the JS-side callback, dispatches
+ * the underlying native stream (whatever method signature that is — the
+ * closure captures `messages` / `config` / `userMessage` etc) and resolves
+ * with a `ChatStreamHandle`. The generator pumps the resulting chunk queue,
+ * transforms each chunk into a `ChatStreamEvent`, and calls `handle.cancel()`
+ * in a `finally` block so early termination (user `break`, exception) still
+ * cleans up native state.
+ *
+ * ## Signal-driven fast-abort
+ *
+ * When an optional `AbortSignal` is supplied and fires, the adapter:
+ *   1. Calls `handle.cancel()` immediately so the native decode stops
+ *      on the next safepoint rather than running to completion.
+ *   2. Wakes the pending `waitForItem()` await by pushing a synthetic
+ *      "aborted" marker into the queue and calling `notify()`. Without
+ *      this wake-up the generator would stay parked on the `await`
+ *      until the next native chunk arrived, which on a fast-abort
+ *      path (client disconnect before first token) never happens.
+ *   3. The generator sees the marker, breaks out of its loop, and the
+ *      finally block runs `cancelOnce()` — which is a no-op because
+ *      `triggerAbort` already flipped the `cancelled` flag. Some
+ *      backends throw on double-cancel, so routing every cancel site
+ *      through `cancelOnce` keeps abort behavior deterministic.
+ *
+ * The finally block is also the landing site for the consumer calling
+ * `.return()` on the outer generator — the existing `yield` cleanup
+ * covers that case. Signal-driven abort covers the window where the
+ * consumer cannot reach `.return()` because they are blocked waiting
+ * for the very `yield` that `waitForItem()` is gating.
+ *
+ * @internal Exported so the VLM wrapper (`@mlx-node/vlm`) can reuse the
+ * exact same bridge without duplicating the plumbing. Not part of the
+ * public API — may change without notice.
  */
-/** @internal Exported for testing only. */
-export async function* _createChatStream(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-nativeMethod, self, messages, config) {
+export async function* _runChatStream(startCall, signal) {
     const queue = [];
     let resolve = null;
     const waitForItem = () => queue.length > 0
@@ -32,77 +77,274 @@ nativeMethod, self, messages, config) {
         queue.push(err ? { error: err } : { chunk });
         notify();
     };
-    const handle = await nativeMethod.call(self, messages, config ?? null, callback);
+    const handle = await startCall(callback);
+    // Guard against double-cancel. Some native backends throw on a
+    // second `cancel()`; we route every cancel site through this
+    // helper so the abort path (via `triggerAbort`) and the unwind
+    // path (via the `finally` block) don't cancel twice and so any
+    // backend that does throw is swallowed rather than escaping as
+    // an error out of an otherwise-clean early termination.
+    let cancelled = false;
+    const cancelOnce = () => {
+        if (cancelled)
+            return;
+        cancelled = true;
+        try {
+            handle.cancel();
+        }
+        catch {
+            // Native backend threw on cancel — nothing actionable here.
+            // Swallow so aborted streams still surface as a clean early
+            // termination via the synthetic `aborted` marker rather than
+            // as an unexpected error out of the generator.
+        }
+    };
+    // Signal-driven fast-abort. If the signal is already aborted at
+    // attach time we still arm the listener so the synchronous abort
+    // dispatch path runs below (calling `handle.cancel()` after the
+    // handle is in hand, not before — there is nothing to cancel
+    // pre-start). For an already-fired signal Node delivers the
+    // `'abort'` event on the next microtask.
+    let onAbort = null;
+    if (signal != null) {
+        const triggerAbort = () => {
+            // Cancel the native side first so any work-in-flight winds
+            // down ASAP. `cancelOnce` is idempotent — the finally block
+            // will invoke it again after the generator unwinds, but the
+            // second call becomes a no-op.
+            cancelOnce();
+            // Push a synthetic abort marker so the consumer-visible
+            // generator breaks out of its loop at the next iteration
+            // rather than waiting for a native chunk that will never
+            // arrive (e.g. client disconnect before first token).
+            queue.push({ aborted: true });
+            notify();
+        };
+        if (signal.aborted) {
+            // Signal already fired before we could attach — dispatch
+            // synchronously so the waitForItem below resolves immediately.
+            triggerAbort();
+        }
+        else {
+            onAbort = triggerAbort;
+            signal.addEventListener('abort', onAbort, { once: true });
+        }
+    }
     try {
-        while (true) {
+        loop: while (true) {
             await waitForItem();
             while (queue.length > 0) {
                 const item = queue.shift();
+                if (item.aborted) {
+                    // Consumer asked us to stop before the next chunk landed.
+                    // Break out so the finally block runs `handle.cancel()`
+                    // (idempotent — `triggerAbort` already called it) and the
+                    // consumer-side `for await` unblocks cleanly. We do NOT
+                    // throw an AbortError: callers (e.g. server endpoints that
+                    // flag client disconnect) have already decided this is not
+                    // an error from their perspective, just an early stop.
+                    break loop;
+                }
                 if (item.error)
                     throw item.error;
                 const chunk = item.chunk;
                 if (chunk.done) {
-                    yield {
+                    // 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,
                         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;
+                    }
+                    yield finalEvent;
                     return;
                 }
-                yield { text: chunk.text, done: false };
+                const delta = { text: chunk.text, done: false };
+                const isReasoning = getNativeIsReasoning(chunk);
+                if (isReasoning !== undefined) {
+                    delta.isReasoning = isReasoning;
+                }
+                yield delta;
             }
         }
     }
     finally {
-        handle.cancel();
+        if (signal != null && onAbort != null) {
+            try {
+                signal.removeEventListener('abort', onAbort);
+            }
+            catch {
+                // removeEventListener shouldn't throw, but stay defensive —
+                // a misbehaving signal must not leak out of the finally.
+            }
+        }
+        cancelOnce();
     }
 }
 /**
- * Qwen3.5 dense model with AsyncGenerator-based `chatStream()`.
+ * Build the streaming-model subclass for a native chat model class.
+ *
+ * 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`).
  *
- * @example
- * ```typescript
- * const model = await Qwen35Model.load('./models/qwen3.5-3b');
- * for await (const event of model.chatStream(messages)) {
- *   if (!event.done) process.stdout.write(event.text);
- * }
- * ```
+ * @internal Exported so the VLM wrapper (`@mlx-node/vlm`) builds its
+ * `QianfanOCRModel` from the same factory. Not part of the public API.
  */
-export class Qwen35Model extends Qwen35ModelNative {
-    static async load(modelPath) {
-        const instance = await Qwen35ModelNative.load(modelPath);
-        Object.setPrototypeOf(instance, Qwen35Model.prototype);
-        return instance;
+export function makeStreamingModel(NativeClass, opts) {
+    const recordPath = opts.recordModelPath;
+    const applyTemplate = opts.applyTemplate ?? recordPath;
+    // 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 {
+        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(userMessage, images, audio, config, signal) {
+            yield* _runChatStream((callback) => nativeContinue.call(this, userMessage, images, audio, (config ?? null), callback), signal);
+        }
+        async *chatStreamSessionContinueTool(toolCallId, content, config, signal, isError) {
+            yield* _runChatStream((callback) => nativeContinueTool.call(this, toolCallId, content, (config ?? null), callback, (isError ?? null)), signal);
+        }
     }
-    // @ts-expect-error — override callback-based chatStream with AsyncGenerator
-    async *chatStream(messages, config) {
-        yield* _createChatStream(_nativeDenseChatStream, this, messages, config);
+    if (applyTemplate) {
+        Object.defineProperty(StreamingModelImpl.prototype, 'applyChatTemplate', {
+            configurable: true,
+            writable: true,
+            value(messages, addGenerationPrompt, tools, enableThinking) {
+                return applyChatTemplateFromModelPath(this, messages, addGenerationPrompt, tools, enableThinking);
+            },
+        });
     }
+    return StreamingModelImpl;
 }
 /**
- * Qwen3.5 MoE model with AsyncGenerator-based `chatStream()`.
+ * Qwen3.5 dense model with AsyncGenerator-based session streaming.
  *
- * @example
- * ```typescript
- * const model = await Qwen35MoeModel.load('./models/qwen3.5-moe');
- * for await (const event of model.chatStream(messages)) {
- *   if (!event.done) process.stdout.write(event.text);
- * }
- * ```
+ * 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 Qwen35MoeModel extends Qwen35MoeModelNative {
-    static async load(modelPath) {
-        const instance = await Qwen35MoeModelNative.load(modelPath);
-        Object.setPrototypeOf(instance, Qwen35MoeModel.prototype);
-        return instance;
-    }
-    // @ts-expect-error — override callback-based chatStream with AsyncGenerator
-    async *chatStream(messages, config) {
-        yield* _createChatStream(_nativeMoeChatStream, this, messages, config);
-    }
+export class Qwen35Model extends makeStreamingModel(Qwen35ModelNative, { recordModelPath: true }) {
+}
+/** 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 }) {
+}
+/** Gemma4 model (text-only) — see {@link Qwen35Model} for the wrapper shape. */
+export class Gemma4Model extends makeStreamingModel(Gemma4ModelNative, { recordModelPath: true }) {
+}
+/**
+ * Qwen3 (first-gen, text-only) model.
+ *
+ * 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 makeStreamingModel(Qwen3ModelNative, {
+    recordModelPath: true,
+    applyTemplate: false,
+}) {
+}
+// -------------------------------------------------------------------
+// Compile-time conformance check
+// -------------------------------------------------------------------
+//
+// 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;
+    const _lfm2 = null;
+    const _gemma4 = null;
+    const _qwen3 = null;
+    void _qwen35;
+    void _moe;
+    void _lfm2;
+    void _gemma4;
+    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/dist/tools/index.d.ts

@@ -1,27 +1,54 @@
 /**
- * Tool calling utilities for Qwen3
+ * Tool calling utilities
  *
- * Provides types and helpers for working with tool/function calling in the chat() API.
+ * Provides types and helpers for working with tool/function calling
+ * through the `ChatSession` API. Tools are passed via `ChatConfig.tools`
+ * on `session.send()`, and a tool result is fed back through
+ * `session.sendToolResult()`.
+ *
+ * **Single tool call per assistant turn.** Each `sendToolResult(...)`
+ * call appends one tool message and immediately re-opens the assistant
+ * turn, so the session API only supports assistant turns that emit
+ * exactly one tool call. If the model emits multiple tool calls in a
+ * single turn, the caller must treat that as an unsupported state:
+ * throw, surface an error to the user, or tighten the system prompt /
+ * tool spec so the model produces at most one call per turn. Do **not**
+ * loop `sendToolResult` across the remaining calls — later results
+ * would be interleaved with a new assistant reply from the first, and
+ * the conversation state would become inconsistent (especially for
+ * stateful tools whose effects must land in order).
  *
  * @example
  * ```typescript
- * import { createToolDefinition, formatToolResponse } from '@mlx-node/lm';
+ * import { createToolDefinition, loadSession } from '@mlx-node/lm';
  *
  * const weatherTool = createToolDefinition(
  *   'get_weather',
  *   'Get weather for a location',
  *   { location: { type: 'string', description: 'City name' } },
- *   ['location']
+ *   ['location'],
  * );
  *
- * const result = await model.chat(messages, { tools: [weatherTool] });
+ * const session = await loadSession('./my-model');
+ *
+ * const result = await session.send('What is the weather in Tokyo?', {
+ *   config: { tools: [weatherTool] },
+ * });
  *
- * for (const call of result.toolCalls) {
- *   if (call.status === 'ok') {
- *     const toolResult = await executeMyTool(call.name, call.arguments);
- *     // Continue conversation with tool result
- *     messages.push({ role: 'user', content: formatToolResponse(toolResult) });
- *   }
+ * const okCalls = result.toolCalls.filter((c) => c.status === 'ok');
+ * if (okCalls.length > 1) {
+ *   throw new Error(
+ *     `ChatSession only supports one tool call per assistant turn; ` +
+ *       `model emitted ${okCalls.length}. Tighten the prompt or tool spec.`,
+ *   );
+ * }
+ * const call = okCalls[0];
+ * if (call) {
+ *   const toolOutput = await executeMyTool(call.name, call.arguments);
+ *   const followUp = await session.sendToolResult(call.id, JSON.stringify(toolOutput), {
+ *     config: { tools: [weatherTool] },
+ *   });
+ *   console.log(followUp.text);
  * }
  * ```
  *

package/dist/tools/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tools/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,cAAc,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tools/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AAEH,cAAc,YAAY,CAAC"}

package/dist/tools/index.js

@@ -1,27 +1,54 @@
 /**
- * Tool calling utilities for Qwen3
+ * Tool calling utilities
  *
- * Provides types and helpers for working with tool/function calling in the chat() API.
+ * Provides types and helpers for working with tool/function calling
+ * through the `ChatSession` API. Tools are passed via `ChatConfig.tools`
+ * on `session.send()`, and a tool result is fed back through
+ * `session.sendToolResult()`.
+ *
+ * **Single tool call per assistant turn.** Each `sendToolResult(...)`
+ * call appends one tool message and immediately re-opens the assistant
+ * turn, so the session API only supports assistant turns that emit
+ * exactly one tool call. If the model emits multiple tool calls in a
+ * single turn, the caller must treat that as an unsupported state:
+ * throw, surface an error to the user, or tighten the system prompt /
+ * tool spec so the model produces at most one call per turn. Do **not**
+ * loop `sendToolResult` across the remaining calls — later results
+ * would be interleaved with a new assistant reply from the first, and
+ * the conversation state would become inconsistent (especially for
+ * stateful tools whose effects must land in order).
  *
  * @example
  * ```typescript
- * import { createToolDefinition, formatToolResponse } from '@mlx-node/lm';
+ * import { createToolDefinition, loadSession } from '@mlx-node/lm';
  *
  * const weatherTool = createToolDefinition(
  *   'get_weather',
  *   'Get weather for a location',
  *   { location: { type: 'string', description: 'City name' } },
- *   ['location']
+ *   ['location'],
  * );
  *
- * const result = await model.chat(messages, { tools: [weatherTool] });
+ * const session = await loadSession('./my-model');
+ *
+ * const result = await session.send('What is the weather in Tokyo?', {
+ *   config: { tools: [weatherTool] },
+ * });
  *
- * for (const call of result.toolCalls) {
- *   if (call.status === 'ok') {
- *     const toolResult = await executeMyTool(call.name, call.arguments);
- *     // Continue conversation with tool result
- *     messages.push({ role: 'user', content: formatToolResponse(toolResult) });
- *   }
+ * const okCalls = result.toolCalls.filter((c) => c.status === 'ok');
+ * if (okCalls.length > 1) {
+ *   throw new Error(
+ *     `ChatSession only supports one tool call per assistant turn; ` +
+ *       `model emitted ${okCalls.length}. Tighten the prompt or tool spec.`,
+ *   );
+ * }
+ * const call = okCalls[0];
+ * if (call) {
+ *   const toolOutput = await executeMyTool(call.name, call.arguments);
+ *   const followUp = await session.sendToolResult(call.id, JSON.stringify(toolOutput), {
+ *     config: { tools: [weatherTool] },
+ *   });
+ *   console.log(followUp.text);
  * }
  * ```
  *

package/dist/tools/types.d.ts

@@ -164,7 +164,8 @@ export interface ApplyChatTemplateOptions {
  * @param description - Description of what the function does
  * @param properties - Object defining the function parameters (will be JSON stringified)
  * @param required - Array of required parameter names
- * @returns A properly formatted ToolDefinition ready for use with model.chat()
+ * @returns A properly formatted ToolDefinition ready to pass via `ChatConfig.tools`
+ *   on `ChatSession.send()` / `sendToolResult()`.
  *
  * @example
  * ```typescript
@@ -173,34 +174,13 @@ export interface ApplyChatTemplateOptions {
  *   'Get weather information for a location',
  *   {
  *     location: { type: 'string', description: 'City name' },
- *     units: { type: 'string', enum: ['celsius', 'fahrenheit'] }
+ *     units: { type: 'string', enum: ['celsius', 'fahrenheit'] },
  *   },
- *   ['location']
+ *   ['location'],
  * );
  *
- * const result = await model.chat(messages, { tools: [weatherTool] });
+ * const result = await session.send(userPrompt, { config: { tools: [weatherTool] } });
  * ```
  */
 export declare function createToolDefinition(name: string, description?: string, properties?: Record<string, FunctionParameterProperty>, required?: string[]): ToolDefinition;
-/**
- * Format a tool response for inclusion in a message
- *
- * Creates a properly formatted tool response string that can be used
- * in tool messages when continuing a conversation after a tool call.
- *
- * @param content - The response content (will be JSON stringified if object)
- * @returns Formatted tool response string wrapped in `<tool_response>` tags
- *
- * @example
- * ```typescript
- * // After executing a tool call from model.chat()
- * const toolResult = await executeMyTool(call.arguments);
- * const responseMessage = {
- *   role: 'user',
- *   content: formatToolResponse(toolResult)
- * };
- * const finalResult = await model.chat([...messages, responseMessage]);
- * ```
- */
-export declare function formatToolResponse(content: unknown): string;
 //# sourceMappingURL=types.d.ts.map

package/dist/tools/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/tools/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,UAAU,CAAC;AAElC;;;;;GAKG;AACH,MAAM,WAAW,yBAAyB;IACxC,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,SAAS,GAAG,OAAO,GAAG,QAAQ,CAAC;IACvE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,CAAC,EAAE,yBAAyB,CAAC;IAClC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,yBAAyB,CAAC,CAAC;IACvD,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,kBAAkB;IACjC,sDAAsD;IACtD,IAAI,EAAE,QAAQ,CAAC;IACf;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,uCAAuC;IACvC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,2BAA2B;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,4CAA4C;IAC5C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,8CAA8C;IAC9C,UAAU,CAAC,EAAE,kBAAkB,CAAC;CACjC;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,yDAAyD;IACzD,IAAI,EAAE,QAAQ,CAAC;IACf,0BAA0B;IAC1B,QAAQ,EAAE,kBAAkB,CAAC;CAC9B;AAED;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,mDAAmD;IACnD,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,wCAAwC;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,mDAAmD;IACnD,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,WAAW,GAAG,MAAM,CAAC;AAEhE;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC,mBAAmB;IACnB,IAAI,EAAE,QAAQ,CAAC;IACf,sBAAsB;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,gEAAgE;IAChE,SAAS,CAAC,EAAE,QAAQ,EAAE,CAAC;IACvB,qEAAqE;IACrE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,mEAAmE;IACnE,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,8DAA8D;IAC9D,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,qDAAqD;IACrD,KAAK,CAAC,EAAE,cAAc,EAAE,CAAC;IACzB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,EACZ,WAAW,CAAC,EAAE,MAAM,EACpB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,yBAAyB,CAAC,EACtD,QAAQ,CAAC,EAAE,MAAM,EAAE,GAClB,cAAc,CAehB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAK3D"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/tools/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,UAAU,CAAC;AAElC;;;;;GAKG;AACH,MAAM,WAAW,yBAAyB;IACxC,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,SAAS,GAAG,OAAO,GAAG,QAAQ,CAAC;IACvE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,CAAC,EAAE,yBAAyB,CAAC;IAClC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,yBAAyB,CAAC,CAAC;IACvD,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,kBAAkB;IACjC,sDAAsD;IACtD,IAAI,EAAE,QAAQ,CAAC;IACf;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,uCAAuC;IACvC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,2BAA2B;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,4CAA4C;IAC5C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,8CAA8C;IAC9C,UAAU,CAAC,EAAE,kBAAkB,CAAC;CACjC;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,yDAAyD;IACzD,IAAI,EAAE,QAAQ,CAAC;IACf,0BAA0B;IAC1B,QAAQ,EAAE,kBAAkB,CAAC;CAC9B;AAED;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,mDAAmD;IACnD,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,wCAAwC;IACxC,IAAI,EAAE,MAAM,CAAC;IACb,mDAAmD;IACnD,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,WAAW,GAAG,MAAM,CAAC;AAEhE;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC,mBAAmB;IACnB,IAAI,EAAE,QAAQ,CAAC;IACf,sBAAsB;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,gEAAgE;IAChE,SAAS,CAAC,EAAE,QAAQ,EAAE,CAAC;IACvB,qEAAqE;IACrE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,mEAAmE;IACnE,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC,8DAA8D;IAC9D,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,qDAAqD;IACrD,KAAK,CAAC,EAAE,cAAc,EAAE,CAAC;IACzB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,EACZ,WAAW,CAAC,EAAE,MAAM,EACpB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,yBAAyB,CAAC,EACtD,QAAQ,CAAC,EAAE,MAAM,EAAE,GAClB,cAAc,CAehB"}

package/dist/tools/types.js

@@ -40,7 +40,8 @@
  * @param description - Description of what the function does
  * @param properties - Object defining the function parameters (will be JSON stringified)
  * @param required - Array of required parameter names
- * @returns A properly formatted ToolDefinition ready for use with model.chat()
+ * @returns A properly formatted ToolDefinition ready to pass via `ChatConfig.tools`
+ *   on `ChatSession.send()` / `sendToolResult()`.
  *
  * @example
  * ```typescript
@@ -49,12 +50,12 @@
  *   'Get weather information for a location',
  *   {
  *     location: { type: 'string', description: 'City name' },
- *     units: { type: 'string', enum: ['celsius', 'fahrenheit'] }
+ *     units: { type: 'string', enum: ['celsius', 'fahrenheit'] },
  *   },
- *   ['location']
+ *   ['location'],
  * );
  *
- * const result = await model.chat(messages, { tools: [weatherTool] });
+ * const result = await session.send(userPrompt, { config: { tools: [weatherTool] } });
  * ```
  */
 export function createToolDefinition(name, description, properties, required) {
@@ -73,29 +74,3 @@ export function createToolDefinition(name, description, properties, required) {
         },
     };
 }
-/**
- * Format a tool response for inclusion in a message
- *
- * Creates a properly formatted tool response string that can be used
- * in tool messages when continuing a conversation after a tool call.
- *
- * @param content - The response content (will be JSON stringified if object)
- * @returns Formatted tool response string wrapped in `<tool_response>` tags
- *
- * @example
- * ```typescript
- * // After executing a tool call from model.chat()
- * const toolResult = await executeMyTool(call.arguments);
- * const responseMessage = {
- *   role: 'user',
- *   content: formatToolResponse(toolResult)
- * };
- * const finalResult = await model.chat([...messages, responseMessage]);
- * ```
- */
-export function formatToolResponse(content) {
-    const contentStr = typeof content === 'string' ? content : JSON.stringify(content);
-    // Qwen3/3.5 expects <tool_response> XML wrapping for tool results.
-    // Other model families may require a different format.
-    return `<tool_response>\n${contentStr}\n</tool_response>`;
-}