@qvac/sdk 0.1.0-dev.1760648187.328e967

package/dist/server/bare/addons/translation/handlers/translate.js

@@ -0,0 +1,86 @@
+import { getModel } from "../../../registry/model-registry.js";
+import { translateServerParamsSchema, } from "../../../../../schemas/index.js";
+export async function* translate(params) {
+    const { modelId, text, modelType } = params;
+    const from = params.modelType === "llm" ? params.from : undefined;
+    const to = params.modelType === "llm" ? params.to : undefined;
+    const context = params.modelType === "llm" ? params.context : undefined;
+    translateServerParamsSchema.parse(params);
+    const model = getModel(modelId);
+    // Prepare input based on model type
+    const input = modelType === "nmt"
+        ? text
+        : [
+            {
+                role: "system",
+                content: `${context ? `${context}. ` : ""}Translate the following text from ${from?.toUpperCase()} into ${to?.toUpperCase()}.Only output the translation, nothing else.\n\n${from?.toUpperCase()}: ${text}\n${to?.toUpperCase()}:`,
+            },
+        ];
+    const startTime = Date.now();
+    let processedTokens = 0;
+    const response = await model.run(input);
+    // Check if the response has an iterate method (like LLM models)
+    if (modelType === "llm" && typeof response.iterate === "function") {
+        for await (const token of response.iterate()) {
+            processedTokens++;
+            yield token;
+        }
+    }
+    else {
+        // For models that don't support iterate, create an async iterator using onUpdate
+        const tokenQueue = [];
+        let isComplete = false;
+        let resolveNext = null;
+        // Start the response processing
+        const responsePromise = response
+            .onUpdate((data) => {
+            processedTokens++;
+            if (resolveNext) {
+                // If there's a pending read, resolve it immediately
+                resolveNext({ value: data, done: false });
+                resolveNext = null;
+            }
+            else {
+                // Otherwise, queue the token
+                tokenQueue.push(data);
+            }
+        })
+            .await()
+            .then(() => {
+            isComplete = true;
+            if (resolveNext) {
+                resolveNext({ value: undefined, done: true });
+                resolveNext = null;
+            }
+        });
+        // Create an async iterator
+        const asyncIterator = {
+            async next() {
+                if (tokenQueue.length > 0) {
+                    return { value: tokenQueue.shift(), done: false };
+                }
+                if (isComplete) {
+                    return { value: undefined, done: true };
+                }
+                // Wait for the next token
+                return new Promise((resolve) => {
+                    resolveNext = resolve;
+                });
+            },
+            [Symbol.asyncIterator]() {
+                return this;
+            },
+        };
+        // Yield tokens as they come
+        for await (const token of asyncIterator) {
+            yield token;
+        }
+        // Ensure the response is fully processed
+        await responsePromise;
+    }
+    const endTime = Date.now();
+    return {
+        processedTokens,
+        processingTime: endTime - startTime,
+    };
+}

package/dist/server/bare/addons/translation/index.d.ts

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

package/dist/server/bare/addons/translation/index.js

@@ -0,0 +1,2 @@
+export { createNmtModel } from "./create-model.js";
+export { translate } from "./handlers/translate.js";

package/dist/server/bare/addons/unload-model.d.ts

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

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

@@ -0,0 +1,20 @@
+import { promises as fsPromises } from "bare-fs";
+import { unregisterModel } from "../registry/model-registry.js";
+import { unregisterAllLoggingStreams } from "../registry/logging-stream-registry.js";
+import { unloadModelParamsSchema } from "../../../schemas/index.js";
+export async function unloadModel(params) {
+    const { modelId, clearStorage } = unloadModelParamsSchema.parse(params);
+    const entry = unregisterModel(modelId);
+    if (!entry) {
+        throw new Error(`Model with ID "${modelId}" is not loaded`);
+    }
+    if (entry.local?.model && entry.local.model.unload) {
+        await entry.local.model.unload();
+    }
+    if (clearStorage && entry.local?.path) {
+        await fsPromises.rm(entry.local.path, { recursive: true, force: true });
+        console.log(`Model storage cleared: ${entry.local.path}`);
+    }
+    unregisterAllLoggingStreams(modelId);
+    console.log(`Model ${modelId} unloaded`);
+}

package/dist/server/bare/addons/whispercpp/create-model.d.ts

@@ -0,0 +1,6 @@
+import TranscriptionWhispercpp from "@qvac/transcription-whispercpp";
+import { type AnyModel } from "../../registry/model-registry";
+import { type WhisperConfig } from "../../../../schemas/index";
+export type WhispercppModel = TranscriptionWhispercpp;
+export declare function createWhisperModel(modelId: string, modelPath: string, whisperConfig: WhisperConfig, vadModelPath?: string): AnyModel;
+//# sourceMappingURL=create-model.d.ts.map

package/dist/server/bare/addons/whispercpp/create-model.js

@@ -0,0 +1,55 @@
+import TranscriptionWhispercpp from "@qvac/transcription-whispercpp";
+import { Readable } from "bare-stream";
+import {} from "../../registry/model-registry.js";
+import {} from "../../../../schemas/index.js";
+import { createStreamLogger } from "../../../../logging/index.js";
+import { parseModelPath } from "../../../utils/index.js";
+// Mimic qvac-lib-dl-filesystem functionality
+function createFilesystemDLMimic(options) {
+    return {
+        dirPath: options.dirPath,
+        getStream: () => {
+            return Readable.from([]);
+        },
+        ready: () => Promise.resolve(),
+        close: () => Promise.resolve(),
+        destroy: () => Promise.resolve(),
+        getFileSize: () => Promise.resolve(0),
+        download: () => Promise.resolve({
+            await: () => Promise.resolve(),
+        }),
+        downloadFiles: () => Promise.resolve([]),
+    };
+}
+export function createWhisperModel(modelId, modelPath, whisperConfig, vadModelPath) {
+    const { dirPath, basePath } = parseModelPath(modelPath);
+    // Handle VAD model path - now uses vadModelPath parameter for consistency
+    let vadModelName = "";
+    let vadDirPath = "./";
+    if (vadModelPath) {
+        const vadParsed = parseModelPath(vadModelPath);
+        vadDirPath = vadParsed.dirPath;
+        vadModelName = vadParsed.basePath;
+    }
+    const dl = createFilesystemDLMimic({
+        dirPath: vadDirPath,
+    });
+    const logger = createStreamLogger(modelId, "whispercpp");
+    const args = {
+        loader: dl,
+        logger,
+        modelName: basePath,
+        diskPath: dirPath,
+        vadModelName,
+        opts: {
+            stats: false,
+        },
+    };
+    const config = {
+        whisperConfig: {
+            ...whisperConfig,
+            vad_model: vadModelPath || "",
+        },
+    };
+    return new TranscriptionWhispercpp(args, config);
+}

package/dist/server/bare/addons/whispercpp/handlers/transcribe-stream.d.ts

@@ -0,0 +1,3 @@
+import { type TranscribeParams } from "../../../../../schemas/index";
+export declare function transcribe(params: TranscribeParams): AsyncGenerator<string, void, void>;
+//# sourceMappingURL=transcribe-stream.d.ts.map

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

@@ -0,0 +1,42 @@
+import { getModel } from "../../../registry/model-registry.js";
+import { Readable } from "bare-stream";
+import fs from "bare-fs";
+import { needsDecoding, decodeAudioToStream } from "../../../../utils/index.js";
+import path from "bare-path";
+import { transcribeParamsSchema } from "../../../../../schemas/index.js";
+export async function* transcribe(params) {
+    const { audioChunk: audioInput, modelId } = transcribeParamsSchema.parse(params);
+    const model = getModel(modelId);
+    let audioStream;
+    // Check if it's a file path or base64 buffer
+    if (typeof audioInput === "string" &&
+        (audioInput.startsWith("/") || audioInput.includes("."))) {
+        // It's a file path - check if it needs decoding
+        if (needsDecoding(audioInput)) {
+            console.log(`Detected encoded format: ${path.extname(audioInput).toLowerCase()}, decoding before transcription...`);
+            audioStream = await decodeAudioToStream(audioInput);
+        }
+        else {
+            // File doesn't need decoding (e.g., RAW), create stream directly
+            audioStream = fs.createReadStream(audioInput);
+        }
+    }
+    else {
+        // It's base64 encoded buffer - decode and create stream
+        const audioBuffer = Buffer.from(audioInput, "base64");
+        audioStream = Readable.from([audioBuffer]);
+    }
+    // Run transcription with streaming enabled
+    const response = await model.run(audioStream);
+    for await (const output of response.iterate()) {
+        console.log("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;
+        }
+    }
+}

package/dist/server/bare/addons/whispercpp/index.d.ts

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

package/dist/server/bare/addons/whispercpp/index.js

@@ -0,0 +1,2 @@
+export { transcribe as transcribeStream } from "./handlers/transcribe-stream.js";
+export { createWhisperModel } from "./create-model.js";

package/dist/server/bare/delegate-rpc-client.d.ts

@@ -0,0 +1,4 @@
+import RPC from "bare-rpc";
+import type { RPCOptions } from "../../schemas/index";
+export declare function getRPC(topic: string, publicKey: string, options?: RPCOptions): Promise<RPC>;
+//# sourceMappingURL=delegate-rpc-client.d.ts.map

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

@@ -0,0 +1,70 @@
+import { getSwarm } from "./hyperswarm.js";
+import RPC from "bare-rpc";
+import { withTimeout } from "../../utils/withTimeout.js";
+// Map of active RPC instances by public key
+const activeRPCs = new Map();
+// 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;
+}
+// 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;
+        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 by peer ID for lookup
+        activeRPCs.set(peerPubkey, rpc);
+        conn.on("close", () => {
+            console.log(`Connection closed for peer: ${peerPubkey}`);
+            activeRPCs.delete(peerPubkey);
+        });
+        conn.on("error", (err) => {
+            console.error(`Connection error for peer ${peerPubkey}:`, err);
+            activeRPCs.delete(peerPubkey);
+        });
+    });
+    return await ensureRPCConnection(topic, publicKey, options.timeout);
+}

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

@@ -0,0 +1,7 @@
+import Hyperswarm from "hyperswarm";
+import { type FirewallConfig } from "../../schemas/provide";
+export declare function getSwarm({ firewallConfig, }?: {
+    firewallConfig?: FirewallConfig | undefined;
+}): Hyperswarm;
+export declare function destroySwarm(): Promise<void>;
+//# sourceMappingURL=hyperswarm.d.ts.map

package/dist/server/bare/hyperswarm.js

@@ -0,0 +1,62 @@
+import process from "bare-process";
+import Hyperswarm from "hyperswarm";
+import crypto from "bare-crypto";
+import { envSchema } from "../../schemas/provide.js";
+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)`);
+        return crypto.randomBytes(32);
+    }
+}
+function createFirewallFunction(config) {
+    if (!config || config.publicKeys.length === 0) {
+        return () => false;
+    }
+    const { mode, publicKeys } = config;
+    const publicKeySet = new Set(publicKeys);
+    return (remotePublicKey) => {
+        const remoteKeyHex = remotePublicKey.toString("hex");
+        if (mode === "allow") {
+            const allowed = publicKeySet.has(remoteKeyHex);
+            if (!allowed) {
+                console.log(`🚫 Firewall: Denied connection from ${remoteKeyHex.substring(0, 16)}... (not in allowlist)`);
+            }
+            else {
+                console.log(`✅ 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)`);
+            }
+            else {
+                console.log(`✅ Firewall: Allowed connection from ${remoteKeyHex.substring(0, 16)}... (not in denylist)`);
+            }
+            return denied;
+        }
+    };
+}
+function createSwarm(firewallConfig) {
+    const seed = getHyperswarmSeedBuffer();
+    const firewall = createFirewallFunction(firewallConfig);
+    return new Hyperswarm({ seed, firewall });
+}
+let swarm;
+export function getSwarm({ firewallConfig, } = {}) {
+    if (swarm) {
+        return swarm;
+    }
+    swarm = createSwarm(firewallConfig);
+    return swarm;
+}
+export async function destroySwarm() {
+    if (swarm) {
+        return swarm.destroy();
+    }
+}

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

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

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

@@ -0,0 +1,12 @@
+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 { 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

@@ -0,0 +1,6 @@
+import { type RagSaveEmbeddingsParams } from "../../../../schemas/index";
+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

@@ -0,0 +1,16 @@
+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;
+    }
+    const result = await rag.saveEmbeddings(documents, saveOpts);
+    return result;
+}

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

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

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

@@ -0,0 +1,15 @@
+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 } = 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,
+    });
+    return results;
+}

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

@@ -0,0 +1,5 @@
+export { saveEmbeddings } from "./handlers/save-embeddings";
+export { search } from "./handlers/search";
+export { deleteEmbeddings } from "./handlers/delete-embeddings";
+export { closeRagInstance, closeAllRagInstances, } from "./rag-manager";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,4 @@
+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";

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,61 @@
+import { RAG, HyperDBAdapter } from "@qvac/rag";
+import Corestore from "corestore";
+import path from "bare-path";
+import process from "bare-process";
+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);
+    }
+};
+export const closeAllRagInstances = async () => {
+    const closures = Array.from(ragInstances.entries()).map(async ([key, entry]) => {
+        await entry.rag.close();
+        ragInstances.delete(key);
+    });
+    await Promise.all(closures);
+};
+// Ensure cleanup on process exit
+process.on("SIGINT", () => {
+    void closeAllRagInstances();
+});

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

@@ -0,0 +1,12 @@
+import type { LogLevel } from "@qvac/logging";
+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(): {
+    totalModels: number;
+    modelIds: string[];
+    totalStreams: number;
+};
+//# sourceMappingURL=logging-stream-registry.d.ts.map

package/dist/server/bare/registry/logging-stream-registry.js

@@ -0,0 +1,46 @@
+const loggingStreams = new Map();
+export function registerLoggingStream(modelId, streamHandler) {
+    if (!loggingStreams.has(modelId)) {
+        loggingStreams.set(modelId, new Set());
+    }
+    loggingStreams.get(modelId).add(streamHandler);
+}
+export function unregisterLoggingStream(modelId, streamHandler) {
+    const streams = loggingStreams.get(modelId);
+    if (streams) {
+        streams.delete(streamHandler);
+        if (streams.size === 0) {
+            loggingStreams.delete(modelId);
+        }
+    }
+}
+export function unregisterAllLoggingStreams(modelId) {
+    // Simply remove all logging handlers for this model
+    // Active streams will naturally terminate when no more logs flow
+    loggingStreams.delete(modelId);
+    console.debug(`Unregistered all logging streams for model ${modelId}`);
+}
+export function sendLogToStreams(modelId, level, namespace, message) {
+    const streams = loggingStreams.get(modelId);
+    if (streams) {
+        for (const streamHandler of streams) {
+            try {
+                streamHandler(level, namespace, message);
+            }
+            catch (error) {
+                console.error(`Error sending log to stream for model ${modelId}:`, error);
+            }
+        }
+    }
+}
+export function hasLoggingStreams(modelId) {
+    const streams = loggingStreams.get(modelId);
+    return streams && streams.size > 0;
+}
+export function getLoggingStreamStats() {
+    return {
+        totalModels: loggingStreams.size,
+        modelIds: Array.from(loggingStreams.keys()),
+        totalStreams: Array.from(loggingStreams.values()).reduce((sum, streams) => sum + streams.size, 0),
+    };
+}