@qvac/sdk 0.4.1 → 0.6.0

package/dist/server/bare/addons/onnx-ocr/handlers/ocr-stream.js

@@ -0,0 +1,109 @@
+import { getModel } from "../../../registry/model-registry.js";
+import fs from "bare-fs";
+import path from "bare-path";
+import { getCacheDir } from "../../../../utils/index.js";
+import { ImageFileNotFoundError, InvalidImageInputError, } from "../../../../../utils/errors-server.js";
+function polygonToBbox(polygon) {
+    const xs = polygon.map((p) => p[0]);
+    const ys = polygon.map((p) => p[1]);
+    return [Math.min(...xs), Math.min(...ys), Math.max(...xs), Math.max(...ys)];
+}
+function normalizeBlock(block) {
+    if (block &&
+        typeof block === "object" &&
+        !Array.isArray(block) &&
+        "text" in block) {
+        const obj = block;
+        return {
+            text: obj.text || "",
+            ...(obj.bbox && { bbox: obj.bbox }),
+            ...(obj.confidence !== undefined && { confidence: obj.confidence }),
+        };
+    }
+    // Addon format: [polygon, text, confidence] where polygon is [[x1,y1], [x2,y2], [x3,y3], [x4,y4]]
+    if (Array.isArray(block) && block.length >= 2) {
+        const blockArr = block;
+        const [polygonOrBbox, text, confidence] = blockArr;
+        const textStr = typeof text === "string" ? text : "";
+        if (Array.isArray(polygonOrBbox) &&
+            polygonOrBbox.length === 4 &&
+            Array.isArray(polygonOrBbox[0]) &&
+            polygonOrBbox[0].length === 2) {
+            return {
+                text: textStr,
+                bbox: polygonToBbox(polygonOrBbox),
+                ...(confidence !== undefined && { confidence: Number(confidence) }),
+            };
+        }
+        if (Array.isArray(polygonOrBbox) &&
+            polygonOrBbox.length === 4 &&
+            typeof polygonOrBbox[0] === "number") {
+            return {
+                text: textStr,
+                bbox: polygonOrBbox,
+                ...(confidence !== undefined && { confidence: Number(confidence) }),
+            };
+        }
+    }
+    return null;
+}
+export async function* ocr(params) {
+    const model = getModel(params.modelId);
+    let imagePath;
+    let cleanupPath = null;
+    switch (params.image.type) {
+        case "base64": {
+            const tempDir = getCacheDir("tmp");
+            const tempPath = path.join(tempDir, `ocr-${Date.now()}.png`);
+            fs.writeFileSync(tempPath, Buffer.from(params.image.value, "base64"));
+            imagePath = tempPath;
+            cleanupPath = tempPath;
+            break;
+        }
+        case "filePath": {
+            imagePath = params.image.value;
+            try {
+                fs.accessSync(imagePath);
+            }
+            catch (error) {
+                throw new ImageFileNotFoundError(imagePath, error);
+            }
+            break;
+        }
+        default:
+            throw new InvalidImageInputError();
+    }
+    try {
+        const response = (await model.run({
+            path: imagePath,
+            ...(params.options && { options: params.options }),
+        }));
+        const rawData = [];
+        await response
+            .onUpdate((data) => {
+            rawData.push(data);
+            return [];
+        })
+            .await();
+        const blocks = rawData
+            .flat(1)
+            .map(normalizeBlock)
+            .filter((b) => b !== null);
+        if (blocks.length > 0) {
+            yield { blocks };
+        }
+        if (response.stats) {
+            yield { blocks: [], stats: response.stats };
+        }
+    }
+    finally {
+        if (cleanupPath) {
+            try {
+                fs.unlinkSync(cleanupPath);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+    }
+}

package/dist/server/bare/addons/onnx-ocr/index.d.ts

@@ -0,0 +1,3 @@
+export { createOCRModel } from "./create-model";
+export { ocr } from "./handlers/ocr-stream";
+//# sourceMappingURL=index.d.ts.map

package/dist/server/bare/addons/onnx-ocr/index.js

@@ -0,0 +1,2 @@
+export { createOCRModel } from "./create-model.js";
+export { ocr } from "./handlers/ocr-stream.js";

package/dist/server/bare/addons/unload-model.js

@@ -2,9 +2,11 @@ import { promises as fsPromises } from "bare-fs";
 import path from "bare-path";
 import { unregisterModel } from "../registry/model-registry.js";
 import { unregisterAllLoggingStreams } from "../registry/logging-stream-registry.js";
+import { unregisterAddonLogger, getServerLogger } from "../../../logging/index.js";
 import { unloadModelParamsSchema } from "../../../schemas/index.js";
 import { ModelNotLoadedError } from "../../../utils/errors-server.js";
 import { detectShardedModel } from "../../utils/index.js";
+const logger = getServerLogger();
 export async function unloadModel(params) {
     const { modelId, clearStorage } = unloadModelParamsSchema.parse(params);
     const entry = unregisterModel(modelId);
@@ -25,14 +27,15 @@ export async function unloadModel(params) {
             // Delete entire shard directory
             const shardDir = path.dirname(modelPath);
             await fsPromises.rm(shardDir, { recursive: true, force: true });
-            console.log(`Sharded model storage cleared: ${shardDir}`);
+            logger.info(`Sharded model storage cleared: ${shardDir}`);
         }
         else {
             // Delete single file
             await fsPromises.rm(modelPath, { recursive: true, force: true });
-            console.log(`Model storage cleared: ${modelPath}`);
+            logger.info(`Model storage cleared: ${modelPath}`);
         }
     }
+    unregisterAddonLogger(modelId);
     unregisterAllLoggingStreams(modelId);
-    console.log(`Model ${modelId} unloaded`);
+    logger.info(`Model ${modelId} unloaded`);
 }

package/dist/server/bare/addons/{whispercpp → whispercpp-transcription}/create-model.js

@@ -1,4 +1,4 @@
-import TranscriptionWhispercpp from "@qvac/transcription-whispercpp";
+import TranscriptionWhispercpp, {} from "@qvac/transcription-whispercpp";
 import {} from "../../registry/model-registry.js";
 import {} from "../../../../schemas/index.js";
 import { createStreamLogger } from "../../../../logging/index.js";
@@ -26,6 +26,7 @@ export function createWhisperModel(modelId, modelPath, whisperConfig, vadModelPa
         },
     };
     const { contextParams, miscConfig, ...whisperParams } = whisperConfig;
+    // Cast to upstream type - our stricter Zod schema is compatible at runtime
     const config = {
         whisperConfig: whisperParams,
         ...(contextParams && { contextParams }),

package/dist/server/bare/addons/whispercpp-transcription/handlers/transcribe-stream.js

@@ -0,0 +1,82 @@
+import { getModel, getModelConfig, } from "../../../registry/model-registry.js";
+import { Readable } from "bare-stream";
+import fs from "bare-fs";
+import { needsDecoding, decodeAudioToStream } from "../../../../utils/index.js";
+import {} from "../../../../../schemas/index.js";
+import { AudioFileNotFoundError, InvalidAudioChunkError, } from "../../../../../utils/errors-server.js";
+import { getServerLogger } from "../../../../../logging/index.js";
+const logger = getServerLogger();
+export async function* transcribe(params) {
+    const model = getModel(params.modelId);
+    const modelConfig = getModelConfig(params.modelId);
+    let originalConfig = null;
+    const audioFormat = modelConfig.audio_format || "s16le";
+    if (params.prompt && typeof model.reload === "function") {
+        originalConfig = modelConfig;
+        const updatedConfig = {
+            ...originalConfig,
+            initial_prompt: params.prompt,
+        };
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { contextParams: _, miscConfig, ...whisperParams } = updatedConfig;
+        await model.reload({
+            whisperConfig: whisperParams,
+            ...(miscConfig && { miscConfig }),
+        });
+    }
+    try {
+        let audioStream;
+        const audioChunk = params.audioChunk;
+        switch (audioChunk.type) {
+            case "base64": {
+                const audioBuffer = Buffer.from(audioChunk.value, "base64");
+                audioStream = Readable.from([audioBuffer]);
+                break;
+            }
+            case "filePath": {
+                const filePath = audioChunk.value;
+                try {
+                    fs.accessSync(filePath);
+                }
+                catch (error) {
+                    throw new AudioFileNotFoundError(filePath, error);
+                }
+                if (needsDecoding(filePath)) {
+                    audioStream = await decodeAudioToStream(filePath, audioFormat);
+                }
+                else {
+                    audioStream = fs.createReadStream(filePath);
+                }
+                break;
+            }
+            default:
+                throw new InvalidAudioChunkError();
+        }
+        // Run transcription with streaming enabled
+        const response = await model.run(audioStream);
+        for await (const output of response.iterate()) {
+            logger.debug("Streaming Transcription Update:", output);
+            // Filter out blank audio chunks and process the text
+            const text = output
+                .filter((chunk) => !chunk.text.includes("[BLANK_AUDIO]"))
+                .map((chunk) => chunk.text)
+                .join("");
+            if (text.trim()) {
+                yield text;
+            }
+        }
+    }
+    finally {
+        if (originalConfig && typeof model.reload === "function") {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const { contextParams: _, miscConfig, ...whisperParams } = originalConfig;
+            await model.reload({
+                whisperConfig: {
+                    ...whisperParams,
+                    initial_prompt: "",
+                },
+                ...(miscConfig && { miscConfig }),
+            });
+        }
+    }
+}

package/dist/server/bare/delegate-rpc-client.js

@@ -2,8 +2,21 @@ import { getSwarm } from "./hyperswarm.js";
 import RPC from "bare-rpc";
 import { withTimeout } from "../../utils/withTimeout.js";
 import { DelegateConnectionFailedError } from "../../utils/errors-server.js";
+import { getServerLogger } from "../../logging/index.js";
+const logger = getServerLogger();
 // Map of active RPC instances by public key
 const activeRPCs = new Map();
+// Map to store underlying connections for cleanup
+const activeConnections = new Map();
+function closeConnection(publicKey) {
+    const existingConnection = activeConnections.get(publicKey);
+    if (existingConnection) {
+        logger.info(`🔌 Closing existing connection for peer: ${publicKey}`);
+        existingConnection.destroy();
+        activeConnections.delete(publicKey);
+        activeRPCs.delete(publicKey);
+    }
+}
 // Establish RPC connection to a peer if not already connected
 async function ensureRPCConnection(topic, publicKey, timeout) {
     // Check if we already have an RPC instance for this peer
@@ -12,7 +25,7 @@ async function ensureRPCConnection(topic, publicKey, timeout) {
     if (!rpc) {
         // Need to establish connection first
         try {
-            console.log(`🔗 Establishing RPC connection to topic: ${topic}, peer: ${publicKey}, timeout: ${timeout}ms`);
+            logger.info(`🔗 Establishing RPC connection to topic: ${topic}, peer: ${publicKey}, timeout: ${timeout}ms`);
             const connectionPromise = (async () => {
                 const topicBuffer = Buffer.from(topic, "hex");
                 // const discovery =
@@ -21,23 +34,23 @@ async function ensureRPCConnection(topic, publicKey, timeout) {
                     client: true,
                 });
                 await swarm.flush();
-                console.log(`✅ Connected to topic: ${topic}`);
-                console.log(`📊 Active RPC connections: ${activeRPCs.size}`);
+                logger.info(`✅ Connected to topic: ${topic}`);
+                logger.debug(`📊 Active RPC connections: ${activeRPCs.size}`);
                 // Check again if we now have an RPC instance for the target peer
                 rpc = activeRPCs.get(publicKey);
                 if (!rpc) {
-                    console.error(`❌ No RPC instance found for peer ${publicKey}`);
-                    console.log(`📊 Available RPC connections:`, Array.from(activeRPCs.keys()));
+                    logger.error(`❌ No RPC instance found for peer ${publicKey}`);
+                    logger.debug(`📊 Available RPC connections:`, Array.from(activeRPCs.keys()));
                     throw new DelegateConnectionFailedError(`Could not establish RPC connection to peer ${publicKey} on topic ${topic}`);
                 }
                 else {
-                    console.log(`✅ RPC instance found for peer ${publicKey}`);
+                    logger.debug(`✅ RPC instance found for peer ${publicKey}`);
                 }
             })();
             await withTimeout(connectionPromise, timeout);
         }
         catch (error) {
-            console.error("Failed to establish RPC connection:", error);
+            logger.error("Failed to establish RPC connection:", error);
             throw new DelegateConnectionFailedError(`RPC connection failed: ${error instanceof Error ? error.message : String(error)}`, error);
         }
     }
@@ -46,25 +59,32 @@ async function ensureRPCConnection(topic, publicKey, timeout) {
 // Create an RPC instance for a specific HyperSwarm peer
 export async function getRPC(topic, publicKey, options = {}) {
     const swarm = getSwarm();
+    // Close existing connection if forceNewConnection is true
+    if (options.forceNewConnection) {
+        closeConnection(publicKey);
+    }
     // Set up connection tracking
     swarm.on("connection", (conn) => {
         const peerPubkey = conn.remotePublicKey?.toString("hex");
         if (!peerPubkey)
             return;
-        console.log(`🍺 New peer connection established: ${peerPubkey}`);
+        logger.debug(`🍺 New peer connection established: ${peerPubkey}`);
         // Create RPC instance for this connection (as client)
         const rpc = new RPC(conn, () => {
             // No-op handler since we're only sending requests, not receiving them
         });
-        // Store RPC instance by peer ID for lookup
+        // Store RPC instance and connection by peer ID for lookup
         activeRPCs.set(peerPubkey, rpc);
+        activeConnections.set(peerPubkey, conn);
         conn.on("close", () => {
-            console.log(`Connection closed for peer: ${peerPubkey}`);
+            logger.debug(`Connection closed for peer: ${peerPubkey}`);
             activeRPCs.delete(peerPubkey);
+            activeConnections.delete(peerPubkey);
         });
         conn.on("error", (err) => {
-            console.error(`Connection error for peer ${peerPubkey}:`, err);
+            logger.error(`Connection error for peer ${peerPubkey}:`, err);
             activeRPCs.delete(peerPubkey);
+            activeConnections.delete(peerPubkey);
         });
     });
     return await ensureRPCConnection(topic, publicKey, options.timeout);

package/dist/server/bare/hyperswarm.js

@@ -3,13 +3,15 @@ import Hyperswarm from "hyperswarm";
 import crypto from "bare-crypto";
 import { envSchema } from "../../schemas/provide.js";
 import { getSDKConfig } from "./registry/config-registry.js";
+import { getServerLogger } from "../../logging/index.js";
+const logger = getServerLogger();
 function getHyperswarmSeedBuffer() {
     const parsedEnv = envSchema.safeParse(process.env);
     if (parsedEnv.success) {
         return Buffer.from(parsedEnv.data.QVAC_HYPERSWARM_SEED, "hex");
     }
     else {
-        console.log(`🎲 No seed provided, generating random seed (provider will have random identity)`);
+        logger.info(`🎲 No seed provided, generating random seed (provider will have random identity)`);
         return crypto.randomBytes(32);
     }
 }
@@ -24,20 +26,20 @@ function createFirewallFunction(config) {
         if (mode === "allow") {
             const allowed = publicKeySet.has(remoteKeyHex);
             if (!allowed) {
-                console.log(`🚫 Firewall: Denied connection from ${remoteKeyHex.substring(0, 16)}... (not in allowlist)`);
+                logger.debug(`🚫 Firewall: Denied connection from ${remoteKeyHex.substring(0, 16)}... (not in allowlist)`);
             }
             else {
-                console.log(`✅ Firewall: Allowed connection from ${remoteKeyHex.substring(0, 16)}... (in allowlist)`);
+                logger.debug(`✅ Firewall: Allowed connection from ${remoteKeyHex.substring(0, 16)}... (in allowlist)`);
             }
             return !allowed;
         }
         else {
             const denied = publicKeySet.has(remoteKeyHex);
             if (denied) {
-                console.log(`🚫 Firewall: Denied connection from ${remoteKeyHex.substring(0, 16)}... (in denylist)`);
+                logger.debug(`🚫 Firewall: Denied connection from ${remoteKeyHex.substring(0, 16)}... (in denylist)`);
             }
             else {
-                console.log(`✅ Firewall: Allowed connection from ${remoteKeyHex.substring(0, 16)}... (not in denylist)`);
+                logger.debug(`✅ Firewall: Allowed connection from ${remoteKeyHex.substring(0, 16)}... (not in denylist)`);
             }
             return denied;
         }

package/dist/server/bare/rag-hyperdb/handlers/chunk.d.ts

@@ -0,0 +1,3 @@
+import { type RagChunkParams } from "../../../../schemas/index";
+export declare function chunk(params: RagChunkParams): Promise<import("@qvac/rag").Doc[]>;
+//# sourceMappingURL=chunk.d.ts.map

package/dist/server/bare/rag-hyperdb/handlers/chunk.js

@@ -0,0 +1,7 @@
+import { LLMChunkAdapter } from "@qvac/rag";
+import { ragChunkParamsSchema } from "../../../../schemas/index.js";
+export async function chunk(params) {
+    const { documents, chunkOpts } = ragChunkParamsSchema.parse(params);
+    const chunker = new LLMChunkAdapter(chunkOpts);
+    return await chunker.chunkText(documents, chunkOpts);
+}

package/dist/server/bare/rag-hyperdb/handlers/close-workspace.d.ts

@@ -0,0 +1,3 @@
+import { type RagCloseWorkspaceParams } from "../../../../schemas/index";
+export declare function closeWorkspace(params: RagCloseWorkspaceParams): Promise<void>;
+//# sourceMappingURL=close-workspace.d.ts.map

package/dist/server/bare/rag-hyperdb/handlers/close-workspace.js

@@ -0,0 +1,9 @@
+import { closeRagInstance, deleteWorkspace, DEFAULT_WORKSPACE, } from "../rag-workspace-manager.js";
+import { ragCloseWorkspaceParamsSchema, } from "../../../../schemas/index.js";
+export async function closeWorkspace(params) {
+    const { workspace, deleteOnClose } = ragCloseWorkspaceParamsSchema.parse(params);
+    await closeRagInstance(workspace);
+    if (deleteOnClose) {
+        await deleteWorkspace(workspace ?? DEFAULT_WORKSPACE);
+    }
+}

package/dist/server/bare/rag-hyperdb/handlers/delete-embeddings.d.ts

@@ -1,3 +1,3 @@
 import { type RagDeleteEmbeddingsParams } from "../../../../schemas/index";
-export declare function deleteEmbeddings(params: RagDeleteEmbeddingsParams): Promise<boolean>;
+export declare function deleteEmbeddings(params: RagDeleteEmbeddingsParams): Promise<void>;
 //# sourceMappingURL=delete-embeddings.d.ts.map

package/dist/server/bare/rag-hyperdb/handlers/delete-embeddings.js

@@ -1,12 +1,11 @@
-import { getRagInstance } from "../rag-manager.js";
-import { embed } from "../../addons/llamacpp/index.js";
-import { ragDeleteEmbeddingsOperationSchema, } from "../../../../schemas/index.js";
+import { getRagDbAdapter, hasRagWorkspaceStorage, } from "../rag-workspace-manager.js";
+import { ragDeleteEmbeddingsParamsSchema, } from "../../../../schemas/index.js";
+import { RAGDeleteFailedError } from "../../../../utils/errors-server.js";
 export async function deleteEmbeddings(params) {
-    const { modelId, ids, workspace } = ragDeleteEmbeddingsOperationSchema.parse(params);
-    const embeddingFunction = async (text) => {
-        return await embed({ modelId, text });
-    };
-    const rag = await getRagInstance(modelId, embeddingFunction, workspace);
-    const success = await rag.deleteEmbeddings(ids);
-    return success;
+    const { ids, workspace } = ragDeleteEmbeddingsParamsSchema.parse(params);
+    if (!hasRagWorkspaceStorage(workspace)) {
+        throw new RAGDeleteFailedError("workspace is not initialized");
+    }
+    const dbAdapter = await getRagDbAdapter(workspace);
+    await dbAdapter.deleteEmbeddings(ids);
 }

package/dist/server/bare/rag-hyperdb/handlers/delete-workspace.d.ts

@@ -0,0 +1,3 @@
+import { type RagDeleteWorkspaceParams } from "../../../../schemas/index";
+export declare function deleteWorkspace(params: RagDeleteWorkspaceParams): Promise<void>;
+//# sourceMappingURL=delete-workspace.d.ts.map

package/dist/server/bare/rag-hyperdb/handlers/delete-workspace.js

@@ -0,0 +1,14 @@
+import { isWorkspaceLoaded, deleteWorkspace as deleteWorkspaceFromManager, } from "../rag-workspace-manager.js";
+import { ragDeleteWorkspaceParamsSchema, } from "../../../../schemas/index.js";
+import { RAGWorkspaceNotFoundError, RAGWorkspaceInUseError, } from "../../../../utils/errors-server.js";
+export async function deleteWorkspace(params) {
+    const { workspace } = ragDeleteWorkspaceParamsSchema.parse(params);
+    // Check if workspace is currently in use
+    if (isWorkspaceLoaded(workspace)) {
+        throw new RAGWorkspaceInUseError(workspace);
+    }
+    const deleted = await deleteWorkspaceFromManager(workspace);
+    if (!deleted) {
+        throw new RAGWorkspaceNotFoundError(workspace);
+    }
+}

package/dist/server/bare/rag-hyperdb/handlers/ingest.d.ts

@@ -0,0 +1,9 @@
+import { type RagIngestParams } from "../../../../schemas/index";
+import type { IngestStage } from "@qvac/rag";
+interface IngestHandlerOptions {
+    onProgress?: (stage: IngestStage, current: number, total: number) => void;
+    signal?: AbortSignal;
+}
+export declare function ingest(params: RagIngestParams, options?: IngestHandlerOptions): Promise<import("@qvac/rag").IngestResult>;
+export {};
+//# sourceMappingURL=ingest.d.ts.map

package/dist/server/bare/rag-hyperdb/handlers/ingest.js

@@ -0,0 +1,18 @@
+import { getRagInstance } from "../rag-workspace-manager.js";
+import { embed } from "../../addons/llamacpp-embedding/index.js";
+import { ragIngestParamsSchema } from "../../../../schemas/index.js";
+export async function ingest(params, options) {
+    const { modelId, documents, chunk, chunkOpts, workspace, progressInterval } = ragIngestParamsSchema.parse(params);
+    async function embeddingFunction(text) {
+        return await embed({ modelId, text });
+    }
+    const rag = await getRagInstance(modelId, embeddingFunction, workspace);
+    const ingestOpts = {
+        chunk,
+        chunkOpts,
+        progressInterval,
+        onProgress: options?.onProgress,
+        signal: options?.signal,
+    };
+    return await rag.ingest(documents, modelId, ingestOpts);
+}

package/dist/server/bare/rag-hyperdb/handlers/list-workspaces.d.ts

@@ -0,0 +1,3 @@
+import { type RagWorkspaceInfo } from "../rag-workspace-manager";
+export declare function listWorkspaces(): RagWorkspaceInfo[];
+//# sourceMappingURL=list-workspaces.d.ts.map

package/dist/server/bare/rag-hyperdb/handlers/list-workspaces.js

@@ -0,0 +1,4 @@
+import { listWorkspaces as listWorkspacesFromManager, } from "../rag-workspace-manager.js";
+export function listWorkspaces() {
+    return listWorkspacesFromManager();
+}

package/dist/server/bare/rag-hyperdb/handlers/reindex.d.ts

@@ -0,0 +1,9 @@
+import { type RagReindexParams } from "../../../../schemas/index";
+import type { ReindexResult, ReindexStage } from "@qvac/rag";
+interface ReindexHandlerOptions {
+    onProgress?: (stage: ReindexStage, current: number, total: number) => void;
+    signal?: AbortSignal;
+}
+export declare function reindex(params: RagReindexParams, options?: ReindexHandlerOptions): Promise<ReindexResult>;
+export {};
+//# sourceMappingURL=reindex.d.ts.map

package/dist/server/bare/rag-hyperdb/handlers/reindex.js

@@ -0,0 +1,16 @@
+import { getRagDbAdapter, hasRagWorkspaceStorage, } from "../rag-workspace-manager.js";
+import { ragReindexParamsSchema } from "../../../../schemas/index.js";
+import { RAGHyperDBFailedError } from "../../../../utils/errors-server.js";
+export async function reindex(params, options) {
+    const { workspace } = ragReindexParamsSchema.parse(params);
+    if (!hasRagWorkspaceStorage(workspace)) {
+        throw new RAGHyperDBFailedError("workspace is not initialized");
+    }
+    const dbAdapter = await getRagDbAdapter(workspace);
+    const reindexOpts = {
+        onProgress: options?.onProgress,
+        signal: options?.signal,
+    };
+    const result = await dbAdapter.reindex(reindexOpts);
+    return result;
+}

package/dist/server/bare/rag-hyperdb/handlers/save-embeddings.d.ts

@@ -1,6 +1,9 @@
 import { type RagSaveEmbeddingsParams } from "../../../../schemas/index";
-export declare function saveEmbeddings(params: RagSaveEmbeddingsParams): Promise<{
-    processed: import("@qvac/rag").SaveEmbeddingsResult[];
-    droppedIndices: number[];
-}>;
+import type { SaveStage } from "@qvac/rag";
+interface SaveEmbeddingsHandlerOptions {
+    onProgress?: (stage: SaveStage, current: number, total: number) => void;
+    signal?: AbortSignal;
+}
+export declare function saveEmbeddings(params: RagSaveEmbeddingsParams, options?: SaveEmbeddingsHandlerOptions): Promise<import("@qvac/rag").SaveEmbeddingsResult[]>;
+export {};
 //# sourceMappingURL=save-embeddings.d.ts.map

package/dist/server/bare/rag-hyperdb/handlers/save-embeddings.js

@@ -1,16 +1,15 @@
-import { getRagInstance } from "../rag-manager.js";
-import { embed } from "../../addons/llamacpp/index.js";
-import { ragSaveEmbeddingsOperationSchema, } from "../../../../schemas/index.js";
-export async function saveEmbeddings(params) {
-    const { modelId, documents, chunk, chunkOpts, workspace } = ragSaveEmbeddingsOperationSchema.parse(params);
-    const embeddingFunction = async (text) => {
-        return await embed({ modelId, text });
-    };
-    const rag = await getRagInstance(modelId, embeddingFunction, workspace);
-    const saveOpts = { chunk };
-    if (chunkOpts) {
-        saveOpts.chunkOpts = chunkOpts;
+import { getRagDbAdapter } from "../rag-workspace-manager.js";
+import { ragSaveEmbeddingsParamsSchema, } from "../../../../schemas/index.js";
+export async function saveEmbeddings(params, options) {
+    const { documents, progressInterval, workspace } = ragSaveEmbeddingsParamsSchema.parse(params);
+    if (documents.length === 0) {
+        return [];
     }
-    const result = await rag.saveEmbeddings(documents, saveOpts);
-    return result;
+    const dbAdapter = await getRagDbAdapter(workspace);
+    const saveOpts = {
+        progressInterval,
+        onProgress: options?.onProgress,
+        signal: options?.signal,
+    };
+    return await dbAdapter.saveEmbeddings(documents, saveOpts);
 }

package/dist/server/bare/rag-hyperdb/handlers/search.js

@@ -1,15 +1,15 @@
-import { getRagInstance } from "../rag-manager.js";
-import { embed } from "../../addons/llamacpp/index.js";
-import { ragSearchOperationSchema } from "../../../../schemas/index.js";
+import { getRagInstance, hasRagWorkspaceStorage, } from "../rag-workspace-manager.js";
+import { embed } from "../../addons/llamacpp-embedding/index.js";
+import { ragSearchParamsSchema } from "../../../../schemas/index.js";
 export async function search(params) {
-    const { modelId, query, topK, n, workspace } = ragSearchOperationSchema.parse(params);
-    const embeddingFunction = async (text) => {
+    const { modelId, query, topK, n, workspace } = ragSearchParamsSchema.parse(params);
+    if (!hasRagWorkspaceStorage(workspace)) {
+        return [];
+    }
+    async function embeddingFunction(text) {
         return await embed({ modelId, text });
-    };
+    }
     const rag = await getRagInstance(modelId, embeddingFunction, workspace);
-    const results = await rag.search(query, {
-        topK,
-        n,
-    });
+    const results = await rag.search(query, { topK, n });
     return results;
 }

package/dist/server/bare/rag-hyperdb/index.d.ts

@@ -1,5 +1,12 @@
+export { chunk } from "./handlers/chunk";
+export { ingest } from "./handlers/ingest";
 export { saveEmbeddings } from "./handlers/save-embeddings";
 export { search } from "./handlers/search";
 export { deleteEmbeddings } from "./handlers/delete-embeddings";
-export { closeRagInstance, closeAllRagInstances, } from "./rag-manager";
+export { reindex } from "./handlers/reindex";
+export { listWorkspaces } from "./handlers/list-workspaces";
+export { closeWorkspace } from "./handlers/close-workspace";
+export { deleteWorkspace } from "./handlers/delete-workspace";
+export { closeAllRagInstances, DEFAULT_WORKSPACE, type RagWorkspaceInfo, } from "./rag-workspace-manager";
+export { registerRagOperation, unregisterRagOperation, cancelRagOperation, } from "./rag-operation-manager";
 //# sourceMappingURL=index.d.ts.map

package/dist/server/bare/rag-hyperdb/index.js

@@ -1,4 +1,11 @@
+export { chunk } from "./handlers/chunk.js";
+export { ingest } from "./handlers/ingest.js";
 export { saveEmbeddings } from "./handlers/save-embeddings.js";
 export { search } from "./handlers/search.js";
 export { deleteEmbeddings } from "./handlers/delete-embeddings.js";
-export { closeRagInstance, closeAllRagInstances, } from "./rag-manager.js";
+export { reindex } from "./handlers/reindex.js";
+export { listWorkspaces } from "./handlers/list-workspaces.js";
+export { closeWorkspace } from "./handlers/close-workspace.js";
+export { deleteWorkspace } from "./handlers/delete-workspace.js";
+export { closeAllRagInstances, DEFAULT_WORKSPACE, } from "./rag-workspace-manager.js";
+export { registerRagOperation, unregisterRagOperation, cancelRagOperation, } from "./rag-operation-manager.js";