@qvac/sdk 0.4.0 → 0.5.0

package/dist/client/api/completion-stream.d.ts

@@ -1,7 +1,8 @@
-import { type CompletionStats, type CompletionClientParams, type ToolCall, type ToolCallEvent, type Tool } from "../../schemas/index";
+import { type CompletionClientParams, type CompletionStats, type McpClientInput, type Tool, type ToolCallEvent, type ToolCallWithCall } from "../../schemas/index";
 import { type ToolInput } from "../../utils/tool-helpers";
 type CompletionParams = Omit<CompletionClientParams, "tools"> & {
     tools?: Tool[] | ToolInput[];
+    mcp?: McpClientInput[];
 };
 /**
  * Generates completion from a language model based on conversation history.
@@ -11,6 +12,7 @@ type CompletionParams = Omit<CompletionClientParams, "tools"> & {
  * @param params.history - Array of conversation messages with role, content, and optional attachments
  * @param params.stream - Whether to stream tokens (true) or return complete response (false). Defaults to true
  * @param params.tools - Optional array of tools (can be simple ToolInput with Zod schemas or full Tool objects)
+ * @param params.mcp - Optional array of MCP client inputs for tool integration
  * @param params.kvCache - Optional KV cache configuration. Cache files are organized hierarchically:
  *   - Structure: `{kvCacheKey}/{modelId}/{configHash}.bin`
  *   - The configHash includes model config + system prompt to ensure cache isolation
@@ -19,12 +21,11 @@ type CompletionParams = Omit<CompletionClientParams, "tools"> & {
  *   - `false` or `undefined`: No caching
  *   - ⚡ Performance: When cache exists, only the last message is sent to the model (includes multimodal attachments)
  *   - 🗑️ Cleanup: Use `deleteCache({ kvCacheKey })` to remove cached sessions
- * @returns Object with tokenStream generator, toolCallStream generator, text promise, toolCalls promise, and stats promise
+ * @returns Object with tokenStream generator, toolCallStream generator, text promise, toolCalls promise (with call() method), and stats promise
  * @example
  * ```typescript
  * import { z } from "zod";
  *
- * // Simple tool definition with Zod
  * const result = completion({
  *   modelId: "llama-2",
  *   history: [
@@ -36,14 +37,23 @@ type CompletionParams = Omit<CompletionClientParams, "tools"> & {
  *     description: "Get current weather",
  *     parameters: z.object({
  *       city: z.string().describe("City name"),
- *       country: z.string().describe("Country code").optional(),
  *     }),
+ *     handler: async (args) => {
+ *       return { temperature: 22, condition: "sunny" };
+ *     }
  *   }]
  * });
  *
  * for await (const token of result.tokenStream) {
  *   process.stdout.write(token);
  * }
+ *
+ * for (const toolCall of await result.toolCalls) {
+ *   if (toolCall.invoke) {
+ *     const toolResult = await toolCall.invoke();
+ *     console.log(toolResult);
+ *   }
+ * }
  * ```
  */
 export declare function completion(params: CompletionParams): {
@@ -51,7 +61,7 @@ export declare function completion(params: CompletionParams): {
     toolCallStream: AsyncGenerator<ToolCallEvent>;
     stats: Promise<CompletionStats | undefined>;
     text: Promise<string>;
-    toolCalls: Promise<ToolCall[]>;
+    toolCalls: Promise<ToolCallWithCall[]>;
 };
 export {};
 //# sourceMappingURL=completion-stream.d.ts.map

package/dist/client/api/completion-stream.js

@@ -1,6 +1,9 @@
-import { completionStreamResponseSchema, } from "../../schemas/index.js";
 import { stream as streamRpc } from "../rpc/rpc-client.js";
-import { validateTools } from "../../utils/tool-helpers.js";
+import { getClientLogger } from "../../logging/index.js";
+import { completionStreamResponseSchema, } from "../../schemas/index.js";
+import { getMcpToolsWithHandlers } from "../../utils/mcp-adapter.js";
+import { attachHandlersToToolCalls, validateTools, } from "../../utils/tool-helpers.js";
+const logger = getClientLogger();
 /**
  * Generates completion from a language model based on conversation history.
  *
@@ -9,6 +12,7 @@ import { validateTools } from "../../utils/tool-helpers.js";
  * @param params.history - Array of conversation messages with role, content, and optional attachments
  * @param params.stream - Whether to stream tokens (true) or return complete response (false). Defaults to true
  * @param params.tools - Optional array of tools (can be simple ToolInput with Zod schemas or full Tool objects)
+ * @param params.mcp - Optional array of MCP client inputs for tool integration
  * @param params.kvCache - Optional KV cache configuration. Cache files are organized hierarchically:
  *   - Structure: `{kvCacheKey}/{modelId}/{configHash}.bin`
  *   - The configHash includes model config + system prompt to ensure cache isolation
@@ -17,12 +21,11 @@ import { validateTools } from "../../utils/tool-helpers.js";
  *   - `false` or `undefined`: No caching
  *   - ⚡ Performance: When cache exists, only the last message is sent to the model (includes multimodal attachments)
  *   - 🗑️ Cleanup: Use `deleteCache({ kvCacheKey })` to remove cached sessions
- * @returns Object with tokenStream generator, toolCallStream generator, text promise, toolCalls promise, and stats promise
+ * @returns Object with tokenStream generator, toolCallStream generator, text promise, toolCalls promise (with call() method), and stats promise
  * @example
  * ```typescript
  * import { z } from "zod";
  *
- * // Simple tool definition with Zod
  * const result = completion({
  *   modelId: "llama-2",
  *   history: [
@@ -34,24 +37,26 @@ import { validateTools } from "../../utils/tool-helpers.js";
  *     description: "Get current weather",
  *     parameters: z.object({
  *       city: z.string().describe("City name"),
- *       country: z.string().describe("Country code").optional(),
  *     }),
+ *     handler: async (args) => {
+ *       return { temperature: 22, condition: "sunny" };
+ *     }
  *   }]
  * });
  *
  * for await (const token of result.tokenStream) {
  *   process.stdout.write(token);
  * }
+ *
+ * for (const toolCall of await result.toolCalls) {
+ *   if (toolCall.invoke) {
+ *     const toolResult = await toolCall.invoke();
+ *     console.log(toolResult);
+ *   }
+ * }
  * ```
  */
 export function completion(params) {
-    const tools = params.tools ? validateTools(params.tools) : undefined;
-    const request = {
-        type: "completionStream",
-        ...params,
-        tools,
-        stream: params.stream ?? true,
-    };
     let stats;
     let statsResolver = () => { };
     let statsRejecter = () => { };
@@ -68,7 +73,6 @@ export function completion(params) {
         toolCallsRejecter = reject;
     });
     toolCallsPromise.catch(() => { });
-    const responses = streamRpc(request);
     const tokenQueue = [];
     const toolEventQueue = [];
     let tokenDone = false;
@@ -79,6 +83,37 @@ export function completion(params) {
     let streamError = null;
     const processResponses = async () => {
         try {
+            let allTools = [];
+            const allHandlers = new Map();
+            if (params.tools) {
+                const { tools, handlers } = validateTools(params.tools);
+                allTools = tools;
+                for (const [name, handler] of handlers) {
+                    if (allHandlers.has(name)) {
+                        logger.warn(`Duplicate tool handler for "${name}", overwriting`);
+                    }
+                    allHandlers.set(name, handler);
+                }
+            }
+            if (params.mcp && params.mcp.length > 0) {
+                const { tools: mcpTools, handlers: mcpHandlers } = await getMcpToolsWithHandlers(params.mcp);
+                allTools = [...mcpTools, ...allTools];
+                for (const [name, handler] of mcpHandlers) {
+                    if (allHandlers.has(name)) {
+                        logger.warn(`Duplicate tool handler for "${name}", overwriting`);
+                    }
+                    allHandlers.set(name, handler);
+                }
+            }
+            const request = {
+                type: "completionStream",
+                modelId: params.modelId,
+                history: params.history,
+                kvCache: params.kvCache,
+                tools: allTools.length > 0 ? allTools : undefined,
+                stream: params.stream ?? true,
+            };
+            const responses = streamRpc(request);
             for await (const response of responses) {
                 if (response &&
                     typeof response === "object" &&
@@ -109,7 +144,8 @@ export function completion(params) {
                         }
                         stats = streamResponse.stats;
                         statsResolver(stats);
-                        toolCallsArray = streamResponse.toolCalls || [];
+                        const rawToolCalls = streamResponse.toolCalls || [];
+                        toolCallsArray = attachHandlersToToolCalls(rawToolCalls, allHandlers);
                         toolCallsResolver(toolCallsArray);
                         tokenDone = true;
                         toolDone = true;

package/dist/client/api/embed.d.ts

@@ -1,11 +1,25 @@
-import { type EmbedParams } from "../../schemas/index";
 /**
- * Generates embeddings for a given text using a specified model.
+ * Generates embeddings for a single text using a specified model.
  *
  * @param params - The parameters for the embedding
  * @param params.modelId - The identifier of the embedding model to use
  * @param params.text - The input text to embed
  * @throws {QvacErrorBase} When the response type is invalid or when the embedding fails
  */
-export declare function embed(params: EmbedParams): Promise<number[]>;
+export declare function embed(params: {
+    modelId: string;
+    text: string;
+}): Promise<number[]>;
+/**
+ * Generates embeddings for multiple texts using a specified model.
+ *
+ * @param params - The parameters for the embedding
+ * @param params.modelId - The identifier of the embedding model to use
+ * @param params.text - The input texts to embed
+ * @throws {QvacErrorBase} When the response type is invalid or when the embedding fails
+ */
+export declare function embed(params: {
+    modelId: string;
+    text: string[];
+}): Promise<number[][]>;
 //# sourceMappingURL=embed.d.ts.map

package/dist/client/api/embed.js

@@ -1,14 +1,6 @@
 import { send } from "../rpc/rpc-client.js";
 import {} from "../../schemas/index.js";
 import { InvalidResponseError, EmbedFailedError } from "../../utils/errors-client.js";
-/**
- * Generates embeddings for a given text using a specified model.
- *
- * @param params - The parameters for the embedding
- * @param params.modelId - The identifier of the embedding model to use
- * @param params.text - The input text to embed
- * @throws {QvacErrorBase} When the response type is invalid or when the embedding fails
- */
 export async function embed(params) {
     const request = {
         type: "embed",

package/dist/client/api/get-model-info.d.ts

@@ -6,7 +6,7 @@ export declare const getModelInfo: (params: GetModelInfoParams) => Promise<{
     hyperbeeKey: string;
     expectedSize: number;
     sha256Checksum: string;
-    addon: "llm" | "whisper" | "embeddings" | "nmt" | "vad" | "tts";
+    addon: "llm" | "whisper" | "embeddings" | "nmt" | "tts" | "vad";
     isCached: boolean;
     isLoaded: boolean;
     cacheFiles: {

package/dist/client/api/index.d.ts

@@ -13,6 +13,5 @@ export { startQVACProvider } from "./provide";
 export { stopQVACProvider } from "./stop-provider";
 export { ragSaveEmbeddings, ragSearch, ragDeleteEmbeddings } from "./rag";
 export { textToSpeech } from "./text-to-speech";
-export { setConfig } from "./set-config";
 export { getModelInfo } from "./get-model-info";
 //# sourceMappingURL=index.d.ts.map

package/dist/client/api/index.js

@@ -13,5 +13,4 @@ export { startQVACProvider } from "./provide.js";
 export { stopQVACProvider } from "./stop-provider.js";
 export { ragSaveEmbeddings, ragSearch, ragDeleteEmbeddings } from "./rag.js";
 export { textToSpeech } from "./text-to-speech.js";
-export { setConfig } from "./set-config.js";
 export { getModelInfo } from "./get-model-info.js";

package/dist/client/api/load-model.d.ts

@@ -1,23 +1,21 @@
-import { type Logger } from "../../logging/index";
-import { type LoadModelOptions as BaseLoadModelOptions } from "../../schemas/index";
-export type LoadModelOptions = BaseLoadModelOptions & {
-    logger?: Logger;
-};
+import { type LoadModelOptions, type ReloadConfigOptions } from "../../schemas/index";
 /**
  * Loads a machine learning model from a local path, remote URL, or Hyperdrive key.
  *
- * This function supports three model types: LLM (Large Language Model), Whisper (speech recognition),
- * and embeddings. It can handle both local file paths and Hyperdrive URLs (pear://).
+ * This function supports multiple model types: LLM (Large Language Model), Whisper (speech recognition),
+ * embeddings, NMT (translation), and TTS. It can handle both local file paths and Hyperdrive URLs (pear://).
  *
  * When `onProgress` is provided, the function uses streaming to provide real-time download progress.
  * Otherwise, it uses a simple request-response pattern for faster execution.
  *
  * @param options - An object that defines all configuration parameters required for loading the model, including:
  *   - modelSrc: The location from which the model weights are fetched (local path, remote URL, or Hyperdrive URL)
- *   - modelType: The type of model ("llm", "whisper", "embeddings", or "nmt")
+ *   - modelType: The type of model ("llm", "whisper", "embeddings", "nmt", or "tts")
  *   - modelConfig: Model-specific configuration options
  *   - projectionModelSrc: (LLM only) Projection model source for multimodal models
  *   - vadModelSrc: (Whisper only) VAD model source for voice activity detection
+ *   - onProgress: Callback for download progress updates
+ *   - logger: Logger instance for model operation logs
  *
  * @returns Promise that resolves to the model ID (either the provided modelSrc or a generated ID)
  *
@@ -89,10 +87,38 @@ export type LoadModelOptions = BaseLoadModelOptions & {
  *   modelType: "llm",
  *   logger // Pass logger in options
  * });
- *
- * // Now any logs from the model operations will appear in your logger automatically
- * // No need to manually manage logging streams!
  * ```
  */
 export declare function loadModel(options: LoadModelOptions): Promise<string>;
+/**
+ * Hot-reloads configuration on an already loaded model.
+ *
+ * @param options - Configuration for reloading config on an existing model:
+ *   - modelId: The ID of an existing loaded model
+ *   - modelType: The type of model (must match the loaded model)
+ *   - modelConfig: New configuration to apply
+ *
+ * @returns Promise that resolves to the model ID
+ *
+ * @throws {QvacErrorBase} When model reload fails, with details in the error message
+ * @throws {QvacErrorBase} When receiving an invalid response type from the server
+ *
+ * @example
+ * ```typescript
+ * // Load new model
+ * const modelId = await loadModel({
+ *   modelSrc: "pear://<hyperdrive-key>/whisper-tiny.gguf",
+ *   modelType: "whisper",
+ *   modelConfig: { language: "en" },
+ * });
+ *
+ * // Later, update the config without reloading the model
+ * await loadModel({
+ *   modelId,
+ *   modelType: "whisper",
+ *   modelConfig: { language: "es" },
+ * });
+ * ```
+ */
+export declare function loadModel(options: ReloadConfigOptions): Promise<string>;
 //# sourceMappingURL=load-model.d.ts.map

package/dist/client/api/load-model.js

@@ -1,107 +1,21 @@
 import { send, stream } from "../rpc/rpc-client.js";
-import {} from "../../logging/index.js";
 import { startLoggingStreamForModel } from "../logging-stream-registry.js";
-import { loadModelOptionsToRequestSchema, } from "../../schemas/index.js";
+import { loadModelOptionsToRequestSchema, reloadConfigOptionsToRequestSchema, } from "../../schemas/index.js";
 import { ModelLoadFailedError, StreamEndedError, InvalidResponseError, } from "../../utils/errors-client.js";
-/**
- * Loads a machine learning model from a local path, remote URL, or Hyperdrive key.
- *
- * This function supports three model types: LLM (Large Language Model), Whisper (speech recognition),
- * and embeddings. It can handle both local file paths and Hyperdrive URLs (pear://).
- *
- * When `onProgress` is provided, the function uses streaming to provide real-time download progress.
- * Otherwise, it uses a simple request-response pattern for faster execution.
- *
- * @param options - An object that defines all configuration parameters required for loading the model, including:
- *   - modelSrc: The location from which the model weights are fetched (local path, remote URL, or Hyperdrive URL)
- *   - modelType: The type of model ("llm", "whisper", "embeddings", or "nmt")
- *   - modelConfig: Model-specific configuration options
- *   - projectionModelSrc: (LLM only) Projection model source for multimodal models
- *   - vadModelSrc: (Whisper only) VAD model source for voice activity detection
- *
- * @returns Promise that resolves to the model ID (either the provided modelSrc or a generated ID)
- *
- * @throws {QvacErrorBase} When model loading fails, with details in the error message
- * @throws {QvacErrorBase} When streaming ends unexpectedly (only when using onProgress)
- * @throws {QvacErrorBase} When receiving an invalid response type from the server
- *
- * @example
- * ```typescript
- * // Local file path - absolute path
- * const localModelId = await loadModel({
- *   modelSrc: "/home/user/models/llama-7b.gguf",
- *   modelType: "llm",
- *   modelConfig: { contextSize: 2048 }
- * });
- *
- * // Local file path - relative path
- * const relativeModelId = await loadModel({
- *   modelSrc: "./models/whisper-base.gguf",
- *   modelType: "whisper"
- * });
- *
- * // Hyperdrive URL with key and path
- * const hyperdriveId = await loadModel({
- *   modelSrc: "pear://<hyperdrive-key>/llama-7b.gguf",
- *   modelType: "llm",
- *   modelConfig: { contextSize: 2048 }
- * });
- *
- * // Remote HTTP/HTTPS URL with progress tracking
- * const remoteId = await loadModel({
- *   modelSrc: "https://huggingface.co/TheBloke/Llama-2-7B-Chat-GGUF/resolve/main/llama-2-7b-chat.Q4_K_M.gguf",
- *   modelType: "llm",
- *   onProgress: (progress) => {
- *     console.log(`Downloaded: ${progress.percentage}%`);
- *   }
- * });
- *
- * // Multimodal model with projection
- * const multimodalId = await loadModel({
- *   modelSrc: "https://huggingface.co/.../main-model.gguf",
- *   modelType: "llm",
- *   projectionModelSrc: "https://huggingface.co/.../projection-model.gguf",
- *   modelConfig: { ctx_size: 512 },
- *   onProgress: (progress) => {
- *     console.log(`Loading: ${progress.percentage}%`);
- *   }
- * });
- *
- * // Whisper with VAD model
- * const whisperId = await loadModel({
- *   modelSrc: "https://huggingface.co/.../whisper-model.gguf",
- *   modelType: "whisper",
- *   vadModelSrc: "https://huggingface.co/.../vad-model.bin",
- *   modelConfig: {
- *     mode: "caption",
- *     output_format: "plaintext",
- *     min_seconds: 2,
- *     max_seconds: 6
- *   }
- * });
- *
- * // Load with automatic logging - logs from the model will be forwarded to your logger
- * import { getLogger } from "../../logging/index.js";
- * const logger = getLogger("my-app");
- *
- * const modelId = await loadModel({
- *   modelSrc: "/path/to/model.gguf",
- *   modelType: "llm",
- *   logger // Pass logger in options
- * });
- *
- * // Now any logs from the model operations will appear in your logger automatically
- * // No need to manually manage logging streams!
- * ```
- */
+import { getClientLogger } from "../../logging/index.js";
+const logger = getClientLogger();
 export async function loadModel(options) {
-    const { logger } = options;
-    const request = loadModelOptionsToRequestSchema.parse(options);
-    if (options.onProgress) {
+    const isReloadConfig = "modelId" in options && !("modelSrc" in options);
+    const request = isReloadConfig
+        ? reloadConfigOptionsToRequestSchema.parse(options)
+        : loadModelOptionsToRequestSchema.parse(options);
+    const modelLogger = isReloadConfig ? undefined : options.logger;
+    const onProgress = isReloadConfig ? undefined : options.onProgress;
+    if (onProgress) {
         // Use streaming for progress updates
         for await (const response of stream(request)) {
             if (response.type === "modelProgress") {
-                options.onProgress(response);
+                onProgress(response);
             }
             else if (response.type === "loadModel") {
                 if (!response.success) {
@@ -109,12 +23,12 @@ export async function loadModel(options) {
                 }
                 const modelId = response.modelId;
                 // Start logging stream in the background if logger is provided, catch to avoid failing the entire loadModel operation
-                if (logger) {
+                if (modelLogger) {
                     try {
-                        startLoggingStreamForModel(modelId, logger);
+                        startLoggingStreamForModel(modelId, modelLogger);
                     }
                     catch (error) {
-                        console.warn(`Failed to start logging stream for model ${modelId}:`, error);
+                        logger.warn(`Failed to start logging stream for model ${modelId}:`, error);
                     }
                 }
                 return modelId;
@@ -122,24 +36,22 @@ export async function loadModel(options) {
         }
         throw new StreamEndedError();
     }
-    else {
-        // Use regular send for simple loading
-        const response = await send(request);
-        if (response.type !== "loadModel") {
-            throw new InvalidResponseError("loadModel");
-        }
-        if (!response.success) {
-            throw new ModelLoadFailedError(response.error);
+    // Use regular send for simple loading
+    const response = await send(request);
+    if (response.type !== "loadModel") {
+        throw new InvalidResponseError("loadModel");
+    }
+    if (!response.success) {
+        throw new ModelLoadFailedError(response.error);
+    }
+    const modelId = response.modelId;
+    if (modelLogger) {
+        try {
+            startLoggingStreamForModel(modelId, modelLogger);
         }
-        const modelId = response.modelId;
-        if (logger) {
-            try {
-                startLoggingStreamForModel(modelId, logger);
-            }
-            catch (error) {
-                console.warn(`Failed to start logging stream for model ${modelId}:`, error);
-            }
+        catch (error) {
+            logger.warn(`Failed to start logging stream for model ${modelId}:`, error);
         }
-        return modelId;
     }
+    return modelId;
 }

package/dist/client/api/logging-stream.d.ts

@@ -1,16 +1,19 @@
 import type { LoggingStreamResponse, LoggingParams } from "../../schemas/logging-stream";
 /**
- * Opens a logging stream for a specific model to receive real-time logs.
+ * Opens a logging stream to receive real-time logs.
  *
  * @param params - The arguments for the logging stream
- * @param params.modelId - The unique identifier of the model to stream logs for
+ * @param params.id - The unique identifier to stream logs for
  * @returns AsyncGenerator yielding logging stream responses
  * @throws {QvacErrorBase} When the response type is invalid or when the stream fails
  *
  * @example
  * ```typescript
  * // Open a logging stream for a model
- * const logStream = loggingStream({ modelId: 'my-model-id' });
+ * const logStream = loggingStream({ id: 'my-model-id' });
+ *
+ * // Or stream SDK server logs
+ * const sdkLogs = loggingStream({ id: SDK_LOG_ID });
  *
  * for await (const logMessage of logStream) {
  *   console.log(`[${logMessage.level}] ${logMessage.namespace}: ${logMessage.message}`);

package/dist/client/api/logging-stream.js

@@ -1,17 +1,20 @@
 import { stream } from "../rpc/rpc-client.js";
 import { InvalidResponseError } from "../../utils/errors-client.js";
 /**
- * Opens a logging stream for a specific model to receive real-time logs.
+ * Opens a logging stream to receive real-time logs.
  *
  * @param params - The arguments for the logging stream
- * @param params.modelId - The unique identifier of the model to stream logs for
+ * @param params.id - The unique identifier to stream logs for
  * @returns AsyncGenerator yielding logging stream responses
  * @throws {QvacErrorBase} When the response type is invalid or when the stream fails
  *
  * @example
  * ```typescript
  * // Open a logging stream for a model
- * const logStream = loggingStream({ modelId: 'my-model-id' });
+ * const logStream = loggingStream({ id: 'my-model-id' });
+ *
+ * // Or stream SDK server logs
+ * const sdkLogs = loggingStream({ id: SDK_LOG_ID });
  *
  * for await (const logMessage of logStream) {
  *   console.log(`[${logMessage.level}] ${logMessage.namespace}: ${logMessage.message}`);

package/dist/client/api/unload-model.js

@@ -2,6 +2,8 @@ import {} from "../../schemas/index.js";
 import { send, close } from "../rpc/rpc-client.js";
 import { stopLoggingStreamForModel } from "../logging-stream-registry.js";
 import { InvalidResponseError, ModelUnloadFailedError, } from "../../utils/errors-client.js";
+import { getClientLogger } from "../../logging/index.js";
+const logger = getClientLogger();
 /**
  * Unloads a previously loaded model from the server.
  *
@@ -29,8 +31,9 @@ export async function unloadModel(params) {
     }
     stopLoggingStreamForModel(params.modelId);
     // Auto-close when no models remain AND no providers are active
-    if (!response.hasActiveModels && !response.hasActiveProviders) {
-        console.log("🧹 No models or providers active, automatically closing RPC connection...");
+    if (response.hasActiveModels === false &&
+        response.hasActiveProviders === false) {
+        logger.info("🧹 No models or providers active, automatically closing RPC connection...");
         await close();
     }
 }

package/dist/client/config-loader/config-utils.d.ts

@@ -0,0 +1,5 @@
+import { type QvacConfig } from "../../schemas/index";
+export type { QvacConfig };
+export declare function validateConfig(config: unknown): QvacConfig;
+export declare function parseJsonConfig(content: string, filePath: string): unknown;
+//# sourceMappingURL=config-utils.d.ts.map

package/dist/client/config-loader/config-utils.js

@@ -0,0 +1,20 @@
+import { qvacConfigSchema } from "../../schemas/index.js";
+import { ConfigValidationFailedError } from "../../utils/errors-client.js";
+export function validateConfig(config) {
+    const result = qvacConfigSchema.safeParse(config);
+    if (!result.success) {
+        const errors = result.error.issues
+            .map((e) => `${String(e.path.join("."))}:  ${e.message}`)
+            .join(", ");
+        throw new ConfigValidationFailedError(errors);
+    }
+    return result.data;
+}
+export function parseJsonConfig(content, filePath) {
+    try {
+        return JSON.parse(content);
+    }
+    catch {
+        throw new ConfigValidationFailedError(`Invalid JSON in config file: ${filePath}`);
+    }
+}

package/dist/client/config-loader/resolve-config.bare.d.ts

@@ -0,0 +1,9 @@
+import { type QvacConfig } from "./config-utils";
+/**
+ * Resolution order for Bare:
+ * 1. QVAC_CONFIG_PATH environment variable
+ * 2. Config file in project root (qvac.config.ts, qvac.config.js, qvac.config.json)
+ * 3. SDK defaults
+ */
+export declare function resolveConfig(): Promise<QvacConfig | undefined>;
+//# sourceMappingURL=resolve-config.bare.d.ts.map