@qvac/sdk 0.1.1 → 0.2.0

package/dist/client/api/completion-stream.d.ts

@@ -7,25 +7,40 @@ import { type CompletionStats, type CompletionClientParams } from "../../schemas
  * @param params.history - Array of conversation messages with role, content, and optional attachments
  * @param params.stream - Whether to stream tokens (true) or return complete response (false). Defaults to true
  * @param params.tools - Optional array of tools that can be used by the model
- * @param params.kvCache - Optional boolean to enable KV cache for faster subsequent completions
+ * @param params.kvCache - Optional KV cache configuration. Cache files are organized hierarchically:
+ *   - Structure: `{kvCacheKey}/{modelId}/{configHash}.bin`
+ *   - The configHash includes model config + system prompt to ensure cache isolation
+ *   - `true`: Auto-generate cache key based on conversation history
+ *   - `"custom-key"`: Use provided string as cache key for manual session management
+ *   - `false` or `undefined`: No caching
+ *   - ⚡ Performance: When cache exists, only the last message is sent to the model (includes multimodal attachments)
+ *   - 🗑️ Cleanup: Use `deleteCache({ kvCacheKey })` to remove cached sessions
  * @returns Object with tokenStream generator, text promise, and stats promise
  * @example
  * ```typescript
- * // Streaming mode
+ * // Streaming mode with auto-generated cache
  * const result = completion({
  *   modelId: "llama-2",
  *   history: [
  *     { role: "user", content: "Hello, how are you?" }
  *   ],
  *   stream: true,
+ *   kvCache: true, // Auto-generate cache key
  * });
  *
  * for await (const token of result.tokenStream) {
  *   console.log(token);
  * }
  *
- * const stats = await result.stats;
- * console.log("Performance:", stats);
+ * // Custom session management with cache key
+ * const sessionResult = completion({
+ *   modelId: "llama-2",
+ *   history: [
+ *     { role: "user", content: "Continue our conversation" }
+ *   ],
+ *   stream: true,
+ *   kvCache: "user-session-123", // Custom cache key
+ * });
  *
  * // Non-streaming mode
  * const response = completion({

package/dist/client/api/completion-stream.js

@@ -8,25 +8,40 @@ import { stream as streamRpc } from "../rpc/rpc-client.js";
  * @param params.history - Array of conversation messages with role, content, and optional attachments
  * @param params.stream - Whether to stream tokens (true) or return complete response (false). Defaults to true
  * @param params.tools - Optional array of tools that can be used by the model
- * @param params.kvCache - Optional boolean to enable KV cache for faster subsequent completions
+ * @param params.kvCache - Optional KV cache configuration. Cache files are organized hierarchically:
+ *   - Structure: `{kvCacheKey}/{modelId}/{configHash}.bin`
+ *   - The configHash includes model config + system prompt to ensure cache isolation
+ *   - `true`: Auto-generate cache key based on conversation history
+ *   - `"custom-key"`: Use provided string as cache key for manual session management
+ *   - `false` or `undefined`: No caching
+ *   - ⚡ Performance: When cache exists, only the last message is sent to the model (includes multimodal attachments)
+ *   - 🗑️ Cleanup: Use `deleteCache({ kvCacheKey })` to remove cached sessions
  * @returns Object with tokenStream generator, text promise, and stats promise
  * @example
  * ```typescript
- * // Streaming mode
+ * // Streaming mode with auto-generated cache
  * const result = completion({
  *   modelId: "llama-2",
  *   history: [
  *     { role: "user", content: "Hello, how are you?" }
  *   ],
  *   stream: true,
+ *   kvCache: true, // Auto-generate cache key
  * });
  *
  * for await (const token of result.tokenStream) {
  *   console.log(token);
  * }
  *
- * const stats = await result.stats;
- * console.log("Performance:", stats);
+ * // Custom session management with cache key
+ * const sessionResult = completion({
+ *   modelId: "llama-2",
+ *   history: [
+ *     { role: "user", content: "Continue our conversation" }
+ *   ],
+ *   stream: true,
+ *   kvCache: "user-session-123", // Custom cache key
+ * });
  *
  * // Non-streaming mode
  * const response = completion({

package/dist/client/api/delete-cache.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Deletes KV cache files.
+ *
+ * @param params - The delete cache parameters
+ * @param params.all - If true, deletes all cache files
+ * @param params.kvCacheKey - The cache key to delete
+ * @param params.modelId - Optional: specific model ID to delete within the cache key. If not provided, deletes entire cache key.
+ * @returns Promise resolving to success status
+ * @example
+ * ```typescript
+ * // Delete all caches
+ * await deleteCache({ all: true });
+ *
+ * // Delete entire cache key (all models)
+ * await deleteCache({ kvCacheKey: "my-session" });
+ *
+ * // Delete only specific model within cache key
+ * await deleteCache({ kvCacheKey: "my-session", modelId: "model-abc123" });
+ * ```
+ */
+export declare function deleteCache(params: {
+    all: true;
+} | {
+    kvCacheKey: string;
+    modelId?: string;
+}): Promise<{
+    success: boolean;
+}>;
+//# sourceMappingURL=delete-cache.d.ts.map

package/dist/client/api/delete-cache.js

@@ -0,0 +1,47 @@
+import { send } from "../rpc/rpc-client.js";
+/**
+ * Deletes KV cache files.
+ *
+ * @param params - The delete cache parameters
+ * @param params.all - If true, deletes all cache files
+ * @param params.kvCacheKey - The cache key to delete
+ * @param params.modelId - Optional: specific model ID to delete within the cache key. If not provided, deletes entire cache key.
+ * @returns Promise resolving to success status
+ * @example
+ * ```typescript
+ * // Delete all caches
+ * await deleteCache({ all: true });
+ *
+ * // Delete entire cache key (all models)
+ * await deleteCache({ kvCacheKey: "my-session" });
+ *
+ * // Delete only specific model within cache key
+ * await deleteCache({ kvCacheKey: "my-session", modelId: "model-abc123" });
+ * ```
+ */
+export async function deleteCache(params) {
+    let req;
+    if ("all" in params && params.all) {
+        req = {
+            type: "deleteCache",
+            all: true,
+        };
+    }
+    else if ("kvCacheKey" in params) {
+        req = {
+            type: "deleteCache",
+            kvCacheKey: params.kvCacheKey,
+            modelId: params.modelId,
+        };
+    }
+    else {
+        throw new Error("Invalid deleteCache parameters");
+    }
+    const response = (await send(req));
+    if (!response.success && response.error) {
+        throw new Error(response.error);
+    }
+    return {
+        success: response.success,
+    };
+}

package/dist/client/api/index.d.ts

@@ -1,6 +1,7 @@
 export { loadModel } from "./load-model";
 export { downloadAsset } from "./download-asset";
 export { completion } from "./completion-stream";
+export { deleteCache } from "./delete-cache";
 export { unloadModel } from "./unload-model";
 export { loggingStream } from "./logging-stream";
 export { ping } from "./ping";

package/dist/client/api/index.js

@@ -1,6 +1,7 @@
 export { loadModel } from "./load-model.js";
 export { downloadAsset } from "./download-asset.js";
 export { completion } from "./completion-stream.js";
+export { deleteCache } from "./delete-cache.js";
 export { unloadModel } from "./unload-model.js";
 export { loggingStream } from "./logging-stream.js";
 export { ping } from "./ping.js";

package/dist/client/rpc/bare-client.d.ts

@@ -11,8 +11,13 @@ export declare function stream<T extends Request>(request: T): AsyncGenerator<{
     stats?: {
         timeToFirstToken: number;
         tokensPerSecond: number;
+        cacheTokens: number;
     } | undefined;
     error?: string | undefined;
+} | {
+    type: "deleteCache";
+    success: boolean;
+    error?: string | undefined;
 } | {
     type: "modelProgress";
     downloaded: number;

package/dist/client/rpc/bare-client.js

@@ -45,8 +45,44 @@ export async function* stream(request) {
         }
         yield* streamWithProgress();
     }
+    else if (request.type === "downloadAsset" &&
+        "withProgress" in request &&
+        request.withProgress) {
+        async function* streamWithProgress() {
+            const queue = [];
+            let done = false;
+            const downloadAssetHandler = handler;
+            downloadAssetHandler(request, (update) => queue.push(update))
+                .then((final) => {
+                queue.push(final);
+                done = true;
+            })
+                .catch((error) => {
+                done = true;
+                throw error;
+            });
+            while (!done || queue.length > 0) {
+                if (queue.length > 0) {
+                    yield queue.shift();
+                }
+                else {
+                    await new Promise((resolve) => setTimeout(resolve, 10));
+                }
+            }
+        }
+        yield* streamWithProgress();
+    }
     else {
-        yield* handler(request);
+        const result = handler(request);
+        // Check if the handler returns a Promise or AsyncGenerator
+        if (Symbol.asyncIterator in result) {
+            // It's an AsyncGenerator
+            yield* result;
+        }
+        else {
+            // It's a Promise, await and yield the single result
+            yield await result;
+        }
     }
 }
 const createMockRPCRequest = () => {

package/dist/examples/download-with-cancel.js

@@ -12,9 +12,9 @@ try {
             const totalMB = (progress.total / 1024 / 1024).toFixed(2);
             const percentage = progress.percentage.toFixed(1);
             console.log(`📊 Progress: ${percentage}% (${downloadedMB}MB / ${totalMB}MB)`);
-            // Example: Stops at 35% (or use Ctrl+C for manual stop)
-            if (parseFloat(percentage) >= 35 && !cancelled) {
-                console.log("\n🚫 Auto-cancelling at 35% for demo purposes...,");
+            // Example: Stops at 10% (or use Ctrl+C for manual stop)
+            if (parseFloat(percentage) >= 10 && !cancelled) {
+                console.log("\n🚫 Auto-cancelling at 10% for demo purposes...,");
                 console.log(`📊 Progress: ${percentage}% (${downloadedMB}MB / ${totalMB}MB)`);
                 console.log(progress);
                 cancelled = true;

package/dist/examples/kv-cache-cleanup.d.ts

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

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

@@ -0,0 +1,88 @@
+import { completion, deleteCache, LLAMA_3_2_1B_INST_Q4_0, loadModel, unloadModel, VERBOSITY, } from "@qvac/sdk";
+try {
+    console.log("🧹 KV Cache Cleanup Demo\n");
+    console.log("Cache structure: {kvCacheKey}/{modelId}/{configHash}.bin\n");
+    console.log("=".repeat(70) + "\n");
+    const modelId = await loadModel({
+        modelSrc: LLAMA_3_2_1B_INST_Q4_0,
+        modelType: "llm",
+        modelConfig: {
+            device: "gpu",
+            ctx_size: 2048,
+            verbosity: VERBOSITY.SILENT,
+        },
+    });
+    // Create some cached sessions
+    const cacheKey1 = "user-alice-session";
+    const cacheKey2 = "user-bob-session";
+    console.log(`📝 Creating cache for key: "${cacheKey1}"`);
+    const result1 = completion({
+        modelId,
+        history: [{ role: "user", content: "Hello, I'm Alice!" }],
+        stream: true,
+        kvCache: cacheKey1,
+    });
+    for await (const token of result1.tokenStream) {
+        process.stdout.write(token);
+    }
+    console.log("\n✅ Cache created\n");
+    console.log(`📝 Creating cache for key: "${cacheKey2}"`);
+    const result2 = completion({
+        modelId,
+        history: [{ role: "user", content: "Hello, I'm Bob!" }],
+        stream: true,
+        kvCache: cacheKey2,
+    });
+    for await (const token of result2.tokenStream) {
+        process.stdout.write(token);
+    }
+    console.log("\n✅ Cache created\n");
+    // Now cleanup specific cache key
+    console.log("=".repeat(70));
+    console.log(`\n🗑️  Deleting cache key: "${cacheKey1}"`);
+    const deleteResult1 = await deleteCache({ kvCacheKey: cacheKey1 });
+    if (deleteResult1.success) {
+        console.log(`✅ Deleted all caches for key "${cacheKey1}"`);
+        console.log(`   (Removed: ${cacheKey1}/{modelId}/{configHash}.bin)`);
+    }
+    // Delete specific model within a cache key
+    console.log(`\n🗑️  Deleting specific model in cache key: "${cacheKey2}"`);
+    const deleteResult2 = await deleteCache({
+        kvCacheKey: cacheKey2,
+        modelId: modelId,
+    });
+    if (deleteResult2.success) {
+        console.log(`✅ Deleted model "${modelId}" from cache key "${cacheKey2}"`);
+        console.log(`   (Removed: ${cacheKey2}/${modelId}/)`);
+    }
+    // Try to delete non-existent cache key (should succeed silently)
+    console.log(`\n🗑️  Deleting non-existent cache key: "non-existent"`);
+    const deleteResult3 = await deleteCache({ kvCacheKey: "non-existent" });
+    if (deleteResult3.success) {
+        console.log("✅ Delete succeeded (cache key didn't exist)");
+    }
+    console.log("\n" + "=".repeat(70));
+    console.log("\n✅ CLEANUP OPTIONS:");
+    console.log("-".repeat(70));
+    console.log("\n1️⃣  Delete entire cache key (all models):");
+    console.log('   await deleteCache({ kvCacheKey: "my-session" })');
+    console.log("   └─ Removes: my-session/ (entire directory)");
+    console.log("\n2️⃣  Delete specific model within cache key:");
+    console.log('   await deleteCache({ kvCacheKey: "my-session", modelId: "model-abc" })');
+    console.log("   └─ Removes: my-session/model-abc/ (specific model directory)");
+    console.log("\n3️⃣  Delete ALL caches (entire cache folder):");
+    console.log("   await deleteCache({ all: true })");
+    console.log("   └─ Removes: ALL cache files from all sessions and models");
+    console.log("\n💡 Use Cases:");
+    console.log("   - User logout → Delete user's cache key");
+    console.log("   - Model updated → Delete old model caches");
+    console.log("   - Disk space cleanup → Delete old cache keys or all caches");
+    console.log("   - Privacy → Clear conversation history");
+    console.log("   - App reset → Delete all caches with { all: true }");
+    await unloadModel({ modelId, clearStorage: false });
+    process.exit(0);
+}
+catch (error) {
+    console.error("❌ Error:", error);
+    process.exit(1);
+}

package/dist/examples/kv-cache-custom-key.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=kv-cache-custom-key.d.ts.map

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

@@ -0,0 +1,87 @@
+import { completion, deleteCache, LLAMA_3_2_1B_INST_Q4_0, loadModel, unloadModel, VERBOSITY, } from "@qvac/sdk";
+const systemPromptMessage = {
+    role: "system",
+    content: `You are a helpful mathematician assistant. 
+   But because you are in the army you have to follow these rules:
+  - If anyone ask you to do an operation you have to answer with "Sir Yes Sir!" and then give the result
+  `,
+};
+try {
+    console.log("🧪 Simple KV Cache Demo: Same vs Different Cache Keys\n");
+    const modelId = await loadModel({
+        modelSrc: LLAMA_3_2_1B_INST_Q4_0,
+        modelType: "llm",
+        modelConfig: {
+            device: "gpu",
+            ctx_size: 2048,
+            verbosity: VERBOSITY.SILENT,
+        },
+    });
+    // Prompt 1 with cache key "session-a" (first time - no cache exists)
+    console.log('📝 Prompt 1: "What is 2+2?" with cache key "session-a"');
+    console.log("   Status: Creating NEW cache (first time)\n");
+    const result1 = completion({
+        modelId,
+        history: [systemPromptMessage, { role: "user", content: "What is 2+2?" }],
+        stream: true,
+        kvCache: "session-a",
+    });
+    console.log("   Response: ");
+    let response1 = "";
+    for await (const token of result1.tokenStream) {
+        response1 += token;
+        process.stdout.write(token);
+    }
+    const stats1 = await result1.stats;
+    console.log(`\n   Stats: TTFT=${stats1?.timeToFirstToken}ms, CacheTokens=${stats1?.cacheTokens}\n`);
+    // Prompt 2 with SAME cache key "session-a" (cache exists - optimized!)
+    // This continues the conversation - asking about the previous answer
+    console.log('\n📝 Prompt 2: "Now multiply that result by 3" with cache key "session-a" (SAME)');
+    console.log("   Status: REUSING existing cache (only last message sent, but context remembered!)\n");
+    const result2 = completion({
+        modelId,
+        history: [
+            systemPromptMessage,
+            { role: "user", content: "What is 2+2?" },
+            { role: "assistant", content: response1 },
+            { role: "user", content: "Now multiply that result by 3" }, // Refers to previous answer!
+        ],
+        stream: true,
+        kvCache: "session-a", // Same cache key!
+    });
+    console.log("   Response: ");
+    for await (const token of result2.tokenStream) {
+        process.stdout.write(token);
+    }
+    const stats2 = await result2.stats;
+    console.log(`\n   Stats: TTFT=${stats2?.timeToFirstToken}ms, CacheTokens=${stats2?.cacheTokens}\n`);
+    // Prompt 3 with DIFFERENT cache key "session-b" (new cache)
+    console.log('\n📝 Prompt 3: "What is 10+10?" with cache key "session-b" (DIFFERENT)');
+    console.log("   Status: Creating NEW cache (different key = isolated cache)\n");
+    const result3 = completion({
+        modelId,
+        history: [systemPromptMessage, { role: "user", content: "What is 10+10?" }],
+        stream: true,
+        kvCache: "session-b", // Different cache key!
+    });
+    console.log("   Response: ");
+    for await (const token of result3.tokenStream) {
+        process.stdout.write(token);
+    }
+    const stats3 = await result3.stats;
+    console.log(`\n   Stats: TTFT=${stats3?.timeToFirstToken}ms, CacheTokens=${stats3?.cacheTokens}\n`);
+    // Summary
+    console.log("\n✅ Summary:");
+    console.log('   - Prompts 1 & 2 share cache key "session-a" → same cache file');
+    console.log("   - Prompt 2 built on Prompt 1's context (model remembered the answer!)");
+    console.log("   - Only the last message was sent, but full conversation context maintained");
+    console.log('   - Prompt 3 uses cache key "session-b" → separate cache file (isolated)');
+    console.log("   - Different cache keys provide complete isolation between sessions");
+    await deleteCache({ all: true });
+    await unloadModel({ modelId, clearStorage: false });
+    process.exit(0);
+}
+catch (error) {
+    console.error("❌ Error:", error);
+    process.exit(1);
+}

package/dist/examples/llamacpp-multimodal.js

@@ -1,4 +1,4 @@
-import { completion, loadModel, unloadModel } from "@qvac/sdk";
+import { completion, loadModel, SMOLVLM2_2_500M_MULTIMODAL_Q8_0, MMPROJ_SMOLVLM2_2_500M_MULTIMODAL_Q8_0, unloadModel, } from "@qvac/sdk";
 if (process.argv.length < 3) {
     console.error(`Specify an image file path as the first argument and a second image file path as the second (optional) argument`);
     process.exit(1);
@@ -8,9 +8,9 @@ try {
     const imageFilePath = process.argv[2];
     // Load the main model with projection in a single step
     const modelId = await loadModel({
-        modelSrc: "https://huggingface.co/ggml-org/SmolVLM2-500M-Video-Instruct-GGUF/resolve/main/SmolVLM2-500M-Video-Instruct-Q8_0.gguf",
+        modelSrc: SMOLVLM2_2_500M_MULTIMODAL_Q8_0,
         modelType: "llm",
-        projectionModelSrc: "https://huggingface.co/ggml-org/SmolVLM2-500M-Video-Instruct-GGUF/resolve/main/mmproj-SmolVLM2-500M-Video-Instruct-Q8_0.gguf",
+        projectionModelSrc: MMPROJ_SMOLVLM2_2_500M_MULTIMODAL_Q8_0,
         modelConfig: {
             ctx_size: 1024,
         },

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

@@ -41,9 +41,10 @@ try {
         documents: medicalArticle,
         chunk: true,
         chunkOpts: {
-            chunkSize: 30,
+            chunkSize: 100,
             chunkOverlap: 10,
             chunkStrategy: "paragraph",
+            splitStrategy: "token",
         },
     });
     console.log(`✅ Created ${medicalResult.processed.length} chunks from medical article`);

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { completion, loadModel, downloadAsset, ping, startQVACProvider, unloadModel, transcribe, transcribeStream, embed, translate, cancel, ragSaveEmbeddings, ragSearch, ragDeleteEmbeddings, } from "./client/api/index";
+export { completion, deleteCache, loadModel, downloadAsset, ping, startQVACProvider, unloadModel, transcribe, transcribeStream, embed, translate, cancel, ragSaveEmbeddings, ragSearch, ragDeleteEmbeddings, } from "./client/api/index";
 export { type ModelProgressUpdate, type LoadModelOptions, type DownloadAssetOptions, type Tool, VERBOSITY, type Attachment, type CompletionParams, type RagSearchResult, type RagSaveEmbeddingsResult, } from "./schemas/index";
 export * from "./models/hyperdrive/index";
 export { SUPPORTED_AUDIO_FORMATS } from "./constants/audio";

package/dist/index.js

@@ -1,5 +1,5 @@
 // Public API exports only
-export { completion, loadModel, downloadAsset, ping, startQVACProvider, unloadModel, transcribe, transcribeStream, embed, translate, cancel, ragSaveEmbeddings, ragSearch, ragDeleteEmbeddings, } from "./client/api/index.js";
+export { completion, deleteCache, loadModel, downloadAsset, ping, startQVACProvider, unloadModel, transcribe, transcribeStream, embed, translate, cancel, ragSaveEmbeddings, ragSearch, ragDeleteEmbeddings, } from "./client/api/index.js";
 export { VERBOSITY, } from "./schemas/index.js";
 // Hyperdrive model constants
 export * from "./models/hyperdrive/index.js";

package/dist/models/hyperdrive/models.d.ts

@@ -62,6 +62,20 @@ export declare const models: readonly [{
     readonly addon: "llm";
     readonly expectedSize: 1056782912;
     readonly sha256Checksum: "c876f159707a4e4f70e045106c69db15bfc935a4981706fd4f65c6e7ea1e81c5";
+}, {
+    readonly hyperdriveKey: "583f04c31d151b29e02aaf98f80d16aff585714ef9e2806a5067651c0f64ae31";
+    readonly hyperbeeKey: "generation:qwen2.5-omni:multimodal::3B::1.0.0";
+    readonly modelId: "Qwen2.5-Omni-3B-Q4_K_M.gguf";
+    readonly addon: "llm";
+    readonly expectedSize: 2104931648;
+    readonly sha256Checksum: "4b0bd358c1e9ec55dd3055ef6d71c958c821533d85916a10cfa89c4552a86e29";
+}, {
+    readonly hyperdriveKey: "583f04c31d151b29e02aaf98f80d16aff585714ef9e2806a5067651c0f64ae31";
+    readonly hyperbeeKey: "generation:qwen2.5-omni:multimodal::3B::1.0.0";
+    readonly modelId: "mmproj-Qwen2.5-Omni-3B-Q8_0.gguf";
+    readonly addon: "llm";
+    readonly expectedSize: 1538031328;
+    readonly sha256Checksum: "4e6c816cd33f7298d07cb780c136a396631e50e62f6501660271f8c6e302e565";
 }, {
     readonly hyperdriveKey: "d331ed49c444f90b3b2a70aa5b820752685142bf2d769a0592ed666140477578";
     readonly hyperbeeKey: "generation:qwen3:instruct::0.6B::1.0.0";
@@ -97,6 +111,34 @@ export declare const models: readonly [{
     readonly addon: "llm";
     readonly expectedSize: 2401075552;
     readonly sha256Checksum: "9cfebb63cd7e6b6d1755ea8ef001fcdadfa17831da1db96eafe3fc554913d5e1";
+}, {
+    readonly hyperdriveKey: "b99c6f5dcadaad827cdcb1a129a3b34aff6ad28056738e0bd559c7ffb807e30f";
+    readonly hyperbeeKey: "generation:smolVLM2:multimodal:2:500M:f16:1.0.0:video-instruct";
+    readonly modelId: "SmolVLM2-500M-Video-Instruct-f16.gguf";
+    readonly addon: "llm";
+    readonly expectedSize: 820424704;
+    readonly sha256Checksum: "80f7e3f04bc2d3324ac1a9f52f5776fe13a69912adf74f8e7edacf773d140d77";
+}, {
+    readonly hyperdriveKey: "b99c6f5dcadaad827cdcb1a129a3b34aff6ad28056738e0bd559c7ffb807e30f";
+    readonly hyperbeeKey: "generation:smolVLM2:multimodal:2:500M:f16:1.0.0:video-instruct";
+    readonly modelId: "mmproj-SmolVLM2-500M-Video-Instruct-f16.gguf";
+    readonly addon: "llm";
+    readonly expectedSize: 199470624;
+    readonly sha256Checksum: "b5dc8ebe7cbeab66a5369693960a52515d7824f13d4063ceca78431f2a6b59b0";
+}, {
+    readonly hyperdriveKey: "73b1bc01d01e25fa27be7d7f434337d14f054b0315e8463766ca31e778ac6576";
+    readonly hyperbeeKey: "generation:smolVLM2:multimodal:2:500M:q8_0:1.0.0:video-instruct";
+    readonly modelId: "SmolVLM2-500M-Video-Instruct-Q8_0.gguf";
+    readonly addon: "llm";
+    readonly expectedSize: 436808704;
+    readonly sha256Checksum: "6f67b8036b2469fcd71728702720c6b51aebd759b78137a8120733b4d66438bc";
+}, {
+    readonly hyperdriveKey: "73b1bc01d01e25fa27be7d7f434337d14f054b0315e8463766ca31e778ac6576";
+    readonly hyperbeeKey: "generation:smolVLM2:multimodal:2:500M:q8_0:1.0.0:video-instruct";
+    readonly modelId: "mmproj-SmolVLM2-500M-Video-Instruct-Q8_0.gguf";
+    readonly addon: "llm";
+    readonly expectedSize: 108785184;
+    readonly sha256Checksum: "921dc7e259f308e5b027111fa185efcbf33db13f6e35749ddf7f5cdb60ef520b";
 }, {
     readonly hyperdriveKey: "268c2e9b2a3420632e4b6649e32822f42d5dfbda4c7e96daec5b629ed20f99f7";
     readonly hyperbeeKey: "translation:ggml-indictrans:dist:2:200M:q0f32:1.0.0:en-hi";
@@ -421,11 +463,17 @@ export declare const GTE_LARGE_FP16: "pear://d1896d9259692818df95bd2480e90c2d057
 export declare const LASER_DOLPHIN_2_6_2X7B_INST_Q2_K: "pear://bd40e4bfae48b5bf436d1b0b447ae26e4c384aebe101a5e7df6ae71c919dadf1/dolphin-mixtral-2x7b-dop-Q2_K.gguf";
 export declare const LLAMA_3_2_1B_INST_Q4_0: "pear://afa79ee07c0a138bb9f11bfaee771fb1bdfca8c82d961cff0474e49827bd1de3/Llama-3.2-1B-Instruct-Q4_0.gguf";
 export declare const QWEN_3_1_7B_INST_Q4: "pear://05d3d7ad9cd650f53c28f85e312ef09a645dd487845897958b3be8a19cb3aab9/Qwen3-1.7B-Q4_0.gguf";
+export declare const QWEN2_5_OMNI_3B_MULTIMODAL: "pear://583f04c31d151b29e02aaf98f80d16aff585714ef9e2806a5067651c0f64ae31/Qwen2.5-Omni-3B-Q4_K_M.gguf";
+export declare const MMPROJ_QWEN2_5_OMNI_3B_MULTIMODAL: "pear://583f04c31d151b29e02aaf98f80d16aff585714ef9e2806a5067651c0f64ae31/mmproj-Qwen2.5-Omni-3B-Q8_0.gguf";
 export declare const QWEN3_0_6B_INST: "pear://d331ed49c444f90b3b2a70aa5b820752685142bf2d769a0592ed666140477578/Qwen3-0.6B-UD-IQ1_S.gguf";
 export declare const QWEN3_4B_INST_Q4: "pear://19ffb75463149955ee24d786dfddd84d41fc872ea813cd4465f5f7299d165adc/model.gguf";
 export declare const QWEN3_600M_INST_Q4: "pear://211874c9885f6b88b9926904420e365f5e74e1b6ac47207b7536408539bef4b7/Qwen3-0.6B-Q4_0.gguf";
 export declare const SALAMANDRATA_2B_INST_Q4: "pear://1610d81772a9e7c37660666dbdfdcef915b6b83c522ea1ad31c19cab0075811d/salamandrata_2b_inst_q4.gguf";
 export declare const SALAMANDRATA_2B_INST_Q8: "pear://96860337b0bdffdbb8ef0df4c8b2c3ab5e78568f5f7e15815a0a6b392512c9b5/salamandrata_2b_inst_q8.gguf";
+export declare const SMOLVLM2_2_500M_MULTIMODAL_F16: "pear://b99c6f5dcadaad827cdcb1a129a3b34aff6ad28056738e0bd559c7ffb807e30f/SmolVLM2-500M-Video-Instruct-f16.gguf";
+export declare const MMPROJ_SMOLVLM2_2_500M_MULTIMODAL_F16: "pear://b99c6f5dcadaad827cdcb1a129a3b34aff6ad28056738e0bd559c7ffb807e30f/mmproj-SmolVLM2-500M-Video-Instruct-f16.gguf";
+export declare const SMOLVLM2_2_500M_MULTIMODAL_Q8_0: "pear://73b1bc01d01e25fa27be7d7f434337d14f054b0315e8463766ca31e778ac6576/SmolVLM2-500M-Video-Instruct-Q8_0.gguf";
+export declare const MMPROJ_SMOLVLM2_2_500M_MULTIMODAL_Q8_0: "pear://73b1bc01d01e25fa27be7d7f434337d14f054b0315e8463766ca31e778ac6576/mmproj-SmolVLM2-500M-Video-Instruct-Q8_0.gguf";
 export declare const MARIAN_EN_HI_INDIC_200M_Q0F32: "pear://268c2e9b2a3420632e4b6649e32822f42d5dfbda4c7e96daec5b629ed20f99f7/ggml-indictrans2-en-indic-dist-200M.bin";
 export declare const MARIAN_HI_EN_INDIC_200M_Q0F32: "pear://dfea395ffe1cb6d259029e5c81c290f8828981987855e23e7b66fd7c705901eb/ggml-indictrans2-indic-en-dist-200M.bin";
 export declare const MARIAN_HI_HI_INDIC_320M_Q0F32: "pear://9a66da960931c449b41e3315d9aea4d3925f2cda024e8a4c139b64d0a539ed41/ggml-indictrans2-indic-indic-dist-320M.bin";
@@ -471,5 +519,5 @@ export declare const WHISPER_LARGE_3: "pear://76fb36d7f16a430618962d3e78b0e22e61
 export declare const WHISPER_SMALL: "pear://c6a987fbb4ad8fba1526e446501f88ee45dfafbf1685410a7aeadb589fe18608/ggml-small.en-q8_0.bin";
 export declare const WHISPER_TINY: "pear://9281d61503593fdf3eaa9d5e5d44746c271ef930aed3b7f8ee9ce153c76399d6/ggml-tiny.bin";
 export declare const WHISPER_TINY_SILERO: "pear://ebfb94b378276da139554668f1ff737644eadff529c2ea0f2662d7df61fd86ca/ggml-tiny.bin";
-export declare function getModelBySrc(modelId: string, hyperdriveKey?: string): HyperdriveItem | undefined;
+export declare function getModelBySrc(modelId: string, hyperdriveKey: string): HyperdriveItem | undefined;
 //# sourceMappingURL=models.d.ts.map