@qvac/sdk 0.4.1 → 0.6.0

package/bare-imports.json

@@ -0,0 +1,35 @@
+{
+  "#rpc": {
+    "react-native": "./dist/client/rpc/expo-rpc-client.js",
+    "bare": "./dist/client/rpc/bare-client.js",
+    "default": "./dist/client/rpc/node-rpc-client.js"
+  },
+  "child_process": {
+    "bare": "bare-subprocess",
+    "default": "child_process"
+  },
+  "crypto": {
+    "bare": "bare-crypto",
+    "default": "crypto"
+  },
+  "fs": {
+    "bare": "bare-fs",
+    "default": "fs"
+  },
+  "os": {
+    "bare": "bare-os",
+    "default": "os"
+  },
+  "path": {
+    "bare": "bare-path",
+    "default": "path"
+  },
+  "process": {
+    "bare": "bare-process",
+    "default": "process"
+  },
+  "readline": {
+    "bare": "bare-readline",
+    "default": "readline"
+  }
+}

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

@@ -3,10 +3,11 @@ import { type CancelParams } from "../../schemas/index";
  * Cancels an ongoing operation.
  *
  * @param params - The parameters for the cancellation
- * @param params.operation - The type of operation to cancel ("inference" or "download")
+ * @param params.operation - The type of operation to cancel ("inference", "downloadAsset", or "rag")
  * @param params.modelId - The model ID (required for inference cancellation)
  * @param params.downloadKey - The download key (required for download cancellation)
  * @param params.clearCache - If true, deletes the partial download file (default: false)
+ * @param params.workspace - The RAG workspace to cancel (optional, defaults to "default")
  * @throws {QvacErrorBase} When the response type is invalid or when the cancellation fails
  *
  * @example
@@ -15,11 +16,19 @@ import { type CancelParams } from "../../schemas/index";
  *
  * @example
  * // Pause download (preserves partial file for automatic resume)
- * await cancel({ operation: "download", downloadKey: "download-key" });
+ * await cancel({ operation: "downloadAsset", downloadKey: "download-key" });
  *
  * @example
  * // Cancel download completely (deletes partial file)
- * await cancel({ operation: "download", downloadKey: "download-key", clearCache: true });
+ * await cancel({ operation: "downloadAsset", downloadKey: "download-key", clearCache: true });
+ *
+ * @example
+ * // Cancel RAG operation on default workspace
+ * await cancel({ operation: "rag" });
+ *
+ * @example
+ * // Cancel RAG operation on specific workspace
+ * await cancel({ operation: "rag", workspace: "my-workspace" });
  */
 export declare function cancel(params: CancelParams): Promise<void>;
 //# sourceMappingURL=cancel.d.ts.map

package/dist/client/api/cancel.js

@@ -5,10 +5,11 @@ import { InvalidResponseError, CancelFailedError } from "../../utils/errors-clie
  * Cancels an ongoing operation.
  *
  * @param params - The parameters for the cancellation
- * @param params.operation - The type of operation to cancel ("inference" or "download")
+ * @param params.operation - The type of operation to cancel ("inference", "downloadAsset", or "rag")
  * @param params.modelId - The model ID (required for inference cancellation)
  * @param params.downloadKey - The download key (required for download cancellation)
  * @param params.clearCache - If true, deletes the partial download file (default: false)
+ * @param params.workspace - The RAG workspace to cancel (optional, defaults to "default")
  * @throws {QvacErrorBase} When the response type is invalid or when the cancellation fails
  *
  * @example
@@ -17,11 +18,19 @@ import { InvalidResponseError, CancelFailedError } from "../../utils/errors-clie
  *
  * @example
  * // Pause download (preserves partial file for automatic resume)
- * await cancel({ operation: "download", downloadKey: "download-key" });
+ * await cancel({ operation: "downloadAsset", downloadKey: "download-key" });
  *
  * @example
  * // Cancel download completely (deletes partial file)
- * await cancel({ operation: "download", downloadKey: "download-key", clearCache: true });
+ * await cancel({ operation: "downloadAsset", downloadKey: "download-key", clearCache: true });
+ *
+ * @example
+ * // Cancel RAG operation on default workspace
+ * await cancel({ operation: "rag" });
+ *
+ * @example
+ * // Cancel RAG operation on specific workspace
+ * await cancel({ operation: "rag", workspace: "my-workspace" });
  */
 export async function cancel(params) {
     const request = {

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

@@ -1,12 +1,12 @@
 import { type GetModelInfoParams } from "../../schemas/index";
-export declare const getModelInfo: (params: GetModelInfoParams) => Promise<{
+export declare function getModelInfo(params: GetModelInfoParams): Promise<{
     name: string;
     modelId: string;
     hyperdriveKey: string;
     hyperbeeKey: string;
     expectedSize: number;
     sha256Checksum: string;
-    addon: "llm" | "whisper" | "embeddings" | "nmt" | "vad" | "tts";
+    addon: "llamacpp-completion" | "whispercpp-transcription" | "llamacpp-embedding" | "nmtcpp-translation" | "onnx-tts" | "onnx-ocr" | "vad";
     isCached: boolean;
     isLoaded: boolean;
     cacheFiles: {

package/dist/client/api/get-model-info.js

@@ -1,7 +1,7 @@
 import {} from "../../schemas/index.js";
 import { send } from "../rpc/rpc-client.js";
 import { InvalidResponseError } from "../../utils/errors-client.js";
-export const getModelInfo = async (params) => {
+export async function getModelInfo(params) {
     const request = {
         type: "getModelInfo",
         name: params.name,
@@ -11,4 +11,4 @@ export const getModelInfo = async (params) => {
         throw new InvalidResponseError("getModelInfo");
     }
     return response.modelInfo;
-};
+}

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

@@ -11,8 +11,8 @@ export { translate } from "./translate";
 export { cancel } from "./cancel";
 export { startQVACProvider } from "./provide";
 export { stopQVACProvider } from "./stop-provider";
-export { ragSaveEmbeddings, ragSearch, ragDeleteEmbeddings } from "./rag";
+export { ragChunk, ragIngest, ragSaveEmbeddings, ragSearch, ragDeleteEmbeddings, ragReindex, ragListWorkspaces, ragCloseWorkspace, ragDeleteWorkspace, } from "./rag";
 export { textToSpeech } from "./text-to-speech";
-export { setConfig } from "./set-config";
 export { getModelInfo } from "./get-model-info";
+export { ocr } from "./ocr";
 //# sourceMappingURL=index.d.ts.map

package/dist/client/api/index.js

@@ -11,7 +11,7 @@ export { translate } from "./translate.js";
 export { cancel } from "./cancel.js";
 export { startQVACProvider } from "./provide.js";
 export { stopQVACProvider } from "./stop-provider.js";
-export { ragSaveEmbeddings, ragSearch, ragDeleteEmbeddings } from "./rag.js";
+export { ragChunk, ragIngest, ragSaveEmbeddings, ragSearch, ragDeleteEmbeddings, ragReindex, ragListWorkspaces, ragCloseWorkspace, ragDeleteWorkspace, } from "./rag.js";
 export { textToSpeech } from "./text-to-speech.js";
-export { setConfig } from "./set-config.js";
 export { getModelInfo } from "./get-model-info.js";
+export { ocr } from "./ocr.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,26 @@
 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, isModelTypeAlias, normalizeModelType, } 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);
+    // Warn about deprecated alias usage
+    if (!isReloadConfig && isModelTypeAlias(options.modelType)) {
+        const canonical = normalizeModelType(options.modelType);
+        logger.warn(`Model type "${options.modelType}" is an alias and will be deprecated. Use "${canonical}" instead.`);
+    }
+    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 +28,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 +41,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;
 }