@qvac/sdk 0.8.1 → 1.1.0

package/dist/client/api/rag.js

@@ -1,226 +1,52 @@
-import { send, stream } from "../rpc/rpc-client.js";
-import { InvalidResponseError, InvalidOperationError, StreamEndedError, RAGChunkFailedError, RAGSaveFailedError, RAGSearchFailedError, RAGDeleteFailedError, RAGCloseWorkspaceFailedError, RAGListWorkspacesFailedError, } from "../../utils/errors-client.js";
-// ============== Chunk ==============
+import { send } from "../rpc/rpc-client.js";
+// ============== Save Embeddings ==============
 /**
- * Chunks documents into smaller pieces for embedding.
- * Part of the segregated flow: ragChunk() → embed() → ragSaveEmbeddings()
+ * Saves document embeddings in the RAG vector database.
  *
- * @param params - The parameters for chunking
- * @param params.documents - Documents to chunk (string or array)
- * @param params.chunkOpts - Chunking options (chunkSize, chunkOverlap, chunkStrategy)
- * @returns Array of chunk results with id and content
- * @throws {RAGChunkFailedError} When the operation fails
- *
- * @example
- * ```typescript
- * const chunks = await ragChunk({
- *   documents: ["Long document text here..."],
- *   chunkOpts: {
- *     chunkSize: 256,
- *     chunkOverlap: 50,
- *     chunkStrategy: "paragraph",
- *   },
- * });
- * ```
+ * @param params - The parameters for saving embeddings
+ * @param params.modelId - The identifier of the embedding model to use
+ * @param params.documents - The documents to embed and save (string or array of strings)
+ * @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
+ * @returns The processed results and dropped indices
  */
-export async function ragChunk(params, options) {
+export async function ragSaveEmbeddings(params) {
     const request = {
         type: "rag",
-        operation: "chunk",
+        operation: "saveEmbeddings",
         ...params,
     };
-    const response = await send(request, options);
-    if (response.type !== "rag") {
-        throw new InvalidResponseError("rag");
-    }
-    if (!response.success) {
-        throw new RAGChunkFailedError(response.error);
-    }
-    if (response.operation !== "chunk") {
-        throw new InvalidOperationError();
-    }
-    return response.chunks;
-}
-// ============== Ingest ==============
-/**
- * Ingests documents into the RAG vector database.
- * Full pipeline: chunk → embed → save
- *
- * **Workspace lifecycle:** This operation implicitly opens (or creates) the workspace.
- * The workspace remains open until closed.
- *
- * @param params - The parameters for ingestion
- * @param params.modelId - The embedding model identifier
- * @param params.documents - Documents to ingest (string or array)
- * @param params.chunk - Whether to chunk documents (default: true)
- * @param params.chunkOpts - Chunking options
- * @param params.workspace - Workspace for isolated storage (default: "default"). Created if it doesn't exist.
- * @param params.onProgress - Progress callback (stage, current, total)
- * @param params.progressInterval - Minimum interval between progress updates in ms
- * @returns Processing results and dropped indices
- * @throws {RAGSaveFailedError} When the operation fails
- * @throws {StreamEndedError} When streaming ends unexpectedly (only when using onProgress)
- *
- * @example
- * ```typescript
- * // Simple ingest
- * const result = await ragIngest({
- *   modelId,
- *   documents: ["Document 1", "Document 2"],
- * });
- *
- * // With progress tracking
- * const result = await ragIngest({
- *   modelId,
- *   documents: ["Document 1", "Document 2"],
- *   workspace: "my-docs",
- *   onProgress: (stage, current, total) => {
- *     console.log(`[${stage}] ${current}/${total}`);
- *   },
- * });
- * ```
- */
-export async function ragIngest(params, options) {
-    const { onProgress, ...requestParams } = params;
-    const request = {
-        type: "rag",
-        operation: "ingest",
-        ...requestParams,
-        chunk: requestParams.chunk ?? true,
-        withProgress: onProgress ? true : undefined,
-    };
-    if (onProgress) {
-        // Use streaming for progress updates
-        for await (const event of stream(request, options)) {
-            if (event.type === "rag:progress" && event.operation === "ingest") {
-                const progress = event;
-                onProgress(progress.stage, progress.current, progress.total);
-                continue;
-            }
-            if (event.type === "rag" && event.operation === "ingest") {
-                if (!event.success) {
-                    throw new RAGSaveFailedError(event.error);
-                }
-                return {
-                    processed: event.processed,
-                    droppedIndices: event.droppedIndices,
-                };
-            }
-        }
-        throw new StreamEndedError();
-    }
-    const response = await send(request, options);
+    const response = await send(request);
     if (response.type !== "rag") {
-        throw new InvalidResponseError("rag");
+        throw new Error("Invalid response type");
     }
     if (!response.success) {
-        throw new RAGSaveFailedError(response.error);
+        throw new Error(response.error ?? "Failed to save embeddings");
     }
-    if (response.operation !== "ingest") {
-        throw new InvalidOperationError();
+    if (response.operation !== "saveEmbeddings") {
+        throw new Error("Invalid operation in response");
     }
     return {
         processed: response.processed,
         droppedIndices: response.droppedIndices,
     };
 }
-// ============== SaveEmbeddings ==============
-/**
- * Saves pre-embedded documents to the RAG vector database.
- * Part of the segregated flow: chunk() → embed() → saveEmbeddings()
- *
- * **Workspace lifecycle:** This operation implicitly opens (or creates) the workspace.
- * The workspace remains open until closed.
- *
- * @param params - The parameters for saving
- * @param params.documents - Pre-embedded documents (must have id, content, embedding, embeddingModelId)
- * @param params.workspace - Workspace for isolated storage (default: "default"). Created if it doesn't exist.
- * @param params.onProgress - Progress callback (stage, current, total)
- * @param params.progressInterval - Minimum interval between progress updates in ms
- * @returns Array of save results
- * @throws {RAGSaveFailedError} When the operation fails
- * @throws {StreamEndedError} When streaming ends unexpectedly (only when using onProgress)
- *
- * @example
- * ```typescript
- * // Segregated flow
- * const chunks = await ragChunk({ documents: ["text1", "text2"] });
- * const embeddings = await embed({ modelId, text: chunks.map(c => c.content) });
- * const embeddedDocs = chunks.map((chunk, i) => ({
- *   ...chunk,
- *   embedding: embeddings[i],
- *   embeddingModelId: modelId,
- * }));
- * const result = await ragSaveEmbeddings({
- *   documents: embeddedDocs,
- *   workspace: "my-workspace",
- * });
- * ```
- */
-export async function ragSaveEmbeddings(params, options) {
-    const { onProgress, ...requestParams } = params;
-    const request = {
-        type: "rag",
-        operation: "saveEmbeddings",
-        ...requestParams,
-        withProgress: onProgress ? true : undefined,
-    };
-    if (onProgress) {
-        for await (const event of stream(request, options)) {
-            if (event.type === "rag:progress" &&
-                event.operation === "saveEmbeddings") {
-                const progress = event;
-                onProgress(progress.stage, progress.current, progress.total);
-                continue;
-            }
-            if (event.type === "rag" && event.operation === "saveEmbeddings") {
-                if (!event.success) {
-                    throw new RAGSaveFailedError(event.error);
-                }
-                return event.processed;
-            }
-        }
-        throw new StreamEndedError();
-    }
-    const response = await send(request, options);
-    if (response.type !== "rag") {
-        throw new InvalidResponseError("rag");
-    }
-    if (!response.success) {
-        throw new RAGSaveFailedError(response.error);
-    }
-    if (response.operation !== "saveEmbeddings") {
-        throw new InvalidOperationError();
-    }
-    return response.processed;
-}
 // ============== Search ==============
 /**
  * Searches for similar documents in the RAG vector database.
  *
- * **Workspace lifecycle:** This operation requires an existing workspace. If the workspace
- * doesn't exist, returns an empty array.
- *
  * @param params - The parameters for searching
  * @param params.modelId - The identifier of the embedding model to use
  * @param params.query - The search query text
  * @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 - Workspace to search in (default: "default").
- * @returns Array of search results with id, content, and score. Empty array if workspace doesn't exist.
- * @throws {RAGSearchFailedError} When the operation fails
- *
- * @example
- * ```typescript
- * const results = await ragSearch({
- *   modelId,
- *   query: "AI and machine learning",
- *   topK: 5,
- *   workspace: "my-docs",
- * });
- * ```
+ * @param params.workspace - Optional workspace for isolated storage
+ * @throws {Error} 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, options) {
+export async function ragSearch(params) {
     const request = {
         type: "rag",
         operation: "search",
@@ -228,15 +54,15 @@ export async function ragSearch(params, options) {
         topK: params.topK ?? 5,
         n: params.n ?? 3,
     };
-    const response = await send(request, options);
+    const response = await send(request);
     if (response.type !== "rag") {
-        throw new InvalidResponseError("rag");
+        throw new Error("Invalid response type");
     }
     if (!response.success) {
-        throw new RAGSearchFailedError(response.error);
+        throw new Error(response.error ?? "Failed to search");
     }
     if (response.operation !== "search") {
-        throw new InvalidOperationError();
+        throw new Error("Invalid operation in response");
     }
     return response.results;
 }
@@ -244,214 +70,28 @@ export async function ragSearch(params, options) {
 /**
  * Deletes document embeddings from the RAG vector database.
  *
- * **Workspace lifecycle:** This operation requires an existing workspace.
- *
  * @param params - The parameters for deleting embeddings
+ * @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 - Workspace to delete from (default: "default")
- * @throws {RAGDeleteFailedError} When the operation fails or workspace doesn't exist
- *
- * @example
- * ```typescript
- * await ragDeleteEmbeddings({
- *   ids: ["doc-1", "doc-2"],
- *   workspace: "my-docs",
- * });
- * ```
+ * @param params.workspace - Optional workspace for isolated storage
+ * @throws {Error} When the response type is invalid or when the operation fails
+ * @returns boolean indicating success
  */
-export async function ragDeleteEmbeddings(params, options) {
+export async function ragDeleteEmbeddings(params) {
     const request = {
         type: "rag",
         operation: "deleteEmbeddings",
         ...params,
     };
-    const response = await send(request, options);
+    const response = await send(request);
     if (response.type !== "rag") {
-        throw new InvalidResponseError("rag");
+        throw new Error("Invalid response type");
     }
     if (!response.success) {
-        throw new RAGDeleteFailedError(response.error);
+        throw new Error(response.error ?? "Failed to delete embeddings");
     }
     if (response.operation !== "deleteEmbeddings") {
-        throw new InvalidOperationError();
-    }
-}
-// ============== Reindex ==============
-/**
- * Reindexes the RAG database to optimize search performance.
- * For HyperDB, this rebalances centroids using k-means clustering.
- *
- * **Workspace lifecycle:** This operation requires an existing workspace.
- *
- * **Note:** Reindex requires a minimum number of documents to perform clustering.
- * For HyperDB, this is 16 documents by default. If there are insufficient documents,
- * `reindexed` will be `false` with `details` explaining the reason.
- *
- * @param params - The parameters for reindexing
- * @param params.workspace - Workspace to reindex (default: "default"). Must already exist.
- * @param params.onProgress - Progress callback (stage, current, total)
- * @returns Reindex result with `reindexed` boolean and optional `details`
- * @throws {RAGSaveFailedError} When the operation fails or workspace doesn't exist
- * @throws {StreamEndedError} When streaming ends unexpectedly (only when using onProgress)
- *
- * @example
- * ```typescript
- * // Simple reindex
- * const result = await ragReindex({
- *   workspace: "my-docs",
- * });
- *
- * // Check result
- * if (!result.reindexed) {
- *   console.log("Reindex skipped:", result.details?.reason);
- * }
- *
- * // With progress tracking
- * const result = await ragReindex({
- *   workspace: "my-docs",
- *   onProgress: (stage, current, total) => {
- *     console.log(`[${stage}] ${current}/${total}`);
- *   },
- * });
- * ```
- */
-export async function ragReindex(params, options) {
-    const { onProgress, ...requestParams } = params;
-    const request = {
-        type: "rag",
-        operation: "reindex",
-        ...requestParams,
-        withProgress: onProgress ? true : undefined,
-    };
-    if (onProgress) {
-        for await (const event of stream(request, options)) {
-            if (event.type === "rag:progress" && event.operation === "reindex") {
-                const progress = event;
-                onProgress(progress.stage, progress.current, progress.total);
-                continue;
-            }
-            if (event.type === "rag" && event.operation === "reindex") {
-                if (!event.success) {
-                    throw new RAGSaveFailedError(event.error);
-                }
-                return event.result;
-            }
-        }
-        throw new StreamEndedError();
-    }
-    const response = await send(request, options);
-    if (response.type !== "rag") {
-        throw new InvalidResponseError("rag");
-    }
-    if (!response.success) {
-        throw new RAGSaveFailedError(response.error);
-    }
-    if (response.operation !== "reindex") {
-        throw new InvalidOperationError();
-    }
-    return response.result;
-}
-// ============== List Workspaces ==============
-/**
- * Lists all RAG workspaces with their open status.
- *
- * Returns all workspaces that exist on disk. The `open` field indicates whether
- * the workspace is currently loaded in memory and holding active resources
- * (Corestore, HyperDB adapter, and possibly a RAG instance).
- *
- * @returns Array of workspace info with name and open status
- * @throws {RAGListWorkspacesFailedError} When the operation fails
- *
- * @example
- * ```typescript
- * const workspaces = await ragListWorkspaces();
- * // [{ name: "default", open: true }, { name: "my-docs", open: false }]
- * ```
- */
-export async function ragListWorkspaces(options) {
-    const request = {
-        type: "rag",
-        operation: "listWorkspaces",
-    };
-    const response = await send(request, options);
-    if (response.type !== "rag") {
-        throw new InvalidResponseError("rag");
-    }
-    if (!response.success) {
-        throw new RAGListWorkspacesFailedError(response.error);
-    }
-    if (response.operation !== "listWorkspaces") {
-        throw new InvalidOperationError();
-    }
-    return response.workspaces;
-}
-// ============== Close Workspace ==============
-/**
- * Closes a RAG workspace, releasing in-memory resources (Corestore, HyperDB adapter, RAG instance).
- *
- * **Workspace lifecycle:** Workspaces are implicitly opened.
- * This function explicitly closes them, releasing memory and file locks. The workspace data
- * remains on disk unless `deleteOnClose` is set to true.
- *
- * @param params - The parameters for closing
- * @param params.workspace - Name of the workspace to close (default: "default")
- * @param params.deleteOnClose - If true, deletes the workspace data from disk after closing (default: false)
- * @throws {RAGCloseWorkspaceFailedError} When the operation fails
- *
- * @example
- * ```typescript
- * // Close a specific workspace
- * await ragCloseWorkspace({ workspace: "my-docs" });
- *
- * // Close and delete in one call
- * await ragCloseWorkspace({ workspace: "my-docs", deleteOnClose: true });
- * ```
- */
-export async function ragCloseWorkspace(params, options) {
-    const request = {
-        type: "rag",
-        operation: "closeWorkspace",
-        ...params,
-    };
-    const response = await send(request, options);
-    if (response.type !== "rag") {
-        throw new InvalidResponseError("rag");
-    }
-    if (!response.success) {
-        throw new RAGCloseWorkspaceFailedError(response.error);
-    }
-    if (response.operation !== "closeWorkspace") {
-        throw new InvalidOperationError();
-    }
-}
-// ============== Delete Workspace ==============
-/**
- * Deletes a RAG workspace and all its data.
- * The workspace must not be currently loaded/in-use.
- *
- * @param params - The parameters for deletion
- * @param params.workspace - Name of the workspace to delete
- * @throws {RAGDeleteFailedError} When the workspace doesn't exist or is currently loaded
- *
- * @example
- * ```typescript
- * await ragDeleteWorkspace({ workspace: "my-docs" });
- * ```
- */
-export async function ragDeleteWorkspace(params, options) {
-    const request = {
-        type: "rag",
-        operation: "deleteWorkspace",
-        ...params,
-    };
-    const response = await send(request, options);
-    if (response.type !== "rag") {
-        throw new InvalidResponseError("rag");
-    }
-    if (!response.success) {
-        throw new RAGDeleteFailedError(response.error);
-    }
-    if (response.operation !== "deleteWorkspace") {
-        throw new InvalidOperationError();
+        throw new Error("Invalid operation in response");
     }
+    return response.success;
 }

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 {QvacErrorBase} When the response type is not "stopProvide" or the request fails
+ * @throws {Error} 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,13 +1,12 @@
 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 {QvacErrorBase} When the response type is not "stopProvide" or the request fails
+ * @throws {Error} When the response type is not "stopProvide" or the request fails
  */
 export async function stopQVACProvider(params) {
     const request = {
@@ -16,10 +15,10 @@ export async function stopQVACProvider(params) {
     };
     const response = await send(request);
     if (response.type !== "stopProvide") {
-        throw new InvalidResponseError("stopProvide");
+        throw new Error("Invalid response type");
     }
     if (response.error) {
-        throw new ProviderStopFailedError(response.error);
+        throw new Error(response.error);
     }
     return response;
 }

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

@@ -1,5 +1,5 @@
-import { type TtsClientParams, type RPCOptions } from "../../schemas/index";
-export declare function textToSpeech(params: TtsClientParams, options?: RPCOptions): {
+import { type TtsClientParams } from "../../schemas/index";
+export declare function textToSpeech(params: TtsClientParams): {
     bufferStream: AsyncGenerator<number>;
     buffer: Promise<number[]>;
     done: Promise<boolean>;

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

@@ -1,6 +1,6 @@
 import { ttsResponseSchema, } from "../../schemas/index.js";
 import { stream as streamRpc } from "../rpc/rpc-client.js";
-export function textToSpeech(params, options) {
+export function textToSpeech(params) {
     const request = {
         type: "textToSpeech",
         modelId: params.modelId,
@@ -14,7 +14,7 @@ export function textToSpeech(params, options) {
     });
     if (params.stream) {
         const bufferStream = (async function* () {
-            for await (const response of streamRpc(request, options)) {
+            for await (const response of streamRpc(request)) {
                 if (response.type === "textToSpeech") {
                     const streamResponse = ttsResponseSchema.parse(response);
                     if (streamResponse.buffer.length > 0) {
@@ -38,7 +38,7 @@ export function textToSpeech(params, options) {
         })();
         const bufferPromise = (async () => {
             let buffer = [];
-            for await (const response of streamRpc(request, options)) {
+            for await (const response of streamRpc(request)) {
                 if (response.type === "textToSpeech") {
                     const streamResponse = ttsResponseSchema.parse(response);
                     buffer = buffer.concat(streamResponse.buffer);

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

@@ -1,4 +1,4 @@
-import { type TranscribeClientParams, type RPCOptions } from "../../schemas/index";
+import { type TranscribeClientParams } from "../../schemas/index";
 /**
  * This function streams audio transcription results in real-time, yielding
  * text chunks as they become available from the model.
@@ -7,11 +7,10 @@ import { type TranscribeClientParams, type RPCOptions } from "../../schemas/inde
  * @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
- * @param options - Optional RPC options including per-call profiling
  * @yields {string} Text chunks as they are transcribed
- * @throws {QvacErrorBase} When transcription fails with an error message
+ * @throws {Error} When transcription fails with an error message
  */
-export declare function transcribeStream(params: TranscribeClientParams, options?: RPCOptions): AsyncGenerator<string, void, unknown>;
+export declare function transcribeStream(params: TranscribeClientParams): AsyncGenerator<string, void, unknown>;
 /**
  * This function provides a simple interface for transcribing audio by
  * collecting all streaming results into a single string response.
@@ -20,9 +19,8 @@ export declare function transcribeStream(params: TranscribeClientParams, options
  * @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
- * @param options - Optional RPC options including per-call profiling
  * @returns {Promise<string>} The complete transcribed text
- * @throws {QvacErrorBase} When transcription fails (propagated from transcribeStream)
+ * @throws {Error} When transcription fails (propagated from transcribeStream)
  */
-export declare function transcribe(params: TranscribeClientParams, options?: RPCOptions): Promise<string>;
+export declare function transcribe(params: TranscribeClientParams): Promise<string>;
 //# sourceMappingURL=transcribe.d.ts.map

package/dist/client/api/transcribe.js

@@ -8,11 +8,10 @@ import { stream } from "../rpc/rpc-client.js";
  * @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
- * @param options - Optional RPC options including per-call profiling
  * @yields {string} Text chunks as they are transcribed
- * @throws {QvacErrorBase} When transcription fails with an error message
+ * @throws {Error} When transcription fails with an error message
  */
-export async function* transcribeStream(params, options) {
+export async function* transcribeStream(params) {
     const request = {
         type: "transcribeStream",
         modelId: params.modelId,
@@ -21,9 +20,12 @@ export async function* transcribeStream(params, options) {
             : { type: "base64", value: params.audioChunk.toString("base64") },
         ...(params.prompt && { prompt: params.prompt }),
     };
-    for await (const response of stream(request, options)) {
+    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}`);
+            }
             if (streamResponse.text) {
                 yield streamResponse.text;
             }
@@ -41,13 +43,12 @@ export async function* transcribeStream(params, options) {
  * @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
- * @param options - Optional RPC options including per-call profiling
  * @returns {Promise<string>} The complete transcribed text
- * @throws {QvacErrorBase} When transcription fails (propagated from transcribeStream)
+ * @throws {Error} When transcription fails (propagated from transcribeStream)
  */
-export async function transcribe(params, options) {
+export async function transcribe(params) {
     let fullText = "";
-    for await (const textChunk of transcribeStream(params, options)) {
+    for await (const textChunk of transcribeStream(params)) {
         fullText += textChunk;
     }
     return fullText;

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

@@ -1,4 +1,4 @@
-import { type TranslateClientParams, type TranslationStats, type RPCOptions } from "../../schemas/index";
+import { type TranslateClientParams, type TranslationStats } from "../../schemas/index";
 /**
  * Translates text from one language to another using a specified translation model.
  * Supports both NMT (Neural Machine Translation) and LLM models.
@@ -10,7 +10,7 @@ import { type TranslateClientParams, type TranslationStats, type RPCOptions } fr
  * @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 {QvacErrorBase} When translation fails with an error message or when language detection fails
+ * @throws {Error} When translation fails with an error message or when language detection fails
  * @example
  * ```typescript
  * // Streaming mode (default)
@@ -39,7 +39,7 @@ import { type TranslateClientParams, type TranslationStats, type RPCOptions } fr
  * console.log(await response.text);
  * ```
  */
-export declare function translate(params: TranslateClientParams, options?: RPCOptions): {
+export declare function translate(params: TranslateClientParams): {
     tokenStream: AsyncGenerator<string>;
     stats: Promise<TranslationStats | undefined>;
     text: Promise<string>;