@loop_ouroboros/mcp-hub-lite 1.0.0

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

@@ -0,0 +1,203 @@
+import { logger } 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';
+/**
+ * Client tracking service that manages client connections and their metadata.
+ *
+ * This service maintains a registry of connected clients (typically IDEs or other
+ * MCP clients) and tracks their connection state, metadata, and workspace roots.
+ * It provides automatic cleanup of stale clients after a timeout period and
+ * publishes connection/disconnection events via the event bus.
+ *
+ * The service is primarily used by the MCP session manager to track which clients
+ * are connected and maintain their context information for proper session management.
+ *
+ * @example
+ * // Update client information when a new connection is established
+ * clientTrackerService.updateClient({
+ *   sessionId: 'session-123',
+ *   clientName: 'VS Code',
+ *   clientVersion: '1.85.0',
+ *   cwd: '/home/user/project'
+ * });
+ *
+ * // Get all currently connected clients
+ * const clients = clientTrackerService.getClients();
+ */
+class ClientTrackerService {
+    clients = new Map();
+    // Use the same timeout as session manager (default 30 minutes)
+    get TIMEOUT_MS() {
+        return configManager.getConfig().security.sessionTimeout;
+    }
+    /**
+     * Creates a new client tracker service instance.
+     *
+     * Initializes the service with automatic periodic cleanup of stale clients
+     * every 60 seconds to prevent memory leaks from disconnected clients.
+     */
+    constructor() {
+        // Periodic cleanup
+        setInterval(() => this.cleanup(), 60000);
+    }
+    /**
+     * Updates or creates a client entry with the provided context information.
+     *
+     * This method is called whenever a client sends a request with context information.
+     * It preserves existing client metadata that isn't provided in the new context,
+     * ensuring that clients don't lose their previously established information.
+     *
+     * If this is a new client (not previously tracked), it publishes a 'client-connected'
+     * event to notify other services about the new connection.
+     *
+     * @param context - The client context containing session ID and optional metadata
+     * @param context.sessionId - Unique identifier for the client session
+     * @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 client IP address
+     *
+     * @example
+     * clientTrackerService.updateClient({
+     *   sessionId: 'session-123',
+     *   clientName: 'VS Code',
+     *   clientVersion: '1.85.0',
+     *   cwd: '/home/user/project'
+     * });
+     */
+    updateClient(context) {
+        const existing = this.clients.get(context.sessionId);
+        const clientInfo = {
+            ...context,
+            // Preserve existing info if not provided in new request
+            clientName: context.clientName || existing?.clientName,
+            clientVersion: context.clientVersion || existing?.clientVersion,
+            protocolVersion: context.protocolVersion || existing?.protocolVersion,
+            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(),
+            roots: existing?.roots // Preserve roots if already fetched
+        };
+        this.clients.set(context.sessionId, clientInfo);
+        // If it's a new client, publish connection event
+        if (!existing) {
+            eventBus.publish('client-connected', {
+                timestamp: Date.now(),
+                client: clientInfo
+            });
+        }
+    }
+    /**
+     * Updates the workspace roots for a specific client session.
+     *
+     * This method is typically called when a client provides its workspace root
+     * directories, which helps determine the client's working directory context.
+     * If the client 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.
+     *
+     * @param sessionId - The unique session identifier for the client
+     * @param roots - Array of client root objects containing URI information
+     *
+     * @example
+     * clientTrackerService.updateClientRoots('session-123', [
+     *   { uri: 'file:///home/user/project' },
+     *   { uri: 'file:///home/user/other-project' }
+     * ]);
+     */
+    updateClientRoots(sessionId, roots) {
+        const client = this.clients.get(sessionId);
+        if (client) {
+            client.roots = roots;
+            client.lastSeen = Date.now();
+            // If CWD is missing, try to infer from roots
+            if (!client.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 {
+                        client.cwd = fileURLToPath(root.uri);
+                    }
+                    catch {
+                        client.cwd = root.uri;
+                    }
+                }
+                else {
+                    client.cwd = root.uri;
+                }
+                logger.debug(`Inferred CWD for session ${sessionId} from roots: ${client.cwd}`);
+            }
+        }
+    }
+    /**
+     * Retrieves all currently tracked client information.
+     *
+     * Returns an array of all active client info objects, including their metadata
+     * and connection state. This is useful for monitoring all connected clients
+     * or displaying client information in administrative interfaces.
+     *
+     * @returns Array of ClientInfo objects representing all tracked clients
+     *
+     * @example
+     * const allClients = clientTrackerService.getClients();
+     * console.log(`Currently tracking ${allClients.length} clients`);
+     */
+    getClients() {
+        return Array.from(this.clients.values());
+    }
+    /**
+     * Retrieves client information for a specific session ID.
+     *
+     * Returns the complete client info object for the given session ID, or undefined
+     * if no client with that session ID is currently being tracked.
+     *
+     * @param sessionId - The unique session identifier to look up
+     * @returns ClientInfo object if found, undefined otherwise
+     *
+     * @example
+     * const client = clientTrackerService.getClient('session-123');
+     * if (client) {
+     *   console.log(`Client ${client.clientName} is connected`);
+     * }
+     */
+    getClient(sessionId) {
+        return this.clients.get(sessionId);
+    }
+    /**
+     * Cleans up stale client entries that haven't been seen recently.
+     *
+     * This private method is called periodically to remove clients that haven't
+     * sent any requests within the timeout period (5 minutes by default). When
+     * a client is removed, it publishes a 'client-disconnected' event to notify
+     * other services about the disconnection.
+     *
+     * This prevents memory leaks from accumulating disconnected clients and ensures
+     * that the client registry only contains active connections.
+     *
+     * @private
+     */
+    cleanup() {
+        const now = Date.now();
+        for (const [id, info] of this.clients.entries()) {
+            if (now - info.lastSeen > this.TIMEOUT_MS) {
+                logger.debug(`Removing stale client: ${id}. Last seen ${formatDuration(now - info.lastSeen)} ago, timeout ${formatDuration(this.TIMEOUT_MS)}`);
+                this.clients.delete(id);
+                eventBus.publish('client-disconnected', {
+                    timestamp: Date.now(),
+                    clientId: id,
+                    client: info
+                });
+            }
+        }
+    }
+}
+export const clientTrackerService = new ClientTrackerService();

package/dist/server/src/services/connection/connection-manager.d.ts

@@ -0,0 +1,478 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import type { Tool } from '../../../shared/models/tool.model.js';
+import type { Resource } from '../../../shared/models/resource.model.js';
+import type { ServerConfig } from '../../config/config.schema.js';
+import type { ServerInstanceConfig } from '../../config/config.schema.js';
+import type { ServerStatus } from './types.js';
+/**
+ * Manages MCP (Model Context Protocol) server connections and provides a unified interface
+ * for tool and resource operations across multiple connected servers.
+ *
+ * This service handles the complete lifecycle of MCP server connections including:
+ * - Establishing connections via various transport protocols (stdio, SSE, HTTP)
+ * - Managing client instances and transport layers
+ * - Caching tools and resources for performance optimization
+ * - Providing both server ID-based and server name-based access patterns
+ * - Handling connection events and error recovery
+ * - Supporting bidirectional communication for tool execution
+ *
+ * The manager uses ToolCache for both server ID-level and server name-level
+ * operations to optimize different access patterns while ensuring data consistency.
+ *
+ * @example
+ * ```typescript
+ * const manager = new McpConnectionManager();
+ * await manager.connect(serverConfig);
+ * const tools = await manager.getTools(serverId);
+ * const result = await manager.callTool(serverId, 'tool-name', { param: 'value' });
+ * ```
+ */
+export declare class McpConnectionManager {
+    private clients;
+    private transports;
+    private serverStatus;
+    private _toolCache;
+    private resourceCache;
+    constructor();
+    /**
+     * Establishes a connection to an MCP server using the specified configuration.
+     *
+     * This method handles the complete connection process including transport creation,
+     * client initialization, validation, and automatic tool/resource discovery.
+     * It supports multiple transport protocols (stdio, SSE, streamable-http, http)
+     * and provides comprehensive error handling with proper status tracking.
+     *
+     * For bidirectional transports (stdio, streamable-http, http), it automatically
+     * fetches and caches available tools and resources upon successful connection.
+     * SSE transports are unidirectional and skip this step for performance reasons.
+     *
+     * The method publishes SERVER_CONNECTED and SERVER_STATUS_CHANGE events upon
+     * successful connection, and SERVER_STATUS_CHANGE events with error details
+     * on failure.
+     *
+     * @param {ServerConfig & ServerInstanceConfig} server - Server configuration containing
+     * connection details, transport type, and instance-specific parameters
+     * @returns {Promise<boolean>} True if connection succeeds, false if it fails
+     * @throws {Error} If server ID is missing or required configuration is invalid
+     *
+     * @example
+     * ```typescript
+     * const serverConfig = {
+     *   id: 'my-server-1',
+     *   type: 'stdio' as const,
+     *   command: 'npx my-mcp-server',
+     *   name: 'My MCP Server'
+     * };
+     * const success = await manager.connect(serverConfig);
+     * if (success) {
+     *   console.log('Connected successfully');
+     * }
+     * ```
+     */
+    connect(server: ServerConfig & ServerInstanceConfig): Promise<boolean>;
+    /**
+     * Disconnects from an MCP server and cleans up all associated resources.
+     *
+     * This method performs a graceful shutdown by closing the client connection,
+     * closing the transport layer, and removing all cached data including tools,
+     * resources, and status information. It also updates the server name-level
+     * tool cache to maintain consistency across multiple instances of the same server.
+     *
+     * The method publishes SERVER_DISCONNECTED and SERVER_STATUS_CHANGE events
+     * upon completion and handles any errors during the disconnection process
+     * without throwing exceptions.
+     *
+     * @param {string} serverId - Unique identifier of the server instance to disconnect
+     * @returns {Promise<void>} Resolves when disconnection is complete
+     *
+     * @example
+     * ```typescript
+     * await manager.disconnect('my-server-1');
+     * console.log('Server disconnected');
+     * ```
+     */
+    disconnect(serverId: string): Promise<void>;
+    /**
+     * Disconnects from all currently connected MCP servers concurrently.
+     *
+     * This method iterates through all active client connections and calls
+     * disconnect() on each one, handling errors individually to ensure
+     * that failure to disconnect from one server doesn't prevent disconnection
+     * from others. All disconnections are performed in parallel for efficiency.
+     *
+     * @returns {Promise<void>} Resolves when all disconnection attempts complete
+     *
+     * @example
+     * ```typescript
+     * await manager.disconnectAll();
+     * console.log('All servers disconnected');
+     * ```
+     */
+    disconnectAll(): Promise<void>;
+    /**
+     * Refreshes the tool cache for a specific server by fetching the latest tool list.
+     *
+     * This method queries the connected MCP server for its current set of available tools,
+     * updates both the server ID-level and server name-level caches, and maintains
+     * accurate tool counts in the server status. It handles server name resolution
+     * to ensure proper caching across multiple instances of the same server.
+     *
+     * @param {string} serverId - Unique identifier of the server instance to refresh
+     * @returns {Promise<Tool[]>} Array of updated tools with server context
+     * @throws {Error} If the server is not connected or tool listing fails
+     *
+     * @example
+     * ```typescript
+     * const tools = await manager.refreshTools('my-server-1');
+     * console.log(`Found ${tools.length} tools`);
+     * ```
+     */
+    refreshTools(serverId: string): Promise<Tool[]>;
+    /**
+     * Refreshes the resource cache for a specific server by fetching available resources.
+     *
+     * This method queries the connected MCP server for its current set of available resources,
+     * handling servers that don't support the resources functionality gracefully by returning
+     * an empty array. It updates the resource cache and maintains accurate resource counts
+     * in the server status.
+     *
+     * The method specifically handles "Method not found" errors (MCP error code -32601)
+     * which indicate that the server doesn't implement the resources protocol, treating
+     * this as a normal case rather than an error.
+     *
+     * @param {string} serverId - Unique identifier of the server instance to refresh
+     * @returns {Promise<Resource[]>} Array of available resources, empty if unsupported
+     * @throws {Error} If the server is not connected or resource listing fails unexpectedly
+     *
+     * @example
+     * ```typescript
+     * const resources = await manager.refreshResources('my-server-1');
+     * console.log(`Found ${resources.length} resources`);
+     * ```
+     */
+    refreshResources(serverId: string): Promise<Resource[]>;
+    /**
+     * Retrieves the current connection status for a specific server instance.
+     *
+     * This method provides access to the server's operational state including connection
+     * status, error information, tool/resource counts, and process details.
+     *
+     * @param {string} serverId - Unique identifier of the server instance
+     * @returns {ServerStatus | undefined} Current status object or undefined if not found
+     *
+     * @example
+     * ```typescript
+     * const status = manager.getStatus('my-server-1');
+     * if (status?.connected) {
+     *   console.log('Server is connected');
+     * }
+     * ```
+     */
+    getStatus(serverId: string): ServerStatus | undefined;
+    /**
+     * Retrieves cached tools for a specific server instance.
+     *
+     * This method returns the currently cached tool list for the specified server,
+     * which may be empty if tools haven't been refreshed yet or if the server
+     * doesn't provide any tools. The method includes logging for debugging purposes.
+     *
+     * @param {string} serverId - Unique identifier of the server instance
+     * @returns {Tool[]} Array of cached tools, empty if none available
+     *
+     * @example
+     * ```typescript
+     * const tools = manager.getTools('my-server-1');
+     * console.log(`Server has ${tools.length} tools`);
+     * ```
+     */
+    getTools(serverId: string): Tool[];
+    /**
+     * Retrieves cached resources for a specific server instance.
+     *
+     * This method returns the currently cached resource list for the specified server,
+     * which may be empty if resources haven't been refreshed yet, if the server doesn't
+     * support resources, or if the server doesn't provide any resources. The method
+     * includes logging for debugging purposes.
+     *
+     * @param {string} serverId - Unique identifier of the server instance
+     * @returns {Resource[]} Array of cached resources, empty if none available
+     *
+     * @example
+     * ```typescript
+     * const resources = manager.getResources('my-server-1');
+     * console.log(`Server has ${resources.length} resources`);
+     * ```
+     */
+    getResources(serverId: string): Resource[];
+    /**
+     * Reads content from a specific resource URI on a connected MCP server.
+     *
+     * This method delegates the resource reading operation to the underlying MCP client,
+     * providing direct access to server-provided resources through their URIs.
+     *
+     * @param {string} serverId - Unique identifier of the connected server instance
+     * @param {string} uri - Resource URI to read (e.g., "file:///path/to/file")
+     * @returns {Promise<unknown>} Resource content as returned by the server
+     * @throws {Error} If the server is not connected or resource reading fails
+     *
+     * @example
+     * ```typescript
+     * const content = await manager.readResource('my-server-1', 'hub://config/settings.json');
+     * console.log('Resource content:', content);
+     * ```
+     */
+    readResource(serverId: string, uri: string): Promise<unknown>;
+    /**
+     * Retrieves all cached tools from all connected server instances.
+     *
+     * This method aggregates tools from all server ID-level caches into a single array,
+     * providing a unified view of all available tools across all connected servers.
+     * The returned tools include server context information for proper identification.
+     *
+     * @returns {Tool[]} Array of all cached tools from all connected servers
+     *
+     * @example
+     * ```typescript
+     * const allTools = manager.getAllTools();
+     * console.log(`Total tools available: ${allTools.length}`);
+     * ```
+     */
+    getAllTools(): Tool[];
+    /**
+     * Retrieves all tool cache entries as server ID to tools mapping.
+     *
+     * This method returns the raw tool cache structure as an array of [serverId, tools] tuples,
+     * providing direct access to the internal caching mechanism for debugging or advanced use cases.
+     *
+     * @returns {[string, Tool[]][]} Array of [serverId, tools] tuples representing the cache
+     *
+     * @example
+     * ```typescript
+     * const cacheEntries = manager.getToolCacheEntries();
+     * cacheEntries.forEach(([serverId, tools]) => {
+     *   console.log(`Server ${serverId} has ${tools.length} tools`);
+     * });
+     * ```
+     */
+    getToolCacheEntries(): [string, Tool[]][];
+    /**
+     * Resolves a server name to its corresponding server instance ID.
+     *
+     * This method provides reverse lookup from server names (as defined in configuration)
+     * to the unique server instance IDs used internally for connection management.
+     * It's useful when you have a server name but need the instance ID for operations.
+     *
+     * @param {string} name - Server name as defined in the configuration
+     * @returns {string | undefined} Corresponding server instance ID or undefined if not found
+     *
+     * @example
+     * ```typescript
+     * const serverId = manager.getServerIdByName('my-mcp-server');
+     * if (serverId) {
+     *   const status = manager.getStatus(serverId);
+     * }
+     * ```
+     */
+    getServerIdByName(name: string): string | undefined;
+    /**
+     * Retrieves the MCP client instance for a server by its name.
+     *
+     * This method resolves a server name to its instance ID and returns the corresponding
+     * MCP client instance, providing direct access to the underlying SDK client for
+     * advanced operations that aren't covered by the manager's high-level methods.
+     *
+     * @param {string} name - Server name as defined in the configuration
+     * @returns {Client | undefined} MCP client instance or undefined if not connected
+     *
+     * @example
+     * ```typescript
+     * const client = manager.getClientByName('my-mcp-server');
+     * if (client) {
+     *   // Use direct client methods for advanced operations
+     *   const result = await client.listPrompts();
+     * }
+     * ```
+     */
+    getClientByName(name: string): Client | undefined;
+    /**
+     * Calls a tool on a connected server using the server name instead of instance ID.
+     *
+     * This method provides a convenient way to execute tools when you have a server name
+     * rather than an instance ID. It resolves the server name to its instance ID and
+     * delegates to the callTool method for actual execution.
+     *
+     * The method is wrapped in OpenTelemetry tracing for observability and includes
+     * comprehensive error handling with proper logging.
+     *
+     * @param {string} name - Server name as defined in the configuration
+     * @param {string} toolName - Name of the tool to execute
+     * @param {Record<string, unknown>} args - Arguments to pass to the tool
+     * @returns {Promise<unknown>} Tool execution result as returned by the server
+     * @throws {Error} If server is not connected, not found, or tool execution fails
+     *
+     * @example
+     * ```typescript
+     * const result = await manager.callToolByName('my-mcp-server', 'list-files', {
+     *   directory: '/home/user'
+     * });
+     * console.log('Tool result:', result);
+     * ```
+     */
+    callToolByName(name: string, toolName: string, args: Record<string, unknown>): Promise<unknown>;
+    /**
+     * Retrieves the connection status for a server using its name instead of instance ID.
+     *
+     * This method resolves a server name to its instance ID and returns the corresponding
+     * server status, providing a convenient way to check server health when working with
+     * server names rather than instance IDs.
+     *
+     * @param {string} name - Server name as defined in the configuration
+     * @returns {ServerStatus | undefined} Current status object or undefined if not found/connected
+     *
+     * @example
+     * ```typescript
+     * const status = manager.getStatusByName('my-mcp-server');
+     * if (status?.connected) {
+     *   console.log('Server is online');
+     * }
+     * ```
+     */
+    getStatusByName(name: string): ServerStatus | undefined;
+    /**
+     * Retrieves cached tools for a server using its name instead of instance ID.
+     *
+     * This method resolves a server name to its instance ID and returns the corresponding
+     * cached tool list, providing a convenient way to access tools when working with
+     * server names rather than instance IDs.
+     *
+     * @param {string} name - Server name as defined in the configuration
+     * @returns {Tool[]} Array of cached tools, empty if none available or not connected
+     *
+     * @example
+     * ```typescript
+     * const tools = manager.getToolsByName('my-mcp-server');
+     * console.log(`Server has ${tools.length} tools`);
+     * ```
+     */
+    getToolsByName(name: string): Tool[];
+    /**
+     * Retrieves cached resources for a server using its name instead of instance ID.
+     *
+     * This method resolves a server name to its instance ID and returns the corresponding
+     * cached resource list, providing a convenient way to access resources when working with
+     * server names rather than instance IDs.
+     *
+     * @param {string} name - Server name as defined in the configuration
+     * @returns {Resource[]} Array of cached resources, empty if none available or not connected
+     *
+     * @example
+     * ```typescript
+     * const resources = manager.getResourcesByName('my-mcp-server');
+     * console.log(`Server has ${resources.length} resources`);
+     * ```
+     */
+    getResourcesByName(name: string): Resource[];
+    /**
+     * Retrieves a specific tool by name from a server's cached tools.
+     *
+     * This method searches the server name-level tool cache for a tool with the specified name,
+     * providing efficient lookup without needing to iterate through all tools manually.
+     *
+     * @param {string} serverName - Server name as defined in the configuration
+     * @param {string} toolName - Exact name of the tool to find
+     * @returns {Tool | undefined} Tool object if found, undefined otherwise
+     *
+     * @example
+     * ```typescript
+     * const tool = manager.getTool('my-mcp-server', 'list-files');
+     * if (tool) {
+     *   console.log('Tool description:', tool.description);
+     * }
+     * ```
+     */
+    getTool(serverName: string, toolName: string): Tool | undefined;
+    /**
+     * Retrieves all cached resources grouped by server name.
+     *
+     * This method aggregates resources from all server instances and groups them by their
+     * corresponding server names, providing a structured view of all available resources
+     * across the system organized by server origin.
+     *
+     * @returns {Record<string, Resource[]>} Object mapping server names to resource arrays
+     *
+     * @example
+     * ```typescript
+     * const allResources = manager.getAllResources();
+     * Object.entries(allResources).forEach(([serverName, resources]) => {
+     *   console.log(`Server ${serverName} has ${resources.length} resources`);
+     * });
+     * ```
+     */
+    getAllResources(): Record<string, Resource[]>;
+    /**
+     * Executes a tool on a connected MCP server using its instance ID.
+     *
+     * This is the primary method for executing tools on connected servers. It delegates
+     * the actual execution to the underlying MCP client and includes comprehensive
+     * error handling with proper logging. The method is wrapped in OpenTelemetry tracing
+     * for observability and monitoring.
+     *
+     * @param {string} serverId - Unique identifier of the connected server instance
+     * @param {string} toolName - Name of the tool to execute
+     * @param {Record<string, unknown>} args - Arguments to pass to the tool
+     * @returns {Promise<unknown>} Tool execution result as returned by the server
+     * @throws {Error} If server is not connected or tool execution fails
+     *
+     * @example
+     * ```typescript
+     * const result = await manager.callTool('my-server-1', 'list-files', {
+     *   directory: '/home/user'
+     * });
+     * console.log('Tool result:', result);
+     * ```
+     */
+    callTool(serverId: string, toolName: string, args: Record<string, unknown>): Promise<unknown>;
+    /**
+     * Retrieves cached tools for a specific server name from the server name-level cache.
+     *
+     * This method provides access to the server name-level tool cache, which aggregates
+     * tools from all instances of the same server name. It's optimized for scenarios
+     * where you need to work with server names rather than individual instance IDs.
+     *
+     * @param {string} serverName - Server name as defined in the configuration
+     * @returns {Tool[]} Array of cached tools for the specified server name
+     *
+     * @example
+     * ```typescript
+     * const tools = manager.getToolsByServerName('my-mcp-server');
+     * console.log(`Server has ${tools.length} tools across all instances`);
+     * ```
+     */
+    getToolsByServerName(serverName: string): Tool[];
+    /**
+     * Retrieves all cached tools from all servers using the server name-level cache.
+     *
+     * This method aggregates tools from the server name-level cache, providing a unified
+     * view of all available tools optimized for search operations and scenarios where
+     * server name context is more relevant than individual instance IDs.
+     *
+     * @returns {Tool[]} Array of all cached tools from all servers
+     *
+     * @example
+     * ```typescript
+     * const allTools = manager.getAllToolsByServerName();
+     * console.log(`Total tools available: ${allTools.length}`);
+     * ```
+     */
+    getAllToolsByServerName(): Tool[];
+    /**
+     * Backward compatibility: direct access to the underlying toolCache Map.
+     * This is maintained for backward compatibility with code that accesses
+     * mcpConnectionManager.toolCache directly.
+     *
+     * @deprecated Use the dedicated methods like getTools(), setTools(), etc. instead
+     */
+    get toolCache(): Map<string, Tool[]>;
+}
+export declare const mcpConnectionManager: McpConnectionManager;
+//# sourceMappingURL=connection-manager.d.ts.map

package/dist/server/src/services/connection/connection-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection-manager.d.ts","sourceRoot":"","sources":["../../../../../src/services/connection/connection-manager.ts"],"names":[],"mappings":"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"}