@qvac/sdk 0.8.1 → 1.0.0

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

@@ -1,212 +1,70 @@
 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";
-import { nowMs } from "../../profiling/index.js";
-import { cacheDelegationConnectionTime, clearPeerConnectionTracking, } from "../rpc/profiling/delegation-profiler.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();
-// Track whether the global connection handler has been registered
-let connectionHandlerRegistered = false;
-const HEALTH_CHECK_TIMEOUT_MS = 1500;
-import { getNextCommandId } from "../rpc/delegate-utils.js";
-function isHeartbeatResponse(payload) {
-    return (typeof payload === "object" &&
-        payload !== null &&
-        payload["type"] === "heartbeat");
-}
-async function isRPCConnectionHealthy(rpc, timeout = HEALTH_CHECK_TIMEOUT_MS) {
-    try {
-        const req = rpc.request(getNextCommandId());
-        req.send(JSON.stringify({ type: "heartbeat" }), "utf-8");
-        const response = await withTimeout(req.reply("utf-8"), timeout);
-        const payload = JSON.parse(response?.toString() || "{}");
-        return isHeartbeatResponse(payload);
-    }
-    catch (error) {
-        logger.debug("RPC health check failed", { error });
-        return false;
+// 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
+    let rpc = activeRPCs.get(publicKey);
+    const swarm = getSwarm();
+    if (!rpc) {
+        // Need to establish connection first
+        try {
+            console.log(`🔗 Establishing RPC connection to topic: ${topic}, peer: ${publicKey}, timeout: ${timeout}ms`);
+            const connectionPromise = (async () => {
+                const topicBuffer = Buffer.from(topic, "hex");
+                // const discovery =
+                swarm.join(topicBuffer, {
+                    server: false,
+                    client: true,
+                });
+                await swarm.flush();
+                console.log(`✅ Connected to topic: ${topic}`);
+                console.log(`📊 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()));
+                    throw new Error(`Could not establish RPC connection to peer ${publicKey} on topic ${topic}`);
+                }
+                else {
+                    console.log(`✅ RPC instance found for peer ${publicKey}`);
+                }
+            })();
+            await withTimeout(connectionPromise, timeout);
+        }
+        catch (error) {
+            console.error("Failed to establish RPC connection:", error);
+            throw new Error(`RPC connection failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
     }
+    return rpc;
 }
-/**
- * Register the swarm "connection" handler once (not per getRPC call).
- * This fixes the event listener leak where each getRPC() call added
- * a new listener, causing duplicate RPC instances on the same stream.
- */
-function ensureConnectionHandler() {
-    if (connectionHandlerRegistered)
-        return;
-    connectionHandlerRegistered = true;
+// Create an RPC instance for a specific HyperSwarm peer
+export async function getRPC(topic, publicKey, options = {}) {
     const swarm = getSwarm();
+    // Set up connection tracking
     swarm.on("connection", (conn) => {
         const peerPubkey = conn.remotePublicKey?.toString("hex");
         if (!peerPubkey)
             return;
-        logger.info(`🍺 New peer connection established: ${peerPubkey}`);
+        console.log(`🍺 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 and connection by peer ID for lookup
+        // Store RPC instance by peer ID for lookup
         activeRPCs.set(peerPubkey, rpc);
-        activeConnections.set(peerPubkey, conn);
         conn.on("close", () => {
-            logger.debug(`Connection closed for peer: ${peerPubkey}`);
+            console.log(`Connection closed for peer: ${peerPubkey}`);
             activeRPCs.delete(peerPubkey);
-            activeConnections.delete(peerPubkey);
-            clearPeerConnectionTracking(peerPubkey);
         });
         conn.on("error", (err) => {
-            logger.error(`Connection error for peer ${peerPubkey}:`, err);
+            console.error(`Connection error for peer ${peerPubkey}:`, err);
             activeRPCs.delete(peerPubkey);
-            activeConnections.delete(peerPubkey);
-            clearPeerConnectionTracking(peerPubkey);
         });
     });
-}
-async function closeConnection(publicKey) {
-    const existingConnection = activeConnections.get(publicKey);
-    if (existingConnection) {
-        logger.info(`🔌 Closing existing connection for peer: ${publicKey}`);
-        // Wait for the close event before returning so Hyperswarm's internal
-        // _allConnections is cleaned up before we attempt to rejoin/flush.
-        await new Promise((resolve) => {
-            const timeout = setTimeout(resolve, 5000);
-            existingConnection.on("close", () => {
-                clearTimeout(timeout);
-                resolve();
-            });
-            existingConnection.destroy();
-        });
-        activeConnections.delete(publicKey);
-        activeRPCs.delete(publicKey);
-        clearPeerConnectionTracking(publicKey);
-    }
-}
-// Establish RPC connection to a peer if not already connected
-async function ensureRPCConnection(topic, publicKey, timeout, healthCheckTimeout) {
-    const healthCheckCap = healthCheckTimeout ?? HEALTH_CHECK_TIMEOUT_MS;
-    const operationStart = nowMs();
-    const getRemainingTimeout = () => {
-        if (timeout === undefined) {
-            return undefined;
-        }
-        return Math.max(timeout - (nowMs() - operationStart), 0);
-    };
-    // Check if we already have an RPC instance for this peer
-    const existingRpc = activeRPCs.get(publicKey);
-    if (existingRpc) {
-        const remainingTimeout = getRemainingTimeout();
-        const probeTimeout = remainingTimeout === undefined
-            ? healthCheckCap
-            : Math.min(remainingTimeout / 2, healthCheckCap);
-        const isHealthy = await isRPCConnectionHealthy(existingRpc, probeTimeout);
-        if (isHealthy) {
-            return existingRpc;
-        }
-        logger.info(`🧹 Cached RPC failed health check for peer ${publicKey}, reconnecting`);
-        cleanupStaleConnection(publicKey);
-    }
-    const swarm = getSwarm();
-    const connectionStart = nowMs();
-    // Track the listener so we can clean it up on timeout
-    let onConnection = () => { };
-    try {
-        logger.info(`🔗 Establishing RPC connection to topic: ${topic}, peer: ${publicKey}, timeout: ${timeout}ms`);
-        const connectionPromise = new Promise((resolve, reject) => {
-            const topicBuffer = Buffer.from(topic, "hex");
-            swarm.join(topicBuffer, {
-                server: false,
-                client: true,
-            });
-            // Wait for the specific peer's connection event instead of just
-            // checking after flush. This handles the case where flush resolves
-            // (discovery done) but the P2P connection is still being established
-            // via holepunching or relays.
-            onConnection = (conn) => {
-                const peerPubkey = conn.remotePublicKey?.toString("hex");
-                if (peerPubkey === publicKey) {
-                    swarm.removeListener("connection", onConnection);
-                    // The global handler (ensureConnectionHandler) will create the RPC
-                    // and store it in activeRPCs. Give it a tick to run first.
-                    const rpc = activeRPCs.get(publicKey);
-                    if (rpc) {
-                        resolve(rpc);
-                    }
-                    else {
-                        // Global handler runs synchronously before us in the same event,
-                        // so this shouldn't happen, but handle it just in case
-                        setTimeout(() => {
-                            const delayedRpc = activeRPCs.get(publicKey);
-                            if (delayedRpc) {
-                                resolve(delayedRpc);
-                            }
-                            else {
-                                reject(new DelegateConnectionFailedError(`Connection established but RPC not created for peer ${publicKey}`));
-                            }
-                        }, 100);
-                    }
-                }
-            };
-            swarm.on("connection", onConnection);
-            // Also flush to trigger discovery. After flush, check if the connection
-            // was already established (the global handler may have caught it).
-            void swarm.flush().then(() => {
-                logger.info(`✅ Flush completed for topic: ${topic}`);
-                logger.debug(`📊 Active RPC connections: ${activeRPCs.size}`);
-                const rpc = activeRPCs.get(publicKey);
-                if (rpc) {
-                    swarm.removeListener("connection", onConnection);
-                    resolve(rpc);
-                }
-                // If not connected after flush, the onConnection listener keeps
-                // waiting until the timeout from withTimeout kicks in.
-                // Hyperswarm may still establish the connection via retries/relays.
-                logger.debug(`⏳ Peer not connected after flush, waiting for connection event...`);
-            });
-        });
-        const rpc = await withTimeout(connectionPromise, getRemainingTimeout());
-        const connectionDuration = nowMs() - connectionStart;
-        cacheDelegationConnectionTime(publicKey, connectionDuration);
-        return rpc;
-    }
-    catch (error) {
-        // Clean up the per-request connection listener
-        swarm.removeListener("connection", onConnection);
-        // Remove stale connection so next attempt creates a fresh one
-        // instead of reusing a dead RPC
-        cleanupStaleConnection(publicKey);
-        logger.error("Failed to establish RPC connection:", error);
-        throw new DelegateConnectionFailedError(`RPC connection failed: ${error instanceof Error ? error.message : String(error)}`, error);
-    }
-}
-// Create an RPC instance for a specific HyperSwarm peer
-export async function getRPC(topic, publicKey, options = {}) {
-    // Ensure the global connection handler is registered (once)
-    ensureConnectionHandler();
-    // Close existing connection if forceNewConnection is true
-    // Await the close to avoid racing with the subsequent join/flush
-    if (options.forceNewConnection) {
-        await closeConnection(publicKey);
-    }
-    return await ensureRPCConnection(topic, publicKey, options.timeout, options.healthCheckTimeout);
-}
-/**
- * Remove a stale RPC connection for a peer.
- * Called when a delegation request fails (e.g., timeout) so the next
- * attempt creates a fresh connection instead of reusing a dead RPC.
- */
-export function cleanupStaleConnection(publicKey) {
-    logger.info(`🗑️ Removing stale connection for peer: ${publicKey} after failed delegation`);
-    activeRPCs.delete(publicKey);
-    const conn = activeConnections.get(publicKey);
-    if (conn) {
-        conn.destroy();
-        activeConnections.delete(publicKey);
-    }
-    clearPeerConnectionTracking(publicKey);
+    return await ensureRPCConnection(topic, publicKey, options.timeout);
 }

package/dist/server/bare/hyperswarm.d.ts

@@ -3,8 +3,5 @@ import { type FirewallConfig } from "../../schemas/provide";
 export declare function getSwarm({ firewallConfig, }?: {
     firewallConfig?: FirewallConfig | undefined;
 }): Hyperswarm;
-export declare function registerProviderTopic(topic: string): void;
-export declare function unregisterProviderTopic(topic: string): void;
-export declare function hasActiveProviders(): boolean;
 export declare function destroySwarm(): Promise<void>;
 //# sourceMappingURL=hyperswarm.d.ts.map

package/dist/server/bare/hyperswarm.js

@@ -2,16 +2,13 @@ import process from "bare-process";
 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 {
-        logger.info(`🎲 No seed provided, generating random seed (provider will have random identity)`);
+        console.log(`🎲 No seed provided, generating random seed (provider will have random identity)`);
         return crypto.randomBytes(32);
     }
 }
@@ -26,20 +23,20 @@ function createFirewallFunction(config) {
         if (mode === "allow") {
             const allowed = publicKeySet.has(remoteKeyHex);
             if (!allowed) {
-                logger.debug(`🚫 Firewall: Denied connection from ${remoteKeyHex.substring(0, 16)}... (not in allowlist)`);
+                console.log(`🚫 Firewall: Denied connection from ${remoteKeyHex.substring(0, 16)}... (not in allowlist)`);
             }
             else {
-                logger.debug(`✅ Firewall: Allowed connection from ${remoteKeyHex.substring(0, 16)}... (in allowlist)`);
+                console.log(`✅ Firewall: Allowed connection from ${remoteKeyHex.substring(0, 16)}... (in allowlist)`);
             }
             return !allowed;
         }
         else {
             const denied = publicKeySet.has(remoteKeyHex);
             if (denied) {
-                logger.debug(`🚫 Firewall: Denied connection from ${remoteKeyHex.substring(0, 16)}... (in denylist)`);
+                console.log(`🚫 Firewall: Denied connection from ${remoteKeyHex.substring(0, 16)}... (in denylist)`);
             }
             else {
-                logger.debug(`✅ Firewall: Allowed connection from ${remoteKeyHex.substring(0, 16)}... (not in denylist)`);
+                console.log(`✅ Firewall: Allowed connection from ${remoteKeyHex.substring(0, 16)}... (not in denylist)`);
             }
             return denied;
         }
@@ -48,19 +45,9 @@ function createFirewallFunction(config) {
 function createSwarm(firewallConfig) {
     const seed = getHyperswarmSeedBuffer();
     const firewall = createFirewallFunction(firewallConfig);
-    const getRelays = () => {
-        const config = getSDKConfig();
-        const relayPublicKeys = config.swarmRelays;
-        if (!relayPublicKeys || relayPublicKeys.length === 0) {
-            return null;
-        }
-        return relayPublicKeys.map((key) => Buffer.from(key, "hex"));
-    };
-    const swarmOptions = { seed, firewall, relayThrough: getRelays };
-    return new Hyperswarm(swarmOptions);
+    return new Hyperswarm({ seed, firewall });
 }
 let swarm;
-const activeProviderTopics = new Set();
 export function getSwarm({ firewallConfig, } = {}) {
     if (swarm) {
         return swarm;
@@ -68,18 +55,8 @@ export function getSwarm({ firewallConfig, } = {}) {
     swarm = createSwarm(firewallConfig);
     return swarm;
 }
-export function registerProviderTopic(topic) {
-    activeProviderTopics.add(topic);
-}
-export function unregisterProviderTopic(topic) {
-    activeProviderTopics.delete(topic);
-}
-export function hasActiveProviders() {
-    return activeProviderTopics.size > 0;
-}
 export async function destroySwarm() {
     if (swarm) {
-        activeProviderTopics.clear();
         return swarm.destroy();
     }
 }

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<void>;
+export declare function deleteEmbeddings(params: RagDeleteEmbeddingsParams): Promise<boolean>;
 //# sourceMappingURL=delete-embeddings.d.ts.map

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

@@ -1,11 +1,12 @@
-import { getRagDbAdapter, hasRagWorkspaceStorage, } from "../rag-workspace-manager.js";
-import { ragDeleteEmbeddingsParamsSchema, } from "../../../../schemas/index.js";
-import { RAGDeleteFailedError } from "../../../../utils/errors-server.js";
+import { getRagInstance } from "../rag-manager.js";
+import { embed } from "../../addons/llamacpp/index.js";
+import { ragDeleteEmbeddingsOperationSchema, } from "../../../../schemas/index.js";
 export async function deleteEmbeddings(params) {
-    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);
+    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;
 }

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

@@ -1,9 +1,6 @@
 import { type RagSaveEmbeddingsParams } from "../../../../schemas/index";
-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 {};
+export declare function saveEmbeddings(params: RagSaveEmbeddingsParams): Promise<{
+    processed: import("@qvac/rag").SaveEmbeddingsResult[];
+    droppedIndices: number[];
+}>;
 //# sourceMappingURL=save-embeddings.d.ts.map

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

@@ -1,15 +1,16 @@
-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 dbAdapter = await getRagDbAdapter(workspace);
-    const saveOpts = {
-        progressInterval,
-        onProgress: options?.onProgress,
-        signal: options?.signal,
+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 });
     };
-    return await dbAdapter.saveEmbeddings(documents, saveOpts);
+    const rag = await getRagInstance(modelId, embeddingFunction, workspace);
+    const saveOpts = { chunk };
+    if (chunkOpts) {
+        saveOpts.chunkOpts = chunkOpts;
+    }
+    const result = await rag.saveEmbeddings(documents, saveOpts);
+    return result;
 }

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

@@ -1,15 +1,15 @@
-import { getRagInstance, hasRagWorkspaceStorage, } from "../rag-workspace-manager.js";
-import { embed } from "../../ops/embed.js";
-import { ragSearchParamsSchema } from "../../../../schemas/index.js";
+import { getRagInstance } from "../rag-manager.js";
+import { embed } from "../../addons/llamacpp/index.js";
+import { ragSearchOperationSchema } from "../../../../schemas/index.js";
 export async function search(params) {
-    const { modelId, query, topK, n, workspace } = ragSearchParamsSchema.parse(params);
-    if (!hasRagWorkspaceStorage(workspace)) {
-        return [];
-    }
-    async function embeddingFunction(text) {
+    const { modelId, query, topK, n, workspace } = ragSearchOperationSchema.parse(params);
+    const embeddingFunction = async (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,12 +1,5 @@
-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 { 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";
+export { closeRagInstance, closeAllRagInstances, } from "./rag-manager";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1,11 +1,4 @@
-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 { 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";
+export { closeRagInstance, closeAllRagInstances, } from "./rag-manager.js";

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

@@ -0,0 +1,5 @@
+import { RAG, type EmbeddingFunction } from "@qvac/rag";
+export declare const getRagInstance: (modelId: string, embeddingFunction: EmbeddingFunction, workspace?: string) => Promise<RAG>;
+export declare const closeRagInstance: (workspace?: string) => Promise<void>;
+export declare const closeAllRagInstances: () => Promise<void>;
+//# sourceMappingURL=rag-manager.d.ts.map

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

@@ -0,0 +1,65 @@
+import { RAG, HyperDBAdapter } from "@qvac/rag";
+import Corestore from "corestore";
+import path from "bare-path";
+import { getEnv } from "../../worker.js";
+const ragInstances = new Map();
+const defaultWorkspace = "default";
+const getStorePath = (workspace) => {
+    const homeDir = getEnv().HOME_DIR;
+    return path.join(homeDir, ".qvac", "rag-hyperdb", workspace);
+};
+export const getRagInstance = async (modelId, embeddingFunction, workspace) => {
+    const key = workspace ?? defaultWorkspace;
+    const existingEntry = ragInstances.get(key);
+    if (existingEntry) {
+        // Validate model consistency
+        if (existingEntry.modelId !== modelId) {
+            throw new Error(`Workspace "${key}" is configured for model "${existingEntry.modelId}", ` +
+                `but you're trying to use model "${modelId}". ` +
+                `Use a different workspace or the same model.`);
+        }
+        return existingEntry.rag;
+    }
+    // Create new instance for this workspace
+    const storePath = getStorePath(key);
+    const corestore = new Corestore(storePath);
+    // Create HyperDB adapter
+    const hyperdbAdapter = new HyperDBAdapter({
+        store: corestore,
+    });
+    const rag = new RAG({
+        dbAdapter: hyperdbAdapter,
+        embeddingFunction,
+    });
+    await rag.ready();
+    ragInstances.set(key, {
+        rag,
+        corestore,
+        modelId,
+    });
+    return rag;
+};
+export const closeRagInstance = async (workspace) => {
+    const key = workspace ?? defaultWorkspace;
+    const entry = ragInstances.get(key);
+    if (entry) {
+        await entry.rag.close();
+        ragInstances.delete(key);
+    }
+};
+let isCleaningUp = false;
+export const closeAllRagInstances = async () => {
+    if (isCleaningUp)
+        return;
+    isCleaningUp = true;
+    try {
+        const closures = Array.from(ragInstances.entries()).map(async ([key, entry]) => {
+            await entry.rag.close();
+            ragInstances.delete(key);
+        });
+        await Promise.all(closures);
+    }
+    catch (error) {
+        console.error("❌ Error during RAG cleanup:", error);
+    }
+};

package/dist/server/bare/registry/logging-stream-registry.d.ts

@@ -1,30 +1,13 @@
-/**
- * Logging Stream Registry
- *
- * Manages RPC subscriptions for streaming logs from server to connected clients.
- *
- * Purpose:
- * - Registers client subscriptions to model/SDK log streams
- * - Routes log messages to subscribed clients via RPC
- * - Buffers logs during model loading (before client subscribes)
- * - Manages stream lifecycle (subscribe/unsubscribe)
- *
- */
 import type { LogLevel } from "@qvac/logging";
-export declare function startLogBuffering(id: string): void;
-export declare function stopLogBufferingWithTimeout(id: string): void;
-export declare function registerLoggingStream(id: string, streamHandler: (level: LogLevel, namespace: string, message: string) => void): void;
-export declare function unregisterLoggingStream(id: string, streamHandler: (level: LogLevel, namespace: string, message: string) => void): void;
-export declare function unregisterAllLoggingStreams(id: string): void;
-export declare function sendLogToStreams(id: string, level: LogLevel, namespace: string, message: string): void;
-export declare function hasLoggingStreams(id: string): boolean | undefined;
+export declare function registerLoggingStream(modelId: string, streamHandler: (level: LogLevel, namespace: string, message: string) => void): void;
+export declare function unregisterLoggingStream(modelId: string, streamHandler: (level: LogLevel, namespace: string, message: string) => void): void;
+export declare function unregisterAllLoggingStreams(modelId: string): void;
+export declare function sendLogToStreams(modelId: string, level: LogLevel, namespace: string, message: string): void;
+export declare function hasLoggingStreams(modelId: string): boolean | undefined;
 export declare function getLoggingStreamStats(): {
-    totalIds: number;
-    ids: string[];
+    totalModels: number;
+    modelIds: string[];
     totalStreams: number;
-    bufferedIds: number;
-    idsWithBuffering: number;
-    activeTimeouts: number;
 };
 export declare function clearAllLoggingStreams(): void;
 //# sourceMappingURL=logging-stream-registry.d.ts.map