@qvac/sdk 0.4.1 → 0.6.0

package/dist/examples/embed-hyperdrive.js

@@ -1,4 +1,11 @@
 import { embed, GTE_LARGE_FP16, loadModel, unloadModel } from "@qvac/sdk";
+function cosineSimilarity(vecA, vecB) {
+    let dotProduct = 0;
+    for (let i = 0; i < vecA.length; i++) {
+        dotProduct += vecA[i] * vecB[i];
+    }
+    return dotProduct;
+}
 try {
     const modelId = await loadModel({
         modelSrc: GTE_LARGE_FP16,
@@ -6,10 +13,39 @@ try {
         onProgress: (progress) => {
             console.log(progress);
         },
+        modelConfig: {
+            gpuLayers: 99,
+            device: "gpu",
+        },
     });
-    const embedding = await embed({ modelId, text: "Hello, world!" });
-    console.log("Embedding (first 20 elements)", embedding.slice(0, 20));
-    console.log("Embeddings length", embedding.length);
+    console.log("\n📝 Example 1: Single Text Embedding");
+    console.log("=".repeat(50));
+    const singleEmbedding = await embed({ modelId, text: "Hello, world!" });
+    console.log("Input: 'Hello, world!'");
+    console.log("Embedding dimensions:", singleEmbedding.length);
+    console.log("First 10 values:", singleEmbedding.slice(0, 10));
+    console.log("\n📝 Example 2: Batch Text Embeddings");
+    console.log("=".repeat(50));
+    const texts = [
+        "The quick brown fox jumps over the lazy dog",
+        "A fast auburn fox leaps over a sleepy canine",
+        "Python is a programming language",
+    ];
+    const batchEmbeddings = await embed({ modelId, text: texts });
+    console.log("Input: Array of", texts.length, "texts");
+    console.log("Output: Array of", batchEmbeddings.length, "embeddings");
+    const [emb1, emb2, emb3] = batchEmbeddings;
+    if (!emb1 || !emb2 || !emb3) {
+        throw new Error("Expected 3 embeddings");
+    }
+    console.log("Each embedding dimensions:", emb1.length);
+    console.log("\n🔍 Similarity Analysis");
+    console.log("=".repeat(50));
+    const similarity1 = cosineSimilarity(emb1, emb2);
+    const similarity2 = cosineSimilarity(emb1, emb3);
+    console.log("Similarity between texts 1 and 2 (similar meaning):", similarity1.toFixed(4));
+    console.log("Similarity between texts 1 and 3 (different topics):", similarity2.toFixed(4));
+    console.log("\n💡 Higher values indicate more similar meanings");
     await unloadModel({ modelId, clearStorage: false });
 }
 catch (error) {

package/dist/examples/kv-cache-cleanup.js

@@ -9,7 +9,7 @@ try {
         modelConfig: {
             device: "gpu",
             ctx_size: 2048,
-            verbosity: VERBOSITY.SILENT,
+            verbosity: VERBOSITY.ERROR,
         },
     });
     // Create some cached sessions

package/dist/examples/kv-cache-custom-key.js

@@ -14,7 +14,7 @@ try {
         modelConfig: {
             device: "gpu",
             ctx_size: 2048,
-            verbosity: VERBOSITY.SILENT,
+            verbosity: VERBOSITY.DEBUG,
         },
     });
     // Prompt 1 with cache key "session-a" (first time - no cache exists)
@@ -70,6 +70,21 @@ try {
     }
     const stats3 = await result3.stats;
     console.log(`\n   Stats: TTFT=${stats3?.timeToFirstToken}ms, CacheTokens=${stats3?.cacheTokens}\n`);
+    // Prompt 4: Go back to session-a to trigger flush of session-b
+    console.log('\n📝 Prompt 4: "What is 5+5?" with cache key "session-a" (BACK TO FIRST)');
+    console.log("   Status: This should trigger session-b to be flushed to disk\n");
+    const result4 = completion({
+        modelId,
+        history: [systemPromptMessage, { role: "user", content: "What is 5+5?" }],
+        stream: true,
+        kvCache: "session-a", // Back to session-a!
+    });
+    console.log("   Response: ");
+    for await (const token of result4.tokenStream) {
+        process.stdout.write(token);
+    }
+    const stats4 = await result4.stats;
+    console.log(`\n   Stats: TTFT=${stats4?.timeToFirstToken}ms, CacheTokens=${stats4?.cacheTokens}\n`);
     // Summary
     console.log("\n✅ Summary:");
     console.log('   - Prompts 1 & 2 share cache key "session-a" → same cache file');

package/dist/examples/kv-cache-example.js

@@ -7,7 +7,7 @@ try {
         modelConfig: {
             device: "gpu",
             ctx_size: 2048,
-            verbosity: VERBOSITY.SILENT,
+            verbosity: VERBOSITY.ERROR,
         },
     });
     console.log("🧠 Testing KV Cache functionality...\n");

package/dist/examples/llamacpp-hyperdrive.js

@@ -14,7 +14,7 @@ try {
         modelConfig: {
             device: "gpu",
             ctx_size: 2048,
-            verbosity: VERBOSITY.SILENT,
+            verbosity: VERBOSITY.ERROR,
         },
     });
     const history = [

package/dist/examples/llamacpp-sharded.js

@@ -1,22 +1,31 @@
-import { completion, loadModel, unloadModel, VERBOSITY, LLAMA_3_2_1B_INST_Q4_0_SHARD, } from "@qvac/sdk";
+import { completion, loadModel, unloadModel, VERBOSITY } from "@qvac/sdk";
+// Sharded models can be loaded from:
+// 1. HTTP archives: "https://example.com/model.tar.gz"
+// 2. HTTP pattern: "https://example.com/model-00001-of-00005.gguf"
+// 3. Hyperdrive: use any sharded model source/constant, eg: LLAMA_3_2_1B_INST_Q4_0_SHARD
+// 4. Local filesystem: pass the path to the first shard file (Note: All shards must be in the same directory)
+// 5. Local archive: pass the path to the archive file (.tar, .tar.gz, .tgz)
 try {
     const modelId = await loadModel({
-        modelSrc: LLAMA_3_2_1B_INST_Q4_0_SHARD,
+        modelSrc: "https://huggingface.co/Qwen/Qwen2.5-Coder-7B-Instruct-GGUF/resolve/main/qwen2.5-coder-7b-instruct-q4_0-00001-of-00002.gguf",
         modelType: "llm",
         modelConfig: {
             device: "gpu",
             ctx_size: 2048,
-            verbosity: VERBOSITY.SILENT,
+            verbosity: VERBOSITY.ERROR,
         },
         onProgress: (progress) => {
+            // For sharded models, progress.shardInfo contains detailed progress for both
+            // individual shards AND overall download progress across all shards
             if (progress.shardInfo) {
+                // For pattern-based or Hyperdrive shards
                 const { shardInfo } = progress;
                 console.log(`📥 Downloading ${shardInfo.shardName} (${shardInfo.currentShard}/${shardInfo.totalShards})\n` +
                     `   File: ${progress.percentage.toFixed(1)}% (${(progress.downloaded / 1024 / 1024).toFixed(2)}MB / ${(progress.total / 1024 / 1024).toFixed(2)}MB)\n` +
                     `   Overall: ${shardInfo.overallPercentage.toFixed(1)}% (${(shardInfo.overallDownloaded / 1024 / 1024).toFixed(2)}MB / ${(shardInfo.overallTotal / 1024 / 1024).toFixed(2)}MB)`);
             }
             else {
-                // Fallback for non-sharded models
+                // For archive-based shards
                 console.log(`📥 Progress: ${progress.percentage.toFixed(1)}% ` +
                     `(${(progress.downloaded / 1024 / 1024).toFixed(2)}MB / ${(progress.total / 1024 / 1024).toFixed(2)}MB)`);
             }

package/dist/examples/logging-file-transport.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=logging-file-transport.d.ts.map

package/dist/examples/{llamacpp-file-logging.js → logging-file-transport.js}

@@ -1,8 +1,6 @@
-import { getLogger } from "../logging/index.js";
-import { loadModel, completion, unloadModel } from "../client/api/index.js";
+import { getLogger, loadModel, completion, unloadModel, LLAMA_3_2_1B_INST_Q4_0, VERBOSITY, } from "@qvac/sdk";
 import { writeFileSync, appendFileSync } from "fs";
 import { join } from "path";
-import { LLAMA_3_2_1B_INST_Q4_0 } from "../models/hyperdrive/index.js";
 try {
     const logFile = join(process.cwd(), "model-logs.txt");
     // Clear previous logs
@@ -10,6 +8,7 @@ try {
     // Create logger with file transport
     const logger = getLogger("llm-file-demo", {
         level: "debug",
+        enableConsole: false, // Disable console output (logs go to file only). Set to true for both console + file
         transports: [
             // File transport - append logs to file
             (level, namespace, message) => {
@@ -17,10 +16,6 @@ try {
                 const logLine = `[${timestamp}] ${level.toUpperCase()} ${namespace}: ${message}\n`;
                 appendFileSync(logFile, logLine);
             },
-            // Console transport for immediate feedback
-            (level, namespace, message) => {
-                console.log(`🔍 [${level.toUpperCase()}] ${namespace}: ${message}`);
-            },
         ],
     });
     logger.info("Starting model demo with file logging");
@@ -31,6 +26,7 @@ try {
         modelConfig: {
             ctx_size: 2048,
             temp: 0.7,
+            verbosity: VERBOSITY.DEBUG,
         },
         logger, // All model logs will be captured
     });

package/dist/examples/logging-streaming.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=logging-streaming.d.ts.map

package/dist/examples/logging-streaming.js

@@ -0,0 +1,75 @@
+import { loadModel, completion, unloadModel, loggingStream, SDK_LOG_ID, LLAMA_3_2_1B_INST_Q4_0, GTE_LARGE_FP16, VERBOSITY, embed, } from "@qvac/sdk";
+try {
+    console.log("🚀 Starting log streaming demo...\n");
+    // Note: To configure logging (level and console output), use config file:
+    // { "loggerLevel": "debug", "loggerConsoleOutput": false } in qvac.config.json/js/ts
+    // Subscribe to SDK server logs in background
+    console.log("📡 Starting SDK server log stream...\n");
+    (async () => {
+        for await (const log of loggingStream({ id: SDK_LOG_ID })) {
+            console.log(`[SDK] [${log.level.toUpperCase()}] [${log.namespace}] ${log.message}`);
+        }
+    })().catch(() => {
+        // Stream terminated - normal on shutdown
+    });
+    // Load models
+    console.log("📥 Loading models (watch SDK logs above)...\n");
+    const llmModelId = await loadModel({
+        modelSrc: LLAMA_3_2_1B_INST_Q4_0,
+        modelType: "llm",
+        modelConfig: {
+            ctx_size: 2048,
+            temp: 0.7,
+            verbosity: VERBOSITY.ERROR, // Only log errors, remaining logs are captured by loggingStream
+        },
+    });
+    const embedModelId = await loadModel({
+        modelSrc: GTE_LARGE_FP16,
+        modelType: "embeddings",
+    });
+    console.log("📡 Starting model-specific log streams...\n");
+    (async () => {
+        for await (const log of loggingStream({ id: llmModelId })) {
+            const timestamp = new Date(log.timestamp).toISOString();
+            console.log(`[LLM] [${timestamp}] [${log.level.toUpperCase()}] ${log.namespace}: ${log.message}`);
+        }
+    })().catch(() => {
+        // Stream terminated - this is normal when model unloads
+    });
+    (async () => {
+        for await (const log of loggingStream({ id: embedModelId })) {
+            const timestamp = new Date(log.timestamp).toISOString();
+            console.log(`[EMBED] [${timestamp}] [${log.level.toUpperCase()}] ${log.namespace}: ${log.message}`);
+        }
+    })().catch(() => {
+        // Stream terminated - this is normal when model unloads
+    });
+    const messages = [
+        { role: "user", content: "Count from 1 to 5 and explain each number." },
+    ];
+    const result = completion({
+        modelId: llmModelId,
+        history: messages,
+        stream: true,
+    });
+    const embedding = await embed({
+        modelId: embedModelId,
+        text: messages[0]?.content ?? "Hello, world!",
+    });
+    console.log("📝 Response:\n");
+    for await (const token of result.tokenStream) {
+        process.stdout.write(token);
+    }
+    console.log("Embedding (first 20 elements)", embedding.slice(0, 20));
+    console.log("Embeddings length", embedding.length);
+    console.log("\n💡 Notice three log streams running:\n" +
+        "   - [SDK] = SDK server operations\n" +
+        "   - [LLM] = LLM model inference logs\n" +
+        "   - [EMBED] = Embedding model logs\n");
+    await unloadModel({ modelId: llmModelId, clearStorage: false });
+    await unloadModel({ modelId: embedModelId, clearStorage: false });
+}
+catch (error) {
+    console.error("❌ Error:", error);
+    process.exit(1);
+}

package/dist/examples/mcp-websearch.d.ts

@@ -0,0 +1,13 @@
+/**
+ * MCP DuckDuckGo Search Example
+ *
+ * A web search example using DuckDuckGo - no API key required!
+ * The server provides tools to search the web and get answers.
+ *
+ * Prerequisites:
+ * - Install MCP SDK: bun add @modelcontextprotocol/sdk
+ *
+ * Run with: bun run examples/mcp-websearch.ts
+ */
+export {};
+//# sourceMappingURL=mcp-websearch.d.ts.map

package/dist/examples/mcp-websearch.js

@@ -0,0 +1,176 @@
+/**
+ * MCP DuckDuckGo Search Example
+ *
+ * A web search example using DuckDuckGo - no API key required!
+ * The server provides tools to search the web and get answers.
+ *
+ * Prerequisites:
+ * - Install MCP SDK: bun add @modelcontextprotocol/sdk
+ *
+ * Run with: bun run examples/mcp-websearch.ts
+ */
+import { completion, loadModel, unloadModel, QWEN_3_1_7B_INST_Q4, } from "../index.js";
+// MCP SDK is a user-installed optional dependency
+// Install with: bun add @modelcontextprotocol/sdk
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+function parseSearchResults(mcpResult) {
+    try {
+        const result = mcpResult;
+        // Extract text content from MCP response
+        const textContent = result.content?.find((c) => c.type === "text");
+        if (!textContent?.text) {
+            return JSON.stringify(mcpResult);
+        }
+        // Parse the JSON array of search results
+        const rawResults = JSON.parse(textContent.text);
+        // Extract just the useful fields (title, url, snippet)
+        const cleanResults = rawResults.slice(0, 5).map((r) => ({
+            title: r.title ?? "Unknown",
+            url: r.url ?? "",
+            snippet: r.snippet ?? "",
+        }));
+        // Format as concise text for LLM
+        return cleanResults
+            .map((r, i) => `[${i + 1}] ${r.title}\n    URL: ${r.url}\n    ${r.snippet}`)
+            .join("\n\n");
+    }
+    catch {
+        // If parsing fails, return a truncated version
+        const str = typeof mcpResult === "string" ? mcpResult : JSON.stringify(mcpResult);
+        return str.slice(0, 2000);
+    }
+}
+let mcpClient = null;
+try {
+    console.log("🦆 MCP DuckDuckGo Search Example\n");
+    // ============================================================
+    // STEP 1: Connect to DuckDuckGo MCP server
+    // ============================================================
+    console.log("1️⃣  Starting DuckDuckGo MCP server...");
+    mcpClient = new Client({
+        name: "qvac-ddg-example",
+        version: "1.0.0",
+    });
+    const transport = new StdioClientTransport({
+        command: "npx",
+        args: ["-y", "@oevortex/ddg_search"],
+    });
+    await mcpClient.connect(transport);
+    console.log("   ✓ MCP server connected\n");
+    // ============================================================
+    // STEP 2: Load model
+    // ============================================================
+    console.log("2️⃣  Loading model...");
+    const modelId = await loadModel({
+        modelSrc: QWEN_3_1_7B_INST_Q4,
+        modelType: "llm",
+        modelConfig: {
+            ctx_size: 4096,
+            tools: true,
+        },
+        onProgress: (progress) => process.stdout.write(`\r   Loading: ${progress.percentage.toFixed(1)}%`),
+    });
+    console.log(`\n   ✓ Model loaded\n`);
+    // ============================================================
+    // STEP 3: Ask AI to search the web (with MCP client)
+    // ============================================================
+    const history = [
+        {
+            role: "system",
+            content: `You are a helpful assistant with access to web search.
+Use the search tool when you need current information.
+Always cite your sources with the URL.`,
+        },
+        {
+            role: "user",
+            content: "What is the current weather in New York City?",
+        },
+    ];
+    console.log("3️⃣  Asking AI to search the web...\n");
+    console.log("🤖 AI Response:");
+    // Pass MCP client directly to completion - tools are adapted internally!
+    const result = completion({
+        modelId,
+        history,
+        stream: true,
+        mcp: [{ client: mcpClient, includeResources: false }],
+    });
+    for await (const token of result.tokenStream) {
+        process.stdout.write(token);
+    }
+    const toolCalls = await result.toolCalls;
+    console.log("\n");
+    // ============================================================
+    // STEP 4: Execute tool calls using call() - automatic MCP routing!
+    // ============================================================
+    if (toolCalls.length > 0) {
+        console.log("4️⃣  Executing search...\n");
+        const toolResults = [];
+        for (const toolCall of toolCalls) {
+            console.log(`🔍 ${toolCall.name}(${JSON.stringify(toolCall.arguments)})`);
+            if (!toolCall.invoke) {
+                console.log(`   ⚠️ No handler found for tool "${toolCall.name}"`);
+                continue;
+            }
+            // Use invoke() - automatically routes to the correct MCP client!
+            const mcpResult = await toolCall.invoke();
+            // Parse and clean up the search results
+            const cleanResult = parseSearchResults(mcpResult);
+            console.log(`   ✓ Got search results:`);
+            console.log(cleanResult
+                .split("\n")
+                .map((l) => `      ${l}`)
+                .join("\n"));
+            console.log();
+            toolResults.push({ id: toolCall.id, result: cleanResult });
+        }
+        // ============================================================
+        // STEP 5: Continue with search results
+        // ============================================================
+        console.log("5️⃣  Getting AI response with search results...\n");
+        history.push({
+            role: "assistant",
+            content: await result.text,
+        });
+        for (const tr of toolResults) {
+            history.push({
+                role: "tool",
+                content: tr.result,
+            });
+        }
+        console.log("🤖 Final Response:");
+        const finalResult = completion({
+            modelId,
+            history,
+            stream: true,
+            mcp: [{ client: mcpClient, includeResources: false }],
+        });
+        for await (const token of finalResult.tokenStream) {
+            process.stdout.write(token);
+        }
+        console.log("\n");
+    }
+    // ============================================================
+    // Cleanup
+    // ============================================================
+    console.log("6️⃣  Cleaning up...");
+    await unloadModel({ modelId, clearStorage: false });
+    console.log("   ✓ Done\n");
+    console.log("🎉 Example completed!");
+    process.exit(0);
+}
+catch (error) {
+    console.error("❌ Error:", error);
+    process.exit(1);
+}
+finally {
+    if (mcpClient) {
+        try {
+            await mcpClient.close();
+        }
+        catch {
+            // Ignore close errors
+        }
+    }
+}

package/dist/examples/ocr-fasttext.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ocr-fasttext.d.ts.map

package/dist/examples/ocr-fasttext.js

@@ -0,0 +1,52 @@
+import { close, loadModel, ocr, OCR_CRAFT_LATIN_RECOGNIZER_1, unloadModel, } from "@qvac/sdk";
+import path from "path";
+import { fileURLToPath } from "url";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const imagePath = process.argv[2] || path.join(__dirname, "image/basic_test.bmp");
+try {
+    console.log("🚀 Loading OCR model...");
+    // Only need to pass the recognizer - detector is auto-derived from same hyperdrive key
+    const modelId = await loadModel({
+        modelSrc: OCR_CRAFT_LATIN_RECOGNIZER_1,
+        modelType: "ocr",
+        modelConfig: {
+            langList: ["en"],
+            useGPU: true,
+            timeout: 30000,
+            magRatio: 1.5,
+            defaultRotationAngles: [90, 180, 270],
+            contrastRetry: false,
+            lowConfidenceThreshold: 0.5,
+            recognizerBatchSize: 1,
+        },
+    });
+    console.log(`✅ Model loaded successfully! Model ID: ${modelId}`);
+    console.log(`\n🔍 Running OCR on: ${imagePath}`);
+    const { blocks } = ocr({
+        modelId,
+        image: imagePath,
+        options: {
+            paragraph: false,
+        },
+    });
+    const result = await blocks;
+    console.log("\n📝 OCR Results:");
+    console.log("================================");
+    for (const block of result) {
+        console.log(`\n📄 Text: ${block.text}`);
+        if (block.bbox) {
+            console.log(`   📍 BBox: [${block.bbox.join(", ")}]`);
+        }
+        if (block.confidence !== undefined) {
+            console.log(`   ✓ Confidence: ${block.confidence}`);
+        }
+    }
+    console.log("\n================================");
+    console.log("\n🔄 Unloading model...");
+    await unloadModel({ modelId, clearStorage: false });
+    console.log("✅ Model unloaded successfully.");
+}
+catch (error) {
+    console.error("❌ Error during OCR processing:", error);
+    close();
+}

package/dist/examples/quickstart.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=quickstart.d.ts.map

package/dist/examples/quickstart.js

@@ -0,0 +1,28 @@
+import { loadModel, LLAMA_3_2_1B_INST_Q4_0, completion, unloadModel, } from "@qvac/sdk";
+try {
+    // Load a model into memory
+    const modelId = await loadModel({
+        modelSrc: LLAMA_3_2_1B_INST_Q4_0,
+        modelType: "llm",
+        onProgress: (progress) => {
+            console.log(progress);
+        },
+    });
+    // You can use the loaded model multiple times
+    const history = [
+        {
+            role: "user",
+            content: "Explain quantum computing in one sentence",
+        },
+    ];
+    const result = completion({ modelId, history, stream: true });
+    for await (const token of result.tokenStream) {
+        process.stdout.write(token);
+    }
+    // Unload model to free up system resources
+    await unloadModel({ modelId });
+}
+catch (error) {
+    console.error("❌ Error:", error);
+    process.exit(1);
+}

package/dist/examples/rag/rag-hyperdb/cancellation.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cancellation.d.ts.map

package/dist/examples/rag/rag-hyperdb/cancellation.js

@@ -0,0 +1,75 @@
+import { loadModel, unloadModel, GTE_LARGE_FP16, ragIngest, ragCloseWorkspace, cancel, } from "@qvac/sdk";
+const WORKSPACE = "cancellation-demo";
+// Generate sample documents
+function generateDocuments(count) {
+    const topics = [
+        "Machine learning algorithms process data to identify patterns and make decisions.",
+        "Deep neural networks consist of multiple layers that extract higher-level features.",
+        "Natural language processing enables computers to understand human language.",
+        "Computer vision systems analyze visual information from images and videos.",
+        "Reinforcement learning trains agents through trial and error using rewards.",
+    ];
+    return Array.from({ length: count }, (_, i) => {
+        const topic = topics[i % topics.length];
+        return `Document ${i + 1}: ${topic} Extended content for document ${i + 1}.`;
+    });
+}
+try {
+    console.log("RAG Cancellation Example\n");
+    // Load embedding model
+    console.log("Loading embedding model...");
+    const modelId = await loadModel({
+        modelSrc: GTE_LARGE_FP16,
+        modelType: "embeddings",
+        onProgress: (progress) => {
+            process.stdout.write(`\r   ${progress.percentage.toFixed(1)}%`);
+        },
+    });
+    console.log("\n✅ Model loaded\n");
+    // Generate documents
+    const documents = generateDocuments(200);
+    console.log(`📄 Processing ${documents.length} documents...\n`);
+    let progressCount = 0;
+    let cancelled = false;
+    try {
+        await ragIngest({
+            modelId,
+            workspace: WORKSPACE,
+            documents,
+            progressInterval: 50,
+            onProgress: (stage, current, total) => {
+                progressCount++;
+                const pct = total > 0 ? Math.round((current / total) * 100) : 0;
+                console.log(`   [${stage}] ${current}/${total} (${pct}%)`);
+                // Cancel during embedding stage after a few updates
+                if (!cancelled && stage === "embedding" && current > 10) {
+                    console.log("\n🛑 Triggering cancellation...\n");
+                    cancelled = true;
+                    void cancel({ operation: "rag", workspace: WORKSPACE });
+                }
+            },
+        });
+        console.log("\n⚠️  Ingest completed (cancellation didn't interrupt in time)");
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        const wasCancelled = msg.toLowerCase().includes("cancel") ||
+            msg.toLowerCase().includes("abort");
+        if (wasCancelled) {
+            console.log("✅ Operation cancelled successfully!");
+            console.log(`   Progress updates received: ${progressCount}`);
+        }
+        else {
+            throw error;
+        }
+    }
+    // Cleanup (workspace may not exist if cancelled early)
+    await ragCloseWorkspace({ workspace: WORKSPACE, deleteOnClose: true }).catch(() => { });
+    await unloadModel({ modelId });
+    console.log("✅ Done");
+    process.exit(0);
+}
+catch (error) {
+    console.error("❌ Error:", error);
+    process.exit(1);
+}

package/dist/examples/rag/rag-hyperdb/ingest.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ingest.d.ts.map