@qvac/sdk 0.4.1 → 0.5.0

package/dist/server/rpc/handlers/provideHandler/handler.js

@@ -1,51 +1,53 @@
 import { getSwarm, registerProviderTopic } from "../../../bare/hyperswarm.js";
 import { setupConnectionHandlers } from "./connection.js";
+import { getServerLogger } from "../../../../logging/index.js";
+const logger = getServerLogger();
 export async function provideHandler(request) {
     const swarm = getSwarm({
         firewallConfig: request.firewall,
     });
-    console.log("🚀 Provide request received:", request);
-    console.log("🔍 Swarm keyPair exists:", !!swarm.keyPair);
-    console.log("🔍 Swarm publicKey:", swarm.keyPair?.publicKey?.toString("hex")?.substring(0, 16));
+    logger.debug("🚀 Provide request received:", request);
+    logger.debug("🔍 Swarm keyPair exists:", !!swarm.keyPair);
+    logger.debug("🔍 Swarm publicKey:", swarm.keyPair?.publicKey?.toString("hex")?.substring(0, 16));
     try {
-        console.log("⚡ Starting provide handler execution");
+        logger.debug("⚡ Starting provide handler execution");
         const pubKey = swarm.keyPair.publicKey;
-        console.log("🔑 Got public key:", pubKey.toString("hex"));
+        logger.debug("🔑 Got public key:", pubKey.toString("hex"));
         // Use provided topic from hex string
         const topic = Buffer.from(request.topic, "hex");
         // Join topic as server (provider)
-        console.log("🌐 Joining topic as server...");
+        logger.info("🌐 Joining topic as server...");
         const discovery = swarm.join(topic, { server: true, client: false });
-        console.log("📡 Discovery object created:", !!discovery);
+        logger.debug("📡 Discovery object created:", !!discovery);
         // Wait for the topic to be fully announced on the DHT
-        console.log("⏳ Waiting for topic announcement...");
+        logger.debug("⏳ Waiting for topic announcement...");
         await discovery.flushed();
-        console.log(`✅ Topic announced: ${topic.toString("hex")}`);
+        logger.info(`✅ Topic announced: ${topic.toString("hex")}`);
         // Wait for connections
-        console.log("⏳ Waiting for swarm flush...");
+        logger.debug("⏳ Waiting for swarm flush...");
         await swarm.flush();
-        console.log(`🎯 Ready to accept connections on topic: ${topic.toString("hex").substring(0, 16)}...`);
+        logger.info(`🎯 Ready to accept connections on topic: ${topic.toString("hex").substring(0, 16)}...`);
         // Handle incoming connections
         setupConnectionHandlers(swarm);
         registerProviderTopic(topic.toString("hex"));
-        console.log("🏁 About to return success response...");
+        logger.debug("🏁 About to return success response...");
         const response = {
             type: "provide",
             success: true,
             publicKey: pubKey.toString("hex"),
         };
-        console.log("📤 Returning response:", response);
+        logger.debug("📤 Returning response:", response);
         return response;
     }
     catch (error) {
-        console.error("❌ Error in provide handler:", error);
-        console.error("❌ Error stack:", error instanceof Error ? error.stack : "No stack trace");
+        logger.error("❌ Error in provide handler:", error);
+        logger.error("❌ Error stack:", error instanceof Error ? error.stack : "No stack trace");
         const errorResponse = {
             type: "provide",
             success: false,
             error: error instanceof Error ? error.message : "Unknown error",
         };
-        console.log("📤 Returning error response:", errorResponse);
+        logger.debug("📤 Returning error response:", errorResponse);
         return errorResponse;
     }
 }

package/dist/server/rpc/handlers/provideHandler/proxy.js

@@ -1,21 +1,23 @@
 import { handleRequest } from "../../handle-request.js";
+import { getServerLogger } from "../../../../logging/index.js";
+const logger = getServerLogger();
 // Proxies RPC requests to the main handler: handleRequest
 export function createRpcProxy() {
     return async (rpcRequest) => {
-        console.log("📬 RPC request callback triggered!");
-        console.log("📦 Raw RPC request data:", rpcRequest.data?.toString());
+        logger.debug("📬 RPC request callback triggered!");
+        logger.debug("📦 Raw RPC request data:", rpcRequest.data?.toString());
         try {
-            console.log("🚀 Calling handleRequest...");
+            logger.debug("🚀 Calling handleRequest...");
             await handleRequest(rpcRequest);
-            console.log("✅ handleRequest completed successfully");
+            logger.debug("✅ handleRequest completed successfully");
         }
         catch (error) {
-            console.error("❌ Error:", error instanceof Error ? error.message : error);
+            logger.error("❌ Error:", error instanceof Error ? error.message : error);
             const errorResponse = JSON.stringify({
                 type: "error",
                 error: error instanceof Error ? error.message : "Unknown error",
             });
-            console.log("📤 Sending error response:", errorResponse);
+            logger.debug("📤 Sending error response:", errorResponse);
             rpcRequest.reply(errorResponse, "utf-8");
         }
     };

package/dist/server/rpc/handlers/rag.js

@@ -1,4 +1,6 @@
 import { saveEmbeddings, search, deleteEmbeddings, } from "../../bare/rag-hyperdb/index.js";
+import { getServerLogger } from "../../../logging/index.js";
+const logger = getServerLogger();
 export async function handleRag(request) {
     try {
         switch (request.operation) {
@@ -32,7 +34,7 @@ export async function handleRag(request) {
         }
     }
     catch (error) {
-        console.error("Error in RAG handler:", error);
+        logger.error("Error in RAG handler:", error);
         const baseError = {
             type: "rag",
             success: false,

package/dist/server/rpc/handlers/stopProvideHandler.js

@@ -1,4 +1,6 @@
 import { getSwarm, unregisterProviderTopic } from "../../bare/hyperswarm.js";
+import { getServerLogger } from "../../../logging/index.js";
+const logger = getServerLogger();
 export function stopProvideHandler(request) {
     const swarm = getSwarm();
     try {
@@ -12,7 +14,7 @@ export function stopProvideHandler(request) {
         };
     }
     catch (error) {
-        console.error("❌ Error in stop provide handler:", error);
+        logger.error("❌ Error in stop provide handler:", error);
         return {
             type: "stopProvide",
             success: false,

package/dist/server/rpc/handlers/transcribe-stream.js

@@ -1,4 +1,6 @@
 import { transcribeStream } from "../../bare/addons/whispercpp/index.js";
+import { getServerLogger } from "../../../logging/index.js";
+const logger = getServerLogger();
 export async function* handleTranscribeStream(request) {
     const { modelId, audioChunk, prompt } = request;
     try {
@@ -20,7 +22,7 @@ export async function* handleTranscribeStream(request) {
         };
     }
     catch (error) {
-        console.error("Error during transcription:", error);
+        logger.error("Error during transcription:", error);
         yield {
             type: "transcribeStream",
             text: "",

package/dist/server/rpc/handlers/translate.js

@@ -1,4 +1,6 @@
 import { translate } from "../../bare/addons/translation/index.js";
+import { getServerLogger } from "../../../logging/index.js";
+const logger = getServerLogger();
 export async function* handleTranslate(request) {
     const { modelId, text, stream, modelType } = request;
     const from = request.modelType === "llm" ? request.from : undefined;
@@ -41,7 +43,7 @@ export async function* handleTranslate(request) {
         };
     }
     catch (error) {
-        console.error("Error during translation:", error);
+        logger.error("Error during translation:", error);
         yield {
             type: "translate",
             token: "",

package/dist/server/rpc/handlers/unload-model.js

@@ -1,10 +1,12 @@
 import { unloadModel } from "../../bare/addons/index.js";
 import { getRegistryStats } from "../../bare/registry/model-registry.js";
 import { hasActiveProviders } from "../../bare/hyperswarm.js";
+import { getServerLogger } from "../../../logging/index.js";
+const logger = getServerLogger();
 export async function handleUnloadModel(request) {
     const { modelId, clearStorage } = request;
     try {
-        console.log("Unloading model", modelId);
+        logger.debug("Unloading model", modelId);
         await unloadModel({ modelId, clearStorage });
         const stats = getRegistryStats();
         const modelsActive = stats.totalModels > 0;
@@ -17,7 +19,7 @@ export async function handleUnloadModel(request) {
         };
     }
     catch (error) {
-        console.error("Error during model unload:", error);
+        logger.error("Error during model unload:", error);
         return {
             type: "unloadModel",
             success: false,

package/dist/server/utils/audio/decoder.d.ts

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

package/dist/server/utils/audio/decoder.js

@@ -1,17 +1,20 @@
 import fs from "bare-fs";
 import path from "bare-path";
-import GSTDecoder from "@qvac/decoder-audio";
+import { FFmpegDecoder } from "@qvac/decoder-audio";
 import { FORMATS_NEEDING_DECODE } from "@qvac/decoder-audio/constants.js";
 import { Readable } from "bare-stream";
+import { getServerLogger } from "../../../logging/index.js";
+import {} from "../../../schemas/index.js";
+const logger = getServerLogger();
 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",
-        },
+const DECODER_TIMEOUT_MS = 10000;
+export async function decodeAudioToStream(inputPath, audioFormat = "s16le") {
+    const decoder = new FFmpegDecoder({
+        config: { audioFormat },
+        logger,
     });
     try {
         await decoder.load();
@@ -20,22 +23,56 @@ export async function decodeAudioToStream(inputPath) {
         const outputStream = new Readable({
             read() { },
         });
+        let hasReceivedData = false;
+        let hasEnded = false;
+        // Fallback timeout in case the decoder hangs without emitting any events
+        const timeoutId = setTimeout(() => {
+            if (!hasEnded) {
+                hasEnded = true;
+                const timeoutError = new Error(`Audio decoding timed out after ${DECODER_TIMEOUT_MS}ms for file: ${inputPath}`);
+                outputStream.destroy(timeoutError);
+            }
+        }, DECODER_TIMEOUT_MS);
         response
             .onUpdate((output) => {
+            hasReceivedData = true;
             const bytes = new Uint8Array(output.outputArray);
             outputStream.push(Buffer.from(bytes));
         })
             .onFinish(() => {
-            outputStream.push(null);
+            if (!hasEnded) {
+                hasEnded = true;
+                clearTimeout(timeoutId);
+                setImmediate(() => void decoder.unload());
+                if (!hasReceivedData) {
+                    outputStream.destroy(new Error(`No audio data decoded from file: ${inputPath}`));
+                }
+                else {
+                    outputStream.push(null);
+                }
+            }
         })
-            .await()
-            .catch((error) => {
-            outputStream.destroy(error instanceof Error ? error : new Error(String(error)));
+            .onError((errorMessage) => {
+            if (!hasEnded) {
+                hasEnded = true;
+                clearTimeout(timeoutId);
+                setImmediate(() => void decoder.unload());
+                outputStream.destroy(new Error(errorMessage));
+            }
+        });
+        response.await().catch((error) => {
+            if (!hasEnded) {
+                hasEnded = true;
+                clearTimeout(timeoutId);
+                setImmediate(() => void decoder.unload());
+                outputStream.destroy(error instanceof Error ? error : new Error(String(error)));
+            }
         });
         return outputStream;
     }
     catch (error) {
-        console.error("Decoding failed:", error instanceof Error ? error.message : String(error));
+        await decoder.unload();
+        logger.error("Decoding failed:", error instanceof Error ? error.message : String(error));
         throw error;
     }
 }

package/dist/server/utils/cache.js

@@ -3,6 +3,8 @@ import path from "bare-path";
 import { getEnv } from "../worker.js";
 import { getConfiguredCacheDir } from "../bare/registry/config-registry.js";
 import { calculateFileChecksum } from "./checksum.js";
+import { getServerLogger } from "../../logging/index.js";
+const logger = getServerLogger();
 export const getCacheDir = (subDir) => {
     const homeDir = getEnv().HOME_DIR;
     const cacheDir = path.join(homeDir, ".qvac", subDir);
@@ -10,7 +12,7 @@ export const getCacheDir = (subDir) => {
         fs.mkdirSync(cacheDir, { recursive: true });
     }
     catch (error) {
-        console.error(`Error creating cache directory (${subDir}):`, error instanceof Error ? error.message : String(error));
+        logger.error(`Error creating cache directory (${subDir}):`, error instanceof Error ? error.message : String(error));
     }
     return cacheDir;
 };
@@ -20,7 +22,7 @@ export const getModelsCacheDir = () => {
         fs.mkdirSync(configuredDir, { recursive: true });
     }
     catch (error) {
-        console.error(`Error creating models cache directory:`, error instanceof Error ? error.message : String(error));
+        logger.error(`Error creating models cache directory:`, error instanceof Error ? error.message : String(error));
     }
     return configuredDir;
 };
@@ -38,7 +40,7 @@ export function getShardedModelCacheDir(hyperdriveKey) {
         fs.mkdirSync(shardDir, { recursive: true });
     }
     catch (error) {
-        console.error(`Error creating sharded model cache directory:`, error instanceof Error ? error.message : String(error));
+        logger.error(`Error creating sharded model cache directory:`, error instanceof Error ? error.message : String(error));
     }
     return shardDir;
 }
@@ -66,14 +68,14 @@ export async function checkShardCompleteness(hyperdriveKey, shardFilenames, shar
         try {
             const stats = await fsPromises.stat(shardPath);
             if (stats.size !== fileMeta.expectedSize) {
-                console.warn(`File ${i + 1} size mismatch: expected ${fileMeta.expectedSize}, got ${stats.size}`);
+                logger.warn(`File ${i + 1} size mismatch: expected ${fileMeta.expectedSize}, got ${stats.size}`);
                 invalidIndices.push(i);
                 continue;
             }
             if (fileMeta.sha256Checksum) {
                 const actualChecksum = await calculateFileChecksum(shardPath);
                 if (actualChecksum !== fileMeta.sha256Checksum) {
-                    console.warn(`File ${i + 1} checksum mismatch for ${fileMeta.filename}. Expected: ${fileMeta.sha256Checksum}. Actual: ${actualChecksum}. Will re-download.`);
+                    logger.warn(`File ${i + 1} checksum mismatch for ${fileMeta.filename}. Expected: ${fileMeta.sha256Checksum}. Actual: ${actualChecksum}. Will re-download.`);
                     invalidIndices.push(i);
                 }
             }

package/dist/server/utils/config-transform.d.ts

@@ -0,0 +1,3 @@
+import type { ModelType } from "../../schemas/index";
+export declare function transformConfigForReload(modelType: ModelType, config: unknown): unknown;
+//# sourceMappingURL=config-transform.d.ts.map

package/dist/server/utils/config-transform.js

@@ -0,0 +1,21 @@
+export function transformConfigForReload(modelType, config) {
+    switch (modelType) {
+        case "whisper": {
+            const whisperConfig = config;
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const { contextParams, miscConfig, ...whisperParams } = whisperConfig;
+            return {
+                whisperConfig: whisperParams,
+                ...(miscConfig && { miscConfig }),
+            };
+        }
+        case "llm":
+        case "embeddings":
+        case "nmt":
+        case "tts":
+            // Return as-is for now
+            return config;
+        default:
+            return config;
+    }
+}

package/dist/server/utils/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./audio/decoder";
 export * from "./cache";
 export * from "./checksum";
+export * from "./config-transform";
 export * from "./hash";
 export * from "./model-path";
 export * from "./shard-utils";

package/dist/server/utils/index.js

@@ -1,6 +1,7 @@
 export * from "./audio/decoder.js";
 export * from "./cache.js";
 export * from "./checksum.js";
+export * from "./config-transform.js";
 export * from "./hash.js";
 export * from "./model-path.js";
 export * from "./shard-utils.js";

package/dist/server/worker.js

@@ -5,9 +5,24 @@ import { destroySwarm } from "./bare/hyperswarm.js";
 import { closeAllRagInstances } from "./bare/rag-hyperdb/rag-manager.js";
 import { cleanupDownloads } from "./rpc/handlers/load-model/download-manager.js";
 import { unloadAllModels } from "./bare/registry/model-registry.js";
-import { clearAllLoggingStreams } from "./bare/registry/logging-stream-registry.js";
-console.log("🐻 Hello from Bare");
-console.log("Arguments to worker:", process.argv);
+import { clearAllLoggingStreams, startLogBuffering, } from "./bare/registry/logging-stream-registry.js";
+import { ADDON_NAMESPACES, createAddonLoggerCallback, clearAllAddonLoggers, getServerLogger, SDK_LOG_ID, } from "../logging/index.js";
+import llmAddonLogging from "@qvac/llm-llamacpp/addonLogging.js";
+import embedAddonLogging from "@qvac/embed-llamacpp/addonLogging.js";
+import ttsAddonLogging from "@qvac/tts-onnx/addonLogging.js";
+import whisperAddonLogging from "@qvac/transcription-whispercpp/addonLogging.js";
+import nmtAddonLogging from "@qvac/translation-nmtcpp/addonLogging.js";
+// Buffer SDK logs from startup so clients can receive them when they subscribe
+startLogBuffering(SDK_LOG_ID);
+const logger = getServerLogger();
+logger.info("🐻 Hello from Bare");
+logger.debug("Arguments to worker:", process.argv);
+// Initialize addon logger callbacks
+llmAddonLogging.setLogger(createAddonLoggerCallback(ADDON_NAMESPACES.LLAMACPP_LLM));
+embedAddonLogging.setLogger(createAddonLoggerCallback(ADDON_NAMESPACES.LLAMACPP_EMBED));
+ttsAddonLogging.setLogger(createAddonLoggerCallback(ADDON_NAMESPACES.TTS));
+whisperAddonLogging.setLogger(createAddonLoggerCallback(ADDON_NAMESPACES.WHISPERCPP));
+nmtAddonLogging.setLogger(createAddonLoggerCallback(ADDON_NAMESPACES.NMTCPP));
 const defaultHomeDir = process.env["HOME"] || process.env["USERPROFILE"] || "/tmp";
 let envConfig = { HOME_DIR: defaultHomeDir };
 let hasRPCConfig = false;
@@ -17,11 +32,11 @@ if (process.argv[2]) {
         const rpcArgs = JSON.parse(process.argv[2]);
         envConfig = { ...envConfig, ...rpcArgs };
         hasRPCConfig = true;
-        console.log("Parsed RPC configuration from arguments");
+        logger.info("Parsed RPC configuration from arguments");
     }
     catch {
         // Not JSON or invalid - use defaults (direct mode)
-        console.log("Using default configuration (direct mode)");
+        logger.info("Using default configuration (direct mode)");
     }
 }
 const validatedEnv = z
@@ -43,22 +58,22 @@ export function ensureRPCSetup() {
     try {
         const ipcSocketPath = validatedEnv.QVAC_IPC_SOCKET_PATH;
         if (ipcSocketPath) {
-            console.log(`Running in desktop mode, connecting to IPC socket: ${ipcSocketPath}`);
+            logger.info(`Running in desktop mode, connecting to IPC socket: ${ipcSocketPath}`);
             // Connect to the IPC server (Named Pipe or Unix Socket)
             const rpc = createIPCClient(ipcSocketPath);
-            console.log("Desktop IPC client created?", !!rpc);
+            logger.debug("Desktop IPC client created?", !!rpc);
         }
         else {
-            console.log("Running in BareKit IPC mode");
+            logger.info("Running in BareKit IPC mode");
             // Start the standard RPC server with BareKit IPC for mobile
             createBareKitRPCServer();
         }
-        console.log("Bare worker started and listening for RPC requests");
-        console.log("Working directory:", process.cwd());
+        logger.info("Bare worker started and listening for RPC requests");
+        logger.debug("Working directory:", process.cwd());
         rpcInitialized = true;
     }
     catch (error) {
-        console.error("Worker error:", error);
+        logger.error("Worker error:", error);
         process.exit(1);
     }
 }
@@ -67,7 +82,17 @@ if (hasRPCConfig) {
     ensureRPCSetup();
 }
 else {
-    console.log("Running in direct mode - RPC setup will be lazy");
+    logger.info("Running in direct mode - RPC setup will be lazy");
+}
+// Centralized logger cleanup
+function clearLoggers() {
+    clearAllLoggingStreams();
+    clearAllAddonLoggers();
+    llmAddonLogging.releaseLogger();
+    embedAddonLogging.releaseLogger();
+    ttsAddonLogging.releaseLogger();
+    whisperAddonLogging.releaseLogger();
+    nmtAddonLogging.releaseLogger();
 }
 // Centralized cleanup for graceful shutdown
 let isShuttingDown = false;
@@ -75,19 +100,19 @@ const shutdownHandler = async () => {
     if (isShuttingDown)
         return;
     isShuttingDown = true;
-    console.log("🐻 Bare worker shutdown signal received, cleaning up...");
+    logger.info("🐻 Bare worker shutdown signal received, cleaning up...");
     try {
-        clearAllLoggingStreams();
+        clearLoggers();
         await Promise.allSettled([
             destroySwarm(),
             closeAllRagInstances(),
             cleanupDownloads(),
             unloadAllModels(),
         ]);
-        console.log("✅ Cleanup completed successfully");
+        logger.info("✅ Cleanup completed successfully");
     }
     catch (error) {
-        console.error("❌ Error during shutdown cleanup:", error);
+        logger.error("❌ Error during shutdown cleanup:", error);
     }
     process.exit(0);
 };

package/dist/utils/errors-client.d.ts

@@ -56,6 +56,18 @@ export declare class SDKNotFoundInNodeModulesError extends QvacErrorBase {
 export declare class WorkerFileNotFoundError extends QvacErrorBase {
     constructor(workerPath: string, cause?: unknown);
 }
+export declare class ConfigFileNotFoundError extends QvacErrorBase {
+    constructor(searchPaths: string, cause?: unknown);
+}
+export declare class ConfigFileInvalidError extends QvacErrorBase {
+    constructor(filePath: string, reason: string, cause?: unknown);
+}
+export declare class ConfigFileParseFailedError extends QvacErrorBase {
+    constructor(filePath: string, error: string, cause?: unknown);
+}
+export declare class ConfigValidationFailedError extends QvacErrorBase {
+    constructor(errors: string, cause?: unknown);
+}
 export declare class ModelUnloadFailedError extends QvacErrorBase {
     constructor(modelId?: string, cause?: unknown);
 }

package/dist/utils/errors-client.js

@@ -100,6 +100,26 @@ export class WorkerFileNotFoundError extends QvacErrorBase {
         super(createErrorOptions(SDK_CLIENT_ERROR_CODES.WORKER_FILE_NOT_FOUND, [workerPath], cause));
     }
 }
+export class ConfigFileNotFoundError extends QvacErrorBase {
+    constructor(searchPaths, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.CONFIG_FILE_NOT_FOUND, [searchPaths], cause));
+    }
+}
+export class ConfigFileInvalidError extends QvacErrorBase {
+    constructor(filePath, reason, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.CONFIG_FILE_INVALID, [filePath, reason], cause));
+    }
+}
+export class ConfigFileParseFailedError extends QvacErrorBase {
+    constructor(filePath, error, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.CONFIG_FILE_PARSE_FAILED, [filePath, error], cause));
+    }
+}
+export class ConfigValidationFailedError extends QvacErrorBase {
+    constructor(errors, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.CONFIG_VALIDATION_FAILED, [errors], cause));
+    }
+}
 // ============== Operation Errors (Client-side wrappers for server operations) ==============
 // These are used by client API to throw errors based on server responses
 // They reference server error codes but are thrown on client side

package/dist/utils/errors-server.d.ts

@@ -68,6 +68,12 @@ export declare class CancelFailedError extends QvacErrorBase {
 export declare class TextToSpeechFailedError extends QvacErrorBase {
     constructor(details?: string, cause?: unknown);
 }
+export declare class ConfigReloadNotSupportedError extends QvacErrorBase {
+    constructor(modelId: string, cause?: unknown);
+}
+export declare class ModelTypeMismatchError extends QvacErrorBase {
+    constructor(expectedType: string, providedType: string, cause?: unknown);
+}
 export declare class RAGSaveFailedError extends QvacErrorBase {
     constructor(details?: string, cause?: unknown);
 }
@@ -125,6 +131,9 @@ export declare class CacheDirNotAbsoluteError extends QvacErrorBase {
 export declare class CacheDirNotWritableError extends QvacErrorBase {
     constructor(cacheDir: string, details?: string, cause?: unknown);
 }
+export declare class ConfigAlreadySetError extends QvacErrorBase {
+    constructor(cause?: unknown);
+}
 export declare class FFmpegNotAvailableError extends QvacErrorBase {
     constructor(cause?: unknown);
 }

package/dist/utils/errors-server.js

@@ -120,6 +120,16 @@ export class TextToSpeechFailedError extends QvacErrorBase {
         super(createErrorOptions(SDK_SERVER_ERROR_CODES.TEXT_TO_SPEECH_FAILED, details ? [details] : undefined, cause));
     }
 }
+export class ConfigReloadNotSupportedError extends QvacErrorBase {
+    constructor(modelId, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.CONFIG_RELOAD_NOT_SUPPORTED, [modelId], cause));
+    }
+}
+export class ModelTypeMismatchError extends QvacErrorBase {
+    constructor(expectedType, providedType, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.MODEL_TYPE_MISMATCH, [expectedType, providedType], cause));
+    }
+}
 // ============== RAG Operation Errors ==============
 export class RAGSaveFailedError extends QvacErrorBase {
     constructor(details, cause) {
@@ -218,6 +228,12 @@ export class CacheDirNotWritableError extends QvacErrorBase {
         super(createErrorOptions(SDK_SERVER_ERROR_CODES.CACHE_DIR_NOT_WRITABLE, details ? [cacheDir, details] : [cacheDir], cause));
     }
 }
+// ============== Config Operations Errors ==============
+export class ConfigAlreadySetError extends QvacErrorBase {
+    constructor(cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.CONFIG_ALREADY_SET, undefined, cause));
+    }
+}
 // ============== System/Runtime Errors ==============
 export class FFmpegNotAvailableError extends QvacErrorBase {
     constructor(cause) {

package/dist/utils/getProcessSafe.d.ts

@@ -0,0 +1,7 @@
+export declare function getProcessSafe(): Promise<{
+    cwd?: () => string;
+    env?: Record<string, string | undefined>;
+    platform?: string;
+    exit?: (code: number) => void;
+} | undefined>;
+//# sourceMappingURL=getProcessSafe.d.ts.map

package/dist/utils/getProcessSafe.js

@@ -0,0 +1,17 @@
+import { detectRuntime } from "./runtime.js";
+export async function getProcessSafe() {
+    const runtime = detectRuntime();
+    if (runtime === "bare") {
+        try {
+            const bareProcess = await import("bare-process");
+            return bareProcess.default;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (typeof process !== "undefined") {
+        return process;
+    }
+    return undefined;
+}

package/dist/utils/mcp-adapter.d.ts

@@ -0,0 +1,12 @@
+import type { Tool } from "../schemas/tools";
+import type { McpClientInput } from "../schemas/mcp-adapter";
+import type { ToolHandler } from "./tool-helpers";
+export type { McpClient, McpClientInput } from "../schemas/mcp-adapter";
+export type ToolHandlerMap = Map<string, ToolHandler>;
+export type McpToolsResult = {
+    tools: Tool[];
+    handlers: ToolHandlerMap;
+};
+export declare function getMcpToolsWithHandlers(clients: McpClientInput[]): Promise<McpToolsResult>;
+export declare function getMcpTools(clients: McpClientInput[]): Promise<Tool[]>;
+//# sourceMappingURL=mcp-adapter.d.ts.map