@qvac/sdk 0.8.1 → 1.0.0

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

@@ -3,13 +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", "downloadAsset", or "rag")
+ * @param params.operation - The type of operation to cancel ("inference" or "download")
  * @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.delegate - Delegation target for remote download cancellation (optional)
- * @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
+ * @throws {Error} When the response type is invalid or when the cancellation fails
  *
  * @example
  * // Cancel inference
@@ -17,27 +15,11 @@ import { type CancelParams } from "../../schemas/index";
  *
  * @example
  * // Pause download (preserves partial file for automatic resume)
- * await cancel({ operation: "downloadAsset", downloadKey: "download-key" });
+ * await cancel({ operation: "download", downloadKey: "download-key" });
  *
  * @example
  * // Cancel download completely (deletes partial file)
- * await cancel({ operation: "downloadAsset", downloadKey: "download-key", clearCache: true });
- *
- * @example
- * // Cancel delegated remote download
- * await cancel({
- *   operation: "downloadAsset",
- *   downloadKey: "download-key",
- *   delegate: { topic: "topicHex", providerPublicKey: "peerHex" },
- * });
- *
- * @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" });
+ * await cancel({ operation: "download", downloadKey: "download-key", clearCache: true });
  */
 export declare function cancel(params: CancelParams): Promise<void>;
 //# sourceMappingURL=cancel.d.ts.map

package/dist/client/api/cancel.js

@@ -1,17 +1,14 @@
 import { send } from "../rpc/rpc-client.js";
 import {} from "../../schemas/index.js";
-import { InvalidResponseError, CancelFailedError } from "../../utils/errors-client.js";
 /**
  * Cancels an ongoing operation.
  *
  * @param params - The parameters for the cancellation
- * @param params.operation - The type of operation to cancel ("inference", "downloadAsset", or "rag")
+ * @param params.operation - The type of operation to cancel ("inference" or "download")
  * @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.delegate - Delegation target for remote download cancellation (optional)
- * @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
+ * @throws {Error} When the response type is invalid or when the cancellation fails
  *
  * @example
  * // Cancel inference
@@ -19,27 +16,11 @@ import { InvalidResponseError, CancelFailedError } from "../../utils/errors-clie
  *
  * @example
  * // Pause download (preserves partial file for automatic resume)
- * await cancel({ operation: "downloadAsset", downloadKey: "download-key" });
+ * await cancel({ operation: "download", downloadKey: "download-key" });
  *
  * @example
  * // Cancel download completely (deletes partial file)
- * await cancel({ operation: "downloadAsset", downloadKey: "download-key", clearCache: true });
- *
- * @example
- * // Cancel delegated remote download
- * await cancel({
- *   operation: "downloadAsset",
- *   downloadKey: "download-key",
- *   delegate: { topic: "topicHex", providerPublicKey: "peerHex" },
- * });
- *
- * @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" });
+ * await cancel({ operation: "download", downloadKey: "download-key", clearCache: true });
  */
 export async function cancel(params) {
     const request = {
@@ -48,9 +29,9 @@ export async function cancel(params) {
     };
     const response = await send(request);
     if (response.type !== "cancel") {
-        throw new InvalidResponseError("cancel");
+        throw new Error("Invalid response type");
     }
     if (!response.success) {
-        throw new CancelFailedError(response.error);
+        throw new Error(response.error ?? "Failed to cancel");
     }
 }

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

@@ -1,10 +1,4 @@
-import { type CompletionClientParams, type CompletionStats, type McpClientInput, type Tool, type ToolCallEvent, type ToolCallWithCall, type RPCOptions } from "../../schemas/index";
-import { type ToolInput } from "../../utils/tool-helpers";
-type CompletionParams = Omit<CompletionClientParams, "tools"> & {
-    tools?: Tool[] | ToolInput[];
-    mcp?: McpClientInput[];
-    rpcOptions?: RPCOptions;
-};
+import { type CompletionStats, type CompletionClientParams, type ToolCall, type ToolCallEvent } from "../../schemas/index";
 /**
  * Generates completion from a language model based on conversation history.
  *
@@ -12,8 +6,7 @@ type CompletionParams = Omit<CompletionClientParams, "tools"> & {
  * @param params.modelId - The identifier of the model to use for completion
  * @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.tools - Optional array of tools that can be used by the model
  * @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
@@ -22,11 +15,10 @@ 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 (with call() method), and stats promise
+ * @returns Object with tokenStream generator, toolCallStream generator, text promise, toolCalls promise, and stats promise
  * @example
  * ```typescript
- * import { z } from "zod";
- *
+ * // Streaming mode with tools
  * const result = completion({
  *   modelId: "llama-2",
  *   history: [
@@ -34,13 +26,15 @@ type CompletionParams = Omit<CompletionClientParams, "tools"> & {
  *   ],
  *   stream: true,
  *   tools: [{
+ *     type: "function",
  *     name: "get_weather",
  *     description: "Get current weather",
- *     parameters: z.object({
- *       city: z.string().describe("City name"),
- *     }),
- *     handler: async (args) => {
- *       return { temperature: 22, condition: "sunny" };
+ *     parameters: {
+ *       type: "object",
+ *       properties: {
+ *         city: { type: "string" }
+ *       },
+ *       required: ["city"]
  *     }
  *   }]
  * });
@@ -49,20 +43,32 @@ type CompletionParams = Omit<CompletionClientParams, "tools"> & {
  *   process.stdout.write(token);
  * }
  *
- * for (const toolCall of await result.toolCalls) {
- *   if (toolCall.invoke) {
- *     const toolResult = await toolCall.invoke();
- *     console.log(toolResult);
+ * for await (const evt of result.toolCallStream) {
+ *   if (evt.type === "toolCall") {
+ *     console.log("Tool:", evt.call.name, evt.call.arguments);
  *   }
  * }
+ *
+ * // Non-streaming mode
+ * const response = completion({
+ *   modelId: "llama-2",
+ *   history: [
+ *     { role: "user", content: "What is the capital of France?" }
+ *   ],
+ *   stream: false,
+ * });
+ *
+ * const text = await response.text;
+ * const stats = await response.stats;
+ * console.log(text);
+ * console.log(stats);
  * ```
  */
-export declare function completion(params: CompletionParams): {
+export declare function completion(params: CompletionClientParams): {
     tokenStream: AsyncGenerator<string>;
     toolCallStream: AsyncGenerator<ToolCallEvent>;
     stats: Promise<CompletionStats | undefined>;
     text: Promise<string>;
-    toolCalls: Promise<ToolCallWithCall[]>;
+    toolCalls: Promise<ToolCall[]>;
 };
-export {};
 //# sourceMappingURL=completion-stream.d.ts.map

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

@@ -1,9 +1,5 @@
-import { stream as streamRpc } from "../rpc/rpc-client.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();
+import { stream as streamRpc } from "../rpc/rpc-client.js";
 /**
  * Generates completion from a language model based on conversation history.
  *
@@ -11,8 +7,7 @@ const logger = getClientLogger();
  * @param params.modelId - The identifier of the model to use for completion
  * @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.tools - Optional array of tools that can be used by the model
  * @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
@@ -21,11 +16,10 @@ const logger = getClientLogger();
  *   - `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 (with call() method), and stats promise
+ * @returns Object with tokenStream generator, toolCallStream generator, text promise, toolCalls promise, and stats promise
  * @example
  * ```typescript
- * import { z } from "zod";
- *
+ * // Streaming mode with tools
  * const result = completion({
  *   modelId: "llama-2",
  *   history: [
@@ -33,13 +27,15 @@ const logger = getClientLogger();
  *   ],
  *   stream: true,
  *   tools: [{
+ *     type: "function",
  *     name: "get_weather",
  *     description: "Get current weather",
- *     parameters: z.object({
- *       city: z.string().describe("City name"),
- *     }),
- *     handler: async (args) => {
- *       return { temperature: 22, condition: "sunny" };
+ *     parameters: {
+ *       type: "object",
+ *       properties: {
+ *         city: { type: "string" }
+ *       },
+ *       required: ["city"]
  *     }
  *   }]
  * });
@@ -48,31 +44,44 @@ const logger = getClientLogger();
  *   process.stdout.write(token);
  * }
  *
- * for (const toolCall of await result.toolCalls) {
- *   if (toolCall.invoke) {
- *     const toolResult = await toolCall.invoke();
- *     console.log(toolResult);
+ * for await (const evt of result.toolCallStream) {
+ *   if (evt.type === "toolCall") {
+ *     console.log("Tool:", evt.call.name, evt.call.arguments);
  *   }
  * }
+ *
+ * // Non-streaming mode
+ * const response = completion({
+ *   modelId: "llama-2",
+ *   history: [
+ *     { role: "user", content: "What is the capital of France?" }
+ *   ],
+ *   stream: false,
+ * });
+ *
+ * const text = await response.text;
+ * const stats = await response.stats;
+ * console.log(text);
+ * console.log(stats);
  * ```
  */
 export function completion(params) {
+    const request = {
+        type: "completionStream",
+        ...params,
+        stream: params.stream ?? true,
+    };
     let stats;
     let statsResolver = () => { };
-    let statsRejecter = () => { };
-    const statsPromise = new Promise((resolve, reject) => {
+    const statsPromise = new Promise((resolve) => {
         statsResolver = resolve;
-        statsRejecter = reject;
     });
-    statsPromise.catch(() => { });
     let toolCallsArray = [];
     let toolCallsResolver = () => { };
-    let toolCallsRejecter = () => { };
-    const toolCallsPromise = new Promise((resolve, reject) => {
+    const toolCallsPromise = new Promise((resolve) => {
         toolCallsResolver = resolve;
-        toolCallsRejecter = reject;
     });
-    toolCallsPromise.catch(() => { });
+    const responses = streamRpc(request);
     const tokenQueue = [];
     const toolEventQueue = [];
     let tokenDone = false;
@@ -80,101 +89,48 @@ export function completion(params) {
     let tokenResolve = null;
     let toolResolve = null;
     let textBuffer = "";
-    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,
-                generationParams: params.generationParams,
-            };
-            const responses = streamRpc(request, params.rpcOptions);
-            for await (const response of responses) {
-                if (response &&
-                    typeof response === "object" &&
-                    "type" in response &&
-                    response.type === "completionStream") {
-                    const streamResponse = completionStreamResponseSchema.parse(response);
-                    if (!streamResponse.done) {
-                        const token = streamResponse.token;
-                        if (token) {
-                            textBuffer += token;
-                            tokenQueue.push(token);
-                            if (tokenResolve) {
-                                tokenResolve();
-                                tokenResolve = null;
-                            }
-                        }
-                        if (streamResponse.toolCallEvent) {
-                            toolEventQueue.push(streamResponse.toolCallEvent);
-                            if (toolResolve) {
-                                toolResolve();
-                                toolResolve = null;
-                            }
-                        }
+        for await (const response of responses) {
+            if (response &&
+                typeof response === "object" &&
+                "type" in response &&
+                response.type === "completionStream") {
+                const streamResponse = completionStreamResponseSchema.parse(response);
+                if (!streamResponse.done) {
+                    const token = streamResponse.token;
+                    textBuffer += token;
+                    tokenQueue.push(token);
+                    if (tokenResolve) {
+                        tokenResolve();
+                        tokenResolve = null;
                     }
-                    else {
-                        if (streamResponse.token) {
-                            textBuffer += streamResponse.token;
-                        }
-                        stats = streamResponse.stats;
-                        statsResolver(stats);
-                        const rawToolCalls = streamResponse.toolCalls || [];
-                        toolCallsArray = attachHandlersToToolCalls(rawToolCalls, allHandlers);
-                        toolCallsResolver(toolCallsArray);
-                        tokenDone = true;
-                        toolDone = true;
-                        if (tokenResolve) {
-                            tokenResolve();
-                            tokenResolve = null;
-                        }
+                    if (streamResponse.toolCallEvent) {
+                        toolEventQueue.push(streamResponse.toolCallEvent);
                         if (toolResolve) {
                             toolResolve();
                             toolResolve = null;
                         }
                     }
                 }
-            }
-        }
-        catch (error) {
-            streamError = error instanceof Error ? error : new Error(String(error));
-            statsRejecter(error);
-            toolCallsRejecter(error);
-            tokenDone = true;
-            toolDone = true;
-            if (tokenResolve) {
-                tokenResolve();
-                tokenResolve = null;
-            }
-            if (toolResolve) {
-                toolResolve();
-                toolResolve = null;
+                else {
+                    if (streamResponse.token) {
+                        textBuffer += streamResponse.token;
+                    }
+                    stats = streamResponse.stats;
+                    statsResolver(stats);
+                    toolCallsArray = streamResponse.toolCalls || [];
+                    toolCallsResolver(toolCallsArray);
+                    tokenDone = true;
+                    toolDone = true;
+                    if (tokenResolve) {
+                        tokenResolve();
+                        tokenResolve = null;
+                    }
+                    if (toolResolve) {
+                        toolResolve();
+                        toolResolve = null;
+                    }
+                }
             }
         }
     };
@@ -183,7 +139,6 @@ export function completion(params) {
         await statsPromise;
         return textBuffer;
     })();
-    textPromise.catch(() => { });
     if (params.stream) {
         const tokenStream = (async function* () {
             while (true) {
@@ -191,9 +146,6 @@ export function completion(params) {
                     yield tokenQueue.shift();
                 }
                 else if (tokenDone) {
-                    if (streamError !== null) {
-                        throw streamError;
-                    }
                     break;
                 }
                 else {
@@ -209,9 +161,6 @@ export function completion(params) {
                     yield toolEventQueue.shift();
                 }
                 else if (toolDone) {
-                    if (streamError !== null) {
-                        throw streamError;
-                    }
                     break;
                 }
                 else {

package/dist/client/api/delete-cache.js

@@ -1,5 +1,4 @@
 import { send } from "../rpc/rpc-client.js";
-import { InvalidDeleteCacheParamsError, DeleteCacheFailedError, } from "../../utils/errors-client.js";
 /**
  * Deletes KV cache files.
  *
@@ -36,11 +35,11 @@ export async function deleteCache(params) {
         };
     }
     else {
-        throw new InvalidDeleteCacheParamsError();
+        throw new Error("Invalid deleteCache parameters");
     }
     const response = (await send(req));
     if (!response.success && response.error) {
-        throw new DeleteCacheFailedError(response.error);
+        throw new Error(response.error);
     }
     return {
         success: response.success,

package/dist/client/api/download-asset.d.ts

@@ -1,4 +1,4 @@
-import { type DownloadAssetOptions as BaseDownloadAssetOptions, type RPCOptions } from "../../schemas/index";
+import { type DownloadAssetOptions as BaseDownloadAssetOptions } from "../../schemas/index";
 export type DownloadAssetOptions = BaseDownloadAssetOptions;
 /**
  * Downloads an asset (model file) without loading it into memory.
@@ -11,13 +11,12 @@ export type DownloadAssetOptions = BaseDownloadAssetOptions;
  *   - assetSrc: The location from which the asset is downloaded (local path, remote URL, or Hyperdrive URL)
  *   - seed: Optional boolean for hyperdrive seeding
  *   - onProgress: Optional callback for download progress
- * @param rpcOptions - Optional RPC options including per-call profiling configuration
  *
  * @returns Promise that resolves to the asset ID (either the provided assetSrc or a generated ID)
  *
- * @throws {QvacErrorBase} When asset download 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
+ * @throws {Error} When asset download 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
  *
  * @example
  * ```typescript
@@ -36,5 +35,5 @@ export type DownloadAssetOptions = BaseDownloadAssetOptions;
  * });
  * ```
  */
-export declare function downloadAsset(options: DownloadAssetOptions, rpcOptions?: RPCOptions): Promise<string>;
+export declare function downloadAsset(options: DownloadAssetOptions): Promise<string>;
 //# sourceMappingURL=download-asset.d.ts.map

package/dist/client/api/download-asset.js

@@ -1,6 +1,5 @@
 import { send, stream } from "../rpc/rpc-client.js";
-import { downloadAssetOptionsToRequestSchema, } from "../../schemas/index.js";
-import { DownloadAssetFailedError, StreamEndedError, InvalidResponseError, } from "../../utils/errors-client.js";
+import { downloadAssetRequestSchema, } from "../../schemas/index.js";
 /**
  * Downloads an asset (model file) without loading it into memory.
  *
@@ -12,13 +11,12 @@ import { DownloadAssetFailedError, StreamEndedError, InvalidResponseError, } fro
  *   - assetSrc: The location from which the asset is downloaded (local path, remote URL, or Hyperdrive URL)
  *   - seed: Optional boolean for hyperdrive seeding
  *   - onProgress: Optional callback for download progress
- * @param rpcOptions - Optional RPC options including per-call profiling configuration
  *
  * @returns Promise that resolves to the asset ID (either the provided assetSrc or a generated ID)
  *
- * @throws {QvacErrorBase} When asset download 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
+ * @throws {Error} When asset download 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
  *
  * @example
  * ```typescript
@@ -37,32 +35,38 @@ import { DownloadAssetFailedError, StreamEndedError, InvalidResponseError, } fro
  * });
  * ```
  */
-export async function downloadAsset(options, rpcOptions) {
-    const request = downloadAssetOptionsToRequestSchema.parse(options);
+export async function downloadAsset(options) {
+    const { assetSrc } = options;
+    const request = downloadAssetRequestSchema.parse({
+        type: "downloadAsset",
+        assetSrc: assetSrc,
+        withProgress: !!options.onProgress,
+        seed: options.seed,
+    });
     if (options.onProgress) {
         // Use streaming for progress updates
-        for await (const response of stream(request, rpcOptions)) {
+        for await (const response of stream(request)) {
             if (response.type === "modelProgress") {
                 options.onProgress(response);
             }
             else if (response.type === "downloadAsset") {
                 if (!response.success) {
-                    throw new DownloadAssetFailedError(response.error);
+                    throw new Error(response.error ?? "Failed to download asset");
                 }
-                return response.assetId;
+                return response.assetId ?? assetSrc;
             }
         }
-        throw new StreamEndedError();
+        throw new Error("Stream ended without final response");
     }
     else {
         // Use regular send for simple downloading
-        const response = await send(request, rpcOptions);
+        const response = await send(request);
         if (response.type !== "downloadAsset") {
-            throw new InvalidResponseError("downloadAsset");
+            throw new Error("Invalid response type");
         }
         if (!response.success) {
-            throw new DownloadAssetFailedError(response.error);
+            throw new Error(response.error ?? "Failed to download asset");
         }
-        return response.assetId;
+        return response.assetId ?? assetSrc;
     }
 }

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

@@ -1,28 +1,11 @@
-import { type RPCOptions } from "../../schemas/index";
+import { type EmbedParams } from "../../schemas/index";
 /**
- * Generates embeddings for a single text using a specified model.
+ * 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
- * @param options - Optional RPC options including per-call profiling
- * @throws {QvacErrorBase} When the response type is invalid or when the embedding fails
+ * @throws {Error} When the response type is invalid or when the embedding fails
  */
-export declare function embed(params: {
-    modelId: string;
-    text: string;
-}, options?: RPCOptions): 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
- * @param options - Optional RPC options including per-call profiling
- * @throws {QvacErrorBase} When the response type is invalid or when the embedding fails
- */
-export declare function embed(params: {
-    modelId: string;
-    text: string[];
-}, options?: RPCOptions): Promise<number[][]>;
+export declare function embed(params: EmbedParams): Promise<number[]>;
 //# sourceMappingURL=embed.d.ts.map