@qvac/sdk 0.5.0 → 0.6.1

package/dist/examples/llamacpp-sharded.js

@@ -1,7 +1,13 @@
-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",
@@ -9,14 +15,17 @@ try {
             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/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

package/dist/examples/rag/{rag-hyperdb.js → rag-hyperdb/ingest.js}

@@ -1,7 +1,8 @@
-import { loadModel, unloadModel, GTE_LARGE_FP16, ragSaveEmbeddings, ragSearch, } from "@qvac/sdk";
+import { loadModel, unloadModel, GTE_LARGE_FP16, ragIngest, ragSearch, ragCloseWorkspace, } from "@qvac/sdk";
 try {
     // Get query from command line or use default
     const query = process.argv[2] || "machine learning algorithms";
+    const workspace = "ingest-example";
     console.log(`🔍 Query: "${query}"`);
     const modelId = await loadModel({
         modelSrc: GTE_LARGE_FP16,
@@ -20,16 +21,18 @@ try {
         "Cloud computing delivers computing services over the internet, allowing users to access resources like storage, processing power, and applications on-demand from anywhere.",
         "Cybersecurity protects digital systems, networks, and data from malicious attacks, unauthorized access, and various forms of cyber threats through multiple layers of defense.",
     ];
-    console.log("📚 Embedding documents...");
-    const docs = await ragSaveEmbeddings({
+    console.log("📚 Ingesting documents...");
+    const result = await ragIngest({
         modelId,
+        workspace,
         documents: samples,
         chunk: false,
     });
-    console.log("🔍 Documents:", docs);
+    console.log(`✅ Ingested ${result.processed.length} documents`);
     console.log("🔎 Searching for similar documents...");
     const results = await ragSearch({
         modelId,
+        workspace,
         query,
         topK: 3,
     });
@@ -41,6 +44,9 @@ try {
         console.log("=".repeat(100));
         console.log();
     });
+    // Cleanup: close and delete workspace
+    await ragCloseWorkspace({ workspace, deleteOnClose: true });
+    console.log(`\n🗑️  Deleted '${workspace}' workspace`);
     await unloadModel({ modelId });
 }
 catch (error) {

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

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

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

@@ -0,0 +1,74 @@
+import { loadModel, unloadModel, embed, GTE_LARGE_FP16, ragChunk, ragSaveEmbeddings, ragSearch, ragCloseWorkspace, } from "@qvac/sdk";
+try {
+    // Get query from command line or use default
+    const query = process.argv[2] || "machine learning algorithms";
+    console.log("🔧 RAG Pipeline Example (Segregated Flow)\n");
+    console.log(`🔍 Query: "${query}"`);
+    const workspace = "pipeline-example";
+    const modelId = await loadModel({
+        modelSrc: GTE_LARGE_FP16,
+        modelType: "embeddings",
+        onProgress: (progress) => {
+            console.log(`Loading model... ${progress.percentage.toFixed(1)}%`);
+        },
+    });
+    const samples = [
+        "Machine learning is a subset of artificial intelligence that focuses on algorithms that can learn and make predictions from data without being explicitly programmed for every task.",
+        "Deep learning uses neural networks with multiple layers to process and learn from complex data patterns, enabling breakthroughs in image recognition and natural language processing.",
+        "Natural language processing combines computational linguistics with machine learning to help computers understand, interpret, and generate human language in a meaningful way.",
+        "Computer vision enables machines to interpret and understand visual information from the world, using techniques like image classification, object detection, and facial recognition.",
+        "Quantum computing leverages quantum mechanical phenomena to process information in fundamentally different ways than classical computers, potentially solving certain problems exponentially faster.",
+        "Blockchain technology creates decentralized, immutable ledgers that enable secure peer-to-peer transactions without requiring a central authority or intermediary.",
+        "Cloud computing delivers computing services over the internet, allowing users to access resources like storage, processing power, and applications on-demand from anywhere.",
+        "Cybersecurity protects digital systems, networks, and data from malicious attacks, unauthorized access, and various forms of cyber threats through multiple layers of defense.",
+    ];
+    console.log("\n📝 Step 1: Chunking documents...");
+    const chunks = await ragChunk({
+        documents: samples,
+        chunkOpts: {
+            chunkSize: 128,
+            chunkOverlap: 20,
+        },
+    });
+    console.log(`   Created ${chunks.length} chunks`);
+    console.log("\n🧠 Step 2: Generating embeddings (batch)...");
+    const texts = chunks.map((chunk) => chunk.content);
+    const embeddings = await embed({ modelId, text: texts });
+    const embeddedDocs = chunks.map((chunk, i) => ({
+        id: chunk.id,
+        content: chunk.content,
+        embedding: embeddings[i],
+        embeddingModelId: modelId,
+    }));
+    console.log(`   Generated ${embeddedDocs.length} embeddings`);
+    console.log("\n💾 Step 3: Saving to vector database...");
+    const saveResult = await ragSaveEmbeddings({
+        workspace,
+        documents: embeddedDocs,
+    });
+    const saved = saveResult.filter((r) => r.status === "fulfilled").length;
+    console.log(`   Saved ${saved}/${saveResult.length} documents`);
+    console.log("\n🔎 Step 4: Searching...");
+    const results = await ragSearch({
+        workspace,
+        modelId,
+        query,
+        topK: 3,
+    });
+    console.log("\n📋 Top 3 most similar documents:");
+    results.forEach((result, index) => {
+        console.log("=".repeat(50) + " Top result:");
+        console.log(`\n${index + 1}. (Score: ${result.score})`);
+        console.log(`   ${result.content}`);
+        console.log("=".repeat(100));
+        console.log();
+    });
+    // Cleanup: close and delete workspace
+    await ragCloseWorkspace({ workspace, deleteOnClose: true });
+    console.log(`🗑️  Deleted '${workspace}' workspace`);
+    await unloadModel({ modelId });
+}
+catch (error) {
+    console.error("❌ Error:", error);
+    process.exit(1);
+}

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

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

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

@@ -0,0 +1,178 @@
+import { loadModel, unloadModel, GTE_LARGE_FP16, ragIngest, ragSearch, ragDeleteEmbeddings, ragListWorkspaces, ragCloseWorkspace, ragReindex, } from "@qvac/sdk";
+try {
+    console.log("🚀 RAG Workspaces with Chunking Example\n");
+    // Load model
+    const modelId = await loadModel({
+        modelSrc: GTE_LARGE_FP16,
+        modelType: "embeddings",
+        onProgress: (p) => process.stdout.write(`\rLoading: ${Math.round(p.percentage * 100)}%`),
+    });
+    console.log("\n");
+    // Medical articles (will be chunked)
+    const medicalArticles = [
+        `COVID-19: A Comprehensive Overview
+    
+    COVID-19 is a respiratory illness caused by the SARS-CoV-2 virus, first identified in December 2019 
+    in Wuhan, China. The virus spreads primarily through respiratory droplets when an infected person 
+    coughs, sneezes, or talks.
+    
+    Common symptoms include fever, cough, fatigue, and loss of taste or smell. Some patients may 
+    experience shortness of breath, muscle aches, sore throat, and headaches. Symptoms typically 
+    appear 2-14 days after exposure to the virus.
+    
+    Vaccines have been developed using various technologies including mRNA, viral vector, and 
+    inactivated virus approaches. These vaccines have proven effective in preventing severe illness, 
+    hospitalization, and death. Booster doses are recommended to maintain immunity.
+    
+    Treatment options vary based on severity. Mild cases often require only supportive care including 
+    rest and hydration. Severe cases may require hospitalization, oxygen therapy, and antiviral 
+    medications such as remdesivir or Paxlovid.`,
+        `Diabetes Management and Prevention
+    
+    Diabetes is a chronic condition affecting how your body processes blood sugar. Type 1 diabetes 
+    occurs when the immune system attacks insulin-producing cells. Type 2 diabetes develops when 
+    the body becomes resistant to insulin or doesn't produce enough.
+    
+    Prevention strategies for Type 2 diabetes include maintaining a healthy weight, regular physical 
+    activity, and a balanced diet rich in whole grains, vegetables, and lean proteins. Regular 
+    monitoring of blood glucose levels is essential for managing the condition.
+    
+    Treatment may include lifestyle modifications, oral medications, and insulin therapy. Complications 
+    can affect the heart, kidneys, eyes, and nervous system if blood sugar is not well controlled.`,
+        `Heart Disease: Risk Factors and Prevention
+    
+    Cardiovascular disease remains the leading cause of death worldwide. Risk factors include high 
+    blood pressure, high cholesterol, smoking, obesity, diabetes, and physical inactivity.
+    
+    Prevention involves adopting a heart-healthy lifestyle: regular exercise, a diet low in saturated 
+    fats and sodium, maintaining a healthy weight, and avoiding tobacco. Regular check-ups can help 
+    detect problems early.
+    
+    Treatment options range from lifestyle changes and medications to surgical interventions like 
+    angioplasty, stent placement, or bypass surgery depending on severity.`,
+        `Mental Health and Wellness
+    
+    Mental health encompasses emotional, psychological, and social well-being. Common conditions 
+    include anxiety disorders, depression, bipolar disorder, and schizophrenia. These affect 
+    thinking, mood, and behavior.
+    
+    Treatment typically involves a combination of psychotherapy, medication, and lifestyle changes. 
+    Cognitive behavioral therapy has proven effective for many conditions. Support systems and 
+    stress management techniques are crucial components of recovery.
+    
+    Early intervention improves outcomes significantly. Reducing stigma around mental health 
+    encourages people to seek help when needed.`,
+    ];
+    // Tech documents (shorter, won't be chunked)
+    const techDocs = [
+        "Artificial intelligence is transforming industries through automation and advanced data analysis capabilities.",
+        "Deep learning neural networks enable breakthroughs in computer vision and natural language processing.",
+    ];
+    // Ingest medical articles with chunking
+    console.log("📚 Ingesting medical articles with chunking...");
+    const medicalResult = await ragIngest({
+        modelId,
+        workspace: "medical",
+        documents: medicalArticles,
+        chunk: true,
+        chunkOpts: {
+            chunkSize: 50,
+            chunkOverlap: 10,
+            chunkStrategy: "paragraph",
+            splitStrategy: "token",
+        },
+    });
+    console.log(`✅ Created ${medicalResult.processed.length} chunks from medical articles`);
+    // Ingest tech docs without chunking
+    console.log("\n📚 Ingesting tech documents...");
+    const techResult = await ragIngest({
+        modelId,
+        workspace: "technology",
+        documents: techDocs,
+        chunk: false,
+    });
+    console.log(`✅ Ingested ${techResult.processed.length} tech documents`);
+    // Test searches
+    const searches = [
+        { workspace: "medical", query: "COVID symptoms fever", label: "Medical" },
+        { workspace: "medical", query: "vaccine technology", label: "Medical" },
+        { workspace: "technology", query: "neural networks", label: "Tech" },
+        { workspace: "technology", query: "COVID", label: "Tech (isolation test)" },
+    ];
+    console.log("\n🔍 Running searches:");
+    for (const { workspace, query, label } of searches) {
+        const results = await ragSearch({ modelId, workspace, query, topK: 1 });
+        console.log(`\n${label}: "${query}"`);
+        if (results.length > 0 && results[0]) {
+            console.log(`  ✓ Score: ${results[0].score.toFixed(3)}`);
+            console.log(`  ✓ Match: ${results[0].content.substring(0, 80)}...`);
+        }
+        else {
+            console.log(`  ✗ No results (workspace isolation working correctly)`);
+        }
+    }
+    // Test a third workspace
+    console.log("\n📁 Testing 'general' workspace...");
+    await ragIngest({
+        modelId,
+        workspace: "general",
+        documents: ["General workspace content for testing"],
+        chunk: false,
+    });
+    const generalSearch = await ragSearch({
+        modelId,
+        workspace: "general",
+        query: "general workspace",
+    });
+    console.log(`General workspace: ${generalSearch?.[0]?.content === "General workspace content for testing" ? "✅ Working" : "❌ Failed"}`);
+    // Reindexing - regenerate embeddings for an existing workspace
+    console.log("\n🔄 Reindexing medical workspace...");
+    const reindexResult = await ragReindex({
+        workspace: "medical",
+        modelId,
+        onProgress: (stage, current, total) => {
+            const pct = total > 0 ? Math.round((current / total) * 100) : 0;
+            console.log(`   [${stage}] ${current}/${total} (${pct}%)`);
+        },
+    });
+    console.log(`${reindexResult.reindexed ? "✅ Reindex completed" : "⚠️  Reindex returned false"} for medical workspace`);
+    if (reindexResult.details) {
+        console.log("   Details:", reindexResult.details);
+    }
+    // Verify reindexed data still works
+    const reindexVerify = await ragSearch({
+        modelId,
+        workspace: "medical",
+        query: "COVID symptoms",
+        topK: 1,
+    });
+    console.log(`   Verification search: ${reindexVerify.length > 0 ? "✅ Working" : "❌ Failed"}`);
+    // Cleanup example
+    const firstChunk = medicalResult.processed.find((p) => p.status === "fulfilled" && p.id);
+    if (firstChunk?.id) {
+        await ragDeleteEmbeddings({
+            workspace: "medical",
+            ids: [firstChunk.id],
+        });
+        console.log("\n🗑️  Deleted one medical chunk");
+    }
+    // List all workspaces
+    console.log("\n📂 Listing workspaces...");
+    const workspaces = await ragListWorkspaces();
+    workspaces.forEach((ws) => {
+        console.log(`  • ${ws.name} (${ws.open ? "open" : "closed"})`);
+    });
+    // Close and delete all workspaces created in this example
+    console.log("\n🗑️  Closing and deleting workspaces...");
+    await ragCloseWorkspace({ workspace: "medical", deleteOnClose: true });
+    console.log("Deleted 'medical' workspace");
+    await ragCloseWorkspace({ workspace: "technology", deleteOnClose: true });
+    console.log("Deleted 'technology' workspace");
+    await ragCloseWorkspace({ workspace: "general", deleteOnClose: true });
+    console.log("Deleted 'general' workspace");
+    await unloadModel({ modelId });
+}
+catch (error) {
+    console.error("❌ Error:", error);
+    process.exit(1);
+}

package/dist/examples/translation/translation-bergamot-batch.d.ts

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

package/dist/examples/translation/translation-bergamot-batch.js

@@ -0,0 +1,49 @@
+import { loadModel, translate, unloadModel, BERGAMOT_ENFR } from "@qvac/sdk";
+try {
+    const modelId = await loadModel({
+        modelSrc: BERGAMOT_ENFR,
+        modelType: "nmt",
+        modelConfig: {
+            engine: "Bergamot",
+            from: "en",
+            to: "fr",
+            beamsize: 1,
+            normalize: 1,
+            temperature: 0.2,
+            norepeatngramsize: 3,
+            lengthpenalty: 1.2,
+        },
+        onProgress: (progress) => {
+            console.log(progress);
+        },
+    });
+    console.log(`✅ Bergamot model loaded: ${modelId}`);
+    // Test with array of texts for batch processing
+    const texts = [
+        "Hello world",
+        "How are you today?",
+        "This is a test of batch translation",
+        "The weather is nice",
+    ];
+    console.log("\n📝 Translating batch of texts:");
+    texts.forEach((text, i) => console.log(`  ${i + 1}. ${text}`));
+    const result = translate({
+        modelId,
+        text: texts, // Pass array for batch processing
+        modelType: "nmt",
+        stream: false,
+    });
+    const translatedText = await result.text;
+    const translations = translatedText.split("\n");
+    console.log("\n✅ Translations:");
+    translations.forEach((translation, i) => {
+        if (i < texts.length) {
+            console.log(`  ${i + 1}. ${texts[i]} -> "${translation}"`);
+        }
+    });
+    await unloadModel({ modelId });
+}
+catch (error) {
+    console.error("❌ Error:", error);
+    process.exit(1);
+}

package/dist/examples/translation/translation-bergamot.d.ts

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

package/dist/examples/translation/translation-bergamot.js

@@ -0,0 +1,39 @@
+import { loadModel, translate, unloadModel, BERGAMOT_ENFR } from "@qvac/sdk";
+try {
+    // Bergamot models automatically derive vocabulary files from the model source
+    // when using pear:// URLs. You can still override them explicitly if needed:
+    // - srcVocabSrc: source vocabulary file (optional)
+    // - dstVocabSrc: target vocabulary file (optional)
+    const modelId = await loadModel({
+        modelSrc: BERGAMOT_ENFR,
+        modelType: "nmt",
+        modelConfig: {
+            engine: "Bergamot",
+            from: "en",
+            to: "fr",
+            beamsize: 1,
+            normalize: 1,
+            temperature: 0.2,
+            norepeatngramsize: 3,
+            lengthpenalty: 1.2,
+        },
+        onProgress: (progress) => {
+            console.log(progress);
+        },
+    });
+    console.log(`✅ Bergamot model loaded: ${modelId}`);
+    const text = "This is a test of the Bergamot translation model.";
+    const result = translate({
+        modelId,
+        text,
+        modelType: "nmt",
+        stream: false,
+    });
+    const translatedText = await result.text;
+    console.log(`Translated text EN -> FR: ${text} -> "${translatedText}"`);
+    await unloadModel({ modelId });
+}
+catch (error) {
+    console.error("❌ Error:", error);
+    process.exit(1);
+}

package/dist/examples/translation/translation-indic.js

@@ -10,6 +10,7 @@ try {
             console.log(progress);
         },
         modelConfig: {
+            engine: "IndicTrans",
             from: "eng_Latn",
             to: "hin_Deva",
         },

package/dist/examples/translation/translation-opus.js

@@ -4,6 +4,7 @@ try {
         modelSrc: MARIAN_OPUS_EN_IT_Q0F32,
         modelType: "nmt",
         modelConfig: {
+            engine: "Opus",
             from: "en",
             to: "it",
             temperature: 0.2,

package/dist/examples/translation/translation-stream.js

@@ -4,6 +4,7 @@ try {
         modelSrc: MARIAN_OPUS_EN_IT_Q0F32,
         modelType: "nmt",
         modelConfig: {
+            engine: "Opus",
             from: "en",
             to: "it",
         },