@qvac/sdk 0.3.0 → 0.4.0

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

@@ -1,7 +1,8 @@
 import { send, stream } from "../rpc/rpc-client.js";
 import {} from "../../logging/index.js";
 import { startLoggingStreamForModel } from "../logging-stream-registry.js";
-import { loadModelRequestSchema, } from "../../schemas/index.js";
+import { loadModelOptionsToRequestSchema, } 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.
  *
@@ -20,9 +21,9 @@ import { loadModelRequestSchema, } from "../../schemas/index.js";
  *
  * @returns Promise that resolves to the model ID (either the provided modelSrc or a generated ID)
  *
- * @throws {Error} When model loading fails, with details in the error message
- * @throws {Error} When streaming ends unexpectedly (only when using onProgress)
- * @throws {Error} When receiving an invalid response type from the server
+ * @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
@@ -94,18 +95,8 @@ import { loadModelRequestSchema, } from "../../schemas/index.js";
  * ```
  */
 export async function loadModel(options) {
-    const { logger, modelSrc } = options;
-    const request = loadModelRequestSchema.parse({
-        type: "loadModel",
-        modelSrc: modelSrc,
-        projectionModelSrc: options.modelType === "llm" ? options.projectionModelSrc : undefined,
-        vadModelSrc: options.modelType === "whisper" ? options.vadModelSrc : undefined,
-        withProgress: !!options.onProgress,
-        seed: options.seed,
-        modelType: options.modelType,
-        modelConfig: options.modelConfig ?? {},
-        delegate: options.delegate,
-    });
+    const { logger } = options;
+    const request = loadModelOptionsToRequestSchema.parse(options);
     if (options.onProgress) {
         // Use streaming for progress updates
         for await (const response of stream(request)) {
@@ -114,9 +105,9 @@ export async function loadModel(options) {
             }
             else if (response.type === "loadModel") {
                 if (!response.success) {
-                    throw new Error(response.error ?? "Failed to load model");
+                    throw new ModelLoadFailedError(response.error);
                 }
-                const modelId = response.modelId ?? modelSrc;
+                const modelId = response.modelId;
                 // Start logging stream in the background if logger is provided, catch to avoid failing the entire loadModel operation
                 if (logger) {
                     try {
@@ -129,18 +120,18 @@ export async function loadModel(options) {
                 return modelId;
             }
         }
-        throw new Error("Stream ended without final response");
+        throw new StreamEndedError();
     }
     else {
         // Use regular send for simple loading
         const response = await send(request);
         if (response.type !== "loadModel") {
-            throw new Error("Invalid response type");
+            throw new InvalidResponseError("loadModel");
         }
         if (!response.success) {
-            throw new Error(response.error ?? "Failed to load model");
+            throw new ModelLoadFailedError(response.error);
         }
-        const modelId = response.modelId ?? modelSrc;
+        const modelId = response.modelId;
         if (logger) {
             try {
                 startLoggingStreamForModel(modelId, logger);

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

@@ -5,7 +5,7 @@ import type { LoggingStreamResponse, LoggingParams } from "../../schemas/logging
  * @param params - The arguments for the logging stream
  * @param params.modelId - The unique identifier of the model to stream logs for
  * @returns AsyncGenerator yielding logging stream responses
- * @throws {Error} When the response type is invalid or when the stream fails
+ * @throws {QvacErrorBase} When the response type is invalid or when the stream fails
  *
  * @example
  * ```typescript

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

@@ -1,11 +1,12 @@
 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.
  *
  * @param params - The arguments for the logging stream
  * @param params.modelId - The unique identifier of the model to stream logs for
  * @returns AsyncGenerator yielding logging stream responses
- * @throws {Error} When the response type is invalid or when the stream fails
+ * @throws {QvacErrorBase} When the response type is invalid or when the stream fails
  *
  * @example
  * ```typescript
@@ -25,7 +26,7 @@ export async function* loggingStream(params) {
     const responseStream = stream(request);
     for await (const response of responseStream) {
         if (response.type !== "loggingStream") {
-            throw new Error("Invalid response type");
+            throw new InvalidResponseError("loggingStream");
         }
         yield response;
     }

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

@@ -2,7 +2,7 @@
  * Sends a ping request to the server and returns the pong response.
  *
  * @returns A promise that resolves to a pong response containing a number.
- * @throws {Error} When the response type is not "pong".
+ * @throws {QvacErrorBase} When the response type is not "pong".
  */
 export declare function ping(): Promise<{
     type: "pong";

package/dist/client/api/ping.js

@@ -1,10 +1,11 @@
 import {} from "../../schemas/index.js";
 import { send } from "../rpc/rpc-client.js";
+import { InvalidResponseError } from "../../utils/errors-client.js";
 /**
  * Sends a ping request to the server and returns the pong response.
  *
  * @returns A promise that resolves to a pong response containing a number.
- * @throws {Error} When the response type is not "pong".
+ * @throws {QvacErrorBase} When the response type is not "pong".
  */
 export async function ping() {
     const request = {
@@ -12,7 +13,7 @@ export async function ping() {
     };
     const response = await send(request);
     if (response.type !== "pong") {
-        throw new Error("Invalid response type");
+        throw new InvalidResponseError("pong");
     }
     return response;
 }

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

@@ -7,7 +7,7 @@ import { type ProvideParams } from "../../schemas/index";
  * @param options.topic - Topic hex string for peer discovery
  * @param options.firewall - Optional firewall configuration to allow/deny specific public keys
  * @returns A promise that resolves to the provide response containing success status and public key
- * @throws {Error} When the response type is not "provide" or the request fails
+ * @throws {QvacErrorBase} When the response type is not "provide" or the request fails
  */
 export declare function startQVACProvider(params: ProvideParams): Promise<{
     type: "provide";

package/dist/client/api/provide.js

@@ -1,5 +1,6 @@
 import {} from "../../schemas/index.js";
 import { send } from "../rpc/rpc-client.js";
+import { InvalidResponseError, ProviderStartFailedError, } from "../../utils/errors-client.js";
 /**
  * Starts a provider service that offers QVAC capabilities to remote peers.
  * The provider's keypair can be controlled via the seed option or QVAC_HYPERSWARM_SEED environment variable.
@@ -8,7 +9,7 @@ import { send } from "../rpc/rpc-client.js";
  * @param options.topic - Topic hex string for peer discovery
  * @param options.firewall - Optional firewall configuration to allow/deny specific public keys
  * @returns A promise that resolves to the provide response containing success status and public key
- * @throws {Error} When the response type is not "provide" or the request fails
+ * @throws {QvacErrorBase} When the response type is not "provide" or the request fails
  */
 export async function startQVACProvider(params) {
     const request = {
@@ -18,10 +19,10 @@ export async function startQVACProvider(params) {
     };
     const response = await send(request);
     if (response.type !== "provide") {
-        throw new Error("Invalid response type");
+        throw new InvalidResponseError("provide");
     }
     if (response.error) {
-        throw new Error(response.error);
+        throw new ProviderStartFailedError(response.error);
     }
     return response;
 }

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

@@ -8,7 +8,7 @@ import type { RagSearchResult, RagSaveEmbeddingsParams, RagSearchParams, RagDele
  * @param params.chunk - Whether to chunk the documents before embedding (default: false)
  * @param params.chunkOpts - Options for chunking documents
  * @param params.workspace - Optional workspace for isolated storage
- * @throws {Error} When the response type is invalid or when the operation fails
+ * @throws {QvacErrorBase} When the response type is invalid or when the operation fails
  * @returns The processed results and dropped indices
  */
 export declare function ragSaveEmbeddings(params: RagSaveEmbeddingsParams): Promise<{
@@ -24,7 +24,7 @@ export declare function ragSaveEmbeddings(params: RagSaveEmbeddingsParams): Prom
  * @param params.topK - Number of top results to retrieve (default: 5)
  * @param params.n - Number of centroids to use for IVF index search (default: 3)
  * @param params.workspace - Optional workspace for isolated storage
- * @throws {Error} When the response type is invalid or when the operation fails
+ * @throws {QvacErrorBase} When the response type is invalid or when the operation fails
  * @returns Array of search results with id, content, and score
  */
 export declare function ragSearch(params: RagSearchParams): Promise<RagSearchResult[]>;
@@ -35,7 +35,7 @@ export declare function ragSearch(params: RagSearchParams): Promise<RagSearchRes
  * @param params.modelId - The identifier of the embedding model (must match workspace model)
  * @param params.ids - Array of document IDs to delete
  * @param params.workspace - Optional workspace for isolated storage
- * @throws {Error} When the response type is invalid or when the operation fails
+ * @throws {QvacErrorBase} When the response type is invalid or when the operation fails
  * @returns boolean indicating success
  */
 export declare function ragDeleteEmbeddings(params: RagDeleteEmbeddingsParams): Promise<true>;

package/dist/client/api/rag.js

@@ -1,4 +1,5 @@
 import { send } from "../rpc/rpc-client.js";
+import { InvalidResponseError, InvalidOperationError, RAGSaveFailedError, RAGSearchFailedError, RAGDeleteFailedError, } from "../../utils/errors-client.js";
 // ============== Save Embeddings ==============
 /**
  * Saves document embeddings in the RAG vector database.
@@ -9,7 +10,7 @@ import { send } from "../rpc/rpc-client.js";
  * @param params.chunk - Whether to chunk the documents before embedding (default: false)
  * @param params.chunkOpts - Options for chunking documents
  * @param params.workspace - Optional workspace for isolated storage
- * @throws {Error} When the response type is invalid or when the operation fails
+ * @throws {QvacErrorBase} When the response type is invalid or when the operation fails
  * @returns The processed results and dropped indices
  */
 export async function ragSaveEmbeddings(params) {
@@ -20,13 +21,13 @@ export async function ragSaveEmbeddings(params) {
     };
     const response = await send(request);
     if (response.type !== "rag") {
-        throw new Error("Invalid response type");
+        throw new InvalidResponseError("rag");
     }
     if (!response.success) {
-        throw new Error(response.error ?? "Failed to save embeddings");
+        throw new RAGSaveFailedError(response.error);
     }
     if (response.operation !== "saveEmbeddings") {
-        throw new Error("Invalid operation in response");
+        throw new InvalidOperationError();
     }
     return {
         processed: response.processed,
@@ -43,7 +44,7 @@ export async function ragSaveEmbeddings(params) {
  * @param params.topK - Number of top results to retrieve (default: 5)
  * @param params.n - Number of centroids to use for IVF index search (default: 3)
  * @param params.workspace - Optional workspace for isolated storage
- * @throws {Error} When the response type is invalid or when the operation fails
+ * @throws {QvacErrorBase} When the response type is invalid or when the operation fails
  * @returns Array of search results with id, content, and score
  */
 export async function ragSearch(params) {
@@ -56,13 +57,13 @@ export async function ragSearch(params) {
     };
     const response = await send(request);
     if (response.type !== "rag") {
-        throw new Error("Invalid response type");
+        throw new InvalidResponseError("rag");
     }
     if (!response.success) {
-        throw new Error(response.error ?? "Failed to search");
+        throw new RAGSearchFailedError(response.error);
     }
     if (response.operation !== "search") {
-        throw new Error("Invalid operation in response");
+        throw new InvalidOperationError();
     }
     return response.results;
 }
@@ -74,7 +75,7 @@ export async function ragSearch(params) {
  * @param params.modelId - The identifier of the embedding model (must match workspace model)
  * @param params.ids - Array of document IDs to delete
  * @param params.workspace - Optional workspace for isolated storage
- * @throws {Error} When the response type is invalid or when the operation fails
+ * @throws {QvacErrorBase} When the response type is invalid or when the operation fails
  * @returns boolean indicating success
  */
 export async function ragDeleteEmbeddings(params) {
@@ -85,13 +86,13 @@ export async function ragDeleteEmbeddings(params) {
     };
     const response = await send(request);
     if (response.type !== "rag") {
-        throw new Error("Invalid response type");
+        throw new InvalidResponseError("rag");
     }
     if (!response.success) {
-        throw new Error(response.error ?? "Failed to delete embeddings");
+        throw new RAGDeleteFailedError(response.error);
     }
     if (response.operation !== "deleteEmbeddings") {
-        throw new Error("Invalid operation in response");
+        throw new InvalidOperationError();
     }
     return response.success;
 }

package/dist/client/api/set-config.d.ts

@@ -0,0 +1,7 @@
+import { type SDKConfig } from "../../schemas/index";
+export declare const setConfig: (config: SDKConfig) => Promise<{
+    type: "setConfig";
+    success: boolean;
+    error?: string | undefined;
+}>;
+//# sourceMappingURL=set-config.d.ts.map

package/dist/client/api/set-config.js

@@ -0,0 +1,20 @@
+import {} from "../../schemas/index.js";
+import { send } from "../rpc/rpc-client.js";
+import { setCachedConfig } from "../config-manager.js";
+import { InvalidResponseError, SetConfigFailedError, } from "../../utils/errors-client.js";
+export const setConfig = async (config) => {
+    // Cache config client-side for automatic replay on worker restart
+    setCachedConfig(config);
+    const request = {
+        type: "setConfig",
+        config,
+    };
+    const response = await send(request);
+    if (response.type !== "setConfig") {
+        throw new InvalidResponseError("setConfig");
+    }
+    if (!response.success) {
+        throw new SetConfigFailedError(response.error);
+    }
+    return response;
+};

package/dist/client/api/stop-provider.d.ts

@@ -5,7 +5,7 @@ import { type StopProvideParams } from "../../schemas/index";
  * @param options - Options object with required topic
  * @param options.topic - Topic hex string to leave
  * @returns A promise that resolves to the stop provide response containing success status
- * @throws {Error} When the response type is not "stopProvide" or the request fails
+ * @throws {QvacErrorBase} When the response type is not "stopProvide" or the request fails
  */
 export declare function stopQVACProvider(params: StopProvideParams): Promise<{
     type: "stopProvide";

package/dist/client/api/stop-provider.js

@@ -1,12 +1,13 @@
 import {} from "../../schemas/index.js";
 import { send } from "../rpc/rpc-client.js";
+import { InvalidResponseError, ProviderStopFailedError, } from "../../utils/errors-client.js";
 /**
  * Stops a running provider service and leaves the specified topic.
  *
  * @param options - Options object with required topic
  * @param options.topic - Topic hex string to leave
  * @returns A promise that resolves to the stop provide response containing success status
- * @throws {Error} When the response type is not "stopProvide" or the request fails
+ * @throws {QvacErrorBase} When the response type is not "stopProvide" or the request fails
  */
 export async function stopQVACProvider(params) {
     const request = {
@@ -15,10 +16,10 @@ export async function stopQVACProvider(params) {
     };
     const response = await send(request);
     if (response.type !== "stopProvide") {
-        throw new Error("Invalid response type");
+        throw new InvalidResponseError("stopProvide");
     }
     if (response.error) {
-        throw new Error(response.error);
+        throw new ProviderStopFailedError(response.error);
     }
     return response;
 }

package/dist/client/api/text-to-speech.d.ts

@@ -0,0 +1,7 @@
+import { type TtsClientParams } from "../../schemas/index";
+export declare function textToSpeech(params: TtsClientParams): {
+    bufferStream: AsyncGenerator<number>;
+    buffer: Promise<number[]>;
+    done: Promise<boolean>;
+};
+//# sourceMappingURL=text-to-speech.d.ts.map

package/dist/client/api/text-to-speech.js

@@ -0,0 +1,58 @@
+import { ttsResponseSchema, } from "../../schemas/index.js";
+import { stream as streamRpc } from "../rpc/rpc-client.js";
+export function textToSpeech(params) {
+    const request = {
+        type: "textToSpeech",
+        modelId: params.modelId,
+        inputType: params.inputType,
+        text: params.text,
+        stream: params.stream,
+    };
+    let doneResolver = () => { };
+    const donePromise = new Promise((resolve) => {
+        doneResolver = resolve;
+    });
+    if (params.stream) {
+        const bufferStream = (async function* () {
+            for await (const response of streamRpc(request)) {
+                if (response.type === "textToSpeech") {
+                    const streamResponse = ttsResponseSchema.parse(response);
+                    if (streamResponse.buffer.length > 0) {
+                        yield* streamResponse.buffer;
+                    }
+                    if (streamResponse.done) {
+                        doneResolver(true);
+                    }
+                }
+            }
+        })();
+        return {
+            bufferStream,
+            buffer: Promise.resolve([]),
+            done: donePromise,
+        };
+    }
+    else {
+        const bufferStream = (async function* () {
+            //Empty generator for non-streaming mode
+        })();
+        const bufferPromise = (async () => {
+            let buffer = [];
+            for await (const response of streamRpc(request)) {
+                if (response.type === "textToSpeech") {
+                    const streamResponse = ttsResponseSchema.parse(response);
+                    buffer = buffer.concat(streamResponse.buffer);
+                    if (streamResponse.done) {
+                        doneResolver(true);
+                    }
+                }
+            }
+            return buffer;
+        })();
+        return {
+            bufferStream,
+            buffer: bufferPromise,
+            done: donePromise,
+        };
+    }
+}

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

@@ -6,8 +6,9 @@ import { type TranscribeClientParams } from "../../schemas/index";
  * @param params - The arguments for the transcription
  * @param params.modelId - The identifier of the transcription model to use
  * @param params.audioChunk - Audio input as either a file path (string) or audio buffer
+ * @param params.prompt - Optional initial prompt to guide the transcription
  * @yields {string} Text chunks as they are transcribed
- * @throws {Error} When transcription fails with an error message
+ * @throws {QvacErrorBase} When transcription fails with an error message
  */
 export declare function transcribeStream(params: TranscribeClientParams): AsyncGenerator<string, void, unknown>;
 /**
@@ -17,8 +18,9 @@ export declare function transcribeStream(params: TranscribeClientParams): AsyncG
  * @param params - The arguments for the transcription
  * @param params.modelId - The identifier of the transcription model to use
  * @param params.audioChunk - Audio input as either a file path (string) or audio buffer
+ * @param params.prompt - Optional initial prompt to guide the transcription
  * @returns {Promise<string>} The complete transcribed text
- * @throws {Error} When transcription fails (propagated from transcribeStream)
+ * @throws {QvacErrorBase} When transcription fails (propagated from transcribeStream)
  */
 export declare function transcribe(params: TranscribeClientParams): Promise<string>;
 //# sourceMappingURL=transcribe.d.ts.map

package/dist/client/api/transcribe.js

@@ -1,5 +1,6 @@
 import { transcribeStreamResponseSchema, } from "../../schemas/index.js";
 import { stream } from "../rpc/rpc-client.js";
+import { TranscriptionFailedError } from "../../utils/errors-client.js";
 /**
  * This function streams audio transcription results in real-time, yielding
  * text chunks as they become available from the model.
@@ -7,22 +8,24 @@ import { stream } from "../rpc/rpc-client.js";
  * @param params - The arguments for the transcription
  * @param params.modelId - The identifier of the transcription model to use
  * @param params.audioChunk - Audio input as either a file path (string) or audio buffer
+ * @param params.prompt - Optional initial prompt to guide the transcription
  * @yields {string} Text chunks as they are transcribed
- * @throws {Error} When transcription fails with an error message
+ * @throws {QvacErrorBase} When transcription fails with an error message
  */
 export async function* transcribeStream(params) {
     const request = {
         type: "transcribeStream",
         modelId: params.modelId,
         audioChunk: typeof params.audioChunk === "string"
-            ? params.audioChunk // File path - send directly
-            : params.audioChunk.toString("base64"), // Buffer - encode to base64
+            ? { type: "filePath", value: params.audioChunk }
+            : { type: "base64", value: params.audioChunk.toString("base64") },
+        ...(params.prompt && { prompt: params.prompt }),
     };
     for await (const response of stream(request)) {
         if (response.type === "transcribeStream") {
             const streamResponse = transcribeStreamResponseSchema.parse(response);
             if (streamResponse.error) {
-                throw new Error(`Transcription failed: ${streamResponse.error}`);
+                throw new TranscriptionFailedError(streamResponse.error);
             }
             if (streamResponse.text) {
                 yield streamResponse.text;
@@ -40,8 +43,9 @@ export async function* transcribeStream(params) {
  * @param params - The arguments for the transcription
  * @param params.modelId - The identifier of the transcription model to use
  * @param params.audioChunk - Audio input as either a file path (string) or audio buffer
+ * @param params.prompt - Optional initial prompt to guide the transcription
  * @returns {Promise<string>} The complete transcribed text
- * @throws {Error} When transcription fails (propagated from transcribeStream)
+ * @throws {QvacErrorBase} When transcription fails (propagated from transcribeStream)
  */
 export async function transcribe(params) {
     let fullText = "";

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

@@ -10,7 +10,7 @@ import { type TranslateClientParams, type TranslationStats } from "../../schemas
  * @param params.to - Target language code
  * @param params.stream - Whether to stream tokens (true) or return complete response (false). Defaults to true.
  * @returns Object with tokenStream generator and text/stats properties
- * @throws {Error} When translation fails with an error message or when language detection fails
+ * @throws {QvacErrorBase} When translation fails with an error message or when language detection fails
  * @example
  * ```typescript
  * // Streaming mode (default)

package/dist/client/api/translate.js

@@ -1,6 +1,7 @@
 import { stream as streamRpc } from "../rpc/rpc-client.js";
 import { translateResponseSchema, } from "../../schemas/index.js";
 import { detectOne } from "@qvac/langdetect-text";
+import { TranslationFailedError } from "../../utils/errors-client.js";
 /**
  * Translates text from one language to another using a specified translation model.
  * Supports both NMT (Neural Machine Translation) and LLM models.
@@ -12,7 +13,7 @@ import { detectOne } from "@qvac/langdetect-text";
  * @param params.to - Target language code
  * @param params.stream - Whether to stream tokens (true) or return complete response (false). Defaults to true.
  * @returns Object with tokenStream generator and text/stats properties
- * @throws {Error} When translation fails with an error message or when language detection fails
+ * @throws {QvacErrorBase} When translation fails with an error message or when language detection fails
  * @example
  * ```typescript
  * // Streaming mode (default)
@@ -48,7 +49,7 @@ export function translate(params) {
         if (modelType === "llm") {
             const detected = detectOne(params.text);
             if (detected.code === "und" || detected.language === "Undetermined") {
-                throw new Error("Could not detect the source language. Please specify the 'from' parameter explicitly.");
+                throw new TranslationFailedError("Could not detect the source language. Please specify the 'from' parameter explicitly.");
             }
             sourceLanguage = detected.language;
         }

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

@@ -2,10 +2,14 @@ import { type UnloadModelParams } from "../../schemas/index";
 /**
  * Unloads a previously loaded model from the server.
  *
+ * When the last model is unloaded (no more models remain), this function
+ * automatically closes the RPC connection, allowing the process to exit
+ * naturally without requiring manual cleanup.
+ *
  * @param params - The parameters for unloading the model
  * @param params.modelId - The unique identifier of the model to unload
  * @param params.clearStorage - Whether to clear the storage for the model
- * @throws {Error} When the response type is invalid or when the unload operation fails
+ * @throws {QvacErrorBase} When the response type is invalid or when the unload operation fails
  */
 export declare function unloadModel(params: UnloadModelParams): Promise<void>;
 //# sourceMappingURL=unload-model.d.ts.map

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

@@ -1,13 +1,18 @@
 import {} from "../../schemas/index.js";
-import { send } from "../rpc/rpc-client.js";
+import { send, close } from "../rpc/rpc-client.js";
 import { stopLoggingStreamForModel } from "../logging-stream-registry.js";
+import { InvalidResponseError, ModelUnloadFailedError, } from "../../utils/errors-client.js";
 /**
  * Unloads a previously loaded model from the server.
  *
+ * When the last model is unloaded (no more models remain), this function
+ * automatically closes the RPC connection, allowing the process to exit
+ * naturally without requiring manual cleanup.
+ *
  * @param params - The parameters for unloading the model
  * @param params.modelId - The unique identifier of the model to unload
  * @param params.clearStorage - Whether to clear the storage for the model
- * @throws {Error} When the response type is invalid or when the unload operation fails
+ * @throws {QvacErrorBase} When the response type is invalid or when the unload operation fails
  */
 export async function unloadModel(params) {
     const request = {
@@ -17,10 +22,15 @@ export async function unloadModel(params) {
     };
     const response = await send(request);
     if (response.type !== "unloadModel") {
-        throw new Error("Invalid response type");
+        throw new InvalidResponseError("unloadModel");
     }
     if (!response.success) {
-        throw new Error("Failed to unload model");
+        throw new ModelUnloadFailedError(params.modelId);
     }
     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...");
+        await close();
+    }
 }

package/dist/client/config-manager.d.ts

@@ -0,0 +1,4 @@
+import type { SDKConfig } from "../schemas/index";
+export declare const setCachedConfig: (config: SDKConfig) => void;
+export declare const getCachedConfig: () => SDKConfig;
+//# sourceMappingURL=config-manager.d.ts.map

package/dist/client/config-manager.js

@@ -0,0 +1,8 @@
+let cachedConfig;
+export const setCachedConfig = (config) => {
+    cachedConfig = config;
+    console.log("📦 Config cached client-side:", config);
+};
+export const getCachedConfig = () => {
+    return cachedConfig;
+};

package/dist/client/index.d.ts

@@ -1,2 +1,2 @@
-export { send, stream } from "./rpc/rpc-client";
+export { send, stream, close } from "./rpc/rpc-client";
 //# sourceMappingURL=index.d.ts.map

package/dist/client/index.js

@@ -1 +1 @@
-export { send, stream } from "./rpc/rpc-client.js";
+export { send, stream, close } from "./rpc/rpc-client.js";

package/dist/client/init-hooks.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Replays cached configuration to the worker after initialization.
+ * This ensures config persists across worker restarts.
+ */
+export declare const replayConfigIfCached: (rpc: any) => Promise<void>;
+//# sourceMappingURL=init-hooks.d.ts.map