@qvac/sdk 0.1.0-dev.1760648187.328e967

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

@@ -0,0 +1,103 @@
+import { completionStreamResponseSchema, } from "../../schemas/index.js";
+import { stream as streamRpc } from "../rpc/rpc-client.js";
+/**
+ * Generates completion from a language model based on conversation history.
+ *
+ * @param params - The completion parameters
+ * @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 that can be used by the model
+ * @param params.kvCache - Optional boolean to enable KV cache for faster subsequent completions
+ * @returns Object with tokenStream generator, text promise, and stats promise
+ * @example
+ * ```typescript
+ * // Streaming mode
+ * const result = completion({
+ *   modelId: "llama-2",
+ *   history: [
+ *     { role: "user", content: "Hello, how are you?" }
+ *   ],
+ *   stream: true,
+ * });
+ *
+ * for await (const token of result.tokenStream) {
+ *   console.log(token);
+ * }
+ *
+ * const stats = await result.stats;
+ * console.log("Performance:", stats);
+ *
+ * // 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 = () => { };
+    const statsPromise = new Promise((resolve) => {
+        statsResolver = resolve;
+    });
+    if (params.stream) {
+        const tokenStream = (async function* () {
+            for await (const response of streamRpc(request)) {
+                if (response.type === "completionStream") {
+                    const streamResponse = completionStreamResponseSchema.parse(response);
+                    if (!streamResponse.done) {
+                        yield streamResponse.token;
+                    }
+                    else {
+                        stats = streamResponse.stats;
+                        statsResolver(stats);
+                    }
+                }
+            }
+        })();
+        const textPromise = Promise.resolve("");
+        return {
+            tokenStream,
+            text: textPromise,
+            stats: statsPromise,
+        };
+    }
+    else {
+        const tokenStream = (async function* () {
+            //Empty generator for non-streaming mode
+        })();
+        const textPromise = (async () => {
+            let buffer = "";
+            for await (const response of streamRpc(request)) {
+                if (response.type === "completionStream") {
+                    const streamResponse = completionStreamResponseSchema.parse(response);
+                    buffer += streamResponse.token;
+                    if (streamResponse.done) {
+                        stats = streamResponse.stats;
+                        statsResolver(stats);
+                    }
+                }
+            }
+            return buffer;
+        })();
+        return {
+            tokenStream,
+            text: textPromise,
+            stats: statsPromise,
+        };
+    }
+}

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

@@ -0,0 +1,39 @@
+import { type DownloadAssetOptions as BaseDownloadAssetOptions } from "../../schemas/index";
+export type DownloadAssetOptions = BaseDownloadAssetOptions;
+/**
+ * Downloads an asset (model file) without loading it into memory.
+ *
+ * This function is specifically designed for download-only operations and
+ * doesn't accept runtime configuration options like modelConfig or delegate.
+ * Use this for download-only operations instead of loadModel for better semantic clarity.
+ *
+ * @param options - Download configuration including:
+ *   - 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
+ *
+ * @returns Promise that resolves to the asset ID (either the provided assetSrc or a generated ID)
+ *
+ * @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
+ * // Download model without loading
+ * const assetId = await downloadAsset({
+ *   assetSrc: "/path/to/model.gguf",
+ *   seed: true
+ * });
+ *
+ * // Download with progress tracking
+ * const assetId = await downloadAsset({
+ *   assetSrc: "pear://key123/model.gguf",
+ *   onProgress: (progress) => {
+ *     console.log(`Downloaded: ${progress.percentage}%`);
+ *   }
+ * });
+ * ```
+ */
+export declare function downloadAsset(options: DownloadAssetOptions): Promise<string>;
+//# sourceMappingURL=download-asset.d.ts.map

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

@@ -0,0 +1,72 @@
+import { send, stream } from "../rpc/rpc-client.js";
+import { downloadAssetRequestSchema, } from "../../schemas/index.js";
+/**
+ * Downloads an asset (model file) without loading it into memory.
+ *
+ * This function is specifically designed for download-only operations and
+ * doesn't accept runtime configuration options like modelConfig or delegate.
+ * Use this for download-only operations instead of loadModel for better semantic clarity.
+ *
+ * @param options - Download configuration including:
+ *   - 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
+ *
+ * @returns Promise that resolves to the asset ID (either the provided assetSrc or a generated ID)
+ *
+ * @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
+ * // Download model without loading
+ * const assetId = await downloadAsset({
+ *   assetSrc: "/path/to/model.gguf",
+ *   seed: true
+ * });
+ *
+ * // Download with progress tracking
+ * const assetId = await downloadAsset({
+ *   assetSrc: "pear://key123/model.gguf",
+ *   onProgress: (progress) => {
+ *     console.log(`Downloaded: ${progress.percentage}%`);
+ *   }
+ * });
+ * ```
+ */
+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)) {
+            if (response.type === "modelProgress") {
+                options.onProgress(response);
+            }
+            else if (response.type === "downloadAsset") {
+                if (!response.success) {
+                    throw new Error(response.error ?? "Failed to download asset");
+                }
+                return response.assetId ?? assetSrc;
+            }
+        }
+        throw new Error("Stream ended without final response");
+    }
+    else {
+        // Use regular send for simple downloading
+        const response = await send(request);
+        if (response.type !== "downloadAsset") {
+            throw new Error("Invalid response type");
+        }
+        if (!response.success) {
+            throw new Error(response.error ?? "Failed to download asset");
+        }
+        return response.assetId ?? assetSrc;
+    }
+}

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

@@ -0,0 +1,11 @@
+import { type EmbedParams } from "../../schemas/index";
+/**
+ * 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 {Error} When the response type is invalid or when the embedding fails
+ */
+export declare function embed(params: EmbedParams): Promise<number[]>;
+//# sourceMappingURL=embed.d.ts.map

package/dist/client/api/embed.js

@@ -0,0 +1,24 @@
+import { send } from "../rpc/rpc-client.js";
+import {} from "../../schemas/index.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 {Error} When the response type is invalid or when the embedding fails
+ */
+export async function embed(params) {
+    const request = {
+        type: "embed",
+        ...params,
+    };
+    const response = await send(request);
+    if (response.type !== "embed") {
+        throw new Error("Invalid response type");
+    }
+    if (!response.success) {
+        throw new Error(response.error ?? "Failed to embed");
+    }
+    return response.embedding;
+}

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

@@ -0,0 +1,13 @@
+export { loadModel } from "./load-model";
+export { downloadAsset } from "./download-asset";
+export { completion } from "./completion-stream";
+export { unloadModel } from "./unload-model";
+export { loggingStream } from "./logging-stream";
+export { ping } from "./ping";
+export { transcribe, transcribeStream } from "./transcribe";
+export { embed } from "./embed";
+export { translate } from "./translate";
+export { cancel } from "./cancel";
+export { startQVACProvider } from "./provide";
+export { ragSaveEmbeddings, ragSearch, ragDeleteEmbeddings } from "./rag";
+//# sourceMappingURL=index.d.ts.map

package/dist/client/api/index.js

@@ -0,0 +1,12 @@
+export { loadModel } from "./load-model.js";
+export { downloadAsset } from "./download-asset.js";
+export { completion } from "./completion-stream.js";
+export { unloadModel } from "./unload-model.js";
+export { loggingStream } from "./logging-stream.js";
+export { ping } from "./ping.js";
+export { transcribe, transcribeStream } from "./transcribe.js";
+export { embed } from "./embed.js";
+export { translate } from "./translate.js";
+export { cancel } from "./cancel.js";
+export { startQVACProvider } from "./provide.js";
+export { ragSaveEmbeddings, ragSearch, ragDeleteEmbeddings } from "./rag.js";

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

@@ -0,0 +1,98 @@
+import { type Logger } from "../../logging/index";
+import { type LoadModelOptions as BaseLoadModelOptions } from "../../schemas/index";
+export type LoadModelOptions = BaseLoadModelOptions & {
+    logger?: Logger;
+};
+/**
+ * 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 {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
+ *
+ * @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";
+ * 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!
+ * ```
+ */
+export declare function loadModel(options: LoadModelOptions): Promise<string>;
+//# sourceMappingURL=load-model.d.ts.map

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

@@ -0,0 +1,154 @@
+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";
+/**
+ * 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 {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
+ *
+ * @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!
+ * ```
+ */
+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,
+    });
+    if (options.onProgress) {
+        // Use streaming for progress updates
+        for await (const response of stream(request)) {
+            if (response.type === "modelProgress") {
+                options.onProgress(response);
+            }
+            else if (response.type === "loadModel") {
+                if (!response.success) {
+                    throw new Error(response.error ?? "Failed to load model");
+                }
+                const modelId = response.modelId ?? modelSrc;
+                // Start logging stream in the background if logger is provided, catch to avoid failing the entire loadModel operation
+                if (logger) {
+                    try {
+                        startLoggingStreamForModel(modelId, logger);
+                    }
+                    catch (error) {
+                        console.warn(`Failed to start logging stream for model ${modelId}:`, error);
+                    }
+                }
+                return modelId;
+            }
+        }
+        throw new Error("Stream ended without final response");
+    }
+    else {
+        // Use regular send for simple loading
+        const response = await send(request);
+        if (response.type !== "loadModel") {
+            throw new Error("Invalid response type");
+        }
+        if (!response.success) {
+            throw new Error(response.error ?? "Failed to load model");
+        }
+        const modelId = response.modelId ?? modelSrc;
+        if (logger) {
+            try {
+                startLoggingStreamForModel(modelId, logger);
+            }
+            catch (error) {
+                console.warn(`Failed to start logging stream for model ${modelId}:`, error);
+            }
+        }
+        return modelId;
+    }
+}

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

@@ -0,0 +1,21 @@
+import type { LoggingStreamResponse, LoggingParams } from "../../schemas/logging-stream";
+/**
+ * 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
+ *
+ * @example
+ * ```typescript
+ * // Open a logging stream for a model
+ * const logStream = loggingStream({ modelId: 'my-model-id' });
+ *
+ * for await (const logMessage of logStream) {
+ *   console.log(`[${logMessage.level}] ${logMessage.namespace}: ${logMessage.message}`);
+ * }
+ * ```
+ */
+export declare function loggingStream(params: LoggingParams): AsyncGenerator<LoggingStreamResponse>;
+//# sourceMappingURL=logging-stream.d.ts.map

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

@@ -0,0 +1,32 @@
+import { stream } from "../rpc/rpc-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
+ *
+ * @example
+ * ```typescript
+ * // Open a logging stream for a model
+ * const logStream = loggingStream({ modelId: 'my-model-id' });
+ *
+ * for await (const logMessage of logStream) {
+ *   console.log(`[${logMessage.level}] ${logMessage.namespace}: ${logMessage.message}`);
+ * }
+ * ```
+ */
+export async function* loggingStream(params) {
+    const request = {
+        type: "loggingStream",
+        ...params,
+    };
+    const responseStream = stream(request);
+    for await (const response of responseStream) {
+        if (response.type !== "loggingStream") {
+            throw new Error("Invalid response type");
+        }
+        yield response;
+    }
+}

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

@@ -0,0 +1,11 @@
+/**
+ * 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".
+ */
+export declare function ping(): Promise<{
+    type: "pong";
+    number: number;
+}>;
+//# sourceMappingURL=ping.d.ts.map

package/dist/client/api/ping.js

@@ -0,0 +1,18 @@
+import {} from "../../schemas/index.js";
+import { send } from "../rpc/rpc-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".
+ */
+export async function ping() {
+    const request = {
+        type: "ping",
+    };
+    const response = await send(request);
+    if (response.type !== "pong") {
+        throw new Error("Invalid response type");
+    }
+    return response;
+}

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

@@ -0,0 +1,18 @@
+import { type ProvideParams } from "../../schemas/index";
+/**
+ * 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.
+ *
+ * @param options - Options object with required topic, optional seed, and optional firewall config
+ * @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
+ */
+export declare function startQVACProvider(params: ProvideParams): Promise<{
+    type: "provide";
+    success: boolean;
+    error?: string | undefined;
+    publicKey?: string | undefined;
+}>;
+//# sourceMappingURL=provide.d.ts.map

package/dist/client/api/provide.js

@@ -0,0 +1,27 @@
+import {} from "../../schemas/index.js";
+import { send } from "../rpc/rpc-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.
+ *
+ * @param options - Options object with required topic, optional seed, and optional firewall config
+ * @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
+ */
+export async function startQVACProvider(params) {
+    const request = {
+        type: "provide",
+        topic: params.topic,
+        firewall: params.firewall,
+    };
+    const response = await send(request);
+    if (response.type !== "provide") {
+        throw new Error("Invalid response type");
+    }
+    if (response.error) {
+        throw new Error(response.error);
+    }
+    return response;
+}