@qvac/sdk 0.2.7-dev.1761566029.f834aa3 → 0.4.0

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

@@ -1,55 +1,86 @@
-import { promises as fsPromises } from "bare-fs";
-import path from "bare-path";
-import process from "bare-process";
-import { registerModel, isModelLoaded, } from "../registry/model-registry.js";
 import { loadModelServerParamsSchema, } from "../../../schemas/index.js";
-import { createWhisperModel } from "./whispercpp/index.js";
-import { createLlmModel } from "./llamacpp/index.js";
-import { createEmbeddingsModel } from "./llamacpp/index.js";
+import { createEmbeddingsModel, createLlmModel, } from "./llamacpp/index.js";
 import { createNmtModel } from "./translation/index.js";
+import { createTtsModel } from "./tts/index.js";
+import { createWhisperModel } from "./whispercpp/index.js";
+import { isModelLoaded, registerModel, } from "../registry/model-registry.js";
+import { detectShardedModel, generateShardFilenames } from "../../utils/index.js";
+import { ESpeakDataPathRequiredError, UnknownModelTypeError, ModelFileNotFoundError, ModelFileNotFoundInDirError, ModelFileLocateFailedError, } from "../../../utils/errors-server.js";
+import { promises as fsPromises } from "bare-fs";
+import path from "bare-path";
 export async function loadModel(params) {
-    const { modelId, modelPath, options, projectionModelPath, vadModelPath } = loadModelServerParamsSchema.parse(params);
+    const { modelId, modelPath, options, projectionModelPath, vadModelPath, ttsConfigModelPath, eSpeakDataPath, modelName, } = loadModelServerParamsSchema.parse(params);
     const { modelConfig, modelType } = options;
     // Check if model is already loaded
     if (isModelLoaded(modelId)) {
         console.log(`${modelType} model ${modelId} is already loaded`);
         return;
     }
-    // Validate the file exists
-    console.log("cwd", process.cwd());
-    try {
-        const modelDir = path.dirname(modelPath);
-        const modelFile = path.basename(modelPath);
-        const files = (await fsPromises.readdir(modelDir));
-        if (!files.includes(modelFile)) {
-            throw new Error(`${modelType} model file ${modelFile} not found in directory ${modelDir}`);
+    // Detect if sharded model
+    const modelFileName = path.basename(modelPath);
+    const shardInfo = detectShardedModel(modelFileName);
+    const isShardedModel = shardInfo.isSharded;
+    if (isShardedModel) {
+        // For sharded models, validate all required files exist
+        const shardDir = path.dirname(modelPath);
+        const allRequiredFiles = generateShardFilenames(modelFileName);
+        for (const shardFile of allRequiredFiles) {
+            const shardPath = path.join(shardDir, shardFile);
+            try {
+                await fsPromises.access(shardPath);
+            }
+            catch (error) {
+                throw new ModelFileNotFoundError(`${shardFile}. Expected ${allRequiredFiles.length} files (shards + companion files) in ${shardDir}`, error);
+            }
         }
-        // File exists, continue
     }
-    catch (error) {
-        console.error(`Error reading ${modelType} model directory:`, error instanceof Error ? error.message : String(error));
-        throw new Error(`Failed to locate ${modelType} model file: ${modelPath}`);
+    else {
+        // For non-sharded models, validate single file exists
+        try {
+            const modelDir = path.dirname(modelPath);
+            const modelFile = path.basename(modelPath);
+            const files = (await fsPromises.readdir(modelDir));
+            if (!files.includes(modelFile)) {
+                throw new ModelFileNotFoundInDirError(modelFile, modelDir, modelType);
+            }
+        }
+        catch (error) {
+            console.error(`Error reading ${modelType} model directory:`, error instanceof Error ? error.message : String(error));
+            throw new ModelFileLocateFailedError(modelType, modelPath, error);
+        }
     }
-    let model;
+    let result;
     switch (modelType) {
         case "llm":
-            model = createLlmModel(modelId, modelPath, modelConfig, projectionModelPath);
+            result = createLlmModel(modelId, modelPath, modelConfig, projectionModelPath);
             break;
         case "whisper":
-            model = createWhisperModel(modelId, modelPath, modelConfig, vadModelPath);
+            result = createWhisperModel(modelId, modelPath, modelConfig, vadModelPath);
             break;
         case "embeddings":
-            model = createEmbeddingsModel(modelId, modelPath, modelConfig);
+            result = createEmbeddingsModel(modelId, modelPath, modelConfig);
             break;
         case "nmt":
-            model = createNmtModel(modelId, modelPath, modelConfig);
+            result = createNmtModel(modelId, modelPath, modelConfig);
+            break;
+        case "tts":
+            if (!eSpeakDataPath) {
+                throw new ESpeakDataPathRequiredError();
+            }
+            result = createTtsModel(modelId, modelPath, modelConfig, ttsConfigModelPath, eSpeakDataPath);
             break;
         default:
             // Should never happen
-            throw new Error(`Unknown model type`);
+            throw new UnknownModelTypeError(modelType);
     }
     console.log(`${modelType}: Loading model ${modelId}...`);
-    await model.load(false);
+    await result.model.load(false);
     console.log(`${modelType} model ${modelId} loaded`);
-    registerModel(modelId, { model, path: modelPath, config: modelConfig });
+    registerModel(modelId, {
+        model: result.model,
+        path: modelPath,
+        config: modelConfig,
+        name: modelName,
+        loader: result.loader,
+    });
 }

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

@@ -1,4 +1,8 @@
 import { type AnyModel } from "../../registry/model-registry";
 import { type NmtConfig } from "../../../../schemas/index";
-export declare function createNmtModel(modelId: string, modelPath: string, nmtConfig: NmtConfig): AnyModel;
+import FilesystemDL from "@qvac/dl-filesystem";
+export declare function createNmtModel(modelId: string, modelPath: string, nmtConfig: NmtConfig): {
+    model: AnyModel;
+    loader: FilesystemDL;
+};
 //# sourceMappingURL=create-model.d.ts.map

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

@@ -1,45 +1,37 @@
 import TranslationNmtcpp from "@qvac/translation-nmtcpp";
-import { Readable } from "bare-stream";
 import {} from "../../registry/model-registry.js";
 import { INDICTRANS_LANGUAGES } 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 Promise.resolve(Readable.from([]));
-        },
-        ready: () => Promise.resolve(),
-        close: () => Promise.resolve(),
-        destroy: () => Promise.resolve(),
-        start: () => Promise.resolve(),
-        stop: () => Promise.resolve(),
-    };
-}
+import FilesystemDL from "@qvac/dl-filesystem";
+import { TranslationFailedError } from "../../../../utils/errors-server.js";
 export function createNmtModel(modelId, modelPath, nmtConfig) {
     const { dirPath, basePath } = parseModelPath(modelPath);
-    const dl = createFilesystemDLMimic({
-        dirPath: "./",
-    });
+    const loader = new FilesystemDL({ dirPath });
     const logger = createStreamLogger(modelId, "nmtcpp");
+    const { mode, from, to, ...generationParams } = nmtConfig;
     const args = {
-        loader: dl,
+        loader,
         logger,
         modelName: basePath,
         diskPath: dirPath,
         params: {
-            mode: nmtConfig.mode,
-            srcLang: nmtConfig.from,
-            dstLang: nmtConfig.to,
+            mode,
+            srcLang: from,
+            dstLang: to,
         },
     };
     const config = {
-        modelType: INDICTRANS_LANGUAGES.includes(nmtConfig.from) &&
-            INDICTRANS_LANGUAGES.includes(nmtConfig.to)
+        modelType: INDICTRANS_LANGUAGES.includes(from) &&
+            INDICTRANS_LANGUAGES.includes(to)
             ? TranslationNmtcpp.ModelTypes.IndicTrans
             : TranslationNmtcpp.ModelTypes.Opus,
+        ...generationParams,
     };
-    return new TranslationNmtcpp(args, config);
+    // Fail fast if model type is IndicTrans
+    if (config.modelType === TranslationNmtcpp.ModelTypes.IndicTrans) {
+        throw new TranslationFailedError("IndicTrans models are not supported with current NMT addon version.");
+    }
+    const model = new TranslationNmtcpp(args, config);
+    return { model, loader };
 }

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

@@ -1,5 +1,12 @@
 import { getModel } from "../../../registry/model-registry.js";
 import { translateServerParamsSchema, } from "../../../../../schemas/index.js";
+import { getLangName } from "@qvac/langdetect-text";
+function getLanguage(code) {
+    if (!code)
+        return "";
+    const fullName = getLangName(code);
+    return fullName ?? code.toUpperCase();
+}
 export async function* translate(params) {
     const { modelId, text, modelType } = params;
     const from = params.modelType === "llm" ? params.from : undefined;
@@ -7,13 +14,15 @@ export async function* translate(params) {
     const context = params.modelType === "llm" ? params.context : undefined;
     translateServerParamsSchema.parse(params);
     const model = getModel(modelId);
+    const fromLanguage = getLanguage(from);
+    const toLanguage = getLanguage(to);
     // 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()}:`,
+                content: `${context ? `${context}. ` : ""}Translate the following text from ${fromLanguage} into ${toLanguage}. Only output the translation, nothing else.\n\n${fromLanguage}: ${text}\n${toLanguage}:`,
             },
         ];
     const startTime = Date.now();

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

@@ -0,0 +1,10 @@
+import ONNXTTS from "@qvac/tts-onnx";
+import { type AnyModel } from "../../registry/model-registry";
+import { type TtsConfig } from "../../../../schemas/index";
+import FilesystemDL from "@qvac/dl-filesystem";
+export type TtsModel = ONNXTTS;
+export declare function createTtsModel(modelId: string, modelPath: string, ttsConfig: TtsConfig, ttsConfigModelPath: string, eSpeakDataPath: string): {
+    model: AnyModel;
+    loader: FilesystemDL;
+};
+//# sourceMappingURL=create-model.d.ts.map

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

@@ -0,0 +1,25 @@
+import ONNXTTS from "@qvac/tts-onnx";
+import {} from "../../registry/model-registry.js";
+import {} from "../../../../schemas/index.js";
+import { createStreamLogger } from "../../../../logging/index.js";
+import { parseModelPath } from "../../../utils/index.js";
+import FilesystemDL from "@qvac/dl-filesystem";
+export function createTtsModel(modelId, modelPath, ttsConfig, ttsConfigModelPath, eSpeakDataPath) {
+    const { dirPath, basePath: fileName } = parseModelPath(modelPath);
+    const loader = new FilesystemDL({ dirPath });
+    const logger = createStreamLogger(modelId, "tts");
+    const args = {
+        loader,
+        logger,
+        mainModelUrl: fileName,
+        configJsonPath: parseModelPath(ttsConfigModelPath).basePath,
+        cache: dirPath,
+        eSpeakDataPath: eSpeakDataPath,
+        opts: { stats: true },
+    };
+    const config = {
+        language: ttsConfig.language,
+    };
+    const model = new ONNXTTS(args, config);
+    return { model, loader };
+}

package/dist/server/bare/addons/tts/handlers/text-to-speech.d.ts

@@ -0,0 +1,3 @@
+import { type TtsRequest, type TtsResponse } from "../../../../../schemas/index";
+export declare function textToSpeech(params: TtsRequest): AsyncGenerator<TtsResponse>;
+//# sourceMappingURL=text-to-speech.d.ts.map

package/dist/server/bare/addons/tts/handlers/text-to-speech.js

@@ -0,0 +1,87 @@
+import { getModel } from "../../../registry/model-registry.js";
+import { ttsRequestSchema } from "../../../../../schemas/index.js";
+export async function* textToSpeech(params) {
+    const { modelId, inputType, text, stream } = ttsRequestSchema.parse(params);
+    const model = getModel(modelId);
+    const response = await model.run({ input: text, inputType });
+    if (!stream) {
+        // Non-streaming mode: wait for complete response and yield once
+        let completeBuffer = [];
+        await response
+            .onUpdate((data) => {
+            completeBuffer = completeBuffer.concat(Array.from(data.outputArray));
+        })
+            .await();
+        yield {
+            type: "textToSpeech",
+            buffer: completeBuffer,
+            done: true,
+        };
+    }
+    else {
+        // Streaming mode: use async iterator pattern
+        const outputQueue = [];
+        let isComplete = false;
+        let resolveNext = null;
+        // Start the response processing
+        const responsePromise = response
+            .onUpdate((data) => {
+            if (resolveNext) {
+                // If there's a pending read, resolve it immediately
+                resolveNext({
+                    value: {
+                        type: "textToSpeech",
+                        buffer: Array.from(data.outputArray),
+                        done: false,
+                    },
+                    done: false,
+                });
+                resolveNext = null;
+            }
+            else {
+                // Otherwise, queue the output
+                outputQueue.push(data);
+            }
+        })
+            .await()
+            .then(() => {
+            isComplete = true;
+            if (resolveNext) {
+                resolveNext({ value: undefined, done: true });
+                resolveNext = null;
+            }
+        });
+        // Create an async iterator
+        const asyncIterator = {
+            async next() {
+                if (outputQueue.length > 0) {
+                    const data = outputQueue.shift();
+                    return {
+                        value: {
+                            type: "textToSpeech",
+                            buffer: Array.from(data.outputArray),
+                            done: false,
+                        },
+                        done: false,
+                    };
+                }
+                if (isComplete) {
+                    return { value: undefined, done: true };
+                }
+                // Wait for the next output
+                return new Promise((resolve) => {
+                    resolveNext = resolve;
+                });
+            },
+            [Symbol.asyncIterator]() {
+                return this;
+            },
+        };
+        // Yield outputs as they come
+        for await (const output of asyncIterator) {
+            yield output;
+        }
+        // Ensure the response is fully processed
+        await responsePromise;
+    }
+}

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

@@ -0,0 +1,3 @@
+export { createTtsModel } from "./create-model";
+export { textToSpeech } from "./handlers/text-to-speech";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,2 @@
+export { createTtsModel } from "./create-model.js";
+export { textToSpeech } from "./handlers/text-to-speech.js";

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

@@ -1,19 +1,37 @@
 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 { unloadModelParamsSchema } from "../../../schemas/index.js";
+import { ModelNotLoadedError } from "../../../utils/errors-server.js";
+import { detectShardedModel } from "../../utils/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`);
+        throw new ModelNotLoadedError(modelId);
+    }
+    if (entry.local?.loader) {
+        await entry.local.loader.close();
     }
     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}`);
+        const modelPath = entry.local.path;
+        const modelFileName = path.basename(modelPath);
+        const shardInfo = detectShardedModel(modelFileName);
+        if (shardInfo.isSharded) {
+            // Delete entire shard directory
+            const shardDir = path.dirname(modelPath);
+            await fsPromises.rm(shardDir, { recursive: true, force: true });
+            console.log(`Sharded model storage cleared: ${shardDir}`);
+        }
+        else {
+            // Delete single file
+            await fsPromises.rm(modelPath, { recursive: true, force: true });
+            console.log(`Model storage cleared: ${modelPath}`);
+        }
     }
     unregisterAllLoggingStreams(modelId);
     console.log(`Model ${modelId} unloaded`);

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

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

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

@@ -1,42 +1,22 @@
 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([]),
-    };
-}
+import FilesystemDL from "@qvac/dl-filesystem";
 export function createWhisperModel(modelId, modelPath, whisperConfig, vadModelPath) {
     const { dirPath, basePath } = parseModelPath(modelPath);
-    // Handle VAD model path - now uses vadModelPath parameter for consistency
+    // Handle VAD model path
     let vadModelName = "";
-    let vadDirPath = "./";
-    if (vadModelPath) {
-        const vadParsed = parseModelPath(vadModelPath);
-        vadDirPath = vadParsed.dirPath;
+    const effectiveVadPath = vadModelPath || whisperConfig.vad_model_path;
+    if (effectiveVadPath) {
+        const vadParsed = parseModelPath(effectiveVadPath);
         vadModelName = vadParsed.basePath;
     }
-    const dl = createFilesystemDLMimic({
-        dirPath: vadDirPath,
-    });
+    const loader = new FilesystemDL({ dirPath });
     const logger = createStreamLogger(modelId, "whispercpp");
     const args = {
-        loader: dl,
+        loader,
         logger,
         modelName: basePath,
         diskPath: dirPath,
@@ -45,11 +25,12 @@ export function createWhisperModel(modelId, modelPath, whisperConfig, vadModelPa
             stats: false,
         },
     };
+    const { contextParams, miscConfig, ...whisperParams } = whisperConfig;
     const config = {
-        whisperConfig: {
-            ...whisperConfig,
-            vad_model: vadModelPath || "",
-        },
+        whisperConfig: whisperParams,
+        ...(contextParams && { contextParams }),
+        ...(miscConfig && { miscConfig }),
     };
-    return new TranscriptionWhispercpp(args, config);
+    const model = new TranscriptionWhispercpp(args, config);
+    return { model, loader };
 }

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

@@ -1,30 +1,51 @@
-import { getModel } from "../../../registry/model-registry.js";
+import { getModel, getModelConfig, updateModelConfig, } 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";
+import {} from "../../../../../schemas/index.js";
+import { AudioFileNotFoundError, InvalidAudioChunkError, } from "../../../../../utils/errors-server.js";
 export async function* transcribe(params) {
-    const { audioChunk: audioInput, modelId } = transcribeParamsSchema.parse(params);
-    const model = getModel(modelId);
+    const model = getModel(params.modelId);
+    if (params.prompt && typeof model.reload === "function") {
+        const existingConfig = getModelConfig(params.modelId);
+        const updatedConfig = {
+            ...existingConfig,
+            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 }),
+        });
+        updateModelConfig(params.modelId, updatedConfig);
+    }
     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);
+    const audioChunk = params.audioChunk;
+    switch (audioChunk.type) {
+        case "base64": {
+            const audioBuffer = Buffer.from(audioChunk.value, "base64");
+            audioStream = Readable.from([audioBuffer]);
+            break;
         }
-        else {
-            // File doesn't need decoding (e.g., RAW), create stream directly
-            audioStream = fs.createReadStream(audioInput);
+        case "filePath": {
+            const filePath = audioChunk.value;
+            try {
+                fs.accessSync(filePath);
+            }
+            catch (error) {
+                throw new AudioFileNotFoundError(filePath, error);
+            }
+            if (needsDecoding(filePath)) {
+                audioStream = await decodeAudioToStream(filePath);
+            }
+            else {
+                audioStream = fs.createReadStream(filePath);
+            }
+            break;
         }
-    }
-    else {
-        // It's base64 encoded buffer - decode and create stream
-        const audioBuffer = Buffer.from(audioInput, "base64");
-        audioStream = Readable.from([audioBuffer]);
+        default:
+            throw new InvalidAudioChunkError();
     }
     // Run transcription with streaming enabled
     const response = await model.run(audioStream);

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

@@ -1,6 +1,7 @@
 import { getSwarm } from "./hyperswarm.js";
 import RPC from "bare-rpc";
 import { withTimeout } from "../../utils/withTimeout.js";
+import { DelegateConnectionFailedError } from "../../utils/errors-server.js";
 // Map of active RPC instances by public key
 const activeRPCs = new Map();
 // Establish RPC connection to a peer if not already connected
@@ -27,7 +28,7 @@ async function ensureRPCConnection(topic, publicKey, timeout) {
                 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}`);
+                    throw new DelegateConnectionFailedError(`Could not establish RPC connection to peer ${publicKey} on topic ${topic}`);
                 }
                 else {
                     console.log(`✅ RPC instance found for peer ${publicKey}`);
@@ -37,7 +38,7 @@ async function ensureRPCConnection(topic, publicKey, timeout) {
         }
         catch (error) {
             console.error("Failed to establish RPC connection:", error);
-            throw new Error(`RPC connection failed: ${error instanceof Error ? error.message : String(error)}`);
+            throw new DelegateConnectionFailedError(`RPC connection failed: ${error instanceof Error ? error.message : String(error)}`, error);
         }
     }
     return rpc;

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

@@ -3,5 +3,8 @@ 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,6 +2,7 @@ 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";
 function getHyperswarmSeedBuffer() {
     const parsedEnv = envSchema.safeParse(process.env);
     if (parsedEnv.success) {
@@ -45,9 +46,19 @@ function createFirewallFunction(config) {
 function createSwarm(firewallConfig) {
     const seed = getHyperswarmSeedBuffer();
     const firewall = createFirewallFunction(firewallConfig);
-    return new Hyperswarm({ seed, firewall });
+    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);
 }
 let swarm;
+const activeProviderTopics = new Set();
 export function getSwarm({ firewallConfig, } = {}) {
     if (swarm) {
         return swarm;
@@ -55,8 +66,18 @@ 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();
     }
 }