@qvac/sdk 0.14.1 → 0.15.0

package/dist/examples/batch-completion.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Batch completion — continuous batching over a single loaded LLM.
+ *
+ * `batchCompletion()` submits multiple prompts to one loaded model in a single
+ * call so the llama.cpp addon can decode the active sequences together. Load the
+ * model with `modelConfig.parallel >= 2` to make the concurrent slots available.
+ *
+ * The returned `BatchCompletionRun` exposes:
+ *  - `events`     — a merged `AsyncIterable<{ id, event }>` across all prompts.
+ *  - `byId(id)`   — per-prompt `events` and a `final` aggregation for one prompt.
+ *  - `ids`        — a `Promise<string[]>` of addon-assigned ids in prompt order.
+ *  - `results`    — a `Promise<BatchCompletionResult[]>` in prompt order. It is
+ *                   ALL-OR-NOTHING for stream-level failures: if the batch
+ *                   handler throws (e.g. a context overflow) the whole run
+ *                   rejects and no per-prompt finals can be recovered. Graceful
+ *                   terminal events such as cancellation still settle each
+ *                   `byId(id).final` according to that id's terminal state.
+ *  - `stats`      — a `Promise<CompletionStats | undefined>`. Stats are
+ *                   BATCH-LEVEL: the addon aggregates decode metrics across the
+ *                   whole batch (e.g. `avgConcurrentSeq`, total tokens), so they
+ *                   surface once here rather than per prompt. Per-prompt
+ *                   `final.stats` is intentionally left undefined.
+ *
+ * Each prompt may additionally carry (not shown here to keep the run fast/cheap):
+ *  - `tools` / `mcp`  — per-prompt tools; handlers attach only to tool calls
+ *                       produced by that prompt. Requires a tool-capable model
+ *                       loaded with `modelConfig.tools: true` (e.g. Qwen). See
+ *                       the `tools/` examples for the tool-calling surface.
+ *  - `attachments`    — the same multimodal attachments `completion()` supports,
+ *                       when the loaded model has a projection model.
+ *  - `responseFormat` — `json_object` / `json_schema` (cannot be combined with
+ *                       `tools` or `mcp`, which already constrain output).
+ *
+ * Run from packages/sdk:
+ *   bun run examples/batch-completion.ts
+ */
+export {};
+//# sourceMappingURL=batch-completion.d.ts.map

package/dist/examples/batch-completion.js

@@ -0,0 +1,100 @@
+/**
+ * Batch completion — continuous batching over a single loaded LLM.
+ *
+ * `batchCompletion()` submits multiple prompts to one loaded model in a single
+ * call so the llama.cpp addon can decode the active sequences together. Load the
+ * model with `modelConfig.parallel >= 2` to make the concurrent slots available.
+ *
+ * The returned `BatchCompletionRun` exposes:
+ *  - `events`     — a merged `AsyncIterable<{ id, event }>` across all prompts.
+ *  - `byId(id)`   — per-prompt `events` and a `final` aggregation for one prompt.
+ *  - `ids`        — a `Promise<string[]>` of addon-assigned ids in prompt order.
+ *  - `results`    — a `Promise<BatchCompletionResult[]>` in prompt order. It is
+ *                   ALL-OR-NOTHING for stream-level failures: if the batch
+ *                   handler throws (e.g. a context overflow) the whole run
+ *                   rejects and no per-prompt finals can be recovered. Graceful
+ *                   terminal events such as cancellation still settle each
+ *                   `byId(id).final` according to that id's terminal state.
+ *  - `stats`      — a `Promise<CompletionStats | undefined>`. Stats are
+ *                   BATCH-LEVEL: the addon aggregates decode metrics across the
+ *                   whole batch (e.g. `avgConcurrentSeq`, total tokens), so they
+ *                   surface once here rather than per prompt. Per-prompt
+ *                   `final.stats` is intentionally left undefined.
+ *
+ * Each prompt may additionally carry (not shown here to keep the run fast/cheap):
+ *  - `tools` / `mcp`  — per-prompt tools; handlers attach only to tool calls
+ *                       produced by that prompt. Requires a tool-capable model
+ *                       loaded with `modelConfig.tools: true` (e.g. Qwen). See
+ *                       the `tools/` examples for the tool-calling surface.
+ *  - `attachments`    — the same multimodal attachments `completion()` supports,
+ *                       when the loaded model has a projection model.
+ *  - `responseFormat` — `json_object` / `json_schema` (cannot be combined with
+ *                       `tools` or `mcp`, which already constrain output).
+ *
+ * Run from packages/sdk:
+ *   bun run examples/batch-completion.ts
+ */
+import { batchCompletion, loadModel, unloadModel, LLAMA_3_2_1B_INST_Q4_0 } from '@qvac/sdk';
+try {
+    // `parallel: 4` opens the concurrent decode slots continuous batching needs.
+    const modelId = await loadModel({
+        modelSrc: LLAMA_3_2_1B_INST_Q4_0,
+        modelType: 'llm',
+        modelConfig: { ctx_size: 4096, parallel: 4 },
+        onProgress: (p) => {
+            const mb = (n) => (n / 1e6).toFixed(1);
+            const line = `▸ Downloading ${p.percentage.toFixed(0)}% (${mb(p.downloaded)}/${mb(p.total)} MB)`;
+            process.stderr.write(process.stderr.isTTY ? `\r${line}` : `${line}\n`);
+            if (p.percentage >= 100)
+                process.stderr.write('\n');
+        }
+    });
+    console.log(`▸ Model loaded: ${modelId}`);
+    const run = batchCompletion({
+        modelId,
+        prompts: [
+            {
+                id: 'cherry',
+                history: [{ role: 'user', content: 'Reply with only the word CHERRY.' }],
+                generationParams: { temp: 0, seed: 42, predict: 16 }
+            },
+            {
+                id: 'banana',
+                history: [{ role: 'user', content: 'Reply with only the word BANANA.' }],
+                generationParams: { temp: 0, seed: 42, predict: 16 }
+            },
+            {
+                id: 'grape',
+                history: [{ role: 'user', content: 'Reply with only the word GRAPE.' }],
+                generationParams: { temp: 0, seed: 42, predict: 16 }
+            }
+        ]
+    });
+    console.log('\n▸ Merged event stream (interleaved across prompts):');
+    for await (const { id, event } of run.events) {
+        if (event.type === 'contentDelta') {
+            process.stdout.write(`[${id}] ${event.text}`);
+        }
+    }
+    // `results` is ordered by prompt and all-or-nothing on stream-level failure.
+    const results = await run.results;
+    console.log('\n\n▸ Ordered results:');
+    for (const { id, final } of results) {
+        console.log(`  ▸ ${id}: ${final.contentText.replace(/\s+/g, ' ').trim()}`);
+    }
+    // Per-prompt aggregation is also available directly via `byId(id)`.
+    const ids = await run.ids;
+    const firstFinal = await run.byId(ids[0]).final;
+    console.log(`\n▸ byId("${ids[0]}").final -> ${firstFinal.contentText.trim()}`);
+    // Batch-level stats (a single CompletionStats for the whole run, or undefined).
+    const stats = await run.stats;
+    if (stats) {
+        console.log(`\n▸ Batch stats: ${stats.tokensPerSecond?.toFixed(1)} tok/s across the batch`);
+    }
+    await unloadModel({ modelId, clearStorage: false });
+    process.exit(0);
+}
+catch (error) {
+    console.error('✖', error);
+    process.exit(1);
+}

package/dist/examples/bci/bci-filesystem-streaming.js

@@ -8,44 +8,44 @@
  *
  * Usage: bun run examples/bci/bci-filesystem-streaming.ts <neural-bin-file-path>
  */
-import { loadModel, unloadModel, bciTranscribeStream, BCI_WINDOWED, } from "@qvac/sdk";
-import { readFileSync } from "fs";
+import { loadModel, unloadModel, bciTranscribeStream, BCI_WINDOWED } from '@qvac/sdk';
+import { readFileSync } from 'fs';
 const args = process.argv.slice(2);
 if (!args[0]) {
-    console.error("Usage: bun run examples/bci/bci-filesystem-streaming.ts <neural-bin-file-path>");
+    console.error('Usage: bun run examples/bci/bci-filesystem-streaming.ts <neural-bin-file-path>');
     process.exit(1);
 }
 const neuralFilePath = args[0];
 // Feed the neural buffer in fixed-size chunks to simulate a live stream.
 const CHUNK_SIZE = 64 * 1024;
 try {
-    console.log("▸ BCI transcribeStream file test");
+    console.log('▸ BCI transcribeStream file test');
     console.log(`▸ File: ${neuralFilePath}`);
     console.log(`▸ Chunk size: ${CHUNK_SIZE} bytes`);
-    console.log("▸ Loading model...");
+    console.log('▸ Loading model...');
     const modelId = await loadModel({
         modelSrc: BCI_WINDOWED,
         modelConfig: {
             whisperConfig: {
-                language: "en",
+                language: 'en',
                 n_threads: 4,
-                temperature: 0.0,
+                temperature: 0.0
             },
             // Session day index selects the day-specific projection matrices.
             // Set this to match the recording session your neural file came from.
             bciConfig: {
-                day_idx: 1,
-            },
-        },
+                day_idx: 1
+            }
+        }
     });
     console.log(`▸ Model loaded: ${modelId}`);
-    console.log("▸ Opening live session...");
-    const session = await bciTranscribeStream({ modelId, emit: "delta" });
-    console.log("▸ Session open. Streaming neural signal...");
+    console.log('▸ Opening live session...');
+    const session = await bciTranscribeStream({ modelId, emit: 'delta' });
+    console.log('▸ Session open. Streaming neural signal...');
     // Drain the session concurrently with writing so the sliding-window
     // decode can make progress as chunks arrive instead of stalling.
     const consume = (async () => {
-        let transcript = "";
+        let transcript = '';
         for await (const text of session) {
             transcript += text;
             process.stdout.write(text);
@@ -61,17 +61,17 @@ try {
         await new Promise((resolve) => setTimeout(resolve, 10));
     }
     console.log(`\n\n▸ Neural signal streamed: ${totalBytes} bytes`);
-    console.log("▸ Waiting for transcription to finish...");
+    console.log('▸ Waiting for transcription to finish...');
     session.end();
     const transcript = await consume;
-    console.log("\n▸ Results");
-    console.log(transcript.trim() || "(no text received)");
-    console.log("▸ Unloading model...");
+    console.log('\n▸ Results');
+    console.log(transcript.trim() || '(no text received)');
+    console.log('▸ Unloading model...');
     await unloadModel({ modelId });
-    console.log("▸ Done.");
+    console.log('▸ Done.');
     process.exit(0);
 }
 catch (error) {
-    console.error("✖", error);
+    console.error('✖', error);
     process.exit(1);
 }

package/dist/examples/bci/bci-filesystem.js

@@ -7,46 +7,46 @@
  *
  * Usage: bun run examples/bci/bci-filesystem.ts <neural-bin-file-path>
  */
-import { loadModel, unloadModel, bciTranscribe, BCI_WINDOWED, } from "@qvac/sdk";
+import { loadModel, unloadModel, bciTranscribe, BCI_WINDOWED } from '@qvac/sdk';
 const args = process.argv.slice(2);
 if (!args[0]) {
-    console.error("Usage: bun run examples/bci/bci-filesystem.ts <neural-bin-file-path>");
+    console.error('Usage: bun run examples/bci/bci-filesystem.ts <neural-bin-file-path>');
     process.exit(1);
 }
 const neuralFilePath = args[0];
 try {
-    console.log("▸ Starting BCI transcription example...");
-    console.log("▸ Loading BCI model...");
+    console.log('▸ Starting BCI transcription example...');
+    console.log('▸ Loading BCI model...');
     const modelId = await loadModel({
         modelSrc: BCI_WINDOWED,
         modelConfig: {
             whisperConfig: {
-                language: "en",
+                language: 'en',
                 n_threads: 4,
-                temperature: 0.0,
+                temperature: 0.0
             },
             // Session day index selects the day-specific projection matrices.
             // Set this to match the recording session your neural file came from.
             bciConfig: {
-                day_idx: 1,
-            },
+                day_idx: 1
+            }
         },
         onProgress: (p) => {
             const mb = (n) => (n / 1e6).toFixed(1);
             const line = `▸ Downloading ${p.percentage.toFixed(0)}% (${mb(p.downloaded)}/${mb(p.total)} MB)`;
             process.stderr.write(process.stderr.isTTY ? `\r${line}` : `${line}\n`);
             if (p.percentage >= 100)
-                process.stderr.write("\n");
-        },
+                process.stderr.write('\n');
+        }
     });
     console.log(`▸ BCI model loaded with ID: ${modelId}`);
-    console.log("▸ Transcribing neural signal...");
+    console.log('▸ Transcribing neural signal...');
     const segments = await bciTranscribe({
         modelId,
         neuralData: neuralFilePath,
-        metadata: true,
+        metadata: true
     });
-    console.log("▸ Transcription result:");
+    console.log('▸ Transcription result:');
     for (const segment of segments) {
         const start = (segment.startMs / 1000).toFixed(2);
         const end = (segment.endMs / 1000).toFixed(2);
@@ -54,14 +54,14 @@ try {
     }
     console.log(segments
         .map((s) => s.text)
-        .join("")
+        .join('')
         .trim());
-    console.log("▸ Unloading BCI model...");
+    console.log('▸ Unloading BCI model...');
     await unloadModel({ modelId });
-    console.log("▸ BCI model unloaded successfully");
+    console.log('▸ BCI model unloaded successfully');
     process.exit(0);
 }
 catch (error) {
-    console.error("✖", error);
+    console.error('✖', error);
     process.exit(1);
 }

package/dist/examples/cache-management.js

@@ -1,15 +1,15 @@
-import { WHISPER_TINY } from "../models/registry/index.js";
-import { downloadAsset, getModelInfo, loadModel, unloadModel } from "..";
+import { WHISPER_TINY } from '../models/registry/index.js';
+import { downloadAsset, getModelInfo, loadModel, unloadModel } from '..';
 const printModelStatus = (info, label) => {
     console.log(`\n▸ ${label}`);
     console.log(`▸ Model Name: ${info.name}`);
     console.log(`▸ Model ID: ${info.modelId}`);
-    console.log(`▸ Blob Core Key: ${info.blobCoreKey?.substring(0, 16) || "N/A"}...`);
+    console.log(`▸ Blob Core Key: ${info.blobCoreKey?.substring(0, 16) || 'N/A'}...`);
     console.log(`▸ Expected Size: ${(info.expectedSize / 1024 / 1024).toFixed(2)} MB`);
     console.log(`▸ Addon: ${info.addon}`);
     console.log(`▸ Cache Files: ${info.cacheFiles.length}`);
-    console.log(`▸ Is Cached: ${info.isCached ? "yes" : "no"}`);
-    console.log(`▸ Is Loaded: ${info.isLoaded ? "yes" : "no"}`);
+    console.log(`▸ Is Cached: ${info.isCached ? 'yes' : 'no'}`);
+    console.log(`▸ Is Loaded: ${info.isLoaded ? 'yes' : 'no'}`);
     if (info.isCached) {
         if (info.cacheFiles.length === 1) {
             console.log(`▸ Cache Path: ${info.cacheFiles[0]?.path}`);
@@ -30,67 +30,67 @@ const printModelStatus = (info, label) => {
     }
 };
 try {
-    console.log("▸ Model Cache Management Demo");
+    console.log('▸ Model Cache Management Demo');
     // 1. Check initial status
-    console.log("\n▸ 1. INITIAL STATUS CHECK");
+    console.log('\n▸ 1. INITIAL STATUS CHECK');
     const initialInfo = await getModelInfo(WHISPER_TINY);
-    printModelStatus(initialInfo, "Initial Status:");
+    printModelStatus(initialInfo, 'Initial Status:');
     // 2. Download if not cached
     if (!initialInfo.isCached) {
-        console.log("\n▸ 2. DOWNLOADING MODEL (not cached)");
-        console.log("▸ Downloading from hyperdrive...");
+        console.log('\n▸ 2. DOWNLOADING MODEL (not cached)');
+        console.log('▸ Downloading from hyperdrive...');
         await downloadAsset({ assetSrc: WHISPER_TINY });
-        console.log("▸ Download complete!");
+        console.log('▸ Download complete!');
         const afterDownload = await getModelInfo(WHISPER_TINY);
-        printModelStatus(afterDownload, "Status After Download:");
+        printModelStatus(afterDownload, 'Status After Download:');
     }
     else {
-        console.log("\n▸ 2. MODEL ALREADY CACHED");
-        console.log("▸ Skipping download...");
+        console.log('\n▸ 2. MODEL ALREADY CACHED');
+        console.log('▸ Skipping download...');
     }
     // 3. Load if not loaded
-    console.log("\n▸ 3. LOADING MODEL INTO MEMORY");
+    console.log('\n▸ 3. LOADING MODEL INTO MEMORY');
     const beforeLoad = await getModelInfo(WHISPER_TINY);
     let modelId;
     if (!beforeLoad.isLoaded) {
-        console.log("▸ Loading model into memory...");
+        console.log('▸ Loading model into memory...');
         modelId = await loadModel({
-            modelSrc: WHISPER_TINY,
+            modelSrc: WHISPER_TINY
         });
         console.log(`▸ Model loaded! ID: ${modelId}`);
         const afterLoad = await getModelInfo(WHISPER_TINY);
-        printModelStatus(afterLoad, "Status After Load:");
+        printModelStatus(afterLoad, 'Status After Load:');
     }
     else {
-        console.log("▸ Model already loaded!");
+        console.log('▸ Model already loaded!');
         const instances = beforeLoad.loadedInstances;
         if (!instances || instances.length === 0) {
-            throw new Error("Model is loaded but no instances found");
+            throw new Error('Model is loaded but no instances found');
         }
         const firstInstance = instances[0];
         if (!firstInstance) {
-            throw new Error("First instance is undefined");
+            throw new Error('First instance is undefined');
         }
         modelId = firstInstance.registryId;
         console.log(`▸ Using existing model ID: ${modelId}`);
     }
     // 4. Demonstrate unload
-    console.log("\n▸ 4. UNLOADING MODEL");
-    console.log("▸ Unloading model from memory...");
+    console.log('\n▸ 4. UNLOADING MODEL');
+    console.log('▸ Unloading model from memory...');
     await unloadModel({ modelId });
-    console.log("▸ Model unloaded!");
+    console.log('▸ Model unloaded!');
     const afterUnload = await getModelInfo(WHISPER_TINY);
-    printModelStatus(afterUnload, "Status After Unload:");
+    printModelStatus(afterUnload, 'Status After Unload:');
     // 5. Summary
-    console.log("\n▸ 5. SUMMARY");
-    console.log("▸ Model Info API works correctly");
-    console.log("▸ Cache status tracked accurately");
-    console.log("▸ Loaded status reflects memory state");
-    console.log("▸ All operations completed successfully");
-    console.log("\n▸ Demo Complete\n");
+    console.log('\n▸ 5. SUMMARY');
+    console.log('▸ Model Info API works correctly');
+    console.log('▸ Cache status tracked accurately');
+    console.log('▸ Loaded status reflects memory state');
+    console.log('▸ All operations completed successfully');
+    console.log('\n▸ Demo Complete\n');
     process.exit(0);
 }
 catch (error) {
-    console.error("✖", error);
+    console.error('✖', error);
     process.exit(1);
 }

package/dist/examples/cancel-by-request-id.js

@@ -34,27 +34,27 @@
  * consumers don't need to catch anything; promise-aggregate consumers
  * pattern-match on `instanceof InferenceCancelledError`.
  */
-import { cancel, completion, loadModel, unloadModel, InferenceCancelledError, QWEN3_600M_INST_Q4, } from "@qvac/sdk";
+import { cancel, completion, loadModel, unloadModel, InferenceCancelledError, QWEN3_600M_INST_Q4 } from '@qvac/sdk';
 try {
     const modelId = await loadModel({
         modelSrc: QWEN3_600M_INST_Q4,
-        modelConfig: { ctx_size: 4096 },
+        modelConfig: { ctx_size: 4096 }
     });
     const run = completion({
         modelId,
         history: [
             {
-                role: "user",
-                content: "Write a long, detailed essay about the history of the Roman Empire.",
-            },
+                role: 'user',
+                content: 'Write a long, detailed essay about the history of the Roman Empire.'
+            }
         ],
-        stream: true,
+        stream: true
     });
     console.log(`▸ requestId: ${run.requestId}`);
     // Cancel after a short delay so we exercise the cancel-mid-decode path.
     setTimeout(() => {
         void cancel({ requestId: run.requestId });
-        console.log("▸ cancel issued");
+        console.log('▸ cancel issued');
     }, 250);
     // Channel 1: the events stream ends normally on cancel. The
     // `completionDone` event's `stopReason` tells you why the loop is
@@ -62,11 +62,11 @@ try {
     let tokenCount = 0;
     let endReason;
     for await (const event of run.events) {
-        if (event.type === "contentDelta") {
+        if (event.type === 'contentDelta') {
             tokenCount++;
             process.stdout.write(event.text);
         }
-        else if (event.type === "completionDone") {
+        else if (event.type === 'completionDone') {
             endReason = event.stopReason;
         }
     }
@@ -81,7 +81,7 @@ try {
     catch (err) {
         if (err instanceof InferenceCancelledError) {
             console.log(`▸ run.text rejected: cancelled (requestId=${err.requestId})`);
-            console.log(`▸ partial text length: ${(err.partial.text ?? "").length}`);
+            console.log(`▸ partial text length: ${(err.partial.text ?? '').length}`);
             if (err.partial.stats?.tokensPerSecond !== undefined) {
                 console.log(`▸ partial stats: ${err.partial.stats.tokensPerSecond.toFixed(1)} tok/s`);
             }
@@ -97,6 +97,6 @@ try {
     process.exit(0);
 }
 catch (error) {
-    console.error("✖", error);
+    console.error('✖', error);
     process.exit(1);
 }

package/dist/examples/classification/classify-image.js

@@ -1,5 +1,5 @@
-import fs from "fs";
-import { startQVACProvider, stopQVACProvider, loadModel, classify, unloadModel, } from "@qvac/sdk";
+import fs from 'fs';
+import { startQVACProvider, stopQVACProvider, loadModel, classify, unloadModel } from '@qvac/sdk';
 /**
  * Classify an image using the bundled MobileNetV3-Small model.
  *
@@ -9,11 +9,11 @@ import { startQVACProvider, stopQVACProvider, loadModel, classify, unloadModel,
 async function main() {
     await startQVACProvider({});
     const modelId = await loadModel({
-        modelType: "ggml-classification",
+        modelType: 'ggml-classification'
     });
-    const image = fs.readFileSync("image.jpg");
+    const image = fs.readFileSync('image.jpg');
     const results = await classify({ modelId, image });
-    console.log("Classification results:");
+    console.log('Classification results:');
     for (const { label, confidence } of results) {
         console.log(`  ${label}: ${(confidence * 100).toFixed(1)}%`);
     }

package/dist/examples/completion-events.js

@@ -14,7 +14,7 @@
  * into dedicated `thinkingDelta` events. `final.raw.fullText` keeps the exact
  * model output.
  */
-import { completion, loadModel, unloadModel, QWEN3_600M_INST_Q4, } from "@qvac/sdk";
+import { completion, loadModel, unloadModel, QWEN3_600M_INST_Q4 } from '@qvac/sdk';
 try {
     const modelId = await loadModel({
         modelSrc: QWEN3_600M_INST_Q4,
@@ -24,23 +24,21 @@ try {
             const line = `▸ Downloading ${p.percentage.toFixed(0)}% (${mb(p.downloaded)}/${mb(p.total)} MB)`;
             process.stderr.write(process.stderr.isTTY ? `\r${line}` : `${line}\n`);
             if (p.percentage >= 100)
-                process.stderr.write("\n");
-        },
+                process.stderr.write('\n');
+        }
     });
     console.log(`▸ Model loaded: ${modelId}`);
     const result = completion({
         modelId,
-        history: [
-            { role: "user", content: "Explain quantum computing in 2 sentences" },
-        ],
+        history: [{ role: 'user', content: 'Explain quantum computing in 2 sentences' }],
         stream: true,
-        captureThinking: true,
+        captureThinking: true
     });
     for await (const event of result.events) {
         handleEvent(event);
     }
     const final = await result.final;
-    console.log("\n▸ Final result");
+    console.log('\n▸ Final result');
     console.log(`▸ Content: ${final.contentText}`);
     if (final.thinkingText) {
         console.log(`▸ Thinking: ${final.thinkingText}`);
@@ -49,7 +47,7 @@ try {
         console.log(`▸ ${final.stats.tokensPerSecond?.toFixed(1)} tok/s`);
     }
     if (final.toolCalls.length > 0) {
-        console.log(`▸ Tool calls: ${final.toolCalls.map((c) => c.name).join(", ")}`);
+        console.log(`▸ Tool calls: ${final.toolCalls.map((c) => c.name).join(', ')}`);
     }
     if (final.stopReason) {
         console.log(`▸ Stop reason: ${final.stopReason}`);
@@ -58,32 +56,32 @@ try {
     await unloadModel({ modelId, clearStorage: false });
 }
 catch (error) {
-    console.error("✖", error);
+    console.error('✖', error);
     process.exit(1);
 }
 function handleEvent(event) {
     switch (event.type) {
-        case "contentDelta":
+        case 'contentDelta':
             process.stdout.write(event.text);
             break;
-        case "thinkingDelta":
+        case 'thinkingDelta':
             process.stdout.write(`\x1b[2m${event.text}\x1b[0m`);
             break;
-        case "toolCall":
+        case 'toolCall':
             console.log(`\n▸ Tool: ${event.call.name}(${JSON.stringify(event.call.arguments)})`);
             break;
-        case "toolError":
+        case 'toolError':
             console.log(`\n✖ Tool error [${event.error.code}]: ${event.error.message}`);
             break;
-        case "completionStats":
+        case 'completionStats':
             console.log(`\n▸ ${event.stats.tokensPerSecond?.toFixed(1)} tok/s`);
             break;
-        case "completionDone":
-            if (event.stopReason === "error" && "error" in event) {
+        case 'completionDone':
+            if (event.stopReason === 'error' && 'error' in event) {
                 console.log(`\n✖ ${event.error.message}`);
             }
             break;
-        case "rawDelta":
+        case 'rawDelta':
             break;
     }
 }