@qvac/sdk 0.4.1 → 0.6.0

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",
         },

package/dist/expo/plugins/withMobileBundle.js

@@ -24,12 +24,9 @@ function withMobileBundle(config) {
             throw new WorkerFileNotFoundError(workerPath);
         }
         try {
-            // Truncate incompatible RPC clients for mobile (keep only rpc-client.js and expo-rpc-client.js)
-            const rpcClientsToTruncate = [
-                "node-rpc-client.js",
-                "bare-rpc-client.js",
-                "bare-client.js",
-            ];
+            // Truncate incompatible RPC clients for mobile
+            // Keep: rpc-client.js, expo-rpc-client.js, bare-client.js (needed for worker bundle)
+            const rpcClientsToTruncate = ["node-rpc-client.js"];
             const truncatedContent = "// This RPC client is not available in mobile environments";
             for (const clientFile of rpcClientsToTruncate) {
                 const clientPath = path.join(qvacSdkPath, "dist", "client", "rpc", clientFile);
@@ -38,9 +35,15 @@ function withMobileBundle(config) {
                     console.log(`🔧 QVAC: Truncated ${clientFile} for mobile compatibility`);
                 }
             }
+            // Copy bare imports configuration for bare-pack
+            const bareImportsSource = path.join(qvacSdkPath, "bare-imports.json");
+            const importsMapPath = path.join(qvacSdkPath, "dist", "imports.json");
+            if (fs.existsSync(bareImportsSource)) {
+                fs.copyFileSync(bareImportsSource, importsMapPath);
+                console.log("🔧 QVAC: Copied bare-imports.json for mobile bundle");
+            }
             // Remove optional modules from the bundle
             const optionalModules = [
-                "crypto",
                 "expo-file-system",
                 "react-native-bare-kit",
                 "@qvac/sdk/worker.mobile.bundle",
@@ -48,9 +51,25 @@ function withMobileBundle(config) {
             const deferFlags = optionalModules
                 .map((mod) => `--defer "${mod}"`)
                 .join(" ");
-            // Generate the bundle using bun bare-pack with the current project's dependencies
-            // We use the project root as working directory so bare-pack uses the user's node_modules
-            execSync(`cd "${projectRoot}" && npx bare-pack --target android-arm64 --target ios-arm64 --target ios-arm64-simulator --linked ${deferFlags} --out "${outputPath}" "${workerPath}"`, { stdio: "inherit", cwd: projectRoot });
+            // Detect bare-pack version (v1.x uses --target, v2.x uses --host)
+            let platformFlag = "--host";
+            try {
+                const versionOutput = execSync(`npx bare-pack --version "${workerPath}"`, { cwd: projectRoot, encoding: "utf-8" }).trim();
+                const versionMatch = versionOutput.match(/v?(\d+)\./);
+                const majorVersion = versionMatch && versionMatch[1] ? parseInt(versionMatch[1], 10) : 2;
+                if (majorVersion < 2) {
+                    platformFlag = "--target";
+                }
+            }
+            catch (error) {
+                throw new Error(`Failed to detect bare-pack version. Ensure bare-pack is installed: npm install bare-pack`, { cause: error });
+            }
+            const platforms = ["android-arm64", "ios-arm64", "ios-arm64-simulator"];
+            const platformFlags = platforms
+                .map((p) => `${platformFlag} ${p}`)
+                .join(" ");
+            // Generate the bundle using bare-pack with the current project's dependencies
+            execSync(`cd "${projectRoot}" && npx bare-pack ${platformFlags} --linked --imports "${importsMapPath}" ${deferFlags} --out "${outputPath}" "${workerPath}"`, { stdio: "inherit", cwd: projectRoot });
             console.log("🫡 QVAC: Mobile worker bundle generated successfully");
         }
         catch (error) {

package/dist/index.d.ts

@@ -1,9 +1,10 @@
-export { completion, deleteCache, loadModel, downloadAsset, ping, startQVACProvider, stopQVACProvider, unloadModel, transcribe, transcribeStream, embed, translate, cancel, ragSaveEmbeddings, ragSearch, ragDeleteEmbeddings, textToSpeech, setConfig, getModelInfo, } from "./client/api/index";
+export { completion, deleteCache, loadModel, downloadAsset, ping, startQVACProvider, stopQVACProvider, unloadModel, transcribe, transcribeStream, embed, translate, cancel, ragChunk, ragIngest, ragSaveEmbeddings, ragSearch, ragDeleteEmbeddings, ragReindex, ragListWorkspaces, ragCloseWorkspace, ragDeleteWorkspace, textToSpeech, getModelInfo, loggingStream, ocr, } from "./client/api/index";
 export { close } from "./client/index";
-export { type ModelProgressUpdate, type LoadModelOptions, type DownloadAssetOptions, type Tool, type ToolCall, type ToolCallError, type ToolCallEvent, type CompletionStats, VERBOSITY, type Attachment, type CompletionParams, type RagSearchResult, type RagSaveEmbeddingsResult, SDK_CLIENT_ERROR_CODES, SDK_SERVER_ERROR_CODES, type SDKConfig, type ModelInfo, type GetModelInfoParams, type LoadedInstance, type CacheFileInfo, toolSchema, } from "./schemas/index";
-export { type ToolInput } from "./utils/tool-helpers";
+export { type ModelProgressUpdate, type LoadModelOptions, type DownloadAssetOptions, type Tool, type ToolCall, type ToolCallWithCall, type ToolCallError, type ToolCallEvent, type CompletionStats, VERBOSITY, type Attachment, type CompletionParams, type RagSearchResult, type RagSaveEmbeddingsResult, type RagReindexResult, type RagEmbeddedDoc, type RagDoc, type RagWorkspaceInfo, type RagCloseWorkspaceParams, type RagDeleteWorkspaceParams, type RagIngestStage, type RagReindexStage, type RagSaveStage, SDK_CLIENT_ERROR_CODES, SDK_SERVER_ERROR_CODES, type QvacConfig, type ModelInfo, type GetModelInfoParams, type LoadedInstance, type CacheFileInfo, toolSchema, type McpClient, type McpClientInput, type OCRClientParams, type OCRTextBlock, type OCROptions, } from "./schemas/index";
+export { type ToolInput, type ToolHandler } from "./utils/tool-helpers";
+export { PUBLIC_MODEL_TYPES as MODEL_TYPES } from "./schemas/index";
 export * from "./models/hyperdrive/index";
 export { SUPPORTED_AUDIO_FORMATS } from "./constants/audio";
-export { getLogger, setGlobalLogLevel } from "./logging/index";
+export { getLogger, SDK_LOG_ID } from "./logging/index";
 export type { Logger, LogTransport, LoggerOptions } from "./logging/index";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,10 +1,12 @@
 // Public API exports only
-export { completion, deleteCache, loadModel, downloadAsset, ping, startQVACProvider, stopQVACProvider, unloadModel, transcribe, transcribeStream, embed, translate, cancel, ragSaveEmbeddings, ragSearch, ragDeleteEmbeddings, textToSpeech, setConfig, getModelInfo, } from "./client/api/index.js";
+export { completion, deleteCache, loadModel, downloadAsset, ping, startQVACProvider, stopQVACProvider, unloadModel, transcribe, transcribeStream, embed, translate, cancel, ragChunk, ragIngest, ragSaveEmbeddings, ragSearch, ragDeleteEmbeddings, ragReindex, ragListWorkspaces, ragCloseWorkspace, ragDeleteWorkspace, textToSpeech, getModelInfo, loggingStream, ocr, } from "./client/api/index.js";
 export { close } from "./client/index.js";
 export { VERBOSITY, SDK_CLIENT_ERROR_CODES, SDK_SERVER_ERROR_CODES, toolSchema, } from "./schemas/index.js";
 export {} from "./utils/tool-helpers.js";
+// Model types - canonical naming with backward-compatible aliases
+export { PUBLIC_MODEL_TYPES as MODEL_TYPES } from "./schemas/index.js";
 // Hyperdrive model constants
 export * from "./models/hyperdrive/index.js";
 export { SUPPORTED_AUDIO_FORMATS } from "./constants/audio.js";
 // Logging exports
-export { getLogger, setGlobalLogLevel } from "./logging/index.js";
+export { getLogger, SDK_LOG_ID } from "./logging/index.js";

package/dist/logging/addon.d.ts

@@ -0,0 +1,6 @@
+import type { Logger } from "./index";
+export declare function registerAddonLogger(modelId: string, namespace: string, logger: Logger): void;
+export declare function unregisterAddonLogger(modelId: string): void;
+export declare function createAddonLoggerCallback(namespace: string): (priority: number, message: string) => void;
+export declare function clearAllAddonLoggers(): void;
+//# sourceMappingURL=addon.d.ts.map

package/dist/logging/addon.js

@@ -0,0 +1,75 @@
+import { unregisterLogger } from "./registry.js";
+// Map C++ addon priority (0-4) to SDK LogLevel
+const PRIORITY_TO_LEVEL = {
+    0: "error",
+    1: "warn",
+    2: "info",
+    3: "debug",
+    4: "debug",
+};
+const ADDON_LOGGERS_KEY = Symbol.for("@qvac/sdk:addon-loggers");
+const MODEL_LOGGERS_KEY = Symbol.for("@qvac/sdk:model-loggers");
+function getAddonLoggers() {
+    const global = globalThis;
+    if (!global[ADDON_LOGGERS_KEY]) {
+        global[ADDON_LOGGERS_KEY] = new Map();
+    }
+    return global[ADDON_LOGGERS_KEY];
+}
+function getModelLoggers() {
+    const global = globalThis;
+    if (!global[MODEL_LOGGERS_KEY]) {
+        global[MODEL_LOGGERS_KEY] = new Map();
+    }
+    return global[MODEL_LOGGERS_KEY];
+}
+export function registerAddonLogger(modelId, namespace, logger) {
+    const addonLoggers = getAddonLoggers();
+    const modelLoggers = getModelLoggers();
+    if (!addonLoggers.has(namespace)) {
+        addonLoggers.set(namespace, new Set());
+    }
+    addonLoggers.get(namespace).add(logger);
+    modelLoggers.set(modelId, { namespace, logger });
+}
+export function unregisterAddonLogger(modelId) {
+    const addonLoggers = getAddonLoggers();
+    const modelLoggers = getModelLoggers();
+    const entry = modelLoggers.get(modelId);
+    if (entry) {
+        addonLoggers.get(entry.namespace)?.delete(entry.logger);
+        unregisterLogger(entry.logger);
+        modelLoggers.delete(modelId);
+    }
+}
+function routeLog(logger, level, message) {
+    switch (level) {
+        case "error":
+            logger.error(message);
+            break;
+        case "warn":
+            logger.warn(message);
+            break;
+        case "info":
+            logger.info(message);
+            break;
+        case "debug":
+            logger.debug(message);
+            break;
+    }
+}
+export function createAddonLoggerCallback(namespace) {
+    return (priority, message) => {
+        const loggers = getAddonLoggers().get(namespace);
+        if (!loggers || loggers.size === 0)
+            return;
+        const level = PRIORITY_TO_LEVEL[priority] ?? "debug";
+        for (const logger of loggers) {
+            routeLog(logger, level, message);
+        }
+    };
+}
+export function clearAllAddonLoggers() {
+    getAddonLoggers().clear();
+    getModelLoggers().clear();
+}