@qvac/sdk 0.3.0 → 0.4.1

package/dist/server/bare/addons/translation/create-model.d.ts

@@ -1,4 +1,8 @@
 import { type AnyModel } from "../../registry/model-registry";
 import { type NmtConfig } from "../../../../schemas/index";
-export declare function createNmtModel(modelId: string, modelPath: string, nmtConfig: NmtConfig): AnyModel;
+import FilesystemDL from "@qvac/dl-filesystem";
+export declare function createNmtModel(modelId: string, modelPath: string, nmtConfig: NmtConfig): {
+    model: AnyModel;
+    loader: FilesystemDL;
+};
 //# sourceMappingURL=create-model.d.ts.map

package/dist/server/bare/addons/translation/create-model.js

@@ -1,45 +1,37 @@
 import TranslationNmtcpp from "@qvac/translation-nmtcpp";
-import { Readable } from "bare-stream";
 import {} from "../../registry/model-registry.js";
 import { INDICTRANS_LANGUAGES } from "../../../../schemas/index.js";
 import { createStreamLogger } from "../../../../logging/index.js";
 import { parseModelPath } from "../../../utils/index.js";
-// Mimic qvac-lib-dl-filesystem functionality
-function createFilesystemDLMimic(options) {
-    return {
-        dirPath: options.dirPath,
-        getStream: () => {
-            return Promise.resolve(Readable.from([]));
-        },
-        ready: () => Promise.resolve(),
-        close: () => Promise.resolve(),
-        destroy: () => Promise.resolve(),
-        start: () => Promise.resolve(),
-        stop: () => Promise.resolve(),
-    };
-}
+import FilesystemDL from "@qvac/dl-filesystem";
+import { TranslationFailedError } from "../../../../utils/errors-server.js";
 export function createNmtModel(modelId, modelPath, nmtConfig) {
     const { dirPath, basePath } = parseModelPath(modelPath);
-    const dl = createFilesystemDLMimic({
-        dirPath: "./",
-    });
+    const loader = new FilesystemDL({ dirPath });
     const logger = createStreamLogger(modelId, "nmtcpp");
+    const { mode, from, to, ...generationParams } = nmtConfig;
     const args = {
-        loader: dl,
+        loader,
         logger,
         modelName: basePath,
         diskPath: dirPath,
         params: {
-            mode: nmtConfig.mode,
-            srcLang: nmtConfig.from,
-            dstLang: nmtConfig.to,
+            mode,
+            srcLang: from,
+            dstLang: to,
         },
     };
     const config = {
-        modelType: INDICTRANS_LANGUAGES.includes(nmtConfig.from) &&
-            INDICTRANS_LANGUAGES.includes(nmtConfig.to)
+        modelType: INDICTRANS_LANGUAGES.includes(from) &&
+            INDICTRANS_LANGUAGES.includes(to)
             ? TranslationNmtcpp.ModelTypes.IndicTrans
             : TranslationNmtcpp.ModelTypes.Opus,
+        ...generationParams,
     };
-    return new TranslationNmtcpp(args, config);
+    // Fail fast if model type is IndicTrans
+    if (config.modelType === TranslationNmtcpp.ModelTypes.IndicTrans) {
+        throw new TranslationFailedError("IndicTrans models are not supported with current NMT addon version.");
+    }
+    const model = new TranslationNmtcpp(args, config);
+    return { model, loader };
 }

package/dist/server/bare/addons/translation/handlers/translate.js

@@ -1,5 +1,12 @@
 import { getModel } from "../../../registry/model-registry.js";
 import { translateServerParamsSchema, } from "../../../../../schemas/index.js";
+import { getLangName } from "@qvac/langdetect-text";
+function getLanguage(code) {
+    if (!code)
+        return "";
+    const fullName = getLangName(code);
+    return fullName ?? code.toUpperCase();
+}
 export async function* translate(params) {
     const { modelId, text, modelType } = params;
     const from = params.modelType === "llm" ? params.from : undefined;
@@ -7,13 +14,15 @@ export async function* translate(params) {
     const context = params.modelType === "llm" ? params.context : undefined;
     translateServerParamsSchema.parse(params);
     const model = getModel(modelId);
+    const fromLanguage = getLanguage(from);
+    const toLanguage = getLanguage(to);
     // Prepare input based on model type
     const input = modelType === "nmt"
         ? text
         : [
             {
                 role: "system",
-                content: `${context ? `${context}. ` : ""}Translate the following text from ${from?.toUpperCase()} into ${to?.toUpperCase()}.Only output the translation, nothing else.\n\n${from?.toUpperCase()}: ${text}\n${to?.toUpperCase()}:`,
+                content: `${context ? `${context}. ` : ""}Translate the following text from ${fromLanguage} into ${toLanguage}. Only output the translation, nothing else.\n\n${fromLanguage}: ${text}\n${toLanguage}:`,
             },
         ];
     const startTime = Date.now();

package/dist/server/bare/addons/tts/create-model.d.ts

@@ -0,0 +1,10 @@
+import ONNXTTS from "@qvac/tts-onnx";
+import { type AnyModel } from "../../registry/model-registry";
+import { type TtsConfig } from "../../../../schemas/index";
+import FilesystemDL from "@qvac/dl-filesystem";
+export type TtsModel = ONNXTTS;
+export declare function createTtsModel(modelId: string, modelPath: string, ttsConfig: TtsConfig, ttsConfigModelPath: string, eSpeakDataPath: string): {
+    model: AnyModel;
+    loader: FilesystemDL;
+};
+//# sourceMappingURL=create-model.d.ts.map

package/dist/server/bare/addons/tts/create-model.js

@@ -0,0 +1,25 @@
+import ONNXTTS from "@qvac/tts-onnx";
+import {} from "../../registry/model-registry.js";
+import {} from "../../../../schemas/index.js";
+import { createStreamLogger } from "../../../../logging/index.js";
+import { parseModelPath } from "../../../utils/index.js";
+import FilesystemDL from "@qvac/dl-filesystem";
+export function createTtsModel(modelId, modelPath, ttsConfig, ttsConfigModelPath, eSpeakDataPath) {
+    const { dirPath, basePath: fileName } = parseModelPath(modelPath);
+    const loader = new FilesystemDL({ dirPath });
+    const logger = createStreamLogger(modelId, "tts");
+    const args = {
+        loader,
+        logger,
+        mainModelUrl: fileName,
+        configJsonPath: parseModelPath(ttsConfigModelPath).basePath,
+        cache: dirPath,
+        eSpeakDataPath: eSpeakDataPath,
+        opts: { stats: true },
+    };
+    const config = {
+        language: ttsConfig.language,
+    };
+    const model = new ONNXTTS(args, config);
+    return { model, loader };
+}

package/dist/server/bare/addons/tts/handlers/text-to-speech.d.ts

@@ -0,0 +1,3 @@
+import { type TtsRequest, type TtsResponse } from "../../../../../schemas/index";
+export declare function textToSpeech(params: TtsRequest): AsyncGenerator<TtsResponse>;
+//# sourceMappingURL=text-to-speech.d.ts.map

package/dist/server/bare/addons/tts/handlers/text-to-speech.js

@@ -0,0 +1,87 @@
+import { getModel } from "../../../registry/model-registry.js";
+import { ttsRequestSchema } from "../../../../../schemas/index.js";
+export async function* textToSpeech(params) {
+    const { modelId, inputType, text, stream } = ttsRequestSchema.parse(params);
+    const model = getModel(modelId);
+    const response = await model.run({ input: text, inputType });
+    if (!stream) {
+        // Non-streaming mode: wait for complete response and yield once
+        let completeBuffer = [];
+        await response
+            .onUpdate((data) => {
+            completeBuffer = completeBuffer.concat(Array.from(data.outputArray));
+        })
+            .await();
+        yield {
+            type: "textToSpeech",
+            buffer: completeBuffer,
+            done: true,
+        };
+    }
+    else {
+        // Streaming mode: use async iterator pattern
+        const outputQueue = [];
+        let isComplete = false;
+        let resolveNext = null;
+        // Start the response processing
+        const responsePromise = response
+            .onUpdate((data) => {
+            if (resolveNext) {
+                // If there's a pending read, resolve it immediately
+                resolveNext({
+                    value: {
+                        type: "textToSpeech",
+                        buffer: Array.from(data.outputArray),
+                        done: false,
+                    },
+                    done: false,
+                });
+                resolveNext = null;
+            }
+            else {
+                // Otherwise, queue the output
+                outputQueue.push(data);
+            }
+        })
+            .await()
+            .then(() => {
+            isComplete = true;
+            if (resolveNext) {
+                resolveNext({ value: undefined, done: true });
+                resolveNext = null;
+            }
+        });
+        // Create an async iterator
+        const asyncIterator = {
+            async next() {
+                if (outputQueue.length > 0) {
+                    const data = outputQueue.shift();
+                    return {
+                        value: {
+                            type: "textToSpeech",
+                            buffer: Array.from(data.outputArray),
+                            done: false,
+                        },
+                        done: false,
+                    };
+                }
+                if (isComplete) {
+                    return { value: undefined, done: true };
+                }
+                // Wait for the next output
+                return new Promise((resolve) => {
+                    resolveNext = resolve;
+                });
+            },
+            [Symbol.asyncIterator]() {
+                return this;
+            },
+        };
+        // Yield outputs as they come
+        for await (const output of asyncIterator) {
+            yield output;
+        }
+        // Ensure the response is fully processed
+        await responsePromise;
+    }
+}

package/dist/server/bare/addons/tts/index.d.ts

@@ -0,0 +1,3 @@
+export { createTtsModel } from "./create-model";
+export { textToSpeech } from "./handlers/text-to-speech";
+//# sourceMappingURL=index.d.ts.map

package/dist/server/bare/addons/tts/index.js

@@ -0,0 +1,2 @@
+export { createTtsModel } from "./create-model.js";
+export { textToSpeech } from "./handlers/text-to-speech.js";

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

@@ -1,19 +1,37 @@
 import { promises as fsPromises } from "bare-fs";
+import path from "bare-path";
 import { unregisterModel } from "../registry/model-registry.js";
 import { unregisterAllLoggingStreams } from "../registry/logging-stream-registry.js";
 import { unloadModelParamsSchema } from "../../../schemas/index.js";
+import { ModelNotLoadedError } from "../../../utils/errors-server.js";
+import { detectShardedModel } from "../../utils/index.js";
 export async function unloadModel(params) {
     const { modelId, clearStorage } = unloadModelParamsSchema.parse(params);
     const entry = unregisterModel(modelId);
     if (!entry) {
-        throw new Error(`Model with ID "${modelId}" is not loaded`);
+        throw new ModelNotLoadedError(modelId);
+    }
+    if (entry.local?.loader) {
+        await entry.local.loader.close();
     }
     if (entry.local?.model && entry.local.model.unload) {
         await entry.local.model.unload();
     }
     if (clearStorage && entry.local?.path) {
-        await fsPromises.rm(entry.local.path, { recursive: true, force: true });
-        console.log(`Model storage cleared: ${entry.local.path}`);
+        const modelPath = entry.local.path;
+        const modelFileName = path.basename(modelPath);
+        const shardInfo = detectShardedModel(modelFileName);
+        if (shardInfo.isSharded) {
+            // Delete entire shard directory
+            const shardDir = path.dirname(modelPath);
+            await fsPromises.rm(shardDir, { recursive: true, force: true });
+            console.log(`Sharded model storage cleared: ${shardDir}`);
+        }
+        else {
+            // Delete single file
+            await fsPromises.rm(modelPath, { recursive: true, force: true });
+            console.log(`Model storage cleared: ${modelPath}`);
+        }
     }
     unregisterAllLoggingStreams(modelId);
     console.log(`Model ${modelId} unloaded`);

package/dist/server/bare/addons/whispercpp/create-model.d.ts

@@ -1,6 +1,10 @@
 import TranscriptionWhispercpp from "@qvac/transcription-whispercpp";
 import { type AnyModel } from "../../registry/model-registry";
 import { type WhisperConfig } from "../../../../schemas/index";
+import FilesystemDL from "@qvac/dl-filesystem";
 export type WhispercppModel = TranscriptionWhispercpp;
-export declare function createWhisperModel(modelId: string, modelPath: string, whisperConfig: WhisperConfig, vadModelPath?: string): AnyModel;
+export declare function createWhisperModel(modelId: string, modelPath: string, whisperConfig: WhisperConfig, vadModelPath?: string): {
+    model: AnyModel;
+    loader: FilesystemDL;
+};
 //# sourceMappingURL=create-model.d.ts.map

package/dist/server/bare/addons/whispercpp/create-model.js

@@ -1,42 +1,22 @@
 import TranscriptionWhispercpp from "@qvac/transcription-whispercpp";
-import { Readable } from "bare-stream";
 import {} from "../../registry/model-registry.js";
 import {} from "../../../../schemas/index.js";
 import { createStreamLogger } from "../../../../logging/index.js";
 import { parseModelPath } from "../../../utils/index.js";
-// Mimic qvac-lib-dl-filesystem functionality
-function createFilesystemDLMimic(options) {
-    return {
-        dirPath: options.dirPath,
-        getStream: () => {
-            return Readable.from([]);
-        },
-        ready: () => Promise.resolve(),
-        close: () => Promise.resolve(),
-        destroy: () => Promise.resolve(),
-        getFileSize: () => Promise.resolve(0),
-        download: () => Promise.resolve({
-            await: () => Promise.resolve(),
-        }),
-        downloadFiles: () => Promise.resolve([]),
-    };
-}
+import FilesystemDL from "@qvac/dl-filesystem";
 export function createWhisperModel(modelId, modelPath, whisperConfig, vadModelPath) {
     const { dirPath, basePath } = parseModelPath(modelPath);
-    // Handle VAD model path - now uses vadModelPath parameter for consistency
+    // Handle VAD model path
     let vadModelName = "";
-    let vadDirPath = "./";
-    if (vadModelPath) {
-        const vadParsed = parseModelPath(vadModelPath);
-        vadDirPath = vadParsed.dirPath;
+    const effectiveVadPath = vadModelPath || whisperConfig.vad_model_path;
+    if (effectiveVadPath) {
+        const vadParsed = parseModelPath(effectiveVadPath);
         vadModelName = vadParsed.basePath;
     }
-    const dl = createFilesystemDLMimic({
-        dirPath: vadDirPath,
-    });
+    const loader = new FilesystemDL({ dirPath });
     const logger = createStreamLogger(modelId, "whispercpp");
     const args = {
-        loader: dl,
+        loader,
         logger,
         modelName: basePath,
         diskPath: dirPath,
@@ -45,11 +25,12 @@ export function createWhisperModel(modelId, modelPath, whisperConfig, vadModelPa
             stats: false,
         },
     };
+    const { contextParams, miscConfig, ...whisperParams } = whisperConfig;
     const config = {
-        whisperConfig: {
-            ...whisperConfig,
-            vad_model: vadModelPath || "",
-        },
+        whisperConfig: whisperParams,
+        ...(contextParams && { contextParams }),
+        ...(miscConfig && { miscConfig }),
     };
-    return new TranscriptionWhispercpp(args, config);
+    const model = new TranscriptionWhispercpp(args, config);
+    return { model, loader };
 }

package/dist/server/bare/addons/whispercpp/handlers/transcribe-stream.js

@@ -1,30 +1,51 @@
-import { getModel } from "../../../registry/model-registry.js";
+import { getModel, getModelConfig, updateModelConfig, } from "../../../registry/model-registry.js";
 import { Readable } from "bare-stream";
 import fs from "bare-fs";
 import { needsDecoding, decodeAudioToStream } from "../../../../utils/index.js";
-import path from "bare-path";
-import { transcribeParamsSchema } from "../../../../../schemas/index.js";
+import {} from "../../../../../schemas/index.js";
+import { AudioFileNotFoundError, InvalidAudioChunkError, } from "../../../../../utils/errors-server.js";
 export async function* transcribe(params) {
-    const { audioChunk: audioInput, modelId } = transcribeParamsSchema.parse(params);
-    const model = getModel(modelId);
+    const model = getModel(params.modelId);
+    if (params.prompt && typeof model.reload === "function") {
+        const existingConfig = getModelConfig(params.modelId);
+        const updatedConfig = {
+            ...existingConfig,
+            initial_prompt: params.prompt,
+        };
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { contextParams: _, miscConfig, ...whisperParams } = updatedConfig;
+        await model.reload({
+            whisperConfig: whisperParams,
+            ...(miscConfig && { miscConfig }),
+        });
+        updateModelConfig(params.modelId, updatedConfig);
+    }
     let audioStream;
-    // Check if it's a file path or base64 buffer
-    if (typeof audioInput === "string" &&
-        (audioInput.startsWith("/") || audioInput.includes("."))) {
-        // It's a file path - check if it needs decoding
-        if (needsDecoding(audioInput)) {
-            console.log(`Detected encoded format: ${path.extname(audioInput).toLowerCase()}, decoding before transcription...`);
-            audioStream = await decodeAudioToStream(audioInput);
+    const audioChunk = params.audioChunk;
+    switch (audioChunk.type) {
+        case "base64": {
+            const audioBuffer = Buffer.from(audioChunk.value, "base64");
+            audioStream = Readable.from([audioBuffer]);
+            break;
         }
-        else {
-            // File doesn't need decoding (e.g., RAW), create stream directly
-            audioStream = fs.createReadStream(audioInput);
+        case "filePath": {
+            const filePath = audioChunk.value;
+            try {
+                fs.accessSync(filePath);
+            }
+            catch (error) {
+                throw new AudioFileNotFoundError(filePath, error);
+            }
+            if (needsDecoding(filePath)) {
+                audioStream = await decodeAudioToStream(filePath);
+            }
+            else {
+                audioStream = fs.createReadStream(filePath);
+            }
+            break;
         }
-    }
-    else {
-        // It's base64 encoded buffer - decode and create stream
-        const audioBuffer = Buffer.from(audioInput, "base64");
-        audioStream = Readable.from([audioBuffer]);
+        default:
+            throw new InvalidAudioChunkError();
     }
     // Run transcription with streaming enabled
     const response = await model.run(audioStream);

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

@@ -1,6 +1,7 @@
 import { getSwarm } from "./hyperswarm.js";
 import RPC from "bare-rpc";
 import { withTimeout } from "../../utils/withTimeout.js";
+import { DelegateConnectionFailedError } from "../../utils/errors-server.js";
 // Map of active RPC instances by public key
 const activeRPCs = new Map();
 // Establish RPC connection to a peer if not already connected
@@ -27,7 +28,7 @@ async function ensureRPCConnection(topic, publicKey, timeout) {
                 if (!rpc) {
                     console.error(`❌ No RPC instance found for peer ${publicKey}`);
                     console.log(`📊 Available RPC connections:`, Array.from(activeRPCs.keys()));
-                    throw new Error(`Could not establish RPC connection to peer ${publicKey} on topic ${topic}`);
+                    throw new DelegateConnectionFailedError(`Could not establish RPC connection to peer ${publicKey} on topic ${topic}`);
                 }
                 else {
                     console.log(`✅ RPC instance found for peer ${publicKey}`);
@@ -37,7 +38,7 @@ async function ensureRPCConnection(topic, publicKey, timeout) {
         }
         catch (error) {
             console.error("Failed to establish RPC connection:", error);
-            throw new Error(`RPC connection failed: ${error instanceof Error ? error.message : String(error)}`);
+            throw new DelegateConnectionFailedError(`RPC connection failed: ${error instanceof Error ? error.message : String(error)}`, error);
         }
     }
     return rpc;

package/dist/server/bare/hyperswarm.d.ts

@@ -3,5 +3,8 @@ import { type FirewallConfig } from "../../schemas/provide";
 export declare function getSwarm({ firewallConfig, }?: {
     firewallConfig?: FirewallConfig | undefined;
 }): Hyperswarm;
+export declare function registerProviderTopic(topic: string): void;
+export declare function unregisterProviderTopic(topic: string): void;
+export declare function hasActiveProviders(): boolean;
 export declare function destroySwarm(): Promise<void>;
 //# sourceMappingURL=hyperswarm.d.ts.map

package/dist/server/bare/hyperswarm.js

@@ -2,6 +2,7 @@ import process from "bare-process";
 import Hyperswarm from "hyperswarm";
 import crypto from "bare-crypto";
 import { envSchema } from "../../schemas/provide.js";
+import { getSDKConfig } from "./registry/config-registry.js";
 function getHyperswarmSeedBuffer() {
     const parsedEnv = envSchema.safeParse(process.env);
     if (parsedEnv.success) {
@@ -45,9 +46,19 @@ function createFirewallFunction(config) {
 function createSwarm(firewallConfig) {
     const seed = getHyperswarmSeedBuffer();
     const firewall = createFirewallFunction(firewallConfig);
-    return new Hyperswarm({ seed, firewall });
+    const getRelays = () => {
+        const config = getSDKConfig();
+        const relayPublicKeys = config.swarmRelays;
+        if (!relayPublicKeys || relayPublicKeys.length === 0) {
+            return null;
+        }
+        return relayPublicKeys.map((key) => Buffer.from(key, "hex"));
+    };
+    const swarmOptions = { seed, firewall, relayThrough: getRelays };
+    return new Hyperswarm(swarmOptions);
 }
 let swarm;
+const activeProviderTopics = new Set();
 export function getSwarm({ firewallConfig, } = {}) {
     if (swarm) {
         return swarm;
@@ -55,8 +66,18 @@ export function getSwarm({ firewallConfig, } = {}) {
     swarm = createSwarm(firewallConfig);
     return swarm;
 }
+export function registerProviderTopic(topic) {
+    activeProviderTopics.add(topic);
+}
+export function unregisterProviderTopic(topic) {
+    activeProviderTopics.delete(topic);
+}
+export function hasActiveProviders() {
+    return activeProviderTopics.size > 0;
+}
 export async function destroySwarm() {
     if (swarm) {
+        activeProviderTopics.clear();
         return swarm.destroy();
     }
 }

package/dist/server/bare/rag-hyperdb/rag-manager.js

@@ -2,6 +2,7 @@ import { RAG, HyperDBAdapter } from "@qvac/rag";
 import Corestore from "corestore";
 import path from "bare-path";
 import { getEnv } from "../../worker.js";
+import { RAGWorkspaceModelMismatchError } from "../../../utils/errors-server.js";
 const ragInstances = new Map();
 const defaultWorkspace = "default";
 const getStorePath = (workspace) => {
@@ -14,9 +15,7 @@ export const getRagInstance = async (modelId, embeddingFunction, workspace) => {
     if (existingEntry) {
         // Validate model consistency
         if (existingEntry.modelId !== modelId) {
-            throw new Error(`Workspace "${key}" is configured for model "${existingEntry.modelId}", ` +
-                `but you're trying to use model "${modelId}". ` +
-                `Use a different workspace or the same model.`);
+            throw new RAGWorkspaceModelMismatchError(key, existingEntry.modelId, modelId);
         }
         return existingEntry.rag;
     }

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

@@ -0,0 +1,5 @@
+import type { SDKConfig } from "../../../schemas/index";
+export declare const setSDKConfig: (config: SDKConfig) => void;
+export declare const getSDKConfig: () => SDKConfig;
+export declare const getConfiguredCacheDir: () => string;
+//# sourceMappingURL=config-registry.d.ts.map

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

@@ -0,0 +1,39 @@
+import fs from "bare-fs";
+import path from "bare-path";
+import { getEnv } from "../../worker.js";
+import { CacheDirNotAbsoluteError, CacheDirNotWritableError, } from "../../../utils/errors-server.js";
+const configRegistry = {
+    cacheDirectory: undefined,
+    swarmRelays: undefined,
+};
+export const setSDKConfig = (config) => {
+    if (config.cacheDirectory !== undefined && config.cacheDirectory !== null) {
+        if (!path.isAbsolute(config.cacheDirectory)) {
+            throw new CacheDirNotAbsoluteError();
+        }
+        try {
+            fs.mkdirSync(config.cacheDirectory, { recursive: true });
+            const testFile = path.join(config.cacheDirectory, ".qvac-test");
+            fs.writeFileSync(testFile, "test");
+            fs.unlinkSync(testFile);
+        }
+        catch (error) {
+            throw new CacheDirNotWritableError(config.cacheDirectory, error instanceof Error ? error.message : String(error), error);
+        }
+        configRegistry.cacheDirectory = config.cacheDirectory;
+        console.log(`✅ Cache directory set to: ${config.cacheDirectory}`);
+    }
+    if (config.swarmRelays !== undefined && config.swarmRelays !== null) {
+        configRegistry.swarmRelays = config.swarmRelays;
+    }
+};
+export const getSDKConfig = () => {
+    return { ...configRegistry };
+};
+const getDefaultCacheDir = () => {
+    const homeDir = getEnv().HOME_DIR;
+    return path.join(homeDir, ".qvac", "models");
+};
+export const getConfiguredCacheDir = () => {
+    return configRegistry.cacheDirectory || getDefaultCacheDir();
+};

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

@@ -1,4 +1,5 @@
 import type EventEmitter from "events";
+import type FilesystemDL from "@qvac/dl-filesystem";
 interface AddonInterface {
     cancel(jobId?: string): Promise<void>;
 }
@@ -8,6 +9,11 @@ export interface AnyModel {
         onUpdate(callback: (data: string) => void): {
             await: () => Promise<void>;
         };
+        onUpdate(callback: (data: {
+            outputArray: Int16Array;
+        }) => void): {
+            await: () => Promise<void>;
+        };
         onError(callback: (error: Error) => void): void;
         onUpdate(callback: (data: Array<{
             text: string;
@@ -20,6 +26,7 @@ export interface AnyModel {
         }>>;
         await(): Promise<void>;
     }>;
+    reload?(config: unknown): Promise<void>;
     unload?(): Promise<void>;
     addon?: AddonInterface;
 }
@@ -33,6 +40,8 @@ interface LocalOptions {
     path: string;
     loadedAt: Date;
     config: unknown;
+    name?: string | undefined;
+    loader: FilesystemDL;
 }
 export interface ModelEntry {
     id: string;
@@ -44,6 +53,8 @@ export declare function registerModel(id: string, options: {
     model: AnyModel;
     path: string;
     config: unknown;
+    loader: FilesystemDL;
+    name?: string | undefined;
 } | {
     topic: string;
     providerPublicKey: string;
@@ -59,8 +70,10 @@ export declare function getModelInfo(id: string): {
     path: string;
     loadedAt: Date;
     config: unknown;
+    name?: string;
 } | null;
 export declare function getModelConfig(id: string): unknown;
+export declare function updateModelConfig(id: string, config: unknown): void;
 export declare function clearRegistry(): void;
 export declare function getRegistryStats(): {
     totalModels: number;