@qvac/sdk 0.4.1 → 0.5.0

package/dist/examples/logging-streaming.js

@@ -0,0 +1,75 @@
+import { loadModel, completion, unloadModel, loggingStream, SDK_LOG_ID, LLAMA_3_2_1B_INST_Q4_0, GTE_LARGE_FP16, VERBOSITY, embed, } from "@qvac/sdk";
+try {
+    console.log("🚀 Starting log streaming demo...\n");
+    // Note: To configure logging (level and console output), use config file:
+    // { "loggerLevel": "debug", "loggerConsoleOutput": false } in qvac.config.json/js/ts
+    // Subscribe to SDK server logs in background
+    console.log("📡 Starting SDK server log stream...\n");
+    (async () => {
+        for await (const log of loggingStream({ id: SDK_LOG_ID })) {
+            console.log(`[SDK] [${log.level.toUpperCase()}] [${log.namespace}] ${log.message}`);
+        }
+    })().catch(() => {
+        // Stream terminated - normal on shutdown
+    });
+    // Load models
+    console.log("📥 Loading models (watch SDK logs above)...\n");
+    const llmModelId = await loadModel({
+        modelSrc: LLAMA_3_2_1B_INST_Q4_0,
+        modelType: "llm",
+        modelConfig: {
+            ctx_size: 2048,
+            temp: 0.7,
+            verbosity: VERBOSITY.ERROR, // Only log errors, remaining logs are captured by loggingStream
+        },
+    });
+    const embedModelId = await loadModel({
+        modelSrc: GTE_LARGE_FP16,
+        modelType: "embeddings",
+    });
+    console.log("📡 Starting model-specific log streams...\n");
+    (async () => {
+        for await (const log of loggingStream({ id: llmModelId })) {
+            const timestamp = new Date(log.timestamp).toISOString();
+            console.log(`[LLM] [${timestamp}] [${log.level.toUpperCase()}] ${log.namespace}: ${log.message}`);
+        }
+    })().catch(() => {
+        // Stream terminated - this is normal when model unloads
+    });
+    (async () => {
+        for await (const log of loggingStream({ id: embedModelId })) {
+            const timestamp = new Date(log.timestamp).toISOString();
+            console.log(`[EMBED] [${timestamp}] [${log.level.toUpperCase()}] ${log.namespace}: ${log.message}`);
+        }
+    })().catch(() => {
+        // Stream terminated - this is normal when model unloads
+    });
+    const messages = [
+        { role: "user", content: "Count from 1 to 5 and explain each number." },
+    ];
+    const result = completion({
+        modelId: llmModelId,
+        history: messages,
+        stream: true,
+    });
+    const embedding = await embed({
+        modelId: embedModelId,
+        text: messages[0]?.content ?? "Hello, world!",
+    });
+    console.log("📝 Response:\n");
+    for await (const token of result.tokenStream) {
+        process.stdout.write(token);
+    }
+    console.log("Embedding (first 20 elements)", embedding.slice(0, 20));
+    console.log("Embeddings length", embedding.length);
+    console.log("\n💡 Notice three log streams running:\n" +
+        "   - [SDK] = SDK server operations\n" +
+        "   - [LLM] = LLM model inference logs\n" +
+        "   - [EMBED] = Embedding model logs\n");
+    await unloadModel({ modelId: llmModelId, clearStorage: false });
+    await unloadModel({ modelId: embedModelId, clearStorage: false });
+}
+catch (error) {
+    console.error("❌ Error:", error);
+    process.exit(1);
+}

package/dist/examples/mcp-websearch.d.ts

@@ -0,0 +1,13 @@
+/**
+ * MCP DuckDuckGo Search Example
+ *
+ * A web search example using DuckDuckGo - no API key required!
+ * The server provides tools to search the web and get answers.
+ *
+ * Prerequisites:
+ * - Install MCP SDK: bun add @modelcontextprotocol/sdk
+ *
+ * Run with: bun run examples/mcp-websearch.ts
+ */
+export {};
+//# sourceMappingURL=mcp-websearch.d.ts.map

package/dist/examples/mcp-websearch.js

@@ -0,0 +1,176 @@
+/**
+ * MCP DuckDuckGo Search Example
+ *
+ * A web search example using DuckDuckGo - no API key required!
+ * The server provides tools to search the web and get answers.
+ *
+ * Prerequisites:
+ * - Install MCP SDK: bun add @modelcontextprotocol/sdk
+ *
+ * Run with: bun run examples/mcp-websearch.ts
+ */
+import { completion, loadModel, unloadModel, QWEN_3_1_7B_INST_Q4, } from "../index.js";
+// MCP SDK is a user-installed optional dependency
+// Install with: bun add @modelcontextprotocol/sdk
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+function parseSearchResults(mcpResult) {
+    try {
+        const result = mcpResult;
+        // Extract text content from MCP response
+        const textContent = result.content?.find((c) => c.type === "text");
+        if (!textContent?.text) {
+            return JSON.stringify(mcpResult);
+        }
+        // Parse the JSON array of search results
+        const rawResults = JSON.parse(textContent.text);
+        // Extract just the useful fields (title, url, snippet)
+        const cleanResults = rawResults.slice(0, 5).map((r) => ({
+            title: r.title ?? "Unknown",
+            url: r.url ?? "",
+            snippet: r.snippet ?? "",
+        }));
+        // Format as concise text for LLM
+        return cleanResults
+            .map((r, i) => `[${i + 1}] ${r.title}\n    URL: ${r.url}\n    ${r.snippet}`)
+            .join("\n\n");
+    }
+    catch {
+        // If parsing fails, return a truncated version
+        const str = typeof mcpResult === "string" ? mcpResult : JSON.stringify(mcpResult);
+        return str.slice(0, 2000);
+    }
+}
+let mcpClient = null;
+try {
+    console.log("🦆 MCP DuckDuckGo Search Example\n");
+    // ============================================================
+    // STEP 1: Connect to DuckDuckGo MCP server
+    // ============================================================
+    console.log("1️⃣  Starting DuckDuckGo MCP server...");
+    mcpClient = new Client({
+        name: "qvac-ddg-example",
+        version: "1.0.0",
+    });
+    const transport = new StdioClientTransport({
+        command: "npx",
+        args: ["-y", "@oevortex/ddg_search"],
+    });
+    await mcpClient.connect(transport);
+    console.log("   ✓ MCP server connected\n");
+    // ============================================================
+    // STEP 2: Load model
+    // ============================================================
+    console.log("2️⃣  Loading model...");
+    const modelId = await loadModel({
+        modelSrc: QWEN_3_1_7B_INST_Q4,
+        modelType: "llm",
+        modelConfig: {
+            ctx_size: 4096,
+            tools: true,
+        },
+        onProgress: (progress) => process.stdout.write(`\r   Loading: ${progress.percentage.toFixed(1)}%`),
+    });
+    console.log(`\n   ✓ Model loaded\n`);
+    // ============================================================
+    // STEP 3: Ask AI to search the web (with MCP client)
+    // ============================================================
+    const history = [
+        {
+            role: "system",
+            content: `You are a helpful assistant with access to web search.
+Use the search tool when you need current information.
+Always cite your sources with the URL.`,
+        },
+        {
+            role: "user",
+            content: "What is the current weather in New York City?",
+        },
+    ];
+    console.log("3️⃣  Asking AI to search the web...\n");
+    console.log("🤖 AI Response:");
+    // Pass MCP client directly to completion - tools are adapted internally!
+    const result = completion({
+        modelId,
+        history,
+        stream: true,
+        mcp: [{ client: mcpClient, includeResources: false }],
+    });
+    for await (const token of result.tokenStream) {
+        process.stdout.write(token);
+    }
+    const toolCalls = await result.toolCalls;
+    console.log("\n");
+    // ============================================================
+    // STEP 4: Execute tool calls using call() - automatic MCP routing!
+    // ============================================================
+    if (toolCalls.length > 0) {
+        console.log("4️⃣  Executing search...\n");
+        const toolResults = [];
+        for (const toolCall of toolCalls) {
+            console.log(`🔍 ${toolCall.name}(${JSON.stringify(toolCall.arguments)})`);
+            if (!toolCall.invoke) {
+                console.log(`   ⚠️ No handler found for tool "${toolCall.name}"`);
+                continue;
+            }
+            // Use invoke() - automatically routes to the correct MCP client!
+            const mcpResult = await toolCall.invoke();
+            // Parse and clean up the search results
+            const cleanResult = parseSearchResults(mcpResult);
+            console.log(`   ✓ Got search results:`);
+            console.log(cleanResult
+                .split("\n")
+                .map((l) => `      ${l}`)
+                .join("\n"));
+            console.log();
+            toolResults.push({ id: toolCall.id, result: cleanResult });
+        }
+        // ============================================================
+        // STEP 5: Continue with search results
+        // ============================================================
+        console.log("5️⃣  Getting AI response with search results...\n");
+        history.push({
+            role: "assistant",
+            content: await result.text,
+        });
+        for (const tr of toolResults) {
+            history.push({
+                role: "tool",
+                content: tr.result,
+            });
+        }
+        console.log("🤖 Final Response:");
+        const finalResult = completion({
+            modelId,
+            history,
+            stream: true,
+            mcp: [{ client: mcpClient, includeResources: false }],
+        });
+        for await (const token of finalResult.tokenStream) {
+            process.stdout.write(token);
+        }
+        console.log("\n");
+    }
+    // ============================================================
+    // Cleanup
+    // ============================================================
+    console.log("6️⃣  Cleaning up...");
+    await unloadModel({ modelId, clearStorage: false });
+    console.log("   ✓ Done\n");
+    console.log("🎉 Example completed!");
+    process.exit(0);
+}
+catch (error) {
+    console.error("❌ Error:", error);
+    process.exit(1);
+}
+finally {
+    if (mcpClient) {
+        try {
+            await mcpClient.close();
+        }
+        catch {
+            // Ignore close errors
+        }
+    }
+}

package/dist/index.d.ts

@@ -1,9 +1,9 @@
-export { completion, deleteCache, loadModel, downloadAsset, ping, startQVACProvider, stopQVACProvider, unloadModel, transcribe, transcribeStream, embed, translate, cancel, ragSaveEmbeddings, ragSearch, ragDeleteEmbeddings, textToSpeech, setConfig, getModelInfo, } from "./client/api/index";
+export { completion, deleteCache, loadModel, downloadAsset, ping, startQVACProvider, stopQVACProvider, unloadModel, transcribe, transcribeStream, embed, translate, cancel, ragSaveEmbeddings, ragSearch, ragDeleteEmbeddings, textToSpeech, getModelInfo, loggingStream, } from "./client/api/index";
 export { close } from "./client/index";
-export { type ModelProgressUpdate, type LoadModelOptions, type DownloadAssetOptions, type Tool, type ToolCall, type ToolCallError, type ToolCallEvent, type CompletionStats, VERBOSITY, type Attachment, type CompletionParams, type RagSearchResult, type RagSaveEmbeddingsResult, SDK_CLIENT_ERROR_CODES, SDK_SERVER_ERROR_CODES, type SDKConfig, type ModelInfo, type GetModelInfoParams, type LoadedInstance, type CacheFileInfo, toolSchema, } from "./schemas/index";
-export { type ToolInput } from "./utils/tool-helpers";
+export { type ModelProgressUpdate, type LoadModelOptions, type DownloadAssetOptions, type Tool, type ToolCall, type ToolCallWithCall, type ToolCallError, type ToolCallEvent, type CompletionStats, VERBOSITY, type Attachment, type CompletionParams, type RagSearchResult, type RagSaveEmbeddingsResult, SDK_CLIENT_ERROR_CODES, SDK_SERVER_ERROR_CODES, type QvacConfig, type ModelInfo, type GetModelInfoParams, type LoadedInstance, type CacheFileInfo, toolSchema, type McpClient, type McpClientInput, } from "./schemas/index";
+export { type ToolInput, type ToolHandler } from "./utils/tool-helpers";
 export * from "./models/hyperdrive/index";
 export { SUPPORTED_AUDIO_FORMATS } from "./constants/audio";
-export { getLogger, setGlobalLogLevel } from "./logging/index";
+export { getLogger, SDK_LOG_ID } from "./logging/index";
 export type { Logger, LogTransport, LoggerOptions } from "./logging/index";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,5 +1,5 @@
 // Public API exports only
-export { completion, deleteCache, loadModel, downloadAsset, ping, startQVACProvider, stopQVACProvider, unloadModel, transcribe, transcribeStream, embed, translate, cancel, ragSaveEmbeddings, ragSearch, ragDeleteEmbeddings, textToSpeech, setConfig, getModelInfo, } from "./client/api/index.js";
+export { completion, deleteCache, loadModel, downloadAsset, ping, startQVACProvider, stopQVACProvider, unloadModel, transcribe, transcribeStream, embed, translate, cancel, ragSaveEmbeddings, ragSearch, ragDeleteEmbeddings, textToSpeech, getModelInfo, loggingStream, } from "./client/api/index.js";
 export { close } from "./client/index.js";
 export { VERBOSITY, SDK_CLIENT_ERROR_CODES, SDK_SERVER_ERROR_CODES, toolSchema, } from "./schemas/index.js";
 export {} from "./utils/tool-helpers.js";
@@ -7,4 +7,4 @@ export {} from "./utils/tool-helpers.js";
 export * from "./models/hyperdrive/index.js";
 export { SUPPORTED_AUDIO_FORMATS } from "./constants/audio.js";
 // Logging exports
-export { getLogger, setGlobalLogLevel } from "./logging/index.js";
+export { getLogger, SDK_LOG_ID } from "./logging/index.js";

package/dist/logging/addon.d.ts

@@ -0,0 +1,6 @@
+import type { Logger } from "./index";
+export declare function registerAddonLogger(modelId: string, namespace: string, logger: Logger): void;
+export declare function unregisterAddonLogger(modelId: string): void;
+export declare function createAddonLoggerCallback(namespace: string): (priority: number, message: string) => void;
+export declare function clearAllAddonLoggers(): void;
+//# sourceMappingURL=addon.d.ts.map

package/dist/logging/addon.js

@@ -0,0 +1,59 @@
+import { unregisterLogger } from "./registry.js";
+// Map C++ addon priority (0-4) to SDK LogLevel
+const PRIORITY_TO_LEVEL = {
+    0: "error",
+    1: "warn",
+    2: "info",
+    3: "debug",
+    4: "debug",
+};
+// Track ALL loggers per namespace: Map<namespace, Set<Logger>>
+const addonLoggers = new Map();
+// Track modelId → { namespace, logger } for cleanup on unload
+const modelLoggers = new Map();
+export function registerAddonLogger(modelId, namespace, logger) {
+    if (!addonLoggers.has(namespace)) {
+        addonLoggers.set(namespace, new Set());
+    }
+    addonLoggers.get(namespace).add(logger);
+    modelLoggers.set(modelId, { namespace, logger });
+}
+export function unregisterAddonLogger(modelId) {
+    const entry = modelLoggers.get(modelId);
+    if (entry) {
+        addonLoggers.get(entry.namespace)?.delete(entry.logger);
+        unregisterLogger(entry.logger);
+        modelLoggers.delete(modelId);
+    }
+}
+function routeLog(logger, level, message) {
+    switch (level) {
+        case "error":
+            logger.error(message);
+            break;
+        case "warn":
+            logger.warn(message);
+            break;
+        case "info":
+            logger.info(message);
+            break;
+        case "debug":
+            logger.debug(message);
+            break;
+    }
+}
+export function createAddonLoggerCallback(namespace) {
+    return (priority, message) => {
+        const loggers = addonLoggers.get(namespace);
+        if (!loggers || loggers.size === 0)
+            return;
+        const level = PRIORITY_TO_LEVEL[priority] ?? "debug";
+        for (const logger of loggers) {
+            routeLog(logger, level, message);
+        }
+    };
+}
+export function clearAllAddonLoggers() {
+    addonLoggers.clear();
+    modelLoggers.clear();
+}

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) {
@@ -40,7 +45,7 @@ export function createBaseLogger(namespace, options, extensions) {
             }
         }
     };
-    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,13 @@
+import { getLogger } from "./logger.js";
+const CLIENT_NAMESPACE = "sdk:client";
+let cachedLogger = null;
+export function getClientLogger(options) {
+    if (!options && cachedLogger) {
+        return cachedLogger;
+    }
+    const logger = getLogger(CLIENT_NAMESPACE, options);
+    if (!options) {
+        cachedLogger = logger;
+    }
+    return logger;
+}

package/dist/logging/index.d.ts

@@ -1,4 +1,9 @@
-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";
 //# sourceMappingURL=index.d.ts.map

package/dist/logging/index.js

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

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

@@ -23,6 +23,3 @@ export function getLogger(namespace, options) {
     }
     return logger;
 }
-export function setGlobalLogLevel(level) {
-    loggerCache.forEach((logger) => logger.setLevel(level));
-}

package/dist/logging/namespaces.d.ts

@@ -0,0 +1,11 @@
+export declare const ADDON_NAMESPACES: {
+    readonly LLAMACPP_LLM: "llamacpp:llm";
+    readonly LLAMACPP_EMBED: "llamacpp:embed";
+    readonly WHISPERCPP: "whispercpp";
+    readonly TTS: "tts";
+    readonly NMTCPP: "nmtcpp";
+};
+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,11 @@
+export const ADDON_NAMESPACES = {
+    LLAMACPP_LLM: "llamacpp:llm",
+    LLAMACPP_EMBED: "llamacpp:embed",
+    WHISPERCPP: "whispercpp",
+    TTS: "tts",
+    NMTCPP: "nmtcpp",
+};
+// 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,26 @@
+/**
+ * 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.
+ */
+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,36 @@
+/**
+ * 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.
+ */
+const allLoggers = new Set();
+export function registerLogger(logger) {
+    allLoggers.add(logger);
+}
+export function unregisterLogger(logger) {
+    allLoggers.delete(logger);
+}
+export function setGlobalLogLevel(level) {
+    for (const logger of allLoggers) {
+        logger.setLevel(level);
+    }
+}
+export function setGlobalConsoleOutput(enabled) {
+    for (const logger of allLoggers) {
+        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/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