@qvac/sdk 0.4.1 → 0.5.0

package/dist/schemas/sdk-errors-client.js

@@ -24,6 +24,10 @@ export const SDK_CLIENT_ERROR_CODES = {
     // Build/Bundle Errors (50,600-50,799)
     SDK_NOT_FOUND_IN_NODE_MODULES: 50600,
     WORKER_FILE_NOT_FOUND: 50601,
+    CONFIG_FILE_NOT_FOUND: 50602,
+    CONFIG_FILE_INVALID: 50603,
+    CONFIG_FILE_PARSE_FAILED: 50604,
+    CONFIG_VALIDATION_FAILED: 50605,
 };
 const clientErrorDefinitions = {
     // Response Validation Errors (50,001-50,199)
@@ -106,6 +110,22 @@ const clientErrorDefinitions = {
         name: "WORKER_FILE_NOT_FOUND",
         message: (workerPath) => `Worker file not found at ${workerPath}`,
     },
+    [SDK_CLIENT_ERROR_CODES.CONFIG_FILE_NOT_FOUND]: {
+        name: "CONFIG_FILE_NOT_FOUND",
+        message: (searchPaths) => `Config file not found. Searched: ${searchPaths}. Create qvac.config.json, qvac.config.js, or qvac.config.ts in your project root.`,
+    },
+    [SDK_CLIENT_ERROR_CODES.CONFIG_FILE_INVALID]: {
+        name: "CONFIG_FILE_INVALID",
+        message: (filePath, reason) => `Config file at ${filePath} is invalid: ${reason}`,
+    },
+    [SDK_CLIENT_ERROR_CODES.CONFIG_FILE_PARSE_FAILED]: {
+        name: "CONFIG_FILE_PARSE_FAILED",
+        message: (filePath, error) => `Failed to parse config file at ${filePath}: ${error}`,
+    },
+    [SDK_CLIENT_ERROR_CODES.CONFIG_VALIDATION_FAILED]: {
+        name: "CONFIG_VALIDATION_FAILED",
+        message: (errors) => `Config validation failed: ${errors}`,
+    },
 };
 addCodes(clientErrorDefinitions, { name: "qvac-sdk-client", version: "1.1.0" });
 export { clientErrorDefinitions as SDK_CLIENT_ERROR_DEFINITIONS };

package/dist/schemas/sdk-errors-server.d.ts

@@ -23,6 +23,8 @@ export declare const SDK_SERVER_ERROR_CODES: {
     readonly ATTACHMENT_NOT_FOUND: 52407;
     readonly CANCEL_FAILED: 52408;
     readonly TEXT_TO_SPEECH_FAILED: 52409;
+    readonly CONFIG_RELOAD_NOT_SUPPORTED: 52410;
+    readonly MODEL_TYPE_MISMATCH: 52411;
     readonly RAG_SAVE_FAILED: 52800;
     readonly RAG_SEARCH_FAILED: 52801;
     readonly RAG_DELETE_FAILED: 52802;
@@ -44,6 +46,7 @@ export declare const SDK_SERVER_ERROR_CODES: {
     readonly CACHE_DIR_NOT_ABSOLUTE: 53202;
     readonly CACHE_DIR_NOT_WRITABLE: 53203;
     readonly SET_CONFIG_FAILED: 53350;
+    readonly CONFIG_ALREADY_SET: 53351;
     readonly FFMPEG_NOT_AVAILABLE: 53500;
     readonly AUDIO_PLAYER_FAILED: 53501;
     readonly INVALID_AUDIO_CHUNK_TYPE: 53502;

package/dist/schemas/sdk-errors-server.js

@@ -27,6 +27,8 @@ export const SDK_SERVER_ERROR_CODES = {
     ATTACHMENT_NOT_FOUND: 52407,
     CANCEL_FAILED: 52408,
     TEXT_TO_SPEECH_FAILED: 52409,
+    CONFIG_RELOAD_NOT_SUPPORTED: 52410,
+    MODEL_TYPE_MISMATCH: 52411,
     // RAG Operations (52,800-52,999)
     RAG_SAVE_FAILED: 52800,
     RAG_SEARCH_FAILED: 52801,
@@ -52,6 +54,7 @@ export const SDK_SERVER_ERROR_CODES = {
     CACHE_DIR_NOT_WRITABLE: 53203,
     // Config Operations (53,350-53,499)
     SET_CONFIG_FAILED: 53350,
+    CONFIG_ALREADY_SET: 53351,
     // System/Runtime (53,500-53,699)
     FFMPEG_NOT_AVAILABLE: 53500,
     AUDIO_PLAYER_FAILED: 53501,
@@ -156,6 +159,14 @@ const serverErrorDefinitions = {
         name: "TEXT_TO_SPEECH_FAILED",
         message: (details) => `Text-to-speech operation failed${details ? `: ${details}` : ""}`,
     },
+    [SDK_SERVER_ERROR_CODES.CONFIG_RELOAD_NOT_SUPPORTED]: {
+        name: "CONFIG_RELOAD_NOT_SUPPORTED",
+        message: (modelId) => `Model "${modelId}" does not support hot config reload`,
+    },
+    [SDK_SERVER_ERROR_CODES.MODEL_TYPE_MISMATCH]: {
+        name: "MODEL_TYPE_MISMATCH",
+        message: (expectedType, providedType) => `Model type mismatch: expected "${expectedType}", got "${providedType}"`,
+    },
     // RAG Operations (52,800-52,999)
     [SDK_SERVER_ERROR_CODES.RAG_SAVE_FAILED]: {
         name: "RAG_SAVE_FAILED",
@@ -244,6 +255,10 @@ const serverErrorDefinitions = {
         name: "SET_CONFIG_FAILED",
         message: (details) => `Failed to set config${details ? `: ${details}` : ""}`,
     },
+    [SDK_SERVER_ERROR_CODES.CONFIG_ALREADY_SET]: {
+        name: "CONFIG_ALREADY_SET",
+        message: "Config has already been set and is immutable. Config can only be set once during SDK initialization.",
+    },
     // System/Runtime (53,500-53,699)
     [SDK_SERVER_ERROR_CODES.FFMPEG_NOT_AVAILABLE]: {
         name: "FFMPEG_NOT_AVAILABLE",

package/dist/schemas/tools.d.ts

@@ -59,4 +59,7 @@ export type Tool = z.infer<typeof toolSchema>;
 export type ToolCall = z.infer<typeof toolCallSchema>;
 export type ToolCallError = z.infer<typeof toolCallErrorSchema>;
 export type ToolCallEvent = z.infer<typeof toolCallEventSchema>;
+export type ToolCallWithCall = ToolCall & {
+    invoke?: () => Promise<unknown>;
+};
 //# sourceMappingURL=tools.d.ts.map

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

@@ -1,6 +1,87 @@
 import { z } from "zod";
 export declare const INDICTRANS_LANGUAGES: readonly ["asm_Beng", "ben_Beng", "brx_Deva", "doi_Deva", "eng_Latn", "gom_Deva", "guj_Gujr", "hin_Deva", "kan_Knda", "kas_Arab", "kas_Deva", "mai_Deva", "mal_Mlym", "mar_Deva", "mni_Beng", "mni_Mtei", "npi_Deva", "ory_Orya", "pan_Guru", "san_Deva", "sat_Olck", "snd_Arab", "snd_Deva", "tam_Taml", "tel_Telu", "urd_Arab"];
 export declare const NMT_LANGUAGES: readonly ["en", "de", "es", "it", "ru", "ja", "asm_Beng", "ben_Beng", "brx_Deva", "doi_Deva", "eng_Latn", "gom_Deva", "guj_Gujr", "hin_Deva", "kan_Knda", "kas_Arab", "kas_Deva", "mai_Deva", "mal_Mlym", "mar_Deva", "mni_Beng", "mni_Mtei", "npi_Deva", "ory_Orya", "pan_Guru", "san_Deva", "sat_Olck", "snd_Arab", "snd_Deva", "tam_Taml", "tel_Telu", "urd_Arab"];
+export declare const nmtConfigBaseSchema: z.ZodObject<{
+    mode: z.ZodOptional<z.ZodEnum<{
+        full: "full";
+    }>>;
+    from: z.ZodEnum<{
+        en: "en";
+        de: "de";
+        es: "es";
+        it: "it";
+        ru: "ru";
+        ja: "ja";
+        asm_Beng: "asm_Beng";
+        ben_Beng: "ben_Beng";
+        brx_Deva: "brx_Deva";
+        doi_Deva: "doi_Deva";
+        eng_Latn: "eng_Latn";
+        gom_Deva: "gom_Deva";
+        guj_Gujr: "guj_Gujr";
+        hin_Deva: "hin_Deva";
+        kan_Knda: "kan_Knda";
+        kas_Arab: "kas_Arab";
+        kas_Deva: "kas_Deva";
+        mai_Deva: "mai_Deva";
+        mal_Mlym: "mal_Mlym";
+        mar_Deva: "mar_Deva";
+        mni_Beng: "mni_Beng";
+        mni_Mtei: "mni_Mtei";
+        npi_Deva: "npi_Deva";
+        ory_Orya: "ory_Orya";
+        pan_Guru: "pan_Guru";
+        san_Deva: "san_Deva";
+        sat_Olck: "sat_Olck";
+        snd_Arab: "snd_Arab";
+        snd_Deva: "snd_Deva";
+        tam_Taml: "tam_Taml";
+        tel_Telu: "tel_Telu";
+        urd_Arab: "urd_Arab";
+    }>;
+    to: z.ZodEnum<{
+        en: "en";
+        de: "de";
+        es: "es";
+        it: "it";
+        ru: "ru";
+        ja: "ja";
+        asm_Beng: "asm_Beng";
+        ben_Beng: "ben_Beng";
+        brx_Deva: "brx_Deva";
+        doi_Deva: "doi_Deva";
+        eng_Latn: "eng_Latn";
+        gom_Deva: "gom_Deva";
+        guj_Gujr: "guj_Gujr";
+        hin_Deva: "hin_Deva";
+        kan_Knda: "kan_Knda";
+        kas_Arab: "kas_Arab";
+        kas_Deva: "kas_Deva";
+        mai_Deva: "mai_Deva";
+        mal_Mlym: "mal_Mlym";
+        mar_Deva: "mar_Deva";
+        mni_Beng: "mni_Beng";
+        mni_Mtei: "mni_Mtei";
+        npi_Deva: "npi_Deva";
+        ory_Orya: "ory_Orya";
+        pan_Guru: "pan_Guru";
+        san_Deva: "san_Deva";
+        sat_Olck: "sat_Olck";
+        snd_Arab: "snd_Arab";
+        snd_Deva: "snd_Deva";
+        tam_Taml: "tam_Taml";
+        tel_Telu: "tel_Telu";
+        urd_Arab: "urd_Arab";
+    }>;
+    beamsize: z.ZodOptional<z.ZodNumber>;
+    lengthpenalty: z.ZodOptional<z.ZodNumber>;
+    maxlength: z.ZodOptional<z.ZodNumber>;
+    repetitionpenalty: z.ZodOptional<z.ZodNumber>;
+    norepeatngramsize: z.ZodOptional<z.ZodNumber>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    topk: z.ZodOptional<z.ZodNumber>;
+    topp: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
 export declare const nmtConfigSchema: z.ZodPipe<z.ZodObject<{
     mode: z.ZodOptional<z.ZodEnum<{
         full: "full";

package/dist/schemas/translation-config.js

@@ -34,8 +34,7 @@ export const NMT_LANGUAGES = [
     ...MARIAN_LANGUAGES,
     ...INDICTRANS_LANGUAGES,
 ];
-export const nmtConfigSchema = z
-    .object({
+export const nmtConfigBaseSchema = z.object({
     mode: z.enum(["full"]).optional(),
     from: z.enum(NMT_LANGUAGES),
     to: z.enum(NMT_LANGUAGES),
@@ -48,8 +47,8 @@ export const nmtConfigSchema = z
     temperature: z.number().optional(),
     topk: z.number().optional(),
     topp: z.number().optional(),
-})
-    .transform((data) => ({
+});
+export const nmtConfigSchema = nmtConfigBaseSchema.transform((data) => ({
     ...data,
     mode: data.mode ?? "full",
     beamsize: data.beamsize ?? 4,

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

@@ -1,4 +1,9 @@
 import { z } from "zod";
+export declare const audioFormatSchema: z.ZodEnum<{
+    f32le: "f32le";
+    s16le: "s16le";
+}>;
+export type AudioFormat = z.infer<typeof audioFormatSchema>;
 export declare const whisperConfigSchema: z.ZodObject<{
     strategy: z.ZodOptional<z.ZodEnum<{
         greedy: "greedy";
@@ -47,7 +52,10 @@ export declare const whisperConfigSchema: z.ZodObject<{
         speech_pad_ms: z.ZodOptional<z.ZodNumber>;
         samples_overlap: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
-    audio_format: z.ZodOptional<z.ZodString>;
+    audio_format: z.ZodOptional<z.ZodEnum<{
+        f32le: "f32le";
+        s16le: "s16le";
+    }>>;
     contextParams: z.ZodOptional<z.ZodObject<{
         model: z.ZodOptional<z.ZodString>;
         use_gpu: z.ZodOptional<z.ZodBoolean>;

package/dist/schemas/whispercpp-config.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+export const audioFormatSchema = z.enum(["f32le", "s16le"]);
 const vadParamsSchema = z
     .object({
     threshold: z.number().optional(),
@@ -60,7 +61,7 @@ export const whisperConfigSchema = z.object({
     beam_search_beam_size: z.number().int().optional(),
     vad_model_path: z.string().optional(),
     vad_params: vadParamsSchema,
-    audio_format: z.string().optional(),
+    audio_format: audioFormatSchema.optional(),
     contextParams: contextParamsSchema,
     miscConfig: miscConfigSchema,
 });

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

@@ -1,6 +1,7 @@
 import LlmLlamacpp from "@qvac/llm-llamacpp";
 import EmbedLlamacpp from "@qvac/embed-llamacpp";
-import { createStreamLogger } from "../../../../logging/index.js";
+import os from "bare-os";
+import { ADDON_NAMESPACES, registerAddonLogger, createStreamLogger, } from "../../../../logging/index.js";
 import { parseModelPath } from "../../../utils/index.js";
 import FilesystemDL from "@qvac/dl-filesystem";
 function transformLlmConfig(llmConfig) {
@@ -23,7 +24,8 @@ function transformLlmConfig(llmConfig) {
 export function createLlmModel(modelId, modelPath, llmConfig, projectionModelPath) {
     const { dirPath, basePath } = parseModelPath(modelPath);
     const loader = new FilesystemDL({ dirPath });
-    const logger = createStreamLogger(modelId, "llamacpp:llm");
+    const logger = createStreamLogger(modelId, ADDON_NAMESPACES.LLAMACPP_LLM);
+    registerAddonLogger(modelId, ADDON_NAMESPACES.LLAMACPP_LLM, logger);
     const llmConfigStrings = transformLlmConfig(llmConfig);
     const args = {
         loader,
@@ -43,7 +45,14 @@ export function createLlmModel(modelId, modelPath, llmConfig, projectionModelPat
 export function createEmbeddingsModel(modelId, modelPath, embedConfig) {
     const { dirPath, basePath } = parseModelPath(modelPath);
     const loader = new FilesystemDL({ dirPath });
-    const logger = createStreamLogger(modelId, "llamacpp:embed");
+    const logger = createStreamLogger(modelId, ADDON_NAMESPACES.LLAMACPP_EMBED);
+    registerAddonLogger(modelId, ADDON_NAMESPACES.LLAMACPP_EMBED, logger);
+    let config = embedConfig.config;
+    const platform = os.platform();
+    if (platform === "android") {
+        // On Android, disable flash attention to prevent crashes
+        config = `${config}\n-fa\toff`;
+    }
     const args = {
         loader,
         opts: { stats: true },
@@ -52,6 +61,6 @@ export function createEmbeddingsModel(modelId, modelPath, embedConfig) {
         modelName: basePath,
         modelPath,
     };
-    const model = new EmbedLlamacpp(args, embedConfig.config);
+    const model = new EmbedLlamacpp(args, config);
     return { model, loader };
 }

package/dist/server/bare/addons/llamacpp/handlers/embed.d.ts

@@ -1,4 +1,12 @@
 import { type EmbedParams } from "../../../../../schemas/index";
-export declare function embed(params: EmbedParams): Promise<number[]>;
+export declare function embed(params: {
+    modelId: string;
+    text: string;
+}): Promise<number[]>;
+export declare function embed(params: {
+    modelId: string;
+    text: string[];
+}): Promise<number[][]>;
+export declare function embed(params: EmbedParams): Promise<number[] | number[][]>;
 export declare function normalizeVector(vector: Float32Array): number[];
 //# sourceMappingURL=embed.d.ts.map

package/dist/server/bare/addons/llamacpp/handlers/embed.js

@@ -6,11 +6,25 @@ export async function embed(params) {
     const model = getModel(modelId);
     const response = await model.run(text);
     const rawEmbeddings = (await response.await());
-    const embeddingVector = rawEmbeddings?.[0]?.[0];
-    if (!embeddingVector || embeddingVector.length === 0) {
-        throw new EmbedNoEmbeddingsError();
+    const embeddingsArray = rawEmbeddings[0];
+    if (Array.isArray(text)) {
+        if (!embeddingsArray || embeddingsArray.length === 0) {
+            throw new EmbedNoEmbeddingsError();
+        }
+        return embeddingsArray.map((embeddingVector) => {
+            if (!embeddingVector || embeddingVector.length === 0) {
+                throw new EmbedNoEmbeddingsError();
+            }
+            return normalizeVector(embeddingVector);
+        });
+    }
+    else {
+        const embeddingVector = embeddingsArray?.[0];
+        if (!embeddingVector || embeddingVector.length === 0) {
+            throw new EmbedNoEmbeddingsError();
+        }
+        return normalizeVector(embeddingVector);
     }
-    return normalizeVector(embeddingVector);
 }
 export function normalizeVector(vector) {
     let sumOfSquares = 0;

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

@@ -2,6 +2,8 @@ import crypto from "bare-crypto";
 import { promises as fsPromises } from "bare-fs";
 import path from "bare-path";
 import { getKVCacheDir } from "../../../utils/index.js";
+import { getServerLogger } from "../../../../logging/index.js";
+const logger = getServerLogger();
 export function extractSystemPrompt(messages) {
     const systemMessage = messages.find((msg) => msg.role === "system");
     return systemMessage ? systemMessage.content : null;
@@ -66,7 +68,7 @@ export async function renameCacheFile(oldPath, newPath) {
         await fsPromises.rename(oldPath, newPath);
     }
     catch (error) {
-        console.error("Error renaming cache file:", error instanceof Error ? error.message : String(error));
+        logger.error("Error renaming cache file:", error instanceof Error ? error.message : String(error));
     }
 }
 export async function customCacheExists(modelId, configHash, cacheKey) {
@@ -87,7 +89,7 @@ export async function deleteCache(options) {
             await fsPromises.mkdir(cacheDir, { recursive: true });
         }
         catch (error) {
-            console.error("Error deleting all caches:", error instanceof Error ? error.message : String(error));
+            logger.error("Error deleting all caches:", error instanceof Error ? error.message : String(error));
         }
     }
     else if ("kvCacheKey" in options) {
@@ -98,7 +100,7 @@ export async function deleteCache(options) {
                 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));
+                logger.error(`Error deleting model cache ${options.kvCacheKey}/${options.modelId}:`, error instanceof Error ? error.message : String(error));
             }
         }
         else {
@@ -106,7 +108,7 @@ export async function deleteCache(options) {
                 await fsPromises.rm(kvCacheDir, { recursive: true });
             }
             catch (error) {
-                console.error(`Error deleting cache ${options.kvCacheKey}:`, error instanceof Error ? error.message : String(error));
+                logger.error(`Error deleting cache ${options.kvCacheKey}:`, error instanceof Error ? error.message : String(error));
             }
         }
     }

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

@@ -4,16 +4,19 @@ import { createNmtModel } from "./translation/index.js";
 import { createTtsModel } from "./tts/index.js";
 import { createWhisperModel } from "./whispercpp/index.js";
 import { isModelLoaded, registerModel, } from "../registry/model-registry.js";
+import { startLogBuffering, stopLogBufferingWithTimeout, } from "../registry/logging-stream-registry.js";
 import { detectShardedModel, generateShardFilenames } from "../../utils/index.js";
 import { ESpeakDataPathRequiredError, UnknownModelTypeError, ModelFileNotFoundError, ModelFileNotFoundInDirError, ModelFileLocateFailedError, } from "../../../utils/errors-server.js";
 import { promises as fsPromises } from "bare-fs";
 import path from "bare-path";
+import { getServerLogger } from "../../../logging/index.js";
+const logger = getServerLogger();
 export async function loadModel(params) {
     const { modelId, modelPath, options, projectionModelPath, vadModelPath, ttsConfigModelPath, eSpeakDataPath, modelName, } = loadModelServerParamsSchema.parse(params);
     const { modelConfig, modelType } = options;
     // Check if model is already loaded
     if (isModelLoaded(modelId)) {
-        console.log(`${modelType} model ${modelId} is already loaded`);
+        logger.info(`${modelType} model ${modelId} is already loaded`);
         return;
     }
     // Detect if sharded model
@@ -45,7 +48,7 @@ export async function loadModel(params) {
             }
         }
         catch (error) {
-            console.error(`Error reading ${modelType} model directory:`, error instanceof Error ? error.message : String(error));
+            logger.error(`Error reading ${modelType} model directory:`, error instanceof Error ? error.message : String(error));
             throw new ModelFileLocateFailedError(modelType, modelPath, error);
         }
     }
@@ -73,13 +76,16 @@ export async function loadModel(params) {
             // Should never happen
             throw new UnknownModelTypeError(modelType);
     }
-    console.log(`${modelType}: Loading model ${modelId}...`);
+    logger.info(`${modelType}: Loading model ${modelId}...`);
+    startLogBuffering(modelId);
     await result.model.load(false);
-    console.log(`${modelType} model ${modelId} loaded`);
+    logger.info(`${modelType} model ${modelId} loaded`);
+    stopLogBufferingWithTimeout(modelId);
     registerModel(modelId, {
         model: result.model,
         path: modelPath,
         config: modelConfig,
+        modelType,
         name: modelName,
         loader: result.loader,
     });

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

@@ -2,9 +2,11 @@ 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 { unregisterAddonLogger, getServerLogger } from "../../../logging/index.js";
 import { unloadModelParamsSchema } from "../../../schemas/index.js";
 import { ModelNotLoadedError } from "../../../utils/errors-server.js";
 import { detectShardedModel } from "../../utils/index.js";
+const logger = getServerLogger();
 export async function unloadModel(params) {
     const { modelId, clearStorage } = unloadModelParamsSchema.parse(params);
     const entry = unregisterModel(modelId);
@@ -25,14 +27,15 @@ export async function unloadModel(params) {
             // Delete entire shard directory
             const shardDir = path.dirname(modelPath);
             await fsPromises.rm(shardDir, { recursive: true, force: true });
-            console.log(`Sharded model storage cleared: ${shardDir}`);
+            logger.info(`Sharded model storage cleared: ${shardDir}`);
         }
         else {
             // Delete single file
             await fsPromises.rm(modelPath, { recursive: true, force: true });
-            console.log(`Model storage cleared: ${modelPath}`);
+            logger.info(`Model storage cleared: ${modelPath}`);
         }
     }
+    unregisterAddonLogger(modelId);
     unregisterAllLoggingStreams(modelId);
-    console.log(`Model ${modelId} unloaded`);
+    logger.info(`Model ${modelId} unloaded`);
 }

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

@@ -1,15 +1,20 @@
-import { getModel, getModelConfig, updateModelConfig, } from "../../../registry/model-registry.js";
+import { getModel, getModelConfig, } 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";
 import { AudioFileNotFoundError, InvalidAudioChunkError, } from "../../../../../utils/errors-server.js";
+import { getServerLogger } from "../../../../../logging/index.js";
+const logger = getServerLogger();
 export async function* transcribe(params) {
     const model = getModel(params.modelId);
+    const modelConfig = getModelConfig(params.modelId);
+    let originalConfig = null;
+    const audioFormat = modelConfig.audio_format || "s16le";
     if (params.prompt && typeof model.reload === "function") {
-        const existingConfig = getModelConfig(params.modelId);
+        originalConfig = modelConfig;
         const updatedConfig = {
-            ...existingConfig,
+            ...originalConfig,
             initial_prompt: params.prompt,
         };
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -18,46 +23,60 @@ export async function* transcribe(params) {
             whisperConfig: whisperParams,
             ...(miscConfig && { miscConfig }),
         });
-        updateModelConfig(params.modelId, updatedConfig);
     }
-    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 (error) {
-                throw new AudioFileNotFoundError(filePath, error);
+    try {
+        let audioStream;
+        const audioChunk = params.audioChunk;
+        switch (audioChunk.type) {
+            case "base64": {
+                const audioBuffer = Buffer.from(audioChunk.value, "base64");
+                audioStream = Readable.from([audioBuffer]);
+                break;
             }
-            if (needsDecoding(filePath)) {
-                audioStream = await decodeAudioToStream(filePath);
+            case "filePath": {
+                const filePath = audioChunk.value;
+                try {
+                    fs.accessSync(filePath);
+                }
+                catch (error) {
+                    throw new AudioFileNotFoundError(filePath, error);
+                }
+                if (needsDecoding(filePath)) {
+                    audioStream = await decodeAudioToStream(filePath, audioFormat);
+                }
+                else {
+                    audioStream = fs.createReadStream(filePath);
+                }
+                break;
             }
-            else {
-                audioStream = fs.createReadStream(filePath);
+            default:
+                throw new InvalidAudioChunkError();
+        }
+        // Run transcription with streaming enabled
+        const response = await model.run(audioStream);
+        for await (const output of response.iterate()) {
+            logger.debug("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;
             }
-            break;
         }
-        default:
-            throw new InvalidAudioChunkError();
     }
-    // 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;
+    finally {
+        if (originalConfig && typeof model.reload === "function") {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const { contextParams: _, miscConfig, ...whisperParams } = originalConfig;
+            await model.reload({
+                whisperConfig: {
+                    ...whisperParams,
+                    initial_prompt: "",
+                },
+                ...(miscConfig && { miscConfig }),
+            });
         }
     }
 }

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

@@ -2,6 +2,8 @@ import { getSwarm } from "./hyperswarm.js";
 import RPC from "bare-rpc";
 import { withTimeout } from "../../utils/withTimeout.js";
 import { DelegateConnectionFailedError } from "../../utils/errors-server.js";
+import { getServerLogger } from "../../logging/index.js";
+const logger = getServerLogger();
 // Map of active RPC instances by public key
 const activeRPCs = new Map();
 // Establish RPC connection to a peer if not already connected
@@ -12,7 +14,7 @@ async function ensureRPCConnection(topic, publicKey, timeout) {
     if (!rpc) {
         // Need to establish connection first
         try {
-            console.log(`🔗 Establishing RPC connection to topic: ${topic}, peer: ${publicKey}, timeout: ${timeout}ms`);
+            logger.info(`🔗 Establishing RPC connection to topic: ${topic}, peer: ${publicKey}, timeout: ${timeout}ms`);
             const connectionPromise = (async () => {
                 const topicBuffer = Buffer.from(topic, "hex");
                 // const discovery =
@@ -21,23 +23,23 @@ async function ensureRPCConnection(topic, publicKey, timeout) {
                     client: true,
                 });
                 await swarm.flush();
-                console.log(`✅ Connected to topic: ${topic}`);
-                console.log(`📊 Active RPC connections: ${activeRPCs.size}`);
+                logger.info(`✅ Connected to topic: ${topic}`);
+                logger.debug(`📊 Active RPC connections: ${activeRPCs.size}`);
                 // Check again if we now have an RPC instance for the target peer
                 rpc = activeRPCs.get(publicKey);
                 if (!rpc) {
-                    console.error(`❌ No RPC instance found for peer ${publicKey}`);
-                    console.log(`📊 Available RPC connections:`, Array.from(activeRPCs.keys()));
+                    logger.error(`❌ No RPC instance found for peer ${publicKey}`);
+                    logger.debug(`📊 Available RPC connections:`, Array.from(activeRPCs.keys()));
                     throw new DelegateConnectionFailedError(`Could not establish RPC connection to peer ${publicKey} on topic ${topic}`);
                 }
                 else {
-                    console.log(`✅ RPC instance found for peer ${publicKey}`);
+                    logger.debug(`✅ RPC instance found for peer ${publicKey}`);
                 }
             })();
             await withTimeout(connectionPromise, timeout);
         }
         catch (error) {
-            console.error("Failed to establish RPC connection:", error);
+            logger.error("Failed to establish RPC connection:", error);
             throw new DelegateConnectionFailedError(`RPC connection failed: ${error instanceof Error ? error.message : String(error)}`, error);
         }
     }
@@ -51,7 +53,7 @@ export async function getRPC(topic, publicKey, options = {}) {
         const peerPubkey = conn.remotePublicKey?.toString("hex");
         if (!peerPubkey)
             return;
-        console.log(`🍺 New peer connection established: ${peerPubkey}`);
+        logger.debug(`🍺 New peer connection established: ${peerPubkey}`);
         // Create RPC instance for this connection (as client)
         const rpc = new RPC(conn, () => {
             // No-op handler since we're only sending requests, not receiving them
@@ -59,11 +61,11 @@ export async function getRPC(topic, publicKey, options = {}) {
         // Store RPC instance by peer ID for lookup
         activeRPCs.set(peerPubkey, rpc);
         conn.on("close", () => {
-            console.log(`Connection closed for peer: ${peerPubkey}`);
+            logger.debug(`Connection closed for peer: ${peerPubkey}`);
             activeRPCs.delete(peerPubkey);
         });
         conn.on("error", (err) => {
-            console.error(`Connection error for peer ${peerPubkey}:`, err);
+            logger.error(`Connection error for peer ${peerPubkey}:`, err);
             activeRPCs.delete(peerPubkey);
         });
     });