@qvac/sdk 0.18.2 → 0.19.0

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

@@ -0,0 +1,128 @@
+import { send, stream } from '../rpc/rpc-client.js';
+import { startLoggingStreamForModel } from '../logging-stream-registry.js';
+import { loadBuiltinToRequestSchema, loadCustomPluginToRequestSchema, reloadConfigOptionsToRequestSchema, isBuiltInModelType, isModelTypeAlias, normalizeModelType, inferModelTypeFromModelSrc, ModelType } from '@qvac/inference/surface';
+import { ModelLoadFailedError, ModelTypeRequiredError, StreamEndedError, InvalidResponseError } from '../../utils/errors-client.js';
+import { assertModelSrcMatchesModelType } from '../../utils/load-model-validation.js';
+import { parseClientInput } from '../parse-input.js';
+import { getClientLogger } from '../../logging/index.js';
+import { decoratePromise } from '../../utils/decorate-promise.js';
+import { generateClientRequestId } from './client-request-id.js';
+const logger = getClientLogger();
+function isReactNativeRuntime() {
+    const runtime = globalThis;
+    return runtime.navigator?.product === 'ReactNative';
+}
+let warnedLocalVideoModelLoad = false;
+export function loadModel(options, rpcOptions) {
+    // Generate a stable `requestId` once, synchronously, before kicking
+    // off any async work. The same id is:
+    //   - threaded onto the request envelope (`request.requestId`) so the
+    //     server's `registry.begin(...)` records it on the registry
+    //     entry; and
+    //   - attached to the returned promise via `decoratePromise` so the
+    //     caller can target this exact call with `cancel({ requestId })`
+    //     before `await` resolves. Generating client-side and surfacing
+    //     it synchronously is what closes the "stop-button race" gap for
+    //     `loadModel` / `downloadAsset` callers — same shape as the
+    //     `CompletionRun.requestId` contract.
+    const requestId = generateClientRequestId();
+    const inner = runLoadModel(options, requestId, rpcOptions);
+    return decoratePromise(inner, { requestId });
+}
+async function runLoadModel(options, requestId, rpcOptions) {
+    const isReloadConfig = 'modelId' in options && !('modelSrc' in options);
+    // Infer `modelType` from `modelSrc` when omitted; the schema still validates
+    // the resolved options below.
+    let resolvedOptions = options;
+    if (!isReloadConfig) {
+        let modelType = resolvedOptions['modelType'];
+        if (typeof modelType === 'string') {
+            assertModelSrcMatchesModelType(resolvedOptions['modelSrc'], modelType);
+        }
+        else if (modelType === undefined) {
+            const inferred = inferModelTypeFromModelSrc(resolvedOptions['modelSrc']);
+            if (!inferred) {
+                throw new ModelTypeRequiredError();
+            }
+            resolvedOptions = { ...resolvedOptions, modelType: inferred };
+            modelType = inferred;
+        }
+        if (typeof modelType === 'string' && isModelTypeAlias(modelType)) {
+            const canonical = normalizeModelType(modelType);
+            logger.warn(`Model type "${modelType}" is an alias and will be deprecated. Use "${canonical}" instead.`);
+        }
+        const canonicalModelType = typeof modelType === 'string' ? normalizeModelType(modelType) : modelType;
+        const modelConfig = resolvedOptions['modelConfig'];
+        if (isReactNativeRuntime() &&
+            canonicalModelType === ModelType.sdcppGeneration &&
+            modelConfig?.mode === 'video' &&
+            !warnedLocalVideoModelLoad) {
+            warnedLocalVideoModelLoad = true;
+            const message = 'QVAC video generation works on React Native, but loading the video ' +
+                'model on-device will usually fail or take several minutes — the video ' +
+                'diffusion models currently shipped by the SDK are too large to load ' +
+                'on typical mobile devices.';
+            logger.warn(message);
+        }
+    }
+    // Splice the client-generated `requestId` onto the resolved options so
+    // the wire envelope carries it. The server uses the same value as the
+    // registry-entry key — that match is what makes
+    // `cancel({ requestId: op.requestId })` a no-op when no match exists
+    // and a precise abort when it does.
+    resolvedOptions = { ...resolvedOptions, requestId };
+    const request = isReloadConfig
+        ? parseClientInput(reloadConfigOptionsToRequestSchema, resolvedOptions)
+        : isBuiltInModelType(resolvedOptions['modelType'])
+            ? parseClientInput(loadBuiltinToRequestSchema, resolvedOptions)
+            : parseClientInput(loadCustomPluginToRequestSchema, resolvedOptions);
+    const modelLogger = isReloadConfig
+        ? undefined
+        : resolvedOptions['logger'];
+    const onProgress = isReloadConfig
+        ? undefined
+        : resolvedOptions['onProgress'];
+    if (onProgress) {
+        // Use streaming for progress updates
+        for await (const response of stream(request, rpcOptions)) {
+            if (response.type === 'modelProgress') {
+                onProgress(response);
+            }
+            else if (response.type === 'loadModel') {
+                if (!response.success) {
+                    throw new ModelLoadFailedError(response.error);
+                }
+                const modelId = response.modelId;
+                // Start logging stream in the background if logger is provided, catch to avoid failing the entire loadModel operation
+                if (modelLogger) {
+                    try {
+                        startLoggingStreamForModel(modelId, modelLogger);
+                    }
+                    catch (error) {
+                        logger.warn(`Failed to start logging stream for model ${modelId}:`, error);
+                    }
+                }
+                return modelId;
+            }
+        }
+        throw new StreamEndedError();
+    }
+    // Use regular send for simple loading
+    const response = await send(request, rpcOptions);
+    if (response.type !== 'loadModel') {
+        throw new InvalidResponseError('loadModel');
+    }
+    if (!response.success) {
+        throw new ModelLoadFailedError(response.error);
+    }
+    const modelId = response.modelId;
+    if (modelLogger) {
+        try {
+            startLoggingStreamForModel(modelId, modelLogger);
+        }
+        catch (error) {
+            logger.warn(`Failed to start logging stream for model ${modelId}:`, error);
+        }
+    }
+    return modelId;
+}

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

@@ -0,0 +1,24 @@
+import type { LoggingStreamResponse, LoggingParams } from '@qvac/inference/surface';
+/**
+ * Opens a logging stream to receive real-time logs.
+ *
+ * @param params - The arguments for the logging stream
+ * @param params.id - The unique identifier to stream logs for
+ * @returns AsyncGenerator yielding logging stream responses
+ * @throws {QvacErrorBase} When the response type is invalid or when the stream fails
+ *
+ * @example
+ * ```typescript
+ * // Open a logging stream for a model
+ * const logStream = loggingStream({ id: 'my-model-id' });
+ *
+ * // Or stream SDK server logs
+ * const sdkLogs = loggingStream({ id: SDK_LOG_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/src/client/api/logging-stream.js

@@ -0,0 +1,36 @@
+import { stream } from '../rpc/rpc-client.js';
+import { InvalidResponseError } from '../../utils/errors-client.js';
+/**
+ * Opens a logging stream to receive real-time logs.
+ *
+ * @param params - The arguments for the logging stream
+ * @param params.id - The unique identifier to stream logs for
+ * @returns AsyncGenerator yielding logging stream responses
+ * @throws {QvacErrorBase} When the response type is invalid or when the stream fails
+ *
+ * @example
+ * ```typescript
+ * // Open a logging stream for a model
+ * const logStream = loggingStream({ id: 'my-model-id' });
+ *
+ * // Or stream SDK server logs
+ * const sdkLogs = loggingStream({ id: SDK_LOG_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 InvalidResponseError('loggingStream');
+        }
+        yield response;
+    }
+}

package/dist/src/client/api/ocr.d.ts

@@ -0,0 +1,40 @@
+import { type OCRClientParams, type OCRTextBlock, type OCRStats } from '@qvac/inference/surface';
+/**
+ * Performs Optical Character Recognition (OCR) on an image to extract text.
+ *
+ * @param params - The OCR parameters
+ * @param params.modelId - The identifier of the loaded OCR model to use
+ * @param params.image - Image input as either a file path (string) or image buffer
+ * @param params.options - Optional OCR options (e.g., paragraph mode)
+ * @param params.stream - Whether to stream blocks as they're detected (true) or return all at once (false). Defaults to false
+ * @returns Object with blockStream generator, blocks promise, and stats promise
+ * @example
+ * ```typescript
+ * // Load an OCR model first. Registry GGUF models resolve their pipeline
+ * // and detector automatically:
+ * //   EasyOCR (default): OCR_LATIN  (CRAFT detector auto-derived)
+ * //   DocTR:             OCR_DOCTR  (DBNet detector auto-derived)
+ * const modelId = await loadModel({
+ *   modelSrc: OCR_LATIN.src,
+ *   modelType: MODEL_TYPES.ggmlOcr,
+ * });
+ *
+ * // Non-streaming mode (default) - get all blocks at once
+ * const { blocks } = ocr({ modelId, image: "/path/to/image.png" });
+ * for (const block of await blocks) {
+ *   console.log(block.text, block.bbox, block.confidence);
+ * }
+ *
+ * // Streaming mode - process blocks as they arrive
+ * const { blockStream } = ocr({ modelId, image: imageBuffer, stream: true });
+ * for await (const blocks of blockStream) {
+ *   console.log("Detected:", blocks);
+ * }
+ * ```
+ */
+export declare function ocr(params: OCRClientParams): {
+    blockStream: AsyncGenerator<OCRTextBlock[]>;
+    blocks: Promise<OCRTextBlock[]>;
+    stats: Promise<OCRStats | undefined>;
+};
+//# sourceMappingURL=ocr.d.ts.map

package/dist/src/client/api/ocr.js

@@ -0,0 +1,97 @@
+import { ocrStreamResponseSchema } from '@qvac/inference/surface';
+import { stream as streamRpc } from '../rpc/rpc-client.js';
+/**
+ * Performs Optical Character Recognition (OCR) on an image to extract text.
+ *
+ * @param params - The OCR parameters
+ * @param params.modelId - The identifier of the loaded OCR model to use
+ * @param params.image - Image input as either a file path (string) or image buffer
+ * @param params.options - Optional OCR options (e.g., paragraph mode)
+ * @param params.stream - Whether to stream blocks as they're detected (true) or return all at once (false). Defaults to false
+ * @returns Object with blockStream generator, blocks promise, and stats promise
+ * @example
+ * ```typescript
+ * // Load an OCR model first. Registry GGUF models resolve their pipeline
+ * // and detector automatically:
+ * //   EasyOCR (default): OCR_LATIN  (CRAFT detector auto-derived)
+ * //   DocTR:             OCR_DOCTR  (DBNet detector auto-derived)
+ * const modelId = await loadModel({
+ *   modelSrc: OCR_LATIN.src,
+ *   modelType: MODEL_TYPES.ggmlOcr,
+ * });
+ *
+ * // Non-streaming mode (default) - get all blocks at once
+ * const { blocks } = ocr({ modelId, image: "/path/to/image.png" });
+ * for (const block of await blocks) {
+ *   console.log(block.text, block.bbox, block.confidence);
+ * }
+ *
+ * // Streaming mode - process blocks as they arrive
+ * const { blockStream } = ocr({ modelId, image: imageBuffer, stream: true });
+ * for await (const blocks of blockStream) {
+ *   console.log("Detected:", blocks);
+ * }
+ * ```
+ */
+export function ocr(params) {
+    const request = {
+        type: 'ocrStream',
+        modelId: params.modelId,
+        image: typeof params.image === 'string'
+            ? { type: 'filePath', value: params.image }
+            : { type: 'base64', value: params.image.toString('base64') },
+        ...(params.options && { options: params.options })
+    };
+    let ocrStats;
+    let statsResolver = () => { };
+    const statsPromise = new Promise((resolve) => {
+        statsResolver = resolve;
+    });
+    if (params.stream) {
+        const blockStream = (async function* () {
+            for await (const response of streamRpc(request)) {
+                if (response.type === 'ocrStream') {
+                    const streamResponse = ocrStreamResponseSchema.parse(response);
+                    if (streamResponse.blocks && streamResponse.blocks.length > 0) {
+                        yield streamResponse.blocks;
+                    }
+                    if (streamResponse.done) {
+                        ocrStats = streamResponse.stats;
+                        statsResolver(ocrStats);
+                    }
+                }
+            }
+        })();
+        return {
+            blockStream,
+            blocks: Promise.resolve([]),
+            stats: statsPromise
+        };
+    }
+    else {
+        const blockStream = (async function* () {
+            // Empty generator for non-streaming mode
+        })();
+        const blocksPromise = (async () => {
+            let allBlocks = [];
+            for await (const response of streamRpc(request)) {
+                if (response.type === 'ocrStream') {
+                    const streamResponse = ocrStreamResponseSchema.parse(response);
+                    if (streamResponse.blocks) {
+                        allBlocks = allBlocks.concat(streamResponse.blocks);
+                    }
+                    if (streamResponse.done) {
+                        ocrStats = streamResponse.stats;
+                        statsResolver(ocrStats);
+                    }
+                }
+            }
+            return allBlocks;
+        })();
+        return {
+            blockStream,
+            blocks: blocksPromise,
+            stats: statsPromise
+        };
+    }
+}

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

@@ -0,0 +1,257 @@
+import type { RagChunkParams, RagDoc, RagIngestParams, RagSaveEmbeddingsParams, RagSaveEmbeddingsResult, RagSearchParams, RagSearchResult, RagDeleteEmbeddingsParams, RagReindexParams, RagReindexResult, RagWorkspaceInfo, RagCloseWorkspaceParams, RagDeleteWorkspaceParams, RPCOptions } from '@qvac/inference/surface';
+/**
+ * Chunks documents into smaller pieces for embedding.
+ * Part of the segregated flow: ragChunk() → embed() → ragSaveEmbeddings()
+ *
+ * @param params - The parameters for chunking
+ * @param params.documents - Documents to chunk (string or array)
+ * @param params.chunkOpts - Chunking options (chunkSize, chunkOverlap, chunkStrategy)
+ * @param options - Optional RPC options (timeout, profiling, force new connection, etc.).
+ * @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",
+ *   },
+ * });
+ * ```
+ */
+export declare function ragChunk(params: RagChunkParams, options?: RPCOptions): Promise<RagDoc[]>;
+/**
+ * @prototype The built-in RAG vector store is not production grade. For production, use an external vector DB (see the RAG guide).
+ *
+ * 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 embedding model, documents, optional chunking settings,
+ *   workspace (default: `"default"`), and progress callback configuration.
+ * @param options - Optional RPC options (timeout, profiling, force new connection, etc.).
+ * @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 declare function ragIngest(params: RagIngestParams, options?: RPCOptions): Promise<{
+    processed: RagSaveEmbeddingsResult[];
+    droppedIndices: number[];
+}> & {
+    requestId: string;
+};
+/**
+ * @prototype The built-in RAG vector store is not production grade. For production, use an external vector DB (see the RAG guide).
+ *
+ * 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 pre-embedded documents, workspace (default:
+ *   `"default"`), and optional progress callback configuration.
+ * @param options - Optional RPC options (timeout, profiling, force new connection, etc.).
+ * @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 { embedding: 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 declare function ragSaveEmbeddings(params: RagSaveEmbeddingsParams, options?: RPCOptions): Promise<RagSaveEmbeddingsResult[]> & {
+    requestId: string;
+};
+/**
+ * @prototype The built-in RAG vector store is not production grade. For production, use an external vector DB (see the RAG guide).
+ *
+ * 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").
+ * @param options - Optional RPC options (timeout, profiling, force new connection, etc.).
+ * @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",
+ * });
+ * ```
+ */
+export declare function ragSearch(params: RagSearchParams, options?: RPCOptions): Promise<RagSearchResult[]>;
+/**
+ * @prototype The built-in RAG vector store is not production grade. For production, use an external vector DB (see the RAG guide).
+ *
+ * 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.ids - Array of document IDs to delete
+ * @param params.workspace - Workspace to delete from (default: "default")
+ * @param options - Optional RPC options (timeout, profiling, force new connection, etc.).
+ * @throws {RAGDeleteFailedError} When the operation fails or workspace doesn't exist
+ *
+ * @example
+ * ```typescript
+ * await ragDeleteEmbeddings({
+ *   ids: ["doc-1", "doc-2"],
+ *   workspace: "my-docs",
+ * });
+ * ```
+ */
+export declare function ragDeleteEmbeddings(params: RagDeleteEmbeddingsParams, options?: RPCOptions): Promise<void>;
+/**
+ * @prototype The built-in RAG vector store is not production grade. For production, use an external vector DB (see the RAG guide).
+ *
+ * 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 existing workspace to reindex (default: `"default"`)
+ *   and optional progress callback.
+ * @param options - Optional RPC options (timeout, profiling, force new connection, etc.).
+ * @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 declare function ragReindex(params: RagReindexParams, options?: RPCOptions): Promise<RagReindexResult> & {
+    requestId: string;
+};
+/**
+ * @prototype The built-in RAG vector store is not production grade. For production, use an external vector DB (see the RAG guide).
+ *
+ * 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).
+ *
+ * @param options - Optional RPC options (timeout, profiling, force new connection, etc.).
+ * @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 declare function ragListWorkspaces(options?: RPCOptions): Promise<RagWorkspaceInfo[]>;
+/**
+ * @prototype The built-in RAG vector store is not production grade. For production, use an external vector DB (see the RAG guide).
+ *
+ * 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 workspace to close (default: `"default"`) and whether
+ *   its on-disk data should also be deleted.
+ * @param options - Optional RPC options (timeout, profiling, force new connection, etc.).
+ * @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 declare function ragCloseWorkspace(params?: RagCloseWorkspaceParams, options?: RPCOptions): Promise<void>;
+/**
+ * @prototype The built-in RAG vector store is not production grade. For production, use an external vector DB (see the RAG guide).
+ *
+ * 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
+ * @param options - Optional RPC options (timeout, profiling, force new connection, etc.).
+ * @throws {RAGDeleteFailedError} When the workspace doesn't exist or is currently loaded
+ *
+ * @example
+ * ```typescript
+ * await ragDeleteWorkspace({ workspace: "my-docs" });
+ * ```
+ */
+export declare function ragDeleteWorkspace(params: RagDeleteWorkspaceParams, options?: RPCOptions): Promise<void>;
+//# sourceMappingURL=rag.d.ts.map