@qvac/sdk 0.5.0 → 0.6.0

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/delegate-rpc-client.js

@@ -6,6 +6,17 @@ 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
@@ -48,6 +59,10 @@ 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");
@@ -58,15 +73,18 @@ export async function getRPC(topic, publicKey, options = {}) {
         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", () => {
             logger.debug(`Connection closed for peer: ${peerPubkey}`);
             activeRPCs.delete(peerPubkey);
+            activeConnections.delete(peerPubkey);
         });
         conn.on("error", (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/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";

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

@@ -0,0 +1,7 @@
+import { type AbortSignal } from "bare-abort-controller";
+export declare function getWorkspaceKey(workspace?: string): string;
+export declare function registerRagOperation(workspace: string | undefined, operation: string): AbortSignal;
+export declare function unregisterRagOperation(workspace?: string): void;
+export declare function cancelRagOperation(workspace?: string): boolean;
+export declare function cancelAllRagOperations(): void;
+//# sourceMappingURL=rag-operation-manager.d.ts.map

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

@@ -0,0 +1,39 @@
+import { AbortController } from "bare-abort-controller";
+import { DEFAULT_WORKSPACE } from "./rag-workspace-manager.js";
+// Map of workspace -> active operation
+const activeOperations = new Map();
+export function getWorkspaceKey(workspace) {
+    return workspace ?? DEFAULT_WORKSPACE;
+}
+export function registerRagOperation(workspace, operation) {
+    const key = getWorkspaceKey(workspace);
+    // Cancel any existing operation on this workspace
+    cancelRagOperation(workspace);
+    const abortController = new AbortController();
+    activeOperations.set(key, {
+        abortController,
+        operation,
+        startTime: Date.now(),
+    });
+    return abortController.signal;
+}
+export function unregisterRagOperation(workspace) {
+    const key = getWorkspaceKey(workspace);
+    activeOperations.delete(key);
+}
+export function cancelRagOperation(workspace) {
+    const key = getWorkspaceKey(workspace);
+    const entry = activeOperations.get(key);
+    if (!entry) {
+        return false;
+    }
+    entry.abortController.abort();
+    activeOperations.delete(key);
+    return true;
+}
+export function cancelAllRagOperations() {
+    for (const [key, entry] of activeOperations.entries()) {
+        entry.abortController.abort();
+        activeOperations.delete(key);
+    }
+}

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

@@ -0,0 +1,15 @@
+import { RAG, HyperDBAdapter, type EmbeddingFunction } from "@qvac/rag";
+export declare const DEFAULT_WORKSPACE = "default";
+export declare function hasRagWorkspaceStorage(workspace?: string): boolean;
+export declare function getRagDbAdapter(workspace?: string): Promise<HyperDBAdapter>;
+export declare function getRagInstance(modelId: string, embeddingFunction: EmbeddingFunction, workspace?: string): Promise<RAG>;
+export declare function closeRagInstance(workspace?: string): Promise<void>;
+export declare function closeAllRagInstances(): Promise<void>;
+export interface RagWorkspaceInfo {
+    name: string;
+    open: boolean;
+}
+export declare function listWorkspaces(): RagWorkspaceInfo[];
+export declare function isWorkspaceLoaded(workspace: string): boolean;
+export declare function deleteWorkspace(workspace: string): Promise<boolean>;
+//# sourceMappingURL=rag-workspace-manager.d.ts.map

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

@@ -0,0 +1,135 @@
+import { RAG, HyperDBAdapter } from "@qvac/rag";
+import Corestore from "corestore";
+import fs, { promises as fsPromises } from "bare-fs";
+import path from "bare-path";
+import { getConfiguredCacheDir } from "../registry/config-registry.js";
+import { RAGWorkspaceModelMismatchError, RAGWorkspaceNotOpenError, } from "../../../utils/errors-server.js";
+import { createStreamLogger, getServerLogger, ADDON_NAMESPACES, } from "../../../logging/index.js";
+import { cancelAllRagOperations } from "./rag-operation-manager.js";
+const logger = getServerLogger();
+const ragWorkspaces = new Map();
+export const DEFAULT_WORKSPACE = "default";
+function getWorkspaceKey(workspace) {
+    return workspace ?? DEFAULT_WORKSPACE;
+}
+function getRagBaseDir() {
+    const cacheDir = getConfiguredCacheDir();
+    return path.join(path.dirname(cacheDir), "rag-hyperdb");
+}
+function getStorePath(workspace) {
+    return path.join(getRagBaseDir(), workspace);
+}
+export function hasRagWorkspaceStorage(workspace) {
+    const key = getWorkspaceKey(workspace);
+    if (ragWorkspaces.has(key))
+        return true;
+    return fs.existsSync(getStorePath(key));
+}
+async function getOrCreateWorkspaceEntry(workspace) {
+    const key = getWorkspaceKey(workspace);
+    const existing = ragWorkspaces.get(key);
+    if (existing) {
+        return existing;
+    }
+    const storePath = getStorePath(key);
+    const corestore = new Corestore(storePath);
+    const dbAdapter = new HyperDBAdapter({
+        store: corestore,
+        dbName: key,
+    });
+    await dbAdapter.ready();
+    const entry = {
+        corestore,
+        dbAdapter,
+    };
+    ragWorkspaces.set(key, entry);
+    return entry;
+}
+export async function getRagDbAdapter(workspace) {
+    const entry = await getOrCreateWorkspaceEntry(workspace);
+    return entry.dbAdapter;
+}
+export async function getRagInstance(modelId, embeddingFunction, workspace) {
+    const key = getWorkspaceKey(workspace);
+    const entry = await getOrCreateWorkspaceEntry(workspace);
+    if (entry.rag) {
+        if (entry.modelId && entry.modelId !== modelId) {
+            throw new RAGWorkspaceModelMismatchError(key, entry.modelId, modelId);
+        }
+        return entry.rag;
+    }
+    const workspaceLogger = createStreamLogger(key, ADDON_NAMESPACES.RAG_HYPERDB);
+    const rag = new RAG({
+        dbAdapter: entry.dbAdapter,
+        embeddingFunction,
+        logger: workspaceLogger,
+    });
+    await rag.ready();
+    entry.rag = rag;
+    entry.modelId = modelId;
+    return rag;
+}
+export async function closeRagInstance(workspace) {
+    const key = getWorkspaceKey(workspace);
+    const entry = ragWorkspaces.get(key);
+    if (!entry) {
+        throw new RAGWorkspaceNotOpenError(key);
+    }
+    if (entry.rag) {
+        await entry.rag.close();
+    }
+    await entry.dbAdapter.close();
+    await entry.corestore.close();
+    ragWorkspaces.delete(key);
+}
+let isCleaningUp = false;
+export async function closeAllRagInstances() {
+    if (isCleaningUp)
+        return;
+    isCleaningUp = true;
+    try {
+        cancelAllRagOperations();
+        const closures = Array.from(ragWorkspaces.entries()).map(async ([key, entry]) => {
+            if (entry.rag) {
+                await entry.rag.close();
+            }
+            await entry.dbAdapter.close();
+            await entry.corestore.close();
+            ragWorkspaces.delete(key);
+        });
+        await Promise.all(closures);
+    }
+    catch (error) {
+        logger.error("❌ Error during RAG cleanup:", error);
+    }
+    finally {
+        isCleaningUp = false;
+    }
+}
+export function listWorkspaces() {
+    const baseDir = getRagBaseDir();
+    if (!fs.existsSync(baseDir)) {
+        return [];
+    }
+    const entries = fs.readdirSync(baseDir, {
+        withFileTypes: true,
+    });
+    const directories = entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith("."));
+    return directories.map((entry) => ({
+        name: entry.name,
+        open: ragWorkspaces.has(entry.name),
+    }));
+}
+export function isWorkspaceLoaded(workspace) {
+    const key = getWorkspaceKey(workspace);
+    return ragWorkspaces.has(key);
+}
+export async function deleteWorkspace(workspace) {
+    const key = getWorkspaceKey(workspace);
+    const storePath = getStorePath(key);
+    if (!fs.existsSync(storePath)) {
+        return false;
+    }
+    await fsPromises.rm(storePath, { recursive: true, force: true });
+    return true;
+}

package/dist/server/bare/registry/config-registry.js

@@ -9,6 +9,8 @@ const configRegistry = {
     swarmRelays: undefined,
     loggerLevel: undefined,
     loggerConsoleOutput: undefined,
+    httpDownloadConcurrency: undefined,
+    deviceDefaults: undefined,
 };
 let configIsSet = false;
 /**
@@ -56,6 +58,15 @@ export function setSDKConfig(config) {
         setGlobalConsoleOutput(config.loggerConsoleOutput);
         logger.info(`Console output ${config.loggerConsoleOutput ? "enabled" : "disabled"}`);
     }
+    if (config.httpDownloadConcurrency !== undefined &&
+        config.httpDownloadConcurrency !== null) {
+        configRegistry.httpDownloadConcurrency = config.httpDownloadConcurrency;
+        logger.info(`HTTP download concurrency set to: ${config.httpDownloadConcurrency}`);
+    }
+    if (config.deviceDefaults !== undefined && config.deviceDefaults !== null) {
+        configRegistry.deviceDefaults = config.deviceDefaults;
+        logger.info(`✅ Device defaults configured: ${config.deviceDefaults.length} pattern(s)`);
+    }
     // Mark config as set - now it's immutable
     configIsSet = true;
 }

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

@@ -51,7 +51,7 @@ export function registerLoggingStream(id, streamHandler) {
                 streamHandler(log.level, log.namespace, log.message);
             }
             catch (error) {
-                console.error(`Error flushing buffered log for ID ${id}:`, error);
+                console.error(`Error flushing buffered log for ID ${id}:`, error); // fallback (avoid recursion)
             }
         }
         logBuffer.delete(id);
@@ -85,7 +85,7 @@ export function sendLogToStreams(id, level, namespace, message) {
                 streamHandler(level, namespace, message);
             }
             catch (error) {
-                console.error(`Error sending log to stream for ID ${id}:`, error);
+                console.error(`Error sending log to stream for ID ${id}:`, error); // fallback (avoid recursion)
             }
         }
     }
@@ -127,6 +127,6 @@ export function clearAllLoggingStreams() {
     modelsWithBuffering.clear();
     bufferingTimeouts.clear();
     if (count > 0) {
-        console.log(`🧹 Cleared logging streams for ${count} ID(s)`);
+        console.log(`🧹 Cleared logging streams for ${count} ID(s)`); // fallback (avoid recursion)
     }
 }

package/dist/server/bare/registry/model-config-registry.d.ts

@@ -0,0 +1,4 @@
+import type { CanonicalModelType } from "../../../schemas/index";
+export { CANONICAL_TO_ALIAS, MODEL_CONFIG_SCHEMAS, BUILTIN_DEVICE_PATTERNS, matchesPattern, findAllMatchingPatterns, getDefaultsFromPattern, resolveModelConfigWithContext, } from "./model-config-utils";
+export declare function resolveModelConfig<T>(modelType: CanonicalModelType, userInput: Record<string, unknown>): T;
+//# sourceMappingURL=model-config-registry.d.ts.map

package/dist/server/bare/registry/model-config-registry.js

@@ -0,0 +1,15 @@
+import { getSDKConfig } from "./config-registry.js";
+import { getRuntimeContext } from "./runtime-context-registry.js";
+import { getServerLogger } from "../../../logging/index.js";
+export { CANONICAL_TO_ALIAS, MODEL_CONFIG_SCHEMAS, BUILTIN_DEVICE_PATTERNS, matchesPattern, findAllMatchingPatterns, getDefaultsFromPattern, resolveModelConfigWithContext, } from "./model-config-utils.js";
+import { BUILTIN_DEVICE_PATTERNS, resolveModelConfigWithContext, } from "./model-config-utils.js";
+const logger = getServerLogger();
+export function resolveModelConfig(modelType, userInput) {
+    const ctx = getRuntimeContext();
+    const userPatterns = getSDKConfig().deviceDefaults ?? [];
+    return resolveModelConfigWithContext(modelType, userInput, ctx, userPatterns, BUILTIN_DEVICE_PATTERNS, (log) => {
+        if (log.appliedPatterns.length > 0) {
+            logger.debug(`[device-defaults] ${modelType}: applied [${log.appliedPatterns.join(" → ")}]`);
+        }
+    });
+}

package/dist/server/bare/registry/model-config-utils.d.ts

@@ -0,0 +1,15 @@
+import type { ZodSchema } from "zod";
+import { type CanonicalModelType, type DevicePattern, type DeviceMatch, type RuntimeContext } from "../../../schemas/index";
+export declare const CANONICAL_TO_ALIAS: Record<CanonicalModelType, string>;
+export declare const MODEL_CONFIG_SCHEMAS: Partial<Record<CanonicalModelType, ZodSchema>>;
+export declare const BUILTIN_DEVICE_PATTERNS: DevicePattern[];
+export declare function matchesPattern(ctx: RuntimeContext, match: DeviceMatch): boolean;
+export declare function findAllMatchingPatterns(ctx: RuntimeContext, patterns: DevicePattern[]): DevicePattern[];
+export declare function getDefaultsFromPattern(modelType: CanonicalModelType, pattern: DevicePattern): Record<string, unknown> | undefined;
+export type ConfigResolutionLog = {
+    appliedPatterns: string[];
+    mergedDefaults: Record<string, unknown>;
+    finalConfig: Record<string, unknown>;
+};
+export declare function resolveModelConfigWithContext<T>(modelType: CanonicalModelType, userInput: Record<string, unknown>, ctx: RuntimeContext, userPatterns: DevicePattern[], builtinPatterns?: DevicePattern[], onLog?: (log: ConfigResolutionLog) => void): T;
+//# sourceMappingURL=model-config-utils.d.ts.map