@loop_ouroboros/mcp-hub-lite 1.0.2 → 1.1.0

package/dist/server/src/services/session-tracker.service.d.ts

@@ -47,8 +47,6 @@ declare class SessionTrackerService {
      * @param context.clientName - Optional name of the client application
      * @param context.clientVersion - Optional version of the client application
      * @param context.protocolVersion - Optional MCP protocol version
-     * @param context.project - Optional project identifier
-     * @param context.cwd - Optional current working directory
      * @param context.userAgent - Optional user agent string
      * @param context.ip - Optional session IP address
      *
@@ -56,8 +54,7 @@ declare class SessionTrackerService {
      * sessionTrackerService.updateSession({
      *   sessionId: 'session-123',
      *   clientName: 'VS Code',
-     *   clientVersion: '1.85.0',
-     *   cwd: '/home/user/project'
+     *   clientVersion: '1.85.0'
      * });
      */
     updateSession(context: SessionContext): void;
@@ -65,12 +62,7 @@ declare class SessionTrackerService {
      * Updates the workspace roots for a specific session.
      *
      * This method is typically called when a session provides its workspace root
-     * directories, which helps determine the session's working directory context.
-     * If the session doesn't have a current working directory (cwd) set, it will
-     * attempt to infer one from the first root URI in the list.
-     *
-     * For file:// URIs, it converts them to local file paths using Node.js's
-     * fileURLToPath utility. For other URI schemes, it uses the URI directly.
+     * directories.
      *
      * @param sessionId - The unique session identifier for the session
      * @param roots - Array of session root objects containing URI information

package/dist/server/src/services/session-tracker.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session-tracker.service.d.ts","sourceRoot":"","sources":["../../../../src/services/session-tracker.service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EACd,WAAW,EACX,WAAW,EACZ,MAAM,wCAAwC,CAAC;AAOhD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,cAAM,qBAAqB;IACzB,OAAO,CAAC,QAAQ,CAAuC;IAEvD,OAAO,KAAK,UAAU,GAErB;IAED;;;;;OAKG;;IAMH;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACI,aAAa,CAAC,OAAO,EAAE,cAAc;IA4B5C;;;;;;;;;;;;;;;;;;;OAmBG;IACI,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,EAAE;IAoDjE;;;;;;;;;;;;OAYG;IACI,WAAW,IAAI,WAAW,EAAE;IAInC;;;;;;;;;;;;;;OAcG;IACI,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS;IAI7D;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,OAAO;CAkBhB;AAED,eAAO,MAAM,qBAAqB,uBAA8B,CAAC;AAEjE,YAAY,EAAE,qBAAqB,EAAE,CAAC"}
+{"version":3,"file":"session-tracker.service.d.ts","sourceRoot":"","sources":["../../../../src/services/session-tracker.service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EACd,WAAW,EACX,WAAW,EACZ,MAAM,wCAAwC,CAAC;AAMhD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,cAAM,qBAAqB;IACzB,OAAO,CAAC,QAAQ,CAAuC;IAEvD,OAAO,KAAK,UAAU,GAErB;IAED;;;;;OAKG;;IAMH;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACI,aAAa,CAAC,OAAO,EAAE,cAAc;IA0B5C;;;;;;;;;;;;;;OAcG;IACI,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,EAAE;IAQjE;;;;;;;;;;;;OAYG;IACI,WAAW,IAAI,WAAW,EAAE;IAInC;;;;;;;;;;;;;;OAcG;IACI,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS;IAI7D;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,OAAO;CAkBhB;AAED,eAAO,MAAM,qBAAqB,uBAA8B,CAAC;AAEjE,YAAY,EAAE,qBAAqB,EAAE,CAAC"}

package/dist/server/src/services/session-tracker.service.js

@@ -1,6 +1,5 @@
 import { logger, LOG_MODULES } from '../utils/logger.js';
 import { eventBus } from './event-bus.service.js';
-import { fileURLToPath } from 'node:url';
 import { configManager } from '../config/config-manager.js';
 import { formatDuration } from '../utils/format-utils.js';
 /**
@@ -57,8 +56,6 @@ class SessionTrackerService {
      * @param context.clientName - Optional name of the client application
      * @param context.clientVersion - Optional version of the client application
      * @param context.protocolVersion - Optional MCP protocol version
-     * @param context.project - Optional project identifier
-     * @param context.cwd - Optional current working directory
      * @param context.userAgent - Optional user agent string
      * @param context.ip - Optional session IP address
      *
@@ -66,8 +63,7 @@ class SessionTrackerService {
      * sessionTrackerService.updateSession({
      *   sessionId: 'session-123',
      *   clientName: 'VS Code',
-     *   clientVersion: '1.85.0',
-     *   cwd: '/home/user/project'
+     *   clientVersion: '1.85.0'
      * });
      */
     updateSession(context) {
@@ -79,8 +75,6 @@ class SessionTrackerService {
             clientVersion: context.clientVersion || existing?.clientVersion,
             protocolVersion: context.protocolVersion || existing?.protocolVersion,
             capabilities: context.capabilities || existing?.capabilities,
-            project: context.project || existing?.project,
-            cwd: context.cwd || existing?.cwd, // Preserve CWD if not provided in new request (e.g. inferred from roots)
             userAgent: context.userAgent || existing?.userAgent,
             ip: context.ip || existing?.ip,
             lastSeen: Date.now(),
@@ -99,12 +93,7 @@ class SessionTrackerService {
      * Updates the workspace roots for a specific session.
      *
      * This method is typically called when a session provides its workspace root
-     * directories, which helps determine the session's working directory context.
-     * If the session doesn't have a current working directory (cwd) set, it will
-     * attempt to infer one from the first root URI in the list.
-     *
-     * For file:// URIs, it converts them to local file paths using Node.js's
-     * fileURLToPath utility. For other URI schemes, it uses the URI directly.
+     * directories.
      *
      * @param sessionId - The unique session identifier for the session
      * @param roots - Array of session root objects containing URI information
@@ -120,46 +109,6 @@ class SessionTrackerService {
         if (session) {
             session.roots = roots;
             session.lastSeen = Date.now();
-            // If CWD is missing, try to infer from roots
-            if (!session.cwd && roots.length > 0) {
-                // Convert file:// uri to path if possible, or just use URI
-                const root = roots[0];
-                if (root.uri.startsWith('file://')) {
-                    try {
-                        session.cwd = fileURLToPath(root.uri);
-                    }
-                    catch {
-                        session.cwd = root.uri;
-                    }
-                }
-                else {
-                    session.cwd = root.uri;
-                }
-                logger.debug(`Inferred CWD for session ${sessionId} from roots: ${session.cwd}`, LOG_MODULES.SESSION_TRACKER);
-            }
-            // If project is missing, try to infer from roots (use name or last path segment)
-            if (!session.project && roots.length > 0) {
-                const root = roots[0];
-                if (root.name) {
-                    session.project = root.name;
-                }
-                else if (root.uri.startsWith('file://')) {
-                    try {
-                        const localPath = fileURLToPath(root.uri);
-                        const pathSegments = localPath.split(/[/\\]/);
-                        const lastSegment = pathSegments.filter(Boolean).pop();
-                        if (lastSegment) {
-                            session.project = lastSegment;
-                        }
-                    }
-                    catch {
-                        // If path parsing fails, don't set project
-                    }
-                }
-                if (session.project) {
-                    logger.debug(`Inferred project for session ${sessionId} from roots: ${session.project}`, LOG_MODULES.SESSION_TRACKER);
-                }
-            }
         }
     }
     /**

package/dist/server/src/services/system-tool-handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"system-tool-handler.d.ts","sourceRoot":"","sources":["../../../../src/services/system-tool-handler.ts"],"names":[],"mappings":"AAsBA;;GAEG;AACH,qBAAa,iBAAiB;IAC5B;;OAEG;WACU,oBAAoB,CAC/B,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,OAAO,CAAC,OAAO,CAAC;CAwEpB"}
+{"version":3,"file":"system-tool-handler.d.ts","sourceRoot":"","sources":["../../../../src/services/system-tool-handler.ts"],"names":[],"mappings":"AAoBA;;GAEG;AACH,qBAAa,iBAAiB;IAC5B;;OAEG;WACU,oBAAoB,CAC/B,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,OAAO,CAAC,OAAO,CAAC;CA8DpB"}

package/dist/server/src/services/system-tool-handler.js

@@ -1,7 +1,7 @@
 import { hubToolsService } from './hub-tools.service.js';
 import { McpError } from '@modelcontextprotocol/sdk/types.js';
 import { logger, LOG_MODULES } from '../utils/logger.js';
-import { LIST_SERVERS_TOOL, FIND_SERVERS_TOOL, LIST_ALL_TOOLS_IN_SERVER_TOOL, FIND_TOOLS_IN_SERVER_TOOL, GET_TOOL_TOOL, CALL_TOOL_TOOL, FIND_TOOLS_TOOL, MCP_HUB_LITE_SERVER } from '../models/system-tools.constants.js';
+import { LIST_SERVERS_TOOL, LIST_TOOLS_IN_SERVER_TOOL, GET_TOOL_TOOL, CALL_TOOL_TOOL, UPDATE_SERVER_DESCRIPTION_TOOL, MCP_HUB_LITE_SERVER } from '../models/system-tools.constants.js';
 import { stringifyForLogging } from '../utils/json-utils.js';
 /**
  * Unified system tool call handler
@@ -18,19 +18,9 @@ export class SystemToolHandler {
                 case LIST_SERVERS_TOOL:
                     result = await hubToolsService.listServers();
                     break;
-                case FIND_SERVERS_TOOL: {
-                    const findServersArgs = toolArgs;
-                    result = await hubToolsService.findServers(findServersArgs);
-                    break;
-                }
-                case LIST_ALL_TOOLS_IN_SERVER_TOOL: {
-                    const listAllToolsArgs = toolArgs;
-                    result = await hubToolsService.listAllToolsInServer(listAllToolsArgs);
-                    break;
-                }
-                case FIND_TOOLS_IN_SERVER_TOOL: {
-                    const findToolsInServerArgs = toolArgs;
-                    result = await hubToolsService.findToolsInServer(findToolsInServerArgs);
+                case LIST_TOOLS_IN_SERVER_TOOL: {
+                    const listToolsArgs = toolArgs;
+                    result = await hubToolsService.listToolsInServer(listToolsArgs);
                     break;
                 }
                 case GET_TOOL_TOOL: {
@@ -50,9 +40,9 @@ export class SystemToolHandler {
                     });
                     break;
                 }
-                case FIND_TOOLS_TOOL: {
-                    const findToolsArgs = toolArgs;
-                    result = await hubToolsService.findTools(findToolsArgs);
+                case UPDATE_SERVER_DESCRIPTION_TOOL: {
+                    const updateDescArgs = toolArgs;
+                    result = await hubToolsService.updateServerDescription(updateDescArgs);
                     break;
                 }
                 default:

package/dist/server/src/utils/composite-key.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Composite key utilities for server instance identification
+ *
+ * This module provides utilities for generating and parsing composite keys
+ * that uniquely identify a server instance across multiple instances
+ * of the same server name.
+ *
+ * Format: `${serverName}-${serverIndex}`
+ * Example: 'my-server-0', 'my-server-1', 'test-server-0'
+ */
+/**
+ * Generates a composite key from serverName and serverIndex
+ * @param serverName - The server name
+ * @param serverIndex - The instance index
+ * @returns Composite key string
+ * @example getCompositeKey('my-server', 0) => 'my-server-0'
+ */
+export declare function getCompositeKey(serverName: string, serverIndex: number): string;
+/**
+ * Parses a composite key back into serverName and serverIndex
+ * @param key - The composite key to parse
+ * @returns Object with serverName and serverIndex, or null if invalid
+ * @example parseCompositeKey('my-server-0') => { serverName: 'my-server', serverIndex: 0 }
+ */
+export declare function parseCompositeKey(key: string): {
+    serverName: string;
+    serverIndex: number;
+} | null;
+//# sourceMappingURL=composite-key.d.ts.map

package/dist/server/src/utils/composite-key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"composite-key.d.ts","sourceRoot":"","sources":["../../../../src/utils/composite-key.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAE/E;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAYjG"}

package/dist/server/src/utils/composite-key.js

@@ -0,0 +1,39 @@
+/**
+ * Composite key utilities for server instance identification
+ *
+ * This module provides utilities for generating and parsing composite keys
+ * that uniquely identify a server instance across multiple instances
+ * of the same server name.
+ *
+ * Format: `${serverName}-${serverIndex}`
+ * Example: 'my-server-0', 'my-server-1', 'test-server-0'
+ */
+/**
+ * Generates a composite key from serverName and serverIndex
+ * @param serverName - The server name
+ * @param serverIndex - The instance index
+ * @returns Composite key string
+ * @example getCompositeKey('my-server', 0) => 'my-server-0'
+ */
+export function getCompositeKey(serverName, serverIndex) {
+    return `${serverName}-${serverIndex}`;
+}
+/**
+ * Parses a composite key back into serverName and serverIndex
+ * @param key - The composite key to parse
+ * @returns Object with serverName and serverIndex, or null if invalid
+ * @example parseCompositeKey('my-server-0') => { serverName: 'my-server', serverIndex: 0 }
+ */
+export function parseCompositeKey(key) {
+    const lastDashIndex = key.lastIndexOf('-');
+    if (lastDashIndex === -1) {
+        return null;
+    }
+    const serverName = key.slice(0, lastDashIndex);
+    const serverIndexPart = key.slice(lastDashIndex + 1);
+    const serverIndex = parseInt(serverIndexPart, 10);
+    if (isNaN(serverIndex)) {
+        return null;
+    }
+    return { serverName, serverIndex };
+}

package/dist/server/src/utils/error-handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"error-handler.d.ts","sourceRoot":"","sources":["../../../../src/utils/error-handler.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,qBAAa,YAAY;IACvB;;OAEG;IACH,MAAM,CAAC,qBAAqB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,KAAK;IAgBrE;;OAEG;IACH,MAAM,CAAC,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,KAAK;IA6BzF;;OAEG;IACH,MAAM,CAAC,kBAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,KAAK;CAWlE"}
+{"version":3,"file":"error-handler.d.ts","sourceRoot":"","sources":["../../../../src/utils/error-handler.ts"],"names":[],"mappings":"AAIA;;GAEG;AACH,qBAAa,YAAY;IACvB;;OAEG;IACH,MAAM,CAAC,qBAAqB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,KAAK;IAgBrE;;OAEG;IACH,MAAM,CAAC,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,KAAK;IA6BzF;;OAEG;IACH,MAAM,CAAC,kBAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,KAAK;CAWlE"}

package/dist/server/src/utils/error-handler.js

@@ -1,5 +1,6 @@
 import { McpError } from '@modelcontextprotocol/sdk/types.js';
-import { logger, LOG_MODULES } from './logger.js';
+import { logger } from './logger.js';
+import { LOG_MODULES } from './logger/log-modules.js';
 /**
  * Unified error handler
  */
@@ -45,7 +46,7 @@ export class ErrorHandler {
      * Handles general errors
      */
     static handleGeneralError(error, message) {
-        logger.error(message, error);
+        logger.error(message, error, LOG_MODULES.ERROR_HANDLER);
         if (error instanceof McpError) {
             throw error;
         }

package/dist/server/src/utils/index.d.ts

@@ -1,2 +1,4 @@
 export { logger, LOG_MODULES } from './logger.js';
+export * from './sort-utils.js';
+export * from './version.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/server/src/utils/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAClD,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC"}

package/dist/server/src/utils/index.js

@@ -1 +1,3 @@
 export { logger, LOG_MODULES } from './logger.js';
+export * from './sort-utils.js';
+export * from './version.js';

package/dist/server/src/utils/instance-id.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Instance ID generation utilities using content-based hashing.
+ */
+import type { ServerInstance } from '../config/config.schema.js';
+/**
+ * Generates a stable 8-character hash from an object.
+ * Uses SHA-256 and returns the first 8 hex characters.
+ *
+ * @param obj - The object to hash
+ * @returns An 8-character hex string
+ */
+export declare function generateInstanceHash(obj: Record<string, unknown>): string;
+/**
+ * Generates a deterministic instance ID based on server name and instance configuration.
+ * The ID format is: ${serverName}-${hash}
+ *
+ * @param serverName - Name of the server
+ * @param instanceConfig - Partial instance configuration
+ * @returns A deterministic instance ID
+ */
+export declare function generateInstanceId(serverName: string, instanceConfig: Partial<ServerInstance>): string;
+//# sourceMappingURL=instance-id.d.ts.map

package/dist/server/src/utils/instance-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance-id.d.ts","sourceRoot":"","sources":["../../../../src/utils/instance-id.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAE/D;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAyBzE;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,MAAM,EAClB,cAAc,EAAE,OAAO,CAAC,cAAc,CAAC,GACtC,MAAM,CAiBR"}

package/dist/server/src/utils/instance-id.js

@@ -0,0 +1,59 @@
+/**
+ * Instance ID generation utilities using content-based hashing.
+ */
+import { createHash } from 'node:crypto';
+/**
+ * Generates a stable 8-character hash from an object.
+ * Uses SHA-256 and returns the first 8 hex characters.
+ *
+ * @param obj - The object to hash
+ * @returns An 8-character hex string
+ */
+export function generateInstanceHash(obj) {
+    function stableStringify(value) {
+        if (value === null || typeof value !== 'object') {
+            return JSON.stringify(value);
+        }
+        if (Array.isArray(value)) {
+            return '[' + value.map(stableStringify).join(',') + ']';
+        }
+        const sortedObj = {};
+        for (const key of Object.keys(value).sort()) {
+            sortedObj[key] = value[key];
+        }
+        return ('{' +
+            Object.keys(sortedObj)
+                .map((key) => JSON.stringify(key) + ':' + stableStringify(sortedObj[key]))
+                .join(',') +
+            '}');
+    }
+    const stableString = stableStringify(obj);
+    const hash = createHash('sha256');
+    hash.update(stableString);
+    return hash.digest('hex').slice(0, 8);
+}
+/**
+ * Generates a deterministic instance ID based on server name and instance configuration.
+ * The ID format is: ${serverName}-${hash}
+ *
+ * @param serverName - Name of the server
+ * @param instanceConfig - Partial instance configuration
+ * @returns A deterministic instance ID
+ */
+export function generateInstanceId(serverName, instanceConfig) {
+    const hashableContent = {};
+    if (instanceConfig.args && instanceConfig.args.length > 0) {
+        hashableContent.args = instanceConfig.args;
+    }
+    if (instanceConfig.env) {
+        hashableContent.env = instanceConfig.env;
+    }
+    if (instanceConfig.headers) {
+        hashableContent.headers = instanceConfig.headers;
+    }
+    if (instanceConfig.tags && Object.keys(instanceConfig.tags).length > 0) {
+        hashableContent.tags = instanceConfig.tags;
+    }
+    const hash = generateInstanceHash(hashableContent);
+    return `${serverName}-${hash}`;
+}

package/dist/server/src/utils/json-utils.d.ts

@@ -23,7 +23,7 @@ type ConfigGetter = () => {
         logging: {
             jsonPretty: boolean;
             mcpCommDebug: boolean;
-            sessionDebug: boolean;
+            apiDebug: boolean;
         };
     };
 };
@@ -60,11 +60,11 @@ export declare function getJsonPrettySetting(): boolean;
  */
 export declare function getMcpCommDebugSetting(): boolean;
 /**
- * Get session debug setting from config getter.
+ * Get API debug setting from config getter.
  *
- * @returns boolean indicating whether to enable session debug logging
+ * @returns boolean indicating whether to enable API debug logging
  */
-export declare function getSessionDebugSetting(): boolean;
+export declare function getApiDebugSetting(): boolean;
 /**
  * Stringify object for logging with dynamic pretty formatting based on LOG_JSON_PRETTY environment variable
  * @param obj Object to stringify

package/dist/server/src/utils/json-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"json-utils.d.ts","sourceRoot":"","sources":["../../../../src/utils/json-utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAQH;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAExD;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,IAAI,OAAO,CAE1C;AAiED;;GAEG;AACH,KAAK,YAAY,GAAG,MAAM;IACxB,MAAM,EAAE;QACN,OAAO,EAAE;YACP,UAAU,EAAE,OAAO,CAAC;YACpB,YAAY,EAAE,OAAO,CAAC;YACtB,YAAY,EAAE,OAAO,CAAC;SACvB,CAAC;KACH,CAAC;CACH,CAAC;AAQF;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,GAAG,IAAI,CAE3E;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAU/E;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,MAAM,CAG1E;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CAiB9C;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,IAAI,OAAO,CAUhD;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,IAAI,OAAO,CAUhD;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAOxD;AAED;;;;;GAKG;AACH,wBAAgB,+BAA+B,CAC7C,GAAG,EAAE,OAAO,EACZ,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,OAAO,GAClD,MAAM,CAOR"}
+{"version":3,"file":"json-utils.d.ts","sourceRoot":"","sources":["../../../../src/utils/json-utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAQH;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAExD;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,IAAI,OAAO,CAE1C;AAiED;;GAEG;AACH,KAAK,YAAY,GAAG,MAAM;IACxB,MAAM,EAAE;QACN,OAAO,EAAE;YACP,UAAU,EAAE,OAAO,CAAC;YACpB,YAAY,EAAE,OAAO,CAAC;YACtB,QAAQ,EAAE,OAAO,CAAC;SACnB,CAAC;KACH,CAAC;CACH,CAAC;AAQF;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,GAAG,IAAI,CAE3E;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAU/E;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,MAAM,CAG1E;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CAiB9C;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,IAAI,OAAO,CAUhD;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CAU5C;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAOxD;AAED;;;;;GAKG;AACH,wBAAgB,+BAA+B,CAC7C,GAAG,EAAE,OAAO,EACZ,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,OAAO,GAClD,MAAM,CAOR"}

package/dist/server/src/utils/json-utils.js

@@ -165,15 +165,15 @@ export function getMcpCommDebugSetting() {
     return getDefaultForDevMode(false);
 }
 /**
- * Get session debug setting from config getter.
+ * Get API debug setting from config getter.
  *
- * @returns boolean indicating whether to enable session debug logging
+ * @returns boolean indicating whether to enable API debug logging
  */
-export function getSessionDebugSetting() {
+export function getApiDebugSetting() {
     if (_configGetter) {
         try {
             const config = _configGetter();
-            return config.system.logging.sessionDebug;
+            return config.system.logging.apiDebug;
         }
         catch {
             // Fall through to default if config getter fails

package/dist/server/src/utils/logger/dev-logger.d.ts

@@ -3,7 +3,8 @@
  * This file contains development log initialization and management.
  */
 import fs from 'fs';
-import { LogRotator, type RotatorConfig } from '../log-rotator.js';
+import { LogRotator } from '../log-rotator.js';
+import type { RotatorConfig } from '../log-rotator.js';
 /**
  * Development logger configuration and setup.
  */

package/dist/server/src/utils/logger/dev-logger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dev-logger.d.ts","sourceRoot":"","sources":["../../../../../src/utils/logger/dev-logger.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,MAAM,IAAI,CAAC;AAEpB,OAAO,EAAE,UAAU,EAAE,KAAK,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEnE;;GAEG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,aAAa,CAA+B;IACpD,OAAO,CAAC,aAAa,CAA2B;IAEhD;;OAEG;IACH,IAAI,MAAM,IAAI,EAAE,CAAC,WAAW,GAAG,IAAI,CAElC;IAED;;;OAGG;IACH,IAAI,OAAO,IAAI,UAAU,GAAG,IAAI,CAE/B;IAED;;;;;;;;;;OAUG;IACH,YAAY,CAAC,aAAa,CAAC,EAAE,aAAa,EAAE,YAAY,CAAC,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI;IAoB/F;;OAEG;IACH,KAAK,IAAI,IAAI;CAMd"}
+{"version":3,"file":"dev-logger.d.ts","sourceRoot":"","sources":["../../../../../src/utils/logger/dev-logger.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,MAAM,IAAI,CAAC;AAEpB,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEvD;;GAEG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,aAAa,CAA+B;IACpD,OAAO,CAAC,aAAa,CAA2B;IAEhD;;OAEG;IACH,IAAI,MAAM,IAAI,EAAE,CAAC,WAAW,GAAG,IAAI,CAElC;IAED;;;OAGG;IACH,IAAI,OAAO,IAAI,UAAU,GAAG,IAAI,CAE/B;IAED;;;;;;;;;;OAUG;IACH,YAAY,CAAC,aAAa,CAAC,EAAE,aAAa,EAAE,YAAY,CAAC,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI;IAoB/F;;OAEG;IACH,KAAK,IAAI,IAAI;CAMd"}

package/dist/server/src/utils/logger/log-formatter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"log-formatter.d.ts","sourceRoot":"","sources":["../../../../../src/utils/logger/log-formatter.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AAE9D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAMnD;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;CACtB;AAsED;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,UAAU,SAAI,GAAG,UAAU,GAAG,IAAI,CAQ/D;AA2HD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM,CAK/D;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CASlD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM,CAatD;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAM7C;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,QAAQ,EACf,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,UAAU,GACnB,MAAM,CAsCR;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,MAAM,CA6B/F;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAiClD"}
+{"version":3,"file":"log-formatter.d.ts","sourceRoot":"","sources":["../../../../../src/utils/logger/log-formatter.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AAE9D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAMnD;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;CACtB;AAsED;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,UAAU,SAAI,GAAG,UAAU,GAAG,IAAI,CAQ/D;AA2HD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM,CAK/D;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CASlD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM,CAatD;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAM7C;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,QAAQ,EACf,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,UAAU,GACnB,MAAM,CAsCR;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,MAAM,CA6B/F;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAyHlD"}

package/dist/server/src/utils/logger/log-formatter.js

@@ -324,25 +324,102 @@ export function createLogMessage(level, message, context) {
  * @returns Formatted error string
  */
 export function formatError(error) {
+    // Special case: handle arrays that might contain errors
+    if (Array.isArray(error)) {
+        if (error.length === 0) {
+            return '';
+        }
+        // If it's a single-element array, unwrap it and format the element
+        if (error.length === 1) {
+            const element = error[0];
+            // Skip empty objects that are likely log context
+            if (typeof element === 'object' &&
+                element !== null &&
+                !Array.isArray(element) &&
+                ('module' in element || 'traceId' in element || 'spanId' in element)) {
+                return '';
+            }
+            // Otherwise format the single element
+            return formatError(element);
+        }
+        // For multi-element arrays, format each element
+        const formattedElements = error
+            .map((elem) => {
+            const formatted = formatError(elem);
+            return formatted || '[skipped]';
+        })
+            .filter((f) => f !== '[skipped]');
+        if (formattedElements.length === 0) {
+            return '';
+        }
+        if (formattedElements.length === 1) {
+            return formattedElements[0];
+        }
+        return `[ ${formattedElements.join(', ')} ]`;
+    }
     if (error instanceof Error) {
-        let result = error.message;
+        let result = '';
+        // Include error name if available
+        if (error.name) {
+            result += error.name;
+        }
+        // Include error message if available
+        if (error.message) {
+            result += result ? `: ${error.message}` : error.message;
+        }
+        // If no name and message, try string representation
+        if (!result) {
+            result = String(error);
+        }
+        // Include stack trace if available
         if (error.stack) {
             const stackLines = error.stack.split('\n').slice(1, 6);
             if (stackLines.length > 0) {
                 result += '\n' + stackLines.join('\n');
             }
         }
+        // Check for non-enumerable properties using Object.getOwnPropertyNames
+        const ownProps = Object.getOwnPropertyNames(error);
+        const extraProps = [];
+        for (const prop of ownProps) {
+            if (prop !== 'name' && prop !== 'message' && prop !== 'stack') {
+                try {
+                    const value = error[prop];
+                    extraProps.push(`${prop}: ${stringifyForLogging(value)}`);
+                }
+                catch {
+                    extraProps.push(`${prop}: [could not serialize]`);
+                }
+            }
+        }
+        if (extraProps.length > 0) {
+            result += '\n  Additional properties: ' + extraProps.join(', ');
+        }
         return result;
     }
     if (typeof error === 'object' && error !== null) {
         if ('module' in error || 'traceId' in error || 'spanId' in error) {
             return '';
         }
-        if (Array.isArray(error) && error.length === 0) {
-            return '';
+        // Check for empty object (both enumerable and non-enumerable properties)
+        const enumKeys = Object.keys(error);
+        const allProps = Object.getOwnPropertyNames(error);
+        if (enumKeys.length === 0 && allProps.length === 0) {
+            return '[empty object]';
         }
-        if (Object.keys(error).length === 0) {
-            return '';
+        // If only non-enumerable properties, show them
+        if (enumKeys.length === 0 && allProps.length > 0) {
+            const props = [];
+            for (const prop of allProps) {
+                try {
+                    const value = error[prop];
+                    props.push(`${prop}: ${stringifyForLogging(value)}`);
+                }
+                catch {
+                    props.push(`${prop}: [could not serialize]`);
+                }
+            }
+            return `{ ${props.join(', ')} }`;
         }
         try {
             return stringifyForLogging(error);

package/dist/server/src/utils/logger/log-modules.d.ts

@@ -24,25 +24,22 @@ export declare const LOG_MODULES: {
     readonly DEV_SERVER: {
         module: string;
     };
-    readonly CONFIG_MANAGER: {
-        module: string;
-    };
-    readonly CONFIG_LOADER: {
+    readonly RUNNER: {
         module: string;
     };
-    readonly CONFIG_CHANGES: {
+    readonly CONFIG_MANAGER: {
         module: string;
     };
-    readonly SESSION_MANAGER: {
+    readonly CONFIG_LOADER: {
         module: string;
     };
-    readonly SESSION: {
+    readonly CONFIG_SAVER: {
         module: string;
     };
-    readonly SESSION_API: {
+    readonly CONFIG_CHANGES: {
         module: string;
     };
-    readonly SESSION_TRACKER: {
+    readonly SERVER_CONFIG_MANAGER: {
         module: string;
     };
     readonly CONNECTION_MANAGER: {
@@ -51,6 +48,9 @@ export declare const LOG_MODULES: {
     readonly HUB_MANAGER: {
         module: string;
     };
+    readonly SERVER_SELECTOR: {
+        module: string;
+    };
     readonly GATEWAY: {
         module: string;
     };
@@ -66,6 +66,9 @@ export declare const LOG_MODULES: {
     readonly TOOL_LIST: {
         module: string;
     };
+    readonly TOOL_LIST_GENERATOR: {
+        module: string;
+    };
     readonly INITIALIZE_HANDLER: {
         module: string;
     };
@@ -81,6 +84,9 @@ export declare const LOG_MODULES: {
     readonly SEARCH: {
         module: string;
     };
+    readonly ERROR_HANDLER: {
+        module: string;
+    };
     readonly COMMUNICATION: {
         module: string;
     };

package/dist/server/src/utils/logger/log-modules.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"log-modules.d.ts","sourceRoot":"","sources":["../../../../../src/utils/logger/log-modules.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA4DtB;;;;;;;;;;;OAWG;mCACmB,MAAM;;;CACpB,CAAC;AAEX;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,OAAO,WAAW,EAAE,SAAS,CAAC,CAAC;AAErE;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,YAAY,CAAC,CAAC"}
+{"version":3,"file":"log-modules.d.ts","sourceRoot":"","sources":["../../../../../src/utils/logger/log-modules.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA8DtB;;;;;;;;;;;OAWG;mCACmB,MAAM;;;CACpB,CAAC;AAEX;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,OAAO,WAAW,EAAE,SAAS,CAAC,CAAC;AAErE;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,YAAY,CAAC,CAAC"}