@qvac/sdk 0.1.1 → 0.2.0-dev.1760804157.f3c48d2

package/dist/schemas/llamacpp-config.d.ts

@@ -14,7 +14,7 @@ export declare const llmConfigSchema: z.ZodObject<{
     lora: z.ZodOptional<z.ZodString>;
     device: z.ZodDefault<z.ZodString>;
     predict: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<-1>, z.ZodLiteral<-2>, z.ZodNumber]>>;
-    system_prompt: z.ZodOptional<z.ZodString>;
+    system_prompt: z.ZodDefault<z.ZodString>;
     no_mmap: z.ZodOptional<z.ZodBoolean>;
     verbosity: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<-1>, z.ZodLiteral<0>, z.ZodLiteral<1>]>>;
     presence_penalty: z.ZodOptional<z.ZodNumber>;

package/dist/schemas/llamacpp-config.js

@@ -25,7 +25,7 @@ export const llmConfigSchema = z.object({
         z.number().int().min(1), // positive integer: fixed token count
     ])
         .optional(),
-    system_prompt: z.string().optional(),
+    system_prompt: z.string().default("You are a helpful assistant."),
     no_mmap: z.boolean().optional(),
     verbosity: verbositySchema.optional(),
     presence_penalty: z.number().optional(),

package/dist/schemas/load-model.d.ts

@@ -12,7 +12,7 @@ export declare const loadModelOptionsSchema: z.ZodPipe<z.ZodUnion<readonly [z.Zo
         lora: z.ZodOptional<z.ZodOptional<z.ZodString>>;
         device: z.ZodOptional<z.ZodDefault<z.ZodString>>;
         predict: z.ZodOptional<z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<-1>, z.ZodLiteral<-2>, z.ZodNumber]>>>;
-        system_prompt: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        system_prompt: z.ZodOptional<z.ZodDefault<z.ZodString>>;
         no_mmap: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
         verbosity: z.ZodOptional<z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<-1>, z.ZodLiteral<0>, z.ZodLiteral<1>]>>>;
         presence_penalty: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
@@ -363,7 +363,7 @@ export declare const loadLlmModelRequestSchema: z.ZodObject<{
         lora: z.ZodOptional<z.ZodString>;
         device: z.ZodDefault<z.ZodString>;
         predict: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<-1>, z.ZodLiteral<-2>, z.ZodNumber]>>;
-        system_prompt: z.ZodOptional<z.ZodString>;
+        system_prompt: z.ZodDefault<z.ZodString>;
         no_mmap: z.ZodOptional<z.ZodBoolean>;
         verbosity: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<-1>, z.ZodLiteral<0>, z.ZodLiteral<1>]>>;
         presence_penalty: z.ZodOptional<z.ZodNumber>;
@@ -543,7 +543,7 @@ export declare const loadModelRequestSchema: z.ZodPipe<z.ZodDiscriminatedUnion<[
         lora: z.ZodOptional<z.ZodString>;
         device: z.ZodDefault<z.ZodString>;
         predict: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<-1>, z.ZodLiteral<-2>, z.ZodNumber]>>;
-        system_prompt: z.ZodOptional<z.ZodString>;
+        system_prompt: z.ZodDefault<z.ZodString>;
         no_mmap: z.ZodOptional<z.ZodBoolean>;
         verbosity: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<-1>, z.ZodLiteral<0>, z.ZodLiteral<1>]>>;
         presence_penalty: z.ZodOptional<z.ZodNumber>;
@@ -704,13 +704,13 @@ export declare const loadModelRequestSchema: z.ZodPipe<z.ZodDiscriminatedUnion<[
         ctx_size: number;
         gpu_layers: number;
         device: string;
+        system_prompt: string;
         temp?: number | undefined;
         top_p?: number | undefined;
         top_k?: number | undefined;
         seed?: number | undefined;
         lora?: string | undefined;
         predict?: number | undefined;
-        system_prompt?: string | undefined;
         no_mmap?: boolean | undefined;
         verbosity?: 0 | 1 | -1 | undefined;
         presence_penalty?: number | undefined;
@@ -801,13 +801,13 @@ export declare const loadModelRequestSchema: z.ZodPipe<z.ZodDiscriminatedUnion<[
         ctx_size: number;
         gpu_layers: number;
         device: string;
+        system_prompt: string;
         temp?: number | undefined;
         top_p?: number | undefined;
         top_k?: number | undefined;
         seed?: number | undefined;
         lora?: string | undefined;
         predict?: number | undefined;
-        system_prompt?: string | undefined;
         no_mmap?: boolean | undefined;
         verbosity?: 0 | 1 | -1 | undefined;
         presence_penalty?: number | undefined;
@@ -925,7 +925,7 @@ export declare const loadModelServerParamsSchema: z.ZodObject<{
             lora: z.ZodOptional<z.ZodOptional<z.ZodString>>;
             device: z.ZodOptional<z.ZodDefault<z.ZodString>>;
             predict: z.ZodOptional<z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<-1>, z.ZodLiteral<-2>, z.ZodNumber]>>>;
-            system_prompt: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            system_prompt: z.ZodOptional<z.ZodDefault<z.ZodString>>;
             no_mmap: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
             verbosity: z.ZodOptional<z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<-1>, z.ZodLiteral<0>, z.ZodLiteral<1>]>>>;
             presence_penalty: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;

package/dist/server/bare/addons/llamacpp/handlers/completion-stream.js

@@ -1,65 +1,121 @@
 import { completionParamsSchema, } from "../../../../../schemas/index.js";
-import { getModel } from "../../../registry/model-registry.js";
-import { findMatchingCache, getCurrentCacheInfo, renameCacheFile, } from "../kv-cache-utils";
-export async function* completion(params) {
-    const { history, modelId, kvCache } = completionParamsSchema.parse(params);
-    const transformedHistory = [];
-    for (const message of history) {
-        if (message.attachments && message.attachments.length > 0) {
-            for (const attachment of message.attachments) {
-                transformedHistory.push({
-                    role: message.role,
-                    content: attachment.path,
-                    type: "media",
-                });
-            }
+import { getModel, getModelConfig, } from "../../../registry/model-registry.js";
+import { findMatchingCache, getCurrentCacheInfo, renameCacheFile, getCacheFilePath, extractSystemPrompt, generateConfigHash, customCacheExists, } from "../kv-cache-utils";
+function transformMessage(message) {
+    const transformed = [];
+    if (message.attachments && message.attachments.length > 0) {
+        for (const attachment of message.attachments) {
+            transformed.push({
+                role: message.role,
+                content: attachment.path,
+                type: "media",
+            });
         }
-        transformedHistory.push({
-            role: message.role,
-            content: message.content,
-        });
     }
-    const model = getModel(modelId);
-    if (kvCache) {
-        const cacheMessages = history.map((msg) => ({
-            role: msg.role,
-            content: msg.content,
-            attachments: msg.attachments ?? undefined,
-        }));
-        const existingCache = await findMatchingCache(cacheMessages);
-        const currentCacheInfo = getCurrentCacheInfo(cacheMessages);
-        const cachePathToUse = existingCache !== null
-            ? existingCache.cachePath
-            : currentCacheInfo.cachePath;
-        const messagesWithCache = [
+    transformed.push({
+        role: message.role,
+        content: message.content,
+    });
+    return transformed;
+}
+function transformMessages(messages) {
+    const transformed = [];
+    for (const message of messages) {
+        transformed.push(...transformMessage(message));
+    }
+    return transformed;
+}
+async function initSystemPromptCache(model, cachePathToUse, systemPromptToUse) {
+    const primeMessages = [
+        { role: "session", content: cachePathToUse },
+        { role: "system", content: systemPromptToUse },
+    ];
+    const primeResponse = await model.run(primeMessages);
+    primeResponse.once("output", () => {
+        void primeResponse.cancel();
+    });
+    await primeResponse.await();
+}
+function prepareMessagesForCache(cachePathToUse, cacheExists, history) {
+    if (cacheExists && history.length > 0) {
+        const lastMessage = history[history.length - 1];
+        const lastTransformedMessages = transformMessage(lastMessage);
+        return [
             { role: "session", content: cachePathToUse },
-            ...transformedHistory,
+            ...lastTransformedMessages,
         ];
-        const response = await model.run(messagesWithCache);
-        for await (const token of response.iterate()) {
-            yield token;
-        }
+    }
+    const historyWithoutSystem = history.filter((msg) => msg.role !== "system");
+    const transformedHistoryWithoutSystem = transformMessages(historyWithoutSystem);
+    return [
+        { role: "session", content: cachePathToUse },
+        ...transformedHistoryWithoutSystem,
+    ];
+}
+async function* processModelResponse(model, messagesToSend, shouldSaveCache) {
+    const response = await model.run(messagesToSend);
+    for await (const token of response.iterate()) {
+        yield token;
+    }
+    if (shouldSaveCache) {
         await model.run([{ role: "session", content: "save" }]);
-        //If there was an existing cache, we rename it with new hash that includes the current message
-        if (existingCache !== null &&
-            existingCache.cachePath !== currentCacheInfo.cachePath) {
-            await renameCacheFile(existingCache.cachePath, currentCacheInfo.cachePath);
+    }
+    const responseWithStats = response;
+    return {
+        timeToFirstToken: responseWithStats.stats?.TTFT ?? 0,
+        tokensPerSecond: responseWithStats.stats?.TPS ?? 0,
+        cacheTokens: responseWithStats.stats?.CacheTokens ?? 0,
+    };
+}
+export async function* completion(params) {
+    const { history, modelId, kvCache } = completionParamsSchema.parse(params);
+    const transformedHistory = transformMessages(history);
+    const model = getModel(modelId);
+    if (kvCache) {
+        const modelConfig = getModelConfig(modelId);
+        const systemPromptFromHistory = extractSystemPrompt(history);
+        const configHash = generateConfigHash(modelConfig, systemPromptFromHistory);
+        const systemPromptToUse = systemPromptFromHistory ||
+            modelConfig.system_prompt ||
+            "You are a helpful assistant.";
+        let cachePathToUse;
+        if (typeof kvCache === "string") {
+            cachePathToUse = await getCacheFilePath(modelId, configHash, kvCache);
+            const cacheExists = await customCacheExists(modelId, configHash, kvCache);
+            if (!cacheExists) {
+                await initSystemPromptCache(model, cachePathToUse, systemPromptToUse);
+            }
+            const messagesToSend = prepareMessagesForCache(cachePathToUse, cacheExists, history);
+            return yield* processModelResponse(model, messagesToSend, true);
+        }
+        else {
+            // Auto-generate cache key based on conversation history
+            const cacheMessages = history.map((msg) => ({
+                role: msg.role,
+                content: msg.content,
+                attachments: msg.attachments ?? undefined,
+            }));
+            const existingCache = await findMatchingCache(modelId, configHash, cacheMessages);
+            const currentCacheInfo = await getCurrentCacheInfo(modelId, configHash, cacheMessages);
+            cachePathToUse =
+                existingCache !== null
+                    ? existingCache.cachePath
+                    : currentCacheInfo.cachePath;
+            const cacheExists = existingCache !== null;
+            if (!cacheExists) {
+                await initSystemPromptCache(model, cachePathToUse, systemPromptToUse);
+            }
+            const messagesToSend = prepareMessagesForCache(cachePathToUse, cacheExists, history);
+            const result = yield* processModelResponse(model, messagesToSend, true);
+            //If there was an existing cache, we rename it with new hash that includes the current message
+            if (existingCache !== null &&
+                existingCache.cachePath !== currentCacheInfo.cachePath) {
+                await renameCacheFile(existingCache.cachePath, currentCacheInfo.cachePath);
+            }
+            return result;
         }
-        const responseWithStats = response;
-        return {
-            timeToFirstToken: responseWithStats.stats?.TTFT ?? 0,
-            tokensPerSecond: responseWithStats.stats?.TPS ?? 0,
-        };
     }
     else {
-        const response = await model.run(transformedHistory);
-        for await (const token of response.iterate()) {
-            yield token;
-        }
-        const responseWithStats = response;
-        return {
-            timeToFirstToken: responseWithStats.stats?.TTFT ?? 0,
-            tokensPerSecond: responseWithStats.stats?.TPS ?? 0,
-        };
+        return yield* processModelResponse(model, transformedHistory, false);
     }
 }

package/dist/server/bare/addons/llamacpp/kv-cache-utils.d.ts

@@ -5,15 +5,24 @@ export interface CacheMessage {
         path: string;
     }[] | undefined;
 }
+export declare function extractSystemPrompt(messages: CacheMessage[]): string | null;
+export declare function generateConfigHash(modelConfig: unknown, systemPrompt: string | null): string;
 export declare function generateCacheKey(messages: CacheMessage[]): string;
-export declare function getCacheFilePath(cacheKey: string): string;
-export declare function findMatchingCache(currentHistory: CacheMessage[]): Promise<{
+export declare function getCacheFilePath(modelId: string, configHash: string, cacheKey: string): Promise<string>;
+export declare function findMatchingCache(modelId: string, configHash: string, currentHistory: CacheMessage[]): Promise<{
     cacheKey: string;
     cachePath: string;
 } | null>;
-export declare function getCurrentCacheInfo(currentHistory: CacheMessage[]): {
+export declare function getCurrentCacheInfo(modelId: string, configHash: string, currentHistory: CacheMessage[]): Promise<{
     cacheKey: string;
     cachePath: string;
-};
+}>;
 export declare function renameCacheFile(oldPath: string, newPath: string): Promise<void>;
+export declare function customCacheExists(modelId: string, configHash: string, cacheKey: string): Promise<boolean>;
+export declare function deleteCache(options: {
+    all: true;
+} | {
+    kvCacheKey: string;
+    modelId?: string;
+}): Promise<void>;
 //# sourceMappingURL=kv-cache-utils.d.ts.map

package/dist/server/bare/addons/llamacpp/kv-cache-utils.js

@@ -2,6 +2,18 @@ import crypto from "bare-crypto";
 import { promises as fsPromises } from "bare-fs";
 import path from "bare-path";
 import { getKVCacheDir } from "../../../utils/index.js";
+export function extractSystemPrompt(messages) {
+    const systemMessage = messages.find((msg) => msg.role === "system");
+    return systemMessage ? systemMessage.content : null;
+}
+export function generateConfigHash(modelConfig, systemPrompt) {
+    const hash = crypto.createHash("sha256");
+    const configStr = JSON.stringify({ config: modelConfig, systemPrompt });
+    const configBuffer = Buffer.from(configStr, "utf8");
+    hash.update(configBuffer);
+    const hashString = hash.digest("hex");
+    return hashString.substring(0, 16);
+}
 export function generateCacheKey(messages) {
     const hash = crypto.createHash("sha256");
     const historyString = JSON.stringify(messages);
@@ -10,18 +22,28 @@ export function generateCacheKey(messages) {
     const hashString = hash.digest("hex");
     return hashString.substring(0, 16);
 }
-export function getCacheFilePath(cacheKey) {
+export async function getCacheFilePath(modelId, configHash, cacheKey) {
     const cacheDir = getKVCacheDir();
-    return path.join(cacheDir, `kvcache${cacheKey}.bin`);
+    const sessionCacheDir = path.join(cacheDir, cacheKey);
+    const modelCacheDir = path.join(sessionCacheDir, modelId);
+    try {
+        await fsPromises.mkdir(sessionCacheDir, { recursive: true });
+        await fsPromises.mkdir(modelCacheDir, { recursive: true });
+    }
+    catch {
+        // Ignore if directories already exist
+    }
+    return path.join(modelCacheDir, `${configHash}.bin`);
 }
-export async function findMatchingCache(currentHistory) {
+// Used for auto-generated cache key
+export async function findMatchingCache(modelId, configHash, currentHistory) {
     if (currentHistory.length <= 1) {
         return null;
     }
     // Generate cache key for history minus the last message
     const previousHistory = currentHistory.slice(0, -1);
     const cacheKey = generateCacheKey(previousHistory);
-    const cachePath = getCacheFilePath(cacheKey);
+    const cachePath = await getCacheFilePath(modelId, configHash, cacheKey);
     try {
         await fsPromises.access(cachePath);
         return { cacheKey, cachePath };
@@ -30,10 +52,9 @@ export async function findMatchingCache(currentHistory) {
         return null;
     }
 }
-export function getCurrentCacheInfo(currentHistory) {
-    // Generate cache path for the current conversation state
+export async function getCurrentCacheInfo(modelId, configHash, currentHistory) {
     const cacheKey = generateCacheKey(currentHistory);
-    const cachePath = getCacheFilePath(cacheKey);
+    const cachePath = await getCacheFilePath(modelId, configHash, cacheKey);
     return { cacheKey, cachePath };
 }
 export async function renameCacheFile(oldPath, newPath) {
@@ -44,3 +65,45 @@ export async function renameCacheFile(oldPath, newPath) {
         console.error("Error renaming cache file:", error instanceof Error ? error.message : String(error));
     }
 }
+export async function customCacheExists(modelId, configHash, cacheKey) {
+    const cachePath = await getCacheFilePath(modelId, configHash, cacheKey);
+    try {
+        await fsPromises.access(cachePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function deleteCache(options) {
+    const cacheDir = getKVCacheDir();
+    if ("all" in options && options.all) {
+        try {
+            await fsPromises.rm(cacheDir, { recursive: true });
+            await fsPromises.mkdir(cacheDir, { recursive: true });
+        }
+        catch (error) {
+            console.error("Error deleting all caches:", error instanceof Error ? error.message : String(error));
+        }
+    }
+    else if ("kvCacheKey" in options) {
+        const kvCacheDir = path.join(cacheDir, options.kvCacheKey);
+        if (options.modelId) {
+            const modelCacheDir = path.join(kvCacheDir, options.modelId);
+            try {
+                await fsPromises.rm(modelCacheDir, { recursive: true });
+            }
+            catch (error) {
+                console.error(`Error deleting model cache ${options.kvCacheKey}/${options.modelId}:`, error instanceof Error ? error.message : String(error));
+            }
+        }
+        else {
+            try {
+                await fsPromises.rm(kvCacheDir, { recursive: true });
+            }
+            catch (error) {
+                console.error(`Error deleting cache ${options.kvCacheKey}:`, error instanceof Error ? error.message : String(error));
+            }
+        }
+    }
+}

package/dist/server/bare/addons/load-model.js

@@ -51,5 +51,5 @@ export async function loadModel(params) {
     console.log(`${modelType}: Loading model ${modelId}...`);
     await model.load(false);
     console.log(`${modelType} model ${modelId} loaded`);
-    registerModel(modelId, { model, path: modelPath });
+    registerModel(modelId, { model, path: modelPath, config: modelConfig });
 }

package/dist/server/bare/registry/model-registry.d.ts

@@ -1,9 +1,10 @@
+import type EventEmitter from "events";
 interface AddonInterface {
     cancel(jobId?: string): Promise<void>;
 }
 export interface AnyModel {
     load(...args: unknown[]): Promise<void>;
-    run(input: unknown): Promise<{
+    run(input: unknown): Promise<EventEmitter & {
         onUpdate(callback: (data: string) => void): {
             await: () => Promise<void>;
         };
@@ -12,6 +13,7 @@ export interface AnyModel {
         }>) => void): {
             await: () => Promise<void>;
         };
+        cancel(): Promise<void>;
         iterate(): AsyncIterableIterator<string | Array<{
             text: string;
         }>>;
@@ -29,6 +31,7 @@ interface LocalOptions {
     model: AnyModel;
     path: string;
     loadedAt: Date;
+    config: unknown;
 }
 export interface ModelEntry {
     id: string;
@@ -39,6 +42,7 @@ export interface ModelEntry {
 export declare function registerModel(id: string, options: {
     model: AnyModel;
     path: string;
+    config: unknown;
 } | {
     topic: string;
     providerPublicKey: string;
@@ -53,7 +57,9 @@ export declare function getModelInfo(id: string): {
     id: string;
     path: string;
     loadedAt: Date;
+    config: unknown;
 } | null;
+export declare function getModelConfig(id: string): unknown;
 export declare function clearRegistry(): void;
 export declare function getRegistryStats(): {
     totalModels: number;

package/dist/server/bare/registry/model-registry.js

@@ -26,6 +26,7 @@ export function registerModel(id, options) {
                 model: options.model,
                 path: options.path,
                 loadedAt: new Date(),
+                config: options.config,
             },
         });
         console.log(`Local model registered: ${id} -> ${options.path}`);
@@ -69,8 +70,16 @@ export function getModelInfo(id) {
         id: entry.id,
         path: entry.local.path,
         loadedAt: entry.local.loadedAt,
+        config: entry.local.config,
     };
 }
+export function getModelConfig(id) {
+    const entry = modelRegistry.get(id);
+    if (!entry || !entry.local) {
+        throw new Error(`Model with ID "${id}" not found or is delegated`);
+    }
+    return entry.local.config;
+}
 export function clearRegistry() {
     modelRegistry.clear();
     console.log("Model registry cleared");

package/dist/server/rpc/handle-request.js

@@ -13,6 +13,7 @@ import { handleLoggingStream } from "./handlers/logging-stream.js";
 import { cancelHandler } from "./handlers/cancelHandler.js";
 import { provideHandler } from "./handlers/provideHandler.js";
 import { handleRag } from "./handlers/rag.js";
+import { handleDeleteCache } from "./handlers/delete-cache.js";
 import { sendErrorResponse, sendStreamErrorResponse } from "../error-handlers";
 export async function handleRequest(req) {
     try {
@@ -209,6 +210,16 @@ export async function handleRequest(req) {
                 }
                 break;
             }
+            case "deleteCache": {
+                try {
+                    const response = await handleDeleteCache(request);
+                    req.reply(JSON.stringify(responseSchema.parse(response)), "utf-8");
+                }
+                catch (error) {
+                    sendErrorResponse(req, error);
+                }
+                break;
+            }
             default: {
                 throw new Error(`Unknown request type`);
             }

package/dist/server/rpc/handlers/delete-cache.d.ts

@@ -0,0 +1,3 @@
+import type { DeleteCacheRequest, DeleteCacheResponse } from "../../../schemas/index";
+export declare function handleDeleteCache(request: DeleteCacheRequest): Promise<DeleteCacheResponse>;
+//# sourceMappingURL=delete-cache.d.ts.map

package/dist/server/rpc/handlers/delete-cache.js

@@ -0,0 +1,29 @@
+import { deleteCache as deleteCacheUtil } from "../../bare/addons/llamacpp/kv-cache-utils.js";
+export async function handleDeleteCache(request) {
+    try {
+        if ("all" in request && request.all) {
+            await deleteCacheUtil({ all: true });
+        }
+        else if ("kvCacheKey" in request) {
+            const params = {
+                kvCacheKey: request.kvCacheKey,
+            };
+            if (request.modelId !== undefined) {
+                params.modelId = request.modelId;
+            }
+            await deleteCacheUtil(params);
+        }
+        return {
+            type: "deleteCache",
+            success: true,
+        };
+    }
+    catch (error) {
+        console.error("Error deleting cache:", error);
+        return {
+            type: "deleteCache",
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qvac/sdk",
-  "version": "0.1.1",
+  "version": "0.2.0-dev.1760804157.f3c48d2",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -60,7 +60,7 @@
     "@qvac/langdetect-text": "^0.1.0",
     "@qvac/logging": "^0.1.0",
     "@qvac/rag": "^0.1.0",
-    "@qvac/transcription-whispercpp": "^0.1.4",
+    "@qvac/transcription-whispercpp": "^0.1.0",
     "@qvac/translation-nmtcpp": "^0.1.0",
     "fast-safe-stringify": "2.1.1",
     "zod": "^4.0.17"

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

@@ -1,6 +0,0 @@
-export declare function parseHyperdriveUrl(url: string): {
-    key: string;
-    path: string;
-};
-export declare function isValidHyperdriveKey(key: string): boolean;
-//# sourceMappingURL=validation.d.ts.map

package/dist/models/hyperdrive/validation.js

@@ -1,12 +0,0 @@
-// Parse hyperdrive URLs: pear://key/path/to/model.gguf
-export function parseHyperdriveUrl(url) {
-    const match = url.match(/^pear:\/\/([0-9a-fA-F]{64})\/(.+)$/);
-    if (!match || !match[1] || !match[2]) {
-        throw new Error(`Invalid hyperdrive URL: "${url}". Expected format: pear://64-char-hex-key/path/to/model.gguf`);
-    }
-    return { key: match[1], path: match[2] };
-}
-// Hyperdrive key validation (32 bytes = 64 hex chars)
-export function isValidHyperdriveKey(key) {
-    return /^[0-9a-fA-F]{64}$/.test(key);
-}

package/dist/server/bare/utilities/audio/decoder.d.ts

@@ -1,4 +0,0 @@
-import { Readable } from "bare-stream";
-export declare function needsDecoding(filePath: string): boolean;
-export declare function decodeAudioToStream(inputPath: string): Promise<Readable>;
-//# sourceMappingURL=decoder.d.ts.map

package/dist/server/bare/utilities/audio/decoder.js

@@ -1,38 +0,0 @@
-import fs from "bare-fs";
-import path from "bare-path";
-import GSTDecoder from "@qvac/decoder-audio";
-import { Readable } from "bare-stream";
-import { FORMATS_NEEDING_DECODE } from "../../../../constants/audio.js";
-export function needsDecoding(filePath) {
-    const ext = path.extname(filePath).toLowerCase();
-    return FORMATS_NEEDING_DECODE.includes(ext);
-}
-export async function decodeAudioToStream(inputPath) {
-    const decoder = new GSTDecoder({
-        config: {
-            audioFormat: "encoded",
-        },
-    });
-    try {
-        await decoder.load();
-        const audioStream = fs.createReadStream(inputPath);
-        const response = await decoder.run(audioStream);
-        const decodedBuffers = [];
-        await response
-            .onUpdate((output) => {
-            const bytes = new Uint8Array(output.outputArray);
-            decodedBuffers.push(bytes);
-        })
-            .onFinish(() => {
-            console.log("Audio decoded to buffer");
-        })
-            .await();
-        // Create a stream from the decoded buffers
-        const combinedBuffer = Buffer.concat(decodedBuffers);
-        return Readable.from([combinedBuffer]);
-    }
-    catch (error) {
-        console.error("Decoding failed:", error instanceof Error ? error.message : String(error));
-        throw error;
-    }
-}

package/dist/server/bare/utilities/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./audio/decoder";
-//# sourceMappingURL=index.d.ts.map

package/dist/server/bare/utilities/index.js

@@ -1 +0,0 @@
-export * from "./audio/decoder.js";

package/dist/server/rpc/handlers/load-model/cache.d.ts

@@ -1,2 +0,0 @@
-export declare function getCacheDir(): string;
-//# sourceMappingURL=cache.d.ts.map

package/dist/server/rpc/handlers/load-model/cache.js

@@ -1,15 +0,0 @@
-import fs from "bare-fs";
-import path from "bare-path";
-import { getEnv } from "../../../worker.js";
-export function getCacheDir() {
-    const homeDir = getEnv().HOME_DIR;
-    const cacheDir = path.join(homeDir, ".qvac", "models");
-    // Ensure cache directory exists
-    try {
-        fs.mkdirSync(cacheDir, { recursive: true });
-    }
-    catch (error) {
-        console.error("Error creating cache directory:", error instanceof Error ? error.message : String(error));
-    }
-    return cacheDir;
-}