@qvac/sdk 0.4.1 → 0.6.0

package/dist/logging/base-logger.js

@@ -1,29 +1,34 @@
 import QvacLogger, {} from "@qvac/logging";
 import { LOG_LEVELS } from "@qvac/logging/constants.js";
 import { isLevelEnabled, formatArg } from "./utils.js";
+import { registerLogger } from "./registry.js";
 export function createBaseLogger(namespace, options, extensions) {
     const qvacLogger = new QvacLogger(console);
     const initialLevel = options?.level ?? LOG_LEVELS.INFO;
     qvacLogger.setLevel(initialLevel);
     const transports = options?.transports || [];
+    let consoleEnabled = options?.enableConsole !== false;
     const log = (level, ...args) => {
         if (!isLevelEnabled(level, qvacLogger.getLevel())) {
             return;
         }
         const message = args.map(formatArg).join(" ");
-        switch (level) {
-            case LOG_LEVELS.ERROR:
-                qvacLogger.error(`[${namespace}]`, ...args);
-                break;
-            case LOG_LEVELS.WARN:
-                qvacLogger.warn(`[${namespace}]`, ...args);
-                break;
-            case LOG_LEVELS.INFO:
-                qvacLogger.info(`[${namespace}]`, ...args);
-                break;
-            case LOG_LEVELS.DEBUG:
-                qvacLogger.debug(`[${namespace}]`, ...args);
-                break;
+        // Log to console if enabled
+        if (consoleEnabled) {
+            switch (level) {
+                case LOG_LEVELS.ERROR:
+                    qvacLogger.error(`[${namespace}]`, ...args);
+                    break;
+                case LOG_LEVELS.WARN:
+                    qvacLogger.warn(`[${namespace}]`, ...args);
+                    break;
+                case LOG_LEVELS.INFO:
+                    qvacLogger.info(`[${namespace}]`, ...args);
+                    break;
+                case LOG_LEVELS.DEBUG:
+                    qvacLogger.debug(`[${namespace}]`, ...args);
+                    break;
+            }
         }
         extensions?.onLog?.(level, namespace, message);
         for (const transport of transports) {
@@ -31,16 +36,16 @@ export function createBaseLogger(namespace, options, extensions) {
                 const result = transport(level, namespace, message);
                 if (result instanceof Promise) {
                     result.catch((error) => {
-                        console.error(`Transport error in ${namespace}:`, error);
+                        console.error(`Transport error in ${namespace}:`, error); // fallback (avoid recursion)
                     });
                 }
             }
             catch (error) {
-                console.error(`Transport error in ${namespace}:`, error);
+                console.error(`Transport error in ${namespace}:`, error); // fallback (avoid recursion)
             }
         }
     };
-    return {
+    const logger = {
         error: (...args) => log(LOG_LEVELS.ERROR, ...args),
         warn: (...args) => log(LOG_LEVELS.WARN, ...args),
         info: (...args) => log(LOG_LEVELS.INFO, ...args),
@@ -51,5 +56,10 @@ export function createBaseLogger(namespace, options, extensions) {
         addTransport: (transport) => {
             transports.push(transport);
         },
+        setConsoleOutput: (enabled) => {
+            consoleEnabled = enabled;
+        },
     };
+    registerLogger(logger);
+    return logger;
 }

package/dist/logging/client-logger.d.ts

@@ -0,0 +1,3 @@
+import type { Logger, LoggerOptions } from "./types";
+export declare function getClientLogger(options?: LoggerOptions): Logger;
+//# sourceMappingURL=client-logger.d.ts.map

package/dist/logging/client-logger.js

@@ -0,0 +1,24 @@
+import { getLogger } from "./logger.js";
+const CLIENT_NAMESPACE = "sdk:client";
+const CLIENT_LOGGER_KEY = Symbol.for("@qvac/sdk:client-logger");
+function getCachedClientLogger() {
+    const global = globalThis;
+    return global[CLIENT_LOGGER_KEY] ?? null;
+}
+function setCachedClientLogger(logger) {
+    const global = globalThis;
+    global[CLIENT_LOGGER_KEY] = logger;
+}
+export function getClientLogger(options) {
+    if (!options) {
+        const cached = getCachedClientLogger();
+        if (cached) {
+            return cached;
+        }
+    }
+    const logger = getLogger(CLIENT_NAMESPACE, options);
+    if (!options) {
+        setCachedClientLogger(logger);
+    }
+    return logger;
+}

package/dist/logging/index.d.ts

@@ -1,4 +1,10 @@
-export { getLogger, setGlobalLogLevel } from "./logger";
+export { getLogger } from "./logger";
+export { setGlobalLogLevel, setGlobalConsoleOutput, registerLogger, unregisterLogger, } from "./registry";
 export { createStreamLogger } from "./stream-logger";
+export { getServerLogger } from "./server-logger";
+export { getClientLogger } from "./client-logger";
 export type { Logger, LoggerOptions, LogTransport } from "./types";
+export { ADDON_NAMESPACES, SDK_LOG_ID, SDK_SERVER_NAMESPACE, type AddonNamespace, } from "./namespaces";
+export { registerAddonLogger, unregisterAddonLogger, createAddonLoggerCallback, clearAllAddonLoggers, } from "./addon";
+export { summarizeRequest } from "./utils";
 //# sourceMappingURL=index.d.ts.map

package/dist/logging/index.js

@@ -1,2 +1,8 @@
-export { getLogger, setGlobalLogLevel } from "./logger.js";
+export { getLogger } from "./logger.js";
+export { setGlobalLogLevel, setGlobalConsoleOutput, registerLogger, unregisterLogger, } from "./registry.js";
 export { createStreamLogger } from "./stream-logger.js";
+export { getServerLogger } from "./server-logger.js";
+export { getClientLogger } from "./client-logger.js";
+export { ADDON_NAMESPACES, SDK_LOG_ID, SDK_SERVER_NAMESPACE, } from "./namespaces.js";
+export { registerAddonLogger, unregisterAddonLogger, createAddonLoggerCallback, clearAllAddonLoggers, } from "./addon.js";
+export { summarizeRequest } from "./utils.js";

package/dist/logging/logger.d.ts

@@ -1,5 +1,3 @@
-import type { LogLevel } from "@qvac/logging";
 import type { Logger, LoggerOptions } from "./types";
 export declare function getLogger(namespace: string, options?: LoggerOptions): Logger;
-export declare function setGlobalLogLevel(level: LogLevel): void;
 //# sourceMappingURL=logger.d.ts.map

package/dist/logging/logger.js

@@ -1,5 +1,13 @@
 import { safeTransport } from "./transport.js";
 import { createBaseLogger } from "./base-logger.js";
+const LOGGER_CACHE_KEY = Symbol.for("@qvac/sdk:logger-cache");
+function getLoggerCache() {
+    const global = globalThis;
+    if (!global[LOGGER_CACHE_KEY]) {
+        global[LOGGER_CACHE_KEY] = new Map();
+    }
+    return global[LOGGER_CACHE_KEY];
+}
 function createLogger(namespace, options) {
     const safeOptions = options
         ? {
@@ -9,20 +17,17 @@ function createLogger(namespace, options) {
         : undefined;
     return createBaseLogger(namespace, safeOptions);
 }
-const loggerCache = new Map();
 export function getLogger(namespace, options) {
+    const cache = getLoggerCache();
     if (!options) {
-        const cached = loggerCache.get(namespace);
+        const cached = cache.get(namespace);
         if (cached) {
             return cached;
         }
     }
     const logger = createLogger(namespace, options);
     if (!options) {
-        loggerCache.set(namespace, logger);
+        cache.set(namespace, logger);
     }
     return logger;
 }
-export function setGlobalLogLevel(level) {
-    loggerCache.forEach((logger) => logger.setLevel(level));
-}

package/dist/logging/namespaces.d.ts

@@ -0,0 +1,12 @@
+export declare const ADDON_NAMESPACES: {
+    readonly LLAMACPP_LLM: "llamacpp:llm";
+    readonly LLAMACPP_EMBED: "llamacpp:embed";
+    readonly WHISPERCPP: "whispercpp";
+    readonly TTS: "tts";
+    readonly NMTCPP: "nmtcpp";
+    readonly RAG_HYPERDB: "rag:hyperdb";
+};
+export type AddonNamespace = (typeof ADDON_NAMESPACES)[keyof typeof ADDON_NAMESPACES];
+export declare const SDK_LOG_ID = "__sdk__";
+export declare const SDK_SERVER_NAMESPACE = "sdk:server";
+//# sourceMappingURL=namespaces.d.ts.map

package/dist/logging/namespaces.js

@@ -0,0 +1,12 @@
+export const ADDON_NAMESPACES = {
+    LLAMACPP_LLM: "llamacpp:llm",
+    LLAMACPP_EMBED: "llamacpp:embed",
+    WHISPERCPP: "whispercpp",
+    TTS: "tts",
+    NMTCPP: "nmtcpp",
+    RAG_HYPERDB: "rag:hyperdb",
+};
+// Reserved ID for SDK server logs
+export const SDK_LOG_ID = "__sdk__";
+// Namespace for all SDK server logs
+export const SDK_SERVER_NAMESPACE = "sdk:server";

package/dist/logging/registry.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Logger Instance Registry (Per-Process)
+ *
+ * Manages the lifecycle of all Logger instances in the CURRENT PROCESS.
+ * Client and server run as separate processes, each with their own registry instance.
+ *
+ * Purpose:
+ * - Tracks all Logger objects in this process (getLogger, createStreamLogger, etc.)
+ * - Enables process-wide log level control via setGlobalLogLevel()
+ * - Enables process-wide console output control via setGlobalConsoleOutput()
+ * - Ensures proper cleanup when loggers are no longer needed
+ *
+ * Config Integration:
+ * - loggerLevel and loggerConsoleOutput from config file apply to both processes
+ * - Client applies settings after loading config, server applies during __init_config
+ *
+ * NOTE: This is separate from server/bare/registry/logging-stream-registry.ts
+ * which manages RPC subscriptions for streaming logs to connected clients.
+ *
+ * IMPORTANT: Some bundlers may evaluate the same logical module multiple times with
+ * subpath imports like `#rpc`, which can duplicate internal module state.
+ * We use globalThis + Symbol.for() to guarantees a single instance across all
+ * module evaluations and runtimes.
+ */
+import type { LogLevel } from "@qvac/logging";
+import type { Logger } from "./types";
+export declare function registerLogger(logger: Logger): void;
+export declare function unregisterLogger(logger: Logger): void;
+export declare function setGlobalLogLevel(level: LogLevel): void;
+export declare function setGlobalConsoleOutput(enabled: boolean): void;
+//# sourceMappingURL=registry.d.ts.map

package/dist/logging/registry.js

@@ -0,0 +1,48 @@
+/**
+ * Logger Instance Registry (Per-Process)
+ *
+ * Manages the lifecycle of all Logger instances in the CURRENT PROCESS.
+ * Client and server run as separate processes, each with their own registry instance.
+ *
+ * Purpose:
+ * - Tracks all Logger objects in this process (getLogger, createStreamLogger, etc.)
+ * - Enables process-wide log level control via setGlobalLogLevel()
+ * - Enables process-wide console output control via setGlobalConsoleOutput()
+ * - Ensures proper cleanup when loggers are no longer needed
+ *
+ * Config Integration:
+ * - loggerLevel and loggerConsoleOutput from config file apply to both processes
+ * - Client applies settings after loading config, server applies during __init_config
+ *
+ * NOTE: This is separate from server/bare/registry/logging-stream-registry.ts
+ * which manages RPC subscriptions for streaming logs to connected clients.
+ *
+ * IMPORTANT: Some bundlers may evaluate the same logical module multiple times with
+ * subpath imports like `#rpc`, which can duplicate internal module state.
+ * We use globalThis + Symbol.for() to guarantees a single instance across all
+ * module evaluations and runtimes.
+ */
+const REGISTRY_KEY = Symbol.for("@qvac/sdk:logger-registry");
+function getRegistry() {
+    const global = globalThis;
+    if (!global[REGISTRY_KEY]) {
+        global[REGISTRY_KEY] = new Set();
+    }
+    return global[REGISTRY_KEY];
+}
+export function registerLogger(logger) {
+    getRegistry().add(logger);
+}
+export function unregisterLogger(logger) {
+    getRegistry().delete(logger);
+}
+export function setGlobalLogLevel(level) {
+    for (const logger of getRegistry()) {
+        logger.setLevel(level);
+    }
+}
+export function setGlobalConsoleOutput(enabled) {
+    for (const logger of getRegistry()) {
+        logger.setConsoleOutput(enabled);
+    }
+}

package/dist/logging/server-logger.d.ts

@@ -0,0 +1,3 @@
+import type { Logger, LoggerOptions } from "./types";
+export declare function getServerLogger(options?: LoggerOptions): Logger;
+//# sourceMappingURL=server-logger.d.ts.map

package/dist/logging/server-logger.js

@@ -0,0 +1,16 @@
+import { createStreamLogger } from "./stream-logger.js";
+import { SDK_LOG_ID, SDK_SERVER_NAMESPACE } from "./namespaces.js";
+let cachedLogger = null;
+export function getServerLogger(options) {
+    if (!options && cachedLogger) {
+        return cachedLogger;
+    }
+    const logger = createStreamLogger(SDK_LOG_ID, SDK_SERVER_NAMESPACE, {
+        enableConsole: true, // SDK logs should still print to console
+        ...options,
+    });
+    if (!options) {
+        cachedLogger = logger;
+    }
+    return logger;
+}

package/dist/logging/stream-logger.d.ts

@@ -1,3 +1,3 @@
 import type { Logger, LoggerOptions } from "./types";
-export declare function createStreamLogger(modelId: string, namespace: string, options?: LoggerOptions): Logger;
+export declare function createStreamLogger(id: string, namespace: string, options?: LoggerOptions): Logger;
 //# sourceMappingURL=stream-logger.d.ts.map

package/dist/logging/stream-logger.js

@@ -1,9 +1,12 @@
 import { sendLogToStreams } from "../server/bare/registry/logging-stream-registry.js";
 import { createBaseLogger } from "./base-logger.js";
-export function createStreamLogger(modelId, namespace, options) {
-    return createBaseLogger(namespace, options, {
+export function createStreamLogger(id, namespace, options) {
+    return createBaseLogger(namespace, {
+        enableConsole: false, // Default to disable console output for stream loggers
+        ...options,
+    }, {
         onLog: (level, namespace, message) => {
-            sendLogToStreams(modelId, level, namespace, message);
+            sendLogToStreams(id, level, namespace, message);
         },
     });
 }

package/dist/logging/transport.js

@@ -4,12 +4,12 @@ export function safeTransport(transport, namespace) {
             const result = transport(level, ns, message);
             if (result instanceof Promise) {
                 result.catch((error) => {
-                    console.error(`Transport error in ${namespace}:`, error);
+                    console.error(`Transport error in ${namespace}:`, error); // fallback (avoid recursion)
                 });
             }
         }
         catch (error) {
-            console.error(`Transport error in ${namespace}:`, error);
+            console.error(`Transport error in ${namespace}:`, error); // fallback (avoid recursion)
         }
     };
 }

package/dist/logging/types.d.ts

@@ -4,6 +4,7 @@ export interface LoggerOptions {
     level?: LogLevel;
     namespace?: string;
     transports?: LogTransport[];
+    enableConsole?: boolean;
 }
 export interface Logger {
     error: (...args: unknown[]) => void;
@@ -14,5 +15,6 @@ export interface Logger {
     setLevel: (level: LogLevel) => void;
     getLevel: () => LogLevel;
     addTransport: (transport: LogTransport) => void;
+    setConsoleOutput: (enabled: boolean) => void;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/logging/utils.d.ts

@@ -1,4 +1,6 @@
 import type { LogLevel } from "@qvac/logging";
+import type { Request } from "../schemas/index";
 export declare function isLevelEnabled(messageLevel: LogLevel, currentLevel: LogLevel): boolean;
 export declare function formatArg(arg: unknown): string;
+export declare function summarizeRequest(request: Request): Record<string, unknown>;
 //# sourceMappingURL=utils.d.ts.map

package/dist/logging/utils.js

@@ -45,3 +45,65 @@ export function formatArg(arg) {
         return "[object]";
     }
 }
+export function summarizeRequest(request) {
+    const summary = { type: request.type };
+    if ("modelId" in request)
+        summary["modelId"] = request["modelId"];
+    // Only summarize requests with large payloads
+    if (request.type === "transcribeStream") {
+        const chunk = request["audioChunk"];
+        summary["audioChunk"] = `[${chunk.type}: ${chunk.value.length} bytes]`;
+        return summary;
+    }
+    if (request.type === "ocrStream") {
+        const img = request["image"];
+        summary["image"] = `[${img.type}: ${img.value.length} bytes]`;
+        return summary;
+    }
+    if (request.type === "embed") {
+        const text = request["text"];
+        if (Array.isArray(text)) {
+            const totalLen = text.reduce((sum, t) => sum + t.length, 0);
+            summary["text"] = `[${text.length} items, ${totalLen} chars]`;
+        }
+        else if (text.length > 200) {
+            summary["text"] = `[${text.length} chars]`;
+        }
+        else {
+            summary["text"] = text;
+        }
+        return summary;
+    }
+    if (request.type === "rag") {
+        const op = request["operation"];
+        if (op === "ingest" || op === "chunk") {
+            summary["operation"] = op;
+            if ("workspace" in request)
+                summary["workspace"] = request["workspace"];
+            const docs = request["documents"];
+            if (Array.isArray(docs)) {
+                const totalLen = docs.reduce((sum, d) => sum + d.length, 0);
+                summary["documents"] = `[${docs.length} docs, ${totalLen} chars]`;
+            }
+            else if (docs.length > 200) {
+                summary["documents"] = `[${docs.length} chars]`;
+            }
+            else {
+                summary["documents"] = docs;
+            }
+            return summary;
+        }
+        if (op === "saveEmbeddings") {
+            summary["operation"] = op;
+            if ("workspace" in request)
+                summary["workspace"] = request["workspace"];
+            const docs = request["documents"];
+            const dims = docs[0]?.embedding?.length ?? 0;
+            summary["documents"] =
+                `[${docs.length} docs with ${dims}-dim embeddings]`;
+            return summary;
+        }
+    }
+    // All other requests - return full request (no large payloads)
+    return request;
+}