@qvac/sdk 0.4.1 → 0.5.0

package/dist/server/bare/hyperswarm.js

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

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

@@ -3,6 +3,8 @@ import Corestore from "corestore";
 import path from "bare-path";
 import { getEnv } from "../../worker.js";
 import { RAGWorkspaceModelMismatchError } from "../../../utils/errors-server.js";
+import { getServerLogger } from "../../../logging/index.js";
+const logger = getServerLogger();
 const ragInstances = new Map();
 const defaultWorkspace = "default";
 const getStorePath = (workspace) => {
@@ -59,6 +61,6 @@ export const closeAllRagInstances = async () => {
         await Promise.all(closures);
     }
     catch (error) {
-        console.error("❌ Error during RAG cleanup:", error);
+        logger.error("❌ Error during RAG cleanup:", error);
     }
 };

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

@@ -1,5 +1,14 @@
-import type { SDKConfig } from "../../../schemas/index";
-export declare const setSDKConfig: (config: SDKConfig) => void;
-export declare const getSDKConfig: () => SDKConfig;
-export declare const getConfiguredCacheDir: () => string;
+import type { QvacConfig } from "../../../schemas/index";
+/**
+ * Sets the SDK configuration. This can only be called ONCE during initialization.
+ * After the first call, the config becomes immutable and any subsequent calls will throw.
+ *
+ * @param config - The configuration to set
+ * @throws {ConfigAlreadySetError} If config has already been set
+ * @throws {CacheDirNotAbsoluteError} If cacheDirectory is not an absolute path
+ * @throws {CacheDirNotWritableError} If cacheDirectory is not writable
+ */
+export declare function setSDKConfig(config: QvacConfig): void;
+export declare function getSDKConfig(): QvacConfig;
+export declare function getConfiguredCacheDir(): string;
 //# sourceMappingURL=config-registry.d.ts.map

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

@@ -1,12 +1,30 @@
 import fs from "bare-fs";
 import path from "bare-path";
 import { getEnv } from "../../worker.js";
-import { CacheDirNotAbsoluteError, CacheDirNotWritableError, } from "../../../utils/errors-server.js";
+import { CacheDirNotAbsoluteError, CacheDirNotWritableError, ConfigAlreadySetError, } from "../../../utils/errors-server.js";
+import { getServerLogger, setGlobalConsoleOutput, setGlobalLogLevel, } from "../../../logging/index.js";
+const logger = getServerLogger();
 const configRegistry = {
     cacheDirectory: undefined,
     swarmRelays: undefined,
+    loggerLevel: undefined,
+    loggerConsoleOutput: undefined,
 };
-export const setSDKConfig = (config) => {
+let configIsSet = false;
+/**
+ * Sets the SDK configuration. This can only be called ONCE during initialization.
+ * After the first call, the config becomes immutable and any subsequent calls will throw.
+ *
+ * @param config - The configuration to set
+ * @throws {ConfigAlreadySetError} If config has already been set
+ * @throws {CacheDirNotAbsoluteError} If cacheDirectory is not an absolute path
+ * @throws {CacheDirNotWritableError} If cacheDirectory is not writable
+ */
+export function setSDKConfig(config) {
+    // Enforce immutability - config can only be set once
+    if (configIsSet) {
+        throw new ConfigAlreadySetError();
+    }
     if (config.cacheDirectory !== undefined && config.cacheDirectory !== null) {
         if (!path.isAbsolute(config.cacheDirectory)) {
             throw new CacheDirNotAbsoluteError();
@@ -21,19 +39,33 @@ export const setSDKConfig = (config) => {
             throw new CacheDirNotWritableError(config.cacheDirectory, error instanceof Error ? error.message : String(error), error);
         }
         configRegistry.cacheDirectory = config.cacheDirectory;
-        console.log(`✅ Cache directory set to: ${config.cacheDirectory}`);
+        logger.info(`✅ Cache directory set to: ${config.cacheDirectory}`);
     }
     if (config.swarmRelays !== undefined && config.swarmRelays !== null) {
         configRegistry.swarmRelays = config.swarmRelays;
+        logger.info(`✅ Swarm relays configured: ${config.swarmRelays.length} relay(s)`);
     }
-};
-export const getSDKConfig = () => {
+    if (config.loggerLevel !== undefined && config.loggerLevel !== null) {
+        configRegistry.loggerLevel = config.loggerLevel;
+        setGlobalLogLevel(config.loggerLevel);
+        logger.info(`Log level set to: ${config.loggerLevel}`);
+    }
+    if (config.loggerConsoleOutput !== undefined &&
+        config.loggerConsoleOutput !== null) {
+        configRegistry.loggerConsoleOutput = config.loggerConsoleOutput;
+        setGlobalConsoleOutput(config.loggerConsoleOutput);
+        logger.info(`Console output ${config.loggerConsoleOutput ? "enabled" : "disabled"}`);
+    }
+    // Mark config as set - now it's immutable
+    configIsSet = true;
+}
+export function getSDKConfig() {
     return { ...configRegistry };
-};
-const getDefaultCacheDir = () => {
+}
+function getDefaultCacheDir() {
     const homeDir = getEnv().HOME_DIR;
     return path.join(homeDir, ".qvac", "models");
-};
-export const getConfiguredCacheDir = () => {
+}
+export function getConfiguredCacheDir() {
     return configRegistry.cacheDirectory || getDefaultCacheDir();
-};
+}

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

@@ -1,13 +1,30 @@
+/**
+ * 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 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 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 getLoggingStreamStats(): {
-    totalModels: number;
-    modelIds: string[];
+    totalIds: number;
+    ids: string[];
     totalStreams: number;
+    bufferedIds: number;
+    idsWithBuffering: number;
+    activeTimeouts: number;
 };
 export declare function clearAllLoggingStreams(): void;
 //# sourceMappingURL=logging-stream-registry.d.ts.map

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

@@ -1,53 +1,132 @@
+/**
+ * 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)
+ *
+ */
 const loggingStreams = new Map();
-export function registerLoggingStream(modelId, streamHandler) {
-    if (!loggingStreams.has(modelId)) {
-        loggingStreams.set(modelId, new Set());
+// Buffering for logs emitted during model loading (before client subscribes)
+const MAX_BUFFERED_LOGS_PER_MODEL = 100;
+const BUFFER_EXPIRY_MS = 30_000;
+const BUFFERING_TIMEOUT_MS = 5_000;
+const logBuffer = new Map();
+const modelsWithBuffering = new Set();
+const bufferingTimeouts = new Map();
+function clearBufferingTimeout(id) {
+    const timeout = bufferingTimeouts.get(id);
+    if (timeout) {
+        clearTimeout(timeout);
+        bufferingTimeouts.delete(id);
     }
-    loggingStreams.get(modelId).add(streamHandler);
 }
-export function unregisterLoggingStream(modelId, streamHandler) {
-    const streams = loggingStreams.get(modelId);
+export function startLogBuffering(id) {
+    modelsWithBuffering.add(id);
+}
+export function stopLogBufferingWithTimeout(id) {
+    clearBufferingTimeout(id);
+    const timeout = setTimeout(() => {
+        if (modelsWithBuffering.has(id)) {
+            modelsWithBuffering.delete(id);
+            logBuffer.delete(id);
+        }
+        bufferingTimeouts.delete(id);
+    }, BUFFERING_TIMEOUT_MS);
+    bufferingTimeouts.set(id, timeout);
+}
+export function registerLoggingStream(id, streamHandler) {
+    if (!loggingStreams.has(id)) {
+        loggingStreams.set(id, new Set());
+    }
+    loggingStreams.get(id).add(streamHandler);
+    const buffered = logBuffer.get(id);
+    if (buffered && buffered.length > 0) {
+        for (const log of buffered) {
+            try {
+                streamHandler(log.level, log.namespace, log.message);
+            }
+            catch (error) {
+                console.error(`Error flushing buffered log for ID ${id}:`, error);
+            }
+        }
+        logBuffer.delete(id);
+    }
+    modelsWithBuffering.delete(id);
+    clearBufferingTimeout(id);
+}
+export function unregisterLoggingStream(id, streamHandler) {
+    const streams = loggingStreams.get(id);
     if (streams) {
         streams.delete(streamHandler);
         if (streams.size === 0) {
-            loggingStreams.delete(modelId);
+            loggingStreams.delete(id);
         }
     }
 }
-export function unregisterAllLoggingStreams(modelId) {
-    // Simply remove all logging handlers for this model
+export function unregisterAllLoggingStreams(id) {
+    // Simply remove all logging handlers
     // Active streams will naturally terminate when no more logs flow
-    loggingStreams.delete(modelId);
-    console.debug(`Unregistered all logging streams for model ${modelId}`);
+    loggingStreams.delete(id);
+    logBuffer.delete(id);
+    modelsWithBuffering.delete(id);
+    clearBufferingTimeout(id);
 }
-export function sendLogToStreams(modelId, level, namespace, message) {
-    const streams = loggingStreams.get(modelId);
-    if (streams) {
+export function sendLogToStreams(id, level, namespace, message) {
+    const streams = loggingStreams.get(id);
+    const isBuffering = modelsWithBuffering.has(id);
+    if (streams && streams.size > 0) {
         for (const streamHandler of streams) {
             try {
                 streamHandler(level, namespace, message);
             }
             catch (error) {
-                console.error(`Error sending log to stream for model ${modelId}:`, error);
+                console.error(`Error sending log to stream for ID ${id}:`, error);
             }
         }
     }
+    else if (isBuffering) {
+        if (!logBuffer.has(id)) {
+            logBuffer.set(id, []);
+        }
+        const buffer = logBuffer.get(id);
+        const now = Date.now();
+        const validLogs = buffer.filter((log) => now - log.timestamp < BUFFER_EXPIRY_MS);
+        if (validLogs.length >= MAX_BUFFERED_LOGS_PER_MODEL) {
+            validLogs.shift();
+        }
+        validLogs.push({ level, namespace, message, timestamp: now });
+        logBuffer.set(id, validLogs);
+    }
 }
-export function hasLoggingStreams(modelId) {
-    const streams = loggingStreams.get(modelId);
+export function hasLoggingStreams(id) {
+    const streams = loggingStreams.get(id);
     return streams && streams.size > 0;
 }
 export function getLoggingStreamStats() {
     return {
-        totalModels: loggingStreams.size,
-        modelIds: Array.from(loggingStreams.keys()),
+        totalIds: loggingStreams.size,
+        ids: Array.from(loggingStreams.keys()),
         totalStreams: Array.from(loggingStreams.values()).reduce((sum, streams) => sum + streams.size, 0),
+        bufferedIds: logBuffer.size,
+        idsWithBuffering: modelsWithBuffering.size,
+        activeTimeouts: bufferingTimeouts.size,
     };
 }
 export function clearAllLoggingStreams() {
     const count = loggingStreams.size;
+    for (const timeout of bufferingTimeouts.values()) {
+        clearTimeout(timeout);
+    }
     loggingStreams.clear();
+    logBuffer.clear();
+    modelsWithBuffering.clear();
+    bufferingTimeouts.clear();
     if (count > 0) {
-        console.log(`🧹 Cleared logging streams for ${count} model(s)`);
+        console.log(`🧹 Cleared logging streams for ${count} ID(s)`);
     }
 }

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

@@ -1,5 +1,6 @@
 import type EventEmitter from "events";
 import type FilesystemDL from "@qvac/dl-filesystem";
+import type { ModelType } from "../../../schemas/index";
 interface AddonInterface {
     cancel(jobId?: string): Promise<void>;
 }
@@ -40,6 +41,7 @@ interface LocalOptions {
     path: string;
     loadedAt: Date;
     config: unknown;
+    modelType: ModelType;
     name?: string | undefined;
     loader: FilesystemDL;
 }
@@ -53,6 +55,7 @@ export declare function registerModel(id: string, options: {
     model: AnyModel;
     path: string;
     config: unknown;
+    modelType: ModelType;
     loader: FilesystemDL;
     name?: string | undefined;
 } | {

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

@@ -1,4 +1,6 @@
 import { ModelAlreadyRegisteredError, ModelNotFoundError, ModelIsDelegatedError, } from "../../../utils/errors-server.js";
+import { getServerLogger } from "../../../logging/index.js";
+const logger = getServerLogger();
 // Global registry state - using stateless functions to manage it
 const modelRegistry = new Map();
 export function registerModel(id, options) {
@@ -17,7 +19,7 @@ export function registerModel(id, options) {
                 timeout,
             },
         });
-        console.log(`Delegated model registered: ${id} -> topic: ${topic}, provider: ${providerPublicKey}, timeout: ${timeout}ms`);
+        logger.info(`Delegated model registered: ${id} -> topic: ${topic}, provider: ${providerPublicKey}, timeout: ${timeout}ms`);
     }
     else {
         modelRegistry.set(id, {
@@ -28,12 +30,13 @@ export function registerModel(id, options) {
                 path: options.path,
                 loadedAt: new Date(),
                 config: options.config,
+                modelType: options.modelType,
                 loader: options.loader,
                 name: options.name,
             },
         });
         const nameStr = options.name ? ` (${options.name})` : "";
-        console.log(`Local model registered: ${id}${nameStr} -> ${options.path}`);
+        logger.info(`Local model registered: ${id}${nameStr} -> ${options.path}`);
     }
 }
 export function getModelEntry(id) {
@@ -56,7 +59,7 @@ export function unregisterModel(id) {
     const entry = modelRegistry.get(id);
     if (entry) {
         modelRegistry.delete(id);
-        console.log(`Model unregistered: ${id}`);
+        logger.debug(`Model unregistered: ${id}`);
         return entry;
     }
     return null;
@@ -99,7 +102,7 @@ export function updateModelConfig(id, config) {
 }
 export function clearRegistry() {
     modelRegistry.clear();
-    console.log("Model registry cleared");
+    logger.info("Model registry cleared");
 }
 export function getRegistryStats() {
     return {
@@ -113,9 +116,9 @@ export async function unloadAllModels() {
         const entry = modelRegistry.get(modelId);
         if (entry?.local?.model && entry.local.model.unload) {
             await entry.local.model.unload();
-            console.log(`Model unloaded: ${modelId}`);
+            logger.debug(`Model unloaded: ${modelId}`);
         }
         modelRegistry.delete(modelId);
     }
-    console.log(`Unloaded ${modelIds.length} models`);
+    logger.info(`Unloaded ${modelIds.length} models`);
 }

package/dist/server/rpc/create-server.js

@@ -1,19 +1,21 @@
 import RPC from "bare-rpc";
 import { connect } from "bare-net";
 import { handleRequest } from "./handle-request.js";
+import { getServerLogger } from "../../logging/index.js";
+const logger = getServerLogger();
 export function createBareKitRPCServer() {
     const { IPC } = globalThis
         .BareKit;
     return new RPC(IPC, handleRequest);
 }
 export function createIPCClient(socketPath) {
-    console.log(`Connecting to IPC socket at ${socketPath}`);
+    logger.info(`Connecting to IPC socket at ${socketPath}`);
     const socket = connect(socketPath);
     socket.on("connect", () => {
-        console.log("Connected to IPC server");
+        logger.info("Connected to IPC server");
     });
     socket.on("error", (err) => {
-        console.error("IPC client connection error:", err);
+        logger.error("IPC client connection error:", err);
     });
     return new RPC(socket, handleRequest);
 }

package/dist/server/rpc/handle-request.js

@@ -5,6 +5,7 @@ import { handleLoadModel } from "./handlers/load-model.js";
 import { handleLoadModelDelegated } from "./handlers/load-model-delegated.js";
 import { handleCompletionStreamDelegated } from "./handlers/completion-stream-delegated.js";
 import { getModelEntry } from "../bare/registry/model-registry.js";
+import { setSDKConfig } from "../bare/registry/config-registry.js";
 import { handleUnloadModel } from "./handlers/unload-model.js";
 import { handleTranscribeStream } from "./handlers/transcribe-stream.js";
 import { handleEmbed } from "./handlers/embed.js";
@@ -16,7 +17,6 @@ import { stopProvideHandler } from "./handlers/stopProvideHandler.js";
 import { handleRag } from "./handlers/rag.js";
 import { handleDeleteCache } from "./handlers/delete-cache.js";
 import { handleTextToSpeech } from "./handlers/text-to-speech.js";
-import { handleSetConfig } from "./handlers/set-config.js";
 import { handleGetModelInfo } from "./handlers/get-model-info.js";
 import { sendErrorResponse, sendStreamErrorResponse, } from "../error-handlers.js";
 import { NoDataReceivedError, UnknownRequestTypeError, } from "../../utils/errors-client.js";
@@ -27,6 +27,24 @@ export async function handleRequest(req) {
             throw new NoDataReceivedError();
         }
         const jsonData = JSON.parse(rawData);
+        // Handle special internal config initialization message
+        if (jsonData &&
+            typeof jsonData === "object" &&
+            "type" in jsonData &&
+            jsonData.type === "__init_config") {
+            try {
+                const configData = jsonData;
+                setSDKConfig(configData.config);
+                req.reply(JSON.stringify({ success: true }), "utf-8");
+            }
+            catch (error) {
+                req.reply(JSON.stringify({
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                }), "utf-8");
+            }
+            return;
+        }
         const request = requestSchema.parse(jsonData);
         switch (request.type) {
             case "downloadAsset": {
@@ -84,13 +102,19 @@ export async function handleRequest(req) {
                         sendStreamErrorResponse(stream, error);
                     }
                 }
+                else if (request.delegate) {
+                    try {
+                        const response = await handleLoadModelDelegated(request);
+                        req.reply(JSON.stringify(responseSchema.parse(response)), "utf-8");
+                    }
+                    catch (error) {
+                        sendErrorResponse(req, error);
+                    }
+                }
                 else {
-                    // Route to appropriate handler based on delegation
+                    // Load without progress/delegate, or reload config
                     try {
-                        const handler = request.delegate
-                            ? handleLoadModelDelegated
-                            : handleLoadModel;
-                        const response = await handler(request);
+                        const response = await handleLoadModel(request);
                         req.reply(JSON.stringify(responseSchema.parse(response)), "utf-8");
                     }
                     catch (error) {
@@ -245,16 +269,6 @@ export async function handleRequest(req) {
                 }
                 break;
             }
-            case "setConfig": {
-                try {
-                    const response = handleSetConfig(request);
-                    req.reply(JSON.stringify(responseSchema.parse(response)), "utf-8");
-                }
-                catch (error) {
-                    sendErrorResponse(req, error);
-                }
-                break;
-            }
             case "getModelInfo": {
                 try {
                     const response = await handleGetModelInfo(request);

package/dist/server/rpc/handlers/cancelHandler.js

@@ -1,5 +1,7 @@
 import { cancel } from "../../bare/addons/index.js";
 import { createCancelFunction } from "./load-model/download-manager.js";
+import { getServerLogger } from "../../../logging/index.js";
+const logger = getServerLogger();
 export async function cancelHandler(request) {
     try {
         switch (request.operation) {
@@ -17,7 +19,7 @@ export async function cancelHandler(request) {
         };
     }
     catch (error) {
-        console.error("Error during cancellation:", error);
+        logger.error("Error during cancellation:", error);
         return {
             type: "cancel",
             success: false,

package/dist/server/rpc/handlers/completion-stream-delegated.js

@@ -2,6 +2,8 @@ import { getModelEntry } from "../../bare/registry/model-registry.js";
 import { getRPC } from "../../bare/delegate-rpc-client.js";
 import { stream } from "../../../client/rpc/rpc-client.js";
 import { ModelIsDelegatedError } from "../../../utils/errors-server.js";
+import { getServerLogger } from "../../../logging/index.js";
+const logger = getServerLogger();
 export async function* handleCompletionStreamDelegated(request) {
     // Get delegation info from model registry
     const entry = getModelEntry(request.modelId);
@@ -10,7 +12,7 @@ export async function* handleCompletionStreamDelegated(request) {
     }
     const { topic, providerPublicKey, timeout } = entry.delegated;
     try {
-        console.log(`📤 Sending delegated completionStream request to provider: ${providerPublicKey}${timeout ? `, timeout: ${timeout}ms` : ""}`);
+        logger.debug(`📤 Sending delegated completionStream request to provider: ${providerPublicKey}${timeout ? `, timeout: ${timeout}ms` : ""}`);
         // Create RPC instance for this HyperSwarm peer
         const rpc = await getRPC(topic, providerPublicKey, { timeout });
         // Use the regular stream function with the HyperSwarm RPC instance
@@ -21,7 +23,7 @@ export async function* handleCompletionStreamDelegated(request) {
         }
     }
     catch (error) {
-        console.error("Error in delegated completion stream:", error);
+        logger.error("Error in delegated completion stream:", error);
         yield {
             type: "completionStream",
             token: `Error communicating with provider: ${error instanceof Error ? error.message : String(error)}`,

package/dist/server/rpc/handlers/delete-cache.js

@@ -1,4 +1,6 @@
 import { deleteCache as deleteCacheUtil } from "../../bare/addons/llamacpp/kv-cache-utils.js";
+import { getServerLogger } from "../../../logging/index.js";
+const logger = getServerLogger();
 export async function handleDeleteCache(request) {
     try {
         if ("all" in request && request.all) {
@@ -19,7 +21,7 @@ export async function handleDeleteCache(request) {
         };
     }
     catch (error) {
-        console.error("Error deleting cache:", error);
+        logger.error("Error deleting cache:", error);
         return {
             type: "deleteCache",
             success: false,

package/dist/server/rpc/handlers/download-asset.js

@@ -1,4 +1,6 @@
 import { resolveModelPath } from "./load-model/resolve.js";
+import { getServerLogger } from "../../../logging/index.js";
+const logger = getServerLogger();
 export async function handleDownloadAsset(request, progressCallback) {
     const { assetSrc, seed } = request;
     try {
@@ -10,7 +12,7 @@ export async function handleDownloadAsset(request, progressCallback) {
         };
     }
     catch (error) {
-        console.error("Error downloading asset:", error);
+        logger.error("Error downloading asset:", error);
         return {
             type: "downloadAsset",
             success: false,

package/dist/server/rpc/handlers/embed.js

@@ -1,4 +1,6 @@
 import { embed } from "../../bare/addons/llamacpp/index.js";
+import { getServerLogger } from "../../../logging/index.js";
+const logger = getServerLogger();
 export async function handleEmbed(request) {
     const { modelId, text } = request;
     try {
@@ -10,7 +12,7 @@ export async function handleEmbed(request) {
         };
     }
     catch (error) {
-        console.error("Error during embedding:", error);
+        logger.error("Error during embedding:", error);
         return {
             type: "embed",
             success: false,

package/dist/server/rpc/handlers/index.d.ts

@@ -27,7 +27,6 @@ export declare const handlers: {
     rag: typeof handleRag;
     cancel: typeof cancelHandler;
     textToSpeech: typeof handleTextToSpeech;
-    setConfig: (request: import("../../../schemas").SetConfigRequest) => import("../../../schemas").SetConfigResponse;
     getModelInfo: (request: import("../../../schemas").GetModelInfoRequest) => Promise<import("../../../schemas").GetModelInfoResponse>;
 };
 //# sourceMappingURL=index.d.ts.map

package/dist/server/rpc/handlers/index.js

@@ -12,7 +12,6 @@ import { handleRag } from "./rag.js";
 import { cancelHandler } from "./cancelHandler.js";
 import { handleDeleteCache } from "./delete-cache.js";
 import { handleTextToSpeech } from "./text-to-speech.js";
-import { handleSetConfig } from "./set-config.js";
 import { handleGetModelInfo } from "./get-model-info.js";
 export const handlers = {
     completionStream: handleCompletionStream,
@@ -29,6 +28,5 @@ export const handlers = {
     rag: handleRag,
     cancel: cancelHandler,
     textToSpeech: handleTextToSpeech,
-    setConfig: handleSetConfig,
     getModelInfo: handleGetModelInfo,
 };