@qvac/sdk 0.8.0 → 1.0.0

package/dist/server/bare/{ops → addons/llamacpp}/kv-cache-utils.js

@@ -1,51 +1,22 @@
 import crypto from "bare-crypto";
 import { promises as fsPromises } from "bare-fs";
 import path from "bare-path";
-import { getKVCacheDir, validateAndJoinPath } from "../../utils/index.js";
-import { getServerLogger } from "../../../logging/index.js";
-const logger = getServerLogger();
-// In-memory registry tracks caches initialized this session (addon defers disk writes)
-const initializedCaches = new Set();
-function getCacheRegistryKey(modelId, configHash, cacheKey) {
-    return `${modelId}:${configHash}:${cacheKey}`;
-}
-export function markCacheInitialized(modelId, configHash, cacheKey) {
-    initializedCaches.add(getCacheRegistryKey(modelId, configHash, cacheKey));
-}
-export function isCacheInitialized(modelId, configHash, cacheKey) {
-    return initializedCaches.has(getCacheRegistryKey(modelId, configHash, cacheKey));
-}
-export function clearCacheRegistry(cacheKey) {
-    if (cacheKey) {
-        for (const key of initializedCaches) {
-            if (key.includes(`:${cacheKey}`)) {
-                initializedCaches.delete(key);
-            }
-        }
-    }
-    else {
-        initializedCaches.clear();
-    }
-}
+import { getKVCacheDir } from "../../../utils/index.js";
 export function extractSystemPrompt(messages) {
     const systemMessage = messages.find((msg) => msg.role === "system");
     return systemMessage ? systemMessage.content : null;
 }
-function getToolNamesForHash(tools) {
-    if (!Array.isArray(tools))
-        return [];
-    return tools
-        .map((t) => t.name)
-        .filter((n) => typeof n === "string")
-        .sort();
-}
-// Cache hash based on system prompt + tool names
-// Different tools = different cache (tools anchored in first message, protected from n_discarded)
-export function generateConfigHash(systemPrompt, tools) {
+export function generateConfigHash(modelConfig, systemPrompt, tools) {
     const hash = crypto.createHash("sha256");
-    const toolNames = getToolNamesForHash(tools);
-    hash.update(Buffer.from(JSON.stringify({ systemPrompt, toolNames }), "utf8"));
-    return hash.digest("hex").substring(0, 16);
+    const configStr = JSON.stringify({
+        config: modelConfig,
+        systemPrompt,
+        tools,
+    });
+    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");
@@ -57,8 +28,8 @@ export function generateCacheKey(messages) {
 }
 export async function getCacheFilePath(modelId, configHash, cacheKey) {
     const cacheDir = getKVCacheDir();
-    const sessionCacheDir = validateAndJoinPath(cacheDir, cacheKey);
-    const modelCacheDir = validateAndJoinPath(sessionCacheDir, modelId);
+    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 });
@@ -95,19 +66,13 @@ export async function renameCacheFile(oldPath, newPath) {
         await fsPromises.rename(oldPath, newPath);
     }
     catch (error) {
-        logger.error("Error renaming cache file:", error instanceof Error ? error.message : String(error));
+        console.error("Error renaming cache file:", error instanceof Error ? error.message : String(error));
     }
 }
 export async function customCacheExists(modelId, configHash, cacheKey) {
-    // Check in-memory registry first (addon defers disk writes)
-    if (isCacheInitialized(modelId, configHash, cacheKey)) {
-        return true;
-    }
-    // Then check file system (for caches from previous runs)
     const cachePath = await getCacheFilePath(modelId, configHash, cacheKey);
     try {
         await fsPromises.access(cachePath);
-        markCacheInitialized(modelId, configHash, cacheKey);
         return true;
     }
     catch {
@@ -122,18 +87,18 @@ export async function deleteCache(options) {
             await fsPromises.mkdir(cacheDir, { recursive: true });
         }
         catch (error) {
-            logger.error("Error deleting all caches:", error instanceof Error ? error.message : String(error));
+            console.error("Error deleting all caches:", error instanceof Error ? error.message : String(error));
         }
     }
     else if ("kvCacheKey" in options) {
-        const kvCacheDir = validateAndJoinPath(cacheDir, options.kvCacheKey);
+        const kvCacheDir = path.join(cacheDir, options.kvCacheKey);
         if (options.modelId) {
-            const modelCacheDir = validateAndJoinPath(kvCacheDir, options.modelId);
+            const modelCacheDir = path.join(kvCacheDir, options.modelId);
             try {
                 await fsPromises.rm(modelCacheDir, { recursive: true });
             }
             catch (error) {
-                logger.error(`Error deleting model cache ${options.kvCacheKey}/${options.modelId}:`, error instanceof Error ? error.message : String(error));
+                console.error(`Error deleting model cache ${options.kvCacheKey}/${options.modelId}:`, error instanceof Error ? error.message : String(error));
             }
         }
         else {
@@ -141,7 +106,7 @@ export async function deleteCache(options) {
                 await fsPromises.rm(kvCacheDir, { recursive: true });
             }
             catch (error) {
-                logger.error(`Error deleting cache ${options.kvCacheKey}:`, error instanceof Error ? error.message : String(error));
+                console.error(`Error deleting cache ${options.kvCacheKey}:`, error instanceof Error ? error.message : String(error));
             }
         }
     }

package/dist/server/bare/addons/load-model.d.ts

@@ -0,0 +1,3 @@
+import { type LoadModelServerParams } from "../../../schemas/index";
+export declare function loadModel(params: LoadModelServerParams): Promise<void>;
+//# sourceMappingURL=load-model.d.ts.map

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

@@ -0,0 +1,62 @@
+import { promises as fsPromises } from "bare-fs";
+import path from "bare-path";
+import process from "bare-process";
+import { registerModel, isModelLoaded, } from "../registry/model-registry.js";
+import { loadModelServerParamsSchema, } from "../../../schemas/index.js";
+import { createWhisperModel } from "./whispercpp/index.js";
+import { createLlmModel } from "./llamacpp/index.js";
+import { createEmbeddingsModel } from "./llamacpp/index.js";
+import { createNmtModel } from "./translation/index.js";
+import { createTtsModel } from "./tts/index.js";
+export async function loadModel(params) {
+    const { modelId, modelPath, options, projectionModelPath, vadModelPath, ttsConfigModelPath, eSpeakDataPath, } = loadModelServerParamsSchema.parse(params);
+    const { modelConfig, modelType } = options;
+    // Check if model is already loaded
+    if (isModelLoaded(modelId)) {
+        console.log(`${modelType} model ${modelId} is already loaded`);
+        return;
+    }
+    // Validate the file exists
+    console.log("cwd", process.cwd());
+    try {
+        const modelDir = path.dirname(modelPath);
+        const modelFile = path.basename(modelPath);
+        const files = (await fsPromises.readdir(modelDir));
+        if (!files.includes(modelFile)) {
+            throw new Error(`${modelType} model file ${modelFile} not found in directory ${modelDir}`);
+        }
+        // File exists, continue
+    }
+    catch (error) {
+        console.error(`Error reading ${modelType} model directory:`, error instanceof Error ? error.message : String(error));
+        throw new Error(`Failed to locate ${modelType} model file: ${modelPath}`);
+    }
+    let model;
+    switch (modelType) {
+        case "llm":
+            model = createLlmModel(modelId, modelPath, modelConfig, projectionModelPath);
+            break;
+        case "whisper":
+            model = createWhisperModel(modelId, modelPath, modelConfig, vadModelPath);
+            break;
+        case "embeddings":
+            model = createEmbeddingsModel(modelId, modelPath, modelConfig);
+            break;
+        case "nmt":
+            model = createNmtModel(modelId, modelPath, modelConfig);
+            break;
+        case "tts":
+            if (!eSpeakDataPath) {
+                throw new Error("eSpeakDataPath is required for TTS models");
+            }
+            model = createTtsModel(modelId, modelPath, modelConfig, ttsConfigModelPath, eSpeakDataPath);
+            break;
+        default:
+            // Should never happen
+            throw new Error(`Unknown model type`);
+    }
+    console.log(`${modelType}: Loading model ${modelId}...`);
+    await model.load(false);
+    console.log(`${modelType} model ${modelId} loaded`);
+    registerModel(modelId, { model, path: modelPath, config: modelConfig });
+}

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

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

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

@@ -0,0 +1,45 @@
+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(),
+    };
+}
+export function createNmtModel(modelId, modelPath, nmtConfig) {
+    const { dirPath, basePath } = parseModelPath(modelPath);
+    const dl = createFilesystemDLMimic({
+        dirPath: "./",
+    });
+    const logger = createStreamLogger(modelId, "nmtcpp");
+    const args = {
+        loader: dl,
+        logger,
+        modelName: basePath,
+        diskPath: dirPath,
+        params: {
+            mode: nmtConfig.mode,
+            srcLang: nmtConfig.from,
+            dstLang: nmtConfig.to,
+        },
+    };
+    const config = {
+        modelType: INDICTRANS_LANGUAGES.includes(nmtConfig.from) &&
+            INDICTRANS_LANGUAGES.includes(nmtConfig.to)
+            ? TranslationNmtcpp.ModelTypes.IndicTrans
+            : TranslationNmtcpp.ModelTypes.Opus,
+    };
+    return new TranslationNmtcpp(args, config);
+}

package/dist/server/bare/addons/translation/handlers/translate.d.ts

@@ -0,0 +1,3 @@
+import { type TranslateParams, type TranslationStats } from "../../../../../schemas/index";
+export declare function translate(params: TranslateParams): AsyncGenerator<string, TranslationStats | undefined, unknown>;
+//# sourceMappingURL=translate.d.ts.map

package/dist/server/bare/{ops → addons/translation/handlers}/translate.js

@@ -1,68 +1,35 @@
-import { getModel } from "../registry/model-registry.js";
-import { translateServerParamsSchema, normalizeModelType, ModelType, AFRICAN_LANGUAGES_MAP, } from "../../../schemas/index.js";
+import { getModel } from "../../../registry/model-registry.js";
+import { translateServerParamsSchema, } from "../../../../../schemas/index.js";
 import { getLangName } from "@qvac/langdetect-text";
-export function getLanguage(code) {
+function getLanguage(code) {
     if (!code)
         return "";
-    if (AFRICAN_LANGUAGES_MAP.has(code))
-        return AFRICAN_LANGUAGES_MAP.get(code);
     const fullName = getLangName(code);
     return fullName ?? code.toUpperCase();
 }
-export function isAfrican(code) {
-    return !!code && AFRICAN_LANGUAGES_MAP.has(code);
-}
 export async function* translate(params) {
-    const { modelId, text, modelType: inputModelType } = params;
-    const canonicalModelType = normalizeModelType(inputModelType);
-    const isLlm = canonicalModelType === ModelType.llamacppCompletion;
-    const from = isLlm ? params.from : undefined;
-    const to = isLlm ? params.to : undefined;
-    const context = isLlm ? params.context : undefined;
-    const afriquePrompt = isLlm && (isAfrican(from) || isAfrican(to));
+    const { modelId, text, modelType } = params;
+    const from = params.modelType === "llm" ? params.from : undefined;
+    const to = params.modelType === "llm" ? params.to : undefined;
+    const context = params.modelType === "llm" ? params.context : undefined;
     translateServerParamsSchema.parse(params);
     const model = getModel(modelId);
     const fromLanguage = getLanguage(from);
     const toLanguage = getLanguage(to);
-    const startTime = Date.now();
-    let processedTokens = 0;
-    // Check if input is an array and model type is NMT
-    if (Array.isArray(text) &&
-        canonicalModelType === ModelType.nmtcppTranslation) {
-        // Use runBatch for batch processing
-        const translations = await model.runBatch(text);
-        // Yield each translation with a newline separator
-        for (let i = 0; i < translations.length; i++) {
-            const translation = translations[i];
-            processedTokens++;
-            yield translation;
-            if (i < translations.length - 1) {
-                yield "\n";
-            }
-        }
-        const endTime = Date.now();
-        return {
-            processedTokens,
-            processingTime: endTime - startTime,
-        };
-    }
-    // Single text processing (for NMT or LLM)
-    const singleText = Array.isArray(text) ? text[0] : text;
     // Prepare input based on model type
-    const input = canonicalModelType === ModelType.nmtcppTranslation
-        ? singleText
+    const input = modelType === "nmt"
+        ? text
         : [
             {
-                role: afriquePrompt ? "user" : "system",
-                content: afriquePrompt
-                    ? `Translate ${fromLanguage} to ${toLanguage}.\n${fromLanguage}: ${singleText}\n${toLanguage}:`
-                    : `${context ? `${context}. ` : ""}Translate the following text from ${fromLanguage} into ${toLanguage}. Only output the translation, nothing else.\n\n${fromLanguage}: ${singleText}\n${toLanguage}:`,
+                role: "system",
+                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();
+    let processedTokens = 0;
     const response = await model.run(input);
     // Check if the response has an iterate method (like LLM models)
-    if (canonicalModelType === ModelType.llamacppCompletion &&
-        typeof response.iterate === "function") {
+    if (modelType === "llm" && typeof response.iterate === "function") {
         for await (const token of response.iterate()) {
             processedTokens++;
             yield token;

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

@@ -0,0 +1,3 @@
+export { createNmtModel } from "./create-model";
+export { translate } from "./handlers/translate";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,2 @@
+export { createNmtModel } from "./create-model.js";
+export { translate } from "./handlers/translate.js";

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

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

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

@@ -0,0 +1,40 @@
+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";
+// Mimic qvac-lib-dl-filesystem functionality
+function createFilesystemDLMimic(options) {
+    return {
+        dirPath: options.dirPath,
+        getStream: () => {
+            return Promise.resolve({
+                async *[Symbol.asyncIterator]() {
+                    await Promise.resolve();
+                    yield Buffer.alloc(0);
+                },
+            });
+        },
+        ready: () => Promise.resolve(),
+    };
+}
+export function createTtsModel(modelId, modelPath, ttsConfig, ttsConfigModelPath, eSpeakDataPath) {
+    const { dirPath, basePath: fileName } = parseModelPath(modelPath);
+    const dl = createFilesystemDLMimic({
+        dirPath: "./",
+    });
+    const logger = createStreamLogger(modelId, "tts");
+    const args = {
+        loader: dl,
+        logger,
+        mainModelUrl: fileName,
+        configJsonPath: parseModelPath(ttsConfigModelPath).basePath,
+        cache: dirPath,
+        eSpeakDataPath: eSpeakDataPath,
+        opts: { stats: true },
+    };
+    const config = {
+        language: ttsConfig.language,
+    };
+    return new ONNXTTS(args, config);
+}

package/dist/server/bare/{plugins/onnx-tts/ops → addons/tts/handlers}/text-to-speech.js

@@ -6,10 +6,10 @@ export async function* textToSpeech(params) {
     const response = await model.run({ input: text, inputType });
     if (!stream) {
         // Non-streaming mode: wait for complete response and yield once
-        let completeBuffer = [];
+        const completeBuffer = [];
         await response
             .onUpdate((data) => {
-            completeBuffer = completeBuffer.concat(Array.from(data.outputArray));
+            completeBuffer.push(...Array.from(data.outputArray));
         })
             .await();
         yield {
@@ -22,9 +22,7 @@ export async function* textToSpeech(params) {
         // Streaming mode: use async iterator pattern
         const outputQueue = [];
         let isComplete = false;
-        let streamError = null;
         let resolveNext = null;
-        let rejectNext = null;
         // Start the response processing
         const responsePromise = response
             .onUpdate((data) => {
@@ -39,7 +37,6 @@ export async function* textToSpeech(params) {
                     done: false,
                 });
                 resolveNext = null;
-                rejectNext = null;
             }
             else {
                 // Otherwise, queue the output
@@ -52,29 +49,11 @@ export async function* textToSpeech(params) {
             if (resolveNext) {
                 resolveNext({ value: undefined, done: true });
                 resolveNext = null;
-                rejectNext = null;
-            }
-        })
-            .catch((err) => {
-            streamError = err;
-            isComplete = true;
-            if (rejectNext) {
-                rejectNext(err);
-                resolveNext = null;
-                rejectNext = null;
             }
         });
         // Create an async iterator
         const asyncIterator = {
             async next() {
-                if (streamError) {
-                    if (streamError instanceof Error)
-                        throw streamError;
-                    const message = typeof streamError === "string"
-                        ? streamError
-                        : JSON.stringify(streamError);
-                    throw new Error(message);
-                }
                 if (outputQueue.length > 0) {
                     const data = outputQueue.shift();
                     return {
@@ -90,9 +69,8 @@ export async function* textToSpeech(params) {
                     return { value: undefined, done: true };
                 }
                 // Wait for the next output
-                return new Promise((resolve, reject) => {
+                return new Promise((resolve) => {
                     resolveNext = resolve;
-                    rejectNext = reject;
                 });
             },
             [Symbol.asyncIterator]() {

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

@@ -0,0 +1,20 @@
+import { promises as fsPromises } from "bare-fs";
+import { unregisterModel } from "../registry/model-registry.js";
+import { unregisterAllLoggingStreams } from "../registry/logging-stream-registry.js";
+import { unloadModelParamsSchema } from "../../../schemas/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`);
+    }
+    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}`);
+    }
+    unregisterAllLoggingStreams(modelId);
+    console.log(`Model ${modelId} unloaded`);
+}

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

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

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

@@ -0,0 +1,55 @@
+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([]),
+    };
+}
+export function createWhisperModel(modelId, modelPath, whisperConfig, vadModelPath) {
+    const { dirPath, basePath } = parseModelPath(modelPath);
+    // Handle VAD model path - now uses vadModelPath parameter for consistency
+    let vadModelName = "";
+    let vadDirPath = "./";
+    if (vadModelPath) {
+        const vadParsed = parseModelPath(vadModelPath);
+        vadDirPath = vadParsed.dirPath;
+        vadModelName = vadParsed.basePath;
+    }
+    const dl = createFilesystemDLMimic({
+        dirPath: vadDirPath,
+    });
+    const logger = createStreamLogger(modelId, "whispercpp");
+    const args = {
+        loader: dl,
+        logger,
+        modelName: basePath,
+        diskPath: dirPath,
+        vadModelName,
+        opts: {
+            stats: false,
+        },
+    };
+    const config = {
+        whisperConfig: {
+            ...whisperConfig,
+            vad_model: vadModelPath || "",
+        },
+    };
+    return new TranscriptionWhispercpp(args, config);
+}

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

@@ -0,0 +1,3 @@
+import { type TranscribeParams } from "../../../../../schemas/index";
+export declare function transcribe(params: TranscribeParams): AsyncGenerator<string, void, void>;
+//# sourceMappingURL=transcribe-stream.d.ts.map

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

@@ -0,0 +1,48 @@
+import { getModel } from "../../../registry/model-registry.js";
+import { Readable } from "bare-stream";
+import fs from "bare-fs";
+import { needsDecoding, decodeAudioToStream } from "../../../../utils/index.js";
+import {} from "../../../../../schemas/index.js";
+export async function* transcribe(params) {
+    const model = getModel(params.modelId);
+    let audioStream;
+    const audioChunk = params.audioChunk;
+    switch (audioChunk.type) {
+        case "base64": {
+            const audioBuffer = Buffer.from(audioChunk.value, "base64");
+            audioStream = Readable.from([audioBuffer]);
+            break;
+        }
+        case "filePath": {
+            const filePath = audioChunk.value;
+            try {
+                fs.accessSync(filePath);
+            }
+            catch {
+                throw new Error(`Audio file not found or not accessible: ${filePath}`);
+            }
+            if (needsDecoding(filePath)) {
+                audioStream = await decodeAudioToStream(filePath);
+            }
+            else {
+                audioStream = fs.createReadStream(filePath);
+            }
+            break;
+        }
+        default:
+            throw new Error(`Invalid audio chunk type`);
+    }
+    // Run transcription with streaming enabled
+    const response = await model.run(audioStream);
+    for await (const output of response.iterate()) {
+        console.log("Streaming Transcription Update:", output);
+        // Filter out blank audio chunks and process the text
+        const text = output
+            .filter((chunk) => !chunk.text.includes("[BLANK_AUDIO]"))
+            .map((chunk) => chunk.text)
+            .join("");
+        if (text.trim()) {
+            yield text;
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+export { transcribe as transcribeStream } from "./handlers/transcribe-stream";
+export { createWhisperModel } from "./create-model";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,2 @@
+export { transcribe as transcribeStream } from "./handlers/transcribe-stream.js";
+export { createWhisperModel } from "./create-model.js";

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

@@ -1,10 +1,4 @@
 import RPC from "bare-rpc";
 import type { RPCOptions } from "../../schemas/index";
 export declare function getRPC(topic: string, publicKey: string, options?: RPCOptions): Promise<RPC>;
-/**
- * Remove a stale RPC connection for a peer.
- * Called when a delegation request fails (e.g., timeout) so the next
- * attempt creates a fresh connection instead of reusing a dead RPC.
- */
-export declare function cleanupStaleConnection(publicKey: string): void;
 //# sourceMappingURL=delegate-rpc-client.d.ts.map