@loop_ouroboros/mcp-hub-lite 1.0.2 → 1.1.1

package/dist/server/src/services/hub-tools/server-selector.d.ts

@@ -1,4 +1,16 @@
 import type { RequestOptions, ServerInstanceInfo, ValidServer } from './types.js';
+/**
+ * Gets the description for a server, using a default if none is provided.
+ *
+ * @param serverConfig - Server configuration object (may contain description in template)
+ * @param serverName - Name of the server
+ * @returns The server description or a default one
+ */
+export declare function getServerDescription(serverConfig: {
+    template?: {
+        description?: string;
+    };
+} | undefined, serverName: string): string;
 /**
  * Type guard to validate that a server object has valid name and configuration.
  *
@@ -22,26 +34,24 @@ export declare function hasValidId(server: unknown): server is ValidServer;
  * Selects the best server instance based on server name and request options.
  *
  * This function resolves a server name to its configuration and instance details,
- * handling both single and multiple instance scenarios. Currently, it returns
- * the first instance for multi-instance servers, but the architecture supports
- * future extensions for intelligent instance selection based on session ID,
- * tags, client ID, or load conditions.
+ * handling both single and multiple instance scenarios using configurable instance
+ * selection strategies (random, round-robin, tag-match-unique).
  *
  * The function performs the following steps:
  * 1. Retrieves all instances of the specified server name
  * 2. Returns undefined if no instances are found
  * 3. Gets the server configuration from the hub manager
- * 4. For single-instance servers, returns the instance directly
- * 5. For multi-instance servers, currently returns the first instance (with future extension support)
+ * 4. Uses InstanceSelector to choose the best instance based on configured strategy
+ * 5. Handles errors based on the strictMode parameter
  *
- * Future extensions planned include:
- * - Session-aware instance selection based on sessionId
- * - Tag-based instance selection for matching specific requirements
- * - Load-balancing across multiple instances
- * - Client-specific instance assignment
+ * Supported instance selection strategies:
+ * - random: Randomly selects from enabled instances
+ * - round-robin: Cycles through enabled instances in order
+ * - tag-match-unique: Selects instance that uniquely matches request tags
  *
  * @param {string} serverName - Name of the server to select an instance for
  * @param {RequestOptions} [requestOptions] - Optional request options for instance selection
+ * @param {boolean} [strictMode=true] - Whether to throw errors for tag-match-unique failures (default: true)
  * @returns {{ name: string; config: ServerConfig; instance: ServerInstanceConfig & Record<string, unknown> } | undefined}
  * Server information with configuration and instance details, or undefined if not found
  *
@@ -52,12 +62,15 @@ export declare function hasValidId(server: unknown): server is ValidServer;
  *   console.log(`Selected instance: ${serverInfo.instance.id}`);
  * }
  *
- * // With request options (future extension)
+ * // With request options for tag matching
  * const serverInfoWithOptions = selectBestInstance('my-mcp-server', {
  *   sessionId: 'session-123',
  *   tags: { environment: 'production' }
  * });
+ *
+ * // Non-strict mode for management operations
+ * const serverInfoNonStrict = selectBestInstance('my-mcp-server', undefined, false);
  * ```
  */
-export declare function selectBestInstance(serverName: string, requestOptions?: RequestOptions): ServerInstanceInfo | undefined;
+export declare function selectBestInstance(serverName: string, requestOptions?: RequestOptions, strictMode?: boolean): ServerInstanceInfo | undefined;
 //# sourceMappingURL=server-selector.d.ts.map

package/dist/server/src/services/hub-tools/server-selector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server-selector.d.ts","sourceRoot":"","sources":["../../../../../src/services/hub-tools/server-selector.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAElF;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,IAAI,WAAW,CAMjE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,MAAM,EAClB,cAAc,CAAC,EAAE,cAAc,GAC9B,kBAAkB,GAAG,SAAS,CA+ChC"}
+{"version":3,"file":"server-selector.d.ts","sourceRoot":"","sources":["../../../../../src/services/hub-tools/server-selector.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAElF;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,YAAY,EAAE;IAAE,QAAQ,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,GAAG,SAAS,EACjE,UAAU,EAAE,MAAM,GACjB,MAAM,CAER;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,IAAI,WAAW,CAMjE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,MAAM,EAClB,cAAc,CAAC,EAAE,cAAc,EAC/B,UAAU,GAAE,OAAc,GACzB,kBAAkB,GAAG,SAAS,CA8ChC"}

package/dist/server/src/services/hub-tools/server-selector.js

@@ -1,4 +1,17 @@
 import { hubManager } from '../hub-manager.service.js';
+import { InstanceSelector, TagMatchUniqueError } from './instance-selector.js';
+import { logger } from '../../utils/logger.js';
+import { LOG_MODULES } from '../../utils/logger/log-modules.js';
+/**
+ * Gets the description for a server, using a default if none is provided.
+ *
+ * @param serverConfig - Server configuration object (may contain description in template)
+ * @param serverName - Name of the server
+ * @returns The server description or a default one
+ */
+export function getServerDescription(serverConfig, serverName) {
+    return serverConfig?.template?.description || `Connected MCP server: ${serverName}`;
+}
 /**
  * Type guard to validate that a server object has valid name and configuration.
  *
@@ -28,26 +41,24 @@ export function hasValidId(server) {
  * Selects the best server instance based on server name and request options.
  *
  * This function resolves a server name to its configuration and instance details,
- * handling both single and multiple instance scenarios. Currently, it returns
- * the first instance for multi-instance servers, but the architecture supports
- * future extensions for intelligent instance selection based on session ID,
- * tags, client ID, or load conditions.
+ * handling both single and multiple instance scenarios using configurable instance
+ * selection strategies (random, round-robin, tag-match-unique).
  *
  * The function performs the following steps:
  * 1. Retrieves all instances of the specified server name
  * 2. Returns undefined if no instances are found
  * 3. Gets the server configuration from the hub manager
- * 4. For single-instance servers, returns the instance directly
- * 5. For multi-instance servers, currently returns the first instance (with future extension support)
+ * 4. Uses InstanceSelector to choose the best instance based on configured strategy
+ * 5. Handles errors based on the strictMode parameter
  *
- * Future extensions planned include:
- * - Session-aware instance selection based on sessionId
- * - Tag-based instance selection for matching specific requirements
- * - Load-balancing across multiple instances
- * - Client-specific instance assignment
+ * Supported instance selection strategies:
+ * - random: Randomly selects from enabled instances
+ * - round-robin: Cycles through enabled instances in order
+ * - tag-match-unique: Selects instance that uniquely matches request tags
  *
  * @param {string} serverName - Name of the server to select an instance for
  * @param {RequestOptions} [requestOptions] - Optional request options for instance selection
+ * @param {boolean} [strictMode=true] - Whether to throw errors for tag-match-unique failures (default: true)
  * @returns {{ name: string; config: ServerConfig; instance: ServerInstanceConfig & Record<string, unknown> } | undefined}
  * Server information with configuration and instance details, or undefined if not found
  *
@@ -58,16 +69,19 @@ export function hasValidId(server) {
  *   console.log(`Selected instance: ${serverInfo.instance.id}`);
  * }
  *
- * // With request options (future extension)
+ * // With request options for tag matching
  * const serverInfoWithOptions = selectBestInstance('my-mcp-server', {
  *   sessionId: 'session-123',
  *   tags: { environment: 'production' }
  * });
+ *
+ * // Non-strict mode for management operations
+ * const serverInfoNonStrict = selectBestInstance('my-mcp-server', undefined, false);
  * ```
  */
-export function selectBestInstance(serverName, requestOptions) {
+export function selectBestInstance(serverName, requestOptions, strictMode = true) {
     // Get all instances of the server
-    const instances = hubManager.getServerInstanceByName(serverName);
+    const instances = hubManager.getServerInstancesByName(serverName);
     if (instances.length === 0) {
         return undefined;
     }
@@ -76,33 +90,26 @@ export function selectBestInstance(serverName, requestOptions) {
     if (!serverConfig) {
         return undefined;
     }
-    // If there's only one instance, return it directly
-    if (instances.length === 1) {
+    try {
+        // Use the new instance selector
+        const selectedInstance = InstanceSelector.selectInstance(serverName, serverConfig, requestOptions);
+        if (!selectedInstance) {
+            return undefined;
+        }
         return {
             name: serverName,
             config: serverConfig,
-            instance: instances[0]
+            instance: selectedInstance
         };
     }
-    // Multi-instance selection logic (for future extension)
-    // Currently simplified implementation: return the first instance
-    // Future extensions could support:
-    // - Selecting specific instance based on sessionId
-    // - Selecting optimal instance based on tags matching
-    // - Selecting dedicated instance based on client ID
-    // - Selecting instance based on load conditions
-    // Although requestOptions is not currently used, it's kept for future extension
-    if (requestOptions?.sessionId) {
-        // In the future, specific instance can be selected based on sessionId
-        // Currently return the first instance temporarily
-    }
-    if (requestOptions?.tags) {
-        // In the future, optimal instance can be selected based on tags matching
-        // Currently return the first instance temporarily
+    catch (error) {
+        // In strict mode, re-throw tag matching errors to maintain correct semantics
+        if (strictMode && error instanceof TagMatchUniqueError) {
+            // Re-throw with server context added to message
+            throw new Error(`[${serverName}] ${error.message}`);
+        }
+        // Handle other errors or non-strict mode gracefully
+        logger.error(`Instance selection failed for server ${serverName}:`, error, LOG_MODULES.SERVER_SELECTOR);
+        return undefined;
     }
-    return {
-        name: serverName,
-        config: serverConfig,
-        instance: instances[0] // Will be extended to intelligent selection logic later
-    };
 }

package/dist/server/src/services/hub-tools/system-tool-definitions.d.ts

@@ -27,12 +27,9 @@ export interface SystemToolDefinition {
  *
  * The method implements all standard system tools:
  * - list-servers: List all connected servers
- * - find-servers: Find servers matching a pattern
- * - list-all-tools-in-server: List tools from a specific server
- * - find-tools-in-server: Find tools in a specific server
+ * - list-tools-in-server: List tools from a specific server
  * - get-tool: Get complete tool schema
  * - call-tool: Call a specific tool from a specific server
- * - find-tools: Find tools across all servers
  *
  * @returns {Array<{ name: string; description: string; inputSchema: JsonSchema; annotations?: ToolAnnotations }>}
  * Array of system tool configurations

package/dist/server/src/services/hub-tools/system-tool-definitions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"system-tool-definitions.d.ts","sourceRoot":"","sources":["../../../../../src/services/hub-tools/system-tool-definitions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAY/D;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,UAAU,CAAC;IACxB,WAAW,CAAC,EAAE,eAAe,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,cAAc,IAAI,oBAAoB,EAAE,CAwMvD"}
+{"version":3,"file":"system-tool-definitions.d.ts","sourceRoot":"","sources":["../../../../../src/services/hub-tools/system-tool-definitions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAU/D;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,UAAU,CAAC;IACxB,WAAW,CAAC,EAAE,eAAe,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,cAAc,IAAI,oBAAoB,EAAE,CA6IvD"}

package/dist/server/src/services/hub-tools/system-tool-definitions.js

@@ -1,4 +1,4 @@
-import { SYSTEM_TOOL_NAMES, 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 } from '../../models/system-tools.constants.js';
+import { SYSTEM_TOOL_NAMES, LIST_SERVERS_TOOL, LIST_TOOLS_IN_SERVER_TOOL, GET_TOOL_TOOL, CALL_TOOL_TOOL, UPDATE_SERVER_DESCRIPTION_TOOL } from '../../models/system-tools.constants.js';
 /**
  * Retrieves the complete list of system tools provided by this service.
  *
@@ -8,12 +8,9 @@ import { SYSTEM_TOOL_NAMES, LIST_SERVERS_TOOL, FIND_SERVERS_TOOL, LIST_ALL_TOOLS
  *
  * The method implements all standard system tools:
  * - list-servers: List all connected servers
- * - find-servers: Find servers matching a pattern
- * - list-all-tools-in-server: List tools from a specific server
- * - find-tools-in-server: Find tools in a specific server
+ * - list-tools-in-server: List tools from a specific server
  * - get-tool: Get complete tool schema
  * - call-tool: Call a specific tool from a specific server
- * - find-tools: Find tools across all servers
  *
  * @returns {Array<{ name: string; description: string; inputSchema: JsonSchema; annotations?: ToolAnnotations }>}
  * Array of system tool configurations
@@ -46,33 +43,7 @@ export function getSystemTools() {
                     }
                 });
                 break;
-            case FIND_SERVERS_TOOL:
-                systemTools.push({
-                    name: toolName,
-                    description: 'Find servers matching a pattern',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            pattern: { type: 'string', description: 'Regex pattern to search for' },
-                            searchIn: {
-                                type: 'string',
-                                enum: ['name', 'description', 'both'],
-                                default: 'both'
-                            },
-                            caseSensitive: { type: 'boolean', default: false }
-                        },
-                        required: ['pattern']
-                    },
-                    annotations: {
-                        title: 'Find Servers',
-                        readOnlyHint: true,
-                        destructiveHint: false,
-                        idempotentHint: true,
-                        openWorldHint: false
-                    }
-                });
-                break;
-            case LIST_ALL_TOOLS_IN_SERVER_TOOL:
+            case LIST_TOOLS_IN_SERVER_TOOL:
                 systemTools.push({
                     name: toolName,
                     description: 'List all tools from a specific server',
@@ -99,40 +70,6 @@ export function getSystemTools() {
                     }
                 });
                 break;
-            case FIND_TOOLS_IN_SERVER_TOOL:
-                systemTools.push({
-                    name: toolName,
-                    description: 'Find tools matching a pattern in a specific server',
-                    inputSchema: {
-                        type: 'object',
-                        properties: {
-                            serverName: { type: 'string', description: 'Name of the MCP server' },
-                            pattern: { type: 'string', description: 'Regex pattern to search for' },
-                            searchIn: {
-                                type: 'string',
-                                enum: ['name', 'description', 'both'],
-                                default: 'both'
-                            },
-                            caseSensitive: { type: 'boolean', default: false },
-                            requestOptions: {
-                                type: 'object',
-                                properties: {
-                                    sessionId: { type: 'string', description: 'Session ID for instance selection' },
-                                    tags: { type: 'object', description: 'Tags for instance selection' }
-                                }
-                            }
-                        },
-                        required: ['serverName', 'pattern']
-                    },
-                    annotations: {
-                        title: 'Find Tools in Server',
-                        readOnlyHint: true,
-                        destructiveHint: false,
-                        idempotentHint: true,
-                        openWorldHint: false
-                    }
-                });
-                break;
             case GET_TOOL_TOOL:
                 systemTools.push({
                     name: toolName,
@@ -164,11 +101,16 @@ export function getSystemTools() {
             case CALL_TOOL_TOOL:
                 systemTools.push({
                     name: toolName,
-                    description: 'Call a specific tool from a specific server',
+                    description: 'Call a specific tool from an external MCP server. ' +
+                        'System tools (list_servers, list_tools_in_server, get_tool, update_server_description) ' +
+                        'must be called directly via tools/call, not through this tool.',
                     inputSchema: {
                         type: 'object',
                         properties: {
-                            serverName: { type: 'string', description: 'Name of the MCP server' },
+                            serverName: {
+                                type: 'string',
+                                description: 'Name of the MCP server (must be an external server, not mcp-hub-lite)'
+                            },
                             toolName: { type: 'string', description: 'Name of the tool to call' },
                             toolArgs: { type: 'object', description: 'Arguments to pass to the tool' },
                             requestOptions: {
@@ -190,26 +132,21 @@ export function getSystemTools() {
                     }
                 });
                 break;
-            case FIND_TOOLS_TOOL:
+            case UPDATE_SERVER_DESCRIPTION_TOOL:
                 systemTools.push({
                     name: toolName,
-                    description: 'Find tools matching a pattern across all connected servers',
+                    description: 'Update the description of a specific MCP server',
                     inputSchema: {
                         type: 'object',
                         properties: {
-                            pattern: { type: 'string', description: 'Regex pattern to search for' },
-                            searchIn: {
-                                type: 'string',
-                                enum: ['name', 'description', 'both'],
-                                default: 'both'
-                            },
-                            caseSensitive: { type: 'boolean', default: false }
+                            serverName: { type: 'string', description: 'Name of the MCP server to update' },
+                            description: { type: 'string', description: 'New description text for the server' }
                         },
-                        required: ['pattern']
+                        required: ['serverName', 'description']
                     },
                     annotations: {
-                        title: 'Find Tools',
-                        readOnlyHint: true,
+                        title: 'Update Server Description',
+                        readOnlyHint: false,
                         destructiveHint: false,
                         idempotentHint: true,
                         openWorldHint: false

package/dist/server/src/services/hub-tools/tool-search.d.ts

@@ -1,4 +1,4 @@
-import type { Tool } from '../../../shared/models/tool.model.js';
+import type { ToolSummary } from '../../../shared/models/tool.model.js';
 import type { RequestOptions } from './types.js';
 /**
  * Search options for server searches.
@@ -42,7 +42,7 @@ export declare function findServers(pattern: string, searchIn?: 'name' | 'descri
  * @param {'name' | 'description' | 'both'} [searchIn='both'] - Where to perform the search
  * @param {boolean} [caseSensitive=false] - Whether the search should be case-sensitive
  * @param {RequestOptions} [requestOptions] - Optional request options for instance selection
- * @returns {Promise<{ serverName: string; tools: Tool[] }>} Object containing server name and matching tools
+ * @returns {Promise<{ serverName: string; tools: ToolSummary[] }>} Object containing server name and matching tools
  * @throws {Error} If the specified server is not found or not connected
  *
  * @example
@@ -53,7 +53,7 @@ export declare function findServers(pattern: string, searchIn?: 'name' | 'descri
  */
 export declare function findToolsInServer(serverName: string, pattern: string, searchIn?: 'name' | 'description' | 'both', caseSensitive?: boolean, requestOptions?: RequestOptions): Promise<{
     serverName: string;
-    tools: Tool[];
+    tools: ToolSummary[];
 }>;
 /**
  * Finds tools matching a pattern across all connected MCP servers.
@@ -66,8 +66,8 @@ export declare function findToolsInServer(serverName: string, pattern: string, s
  * @param {string} pattern - Regex pattern to search for in tool names and descriptions
  * @param {'name' | 'description' | 'both'} [searchIn='both'] - Where to perform the search
  * @param {boolean} [caseSensitive=false] - Whether the search should be case-sensitive
- * @param {() => Promise<Record<string, { tools: Tool[] }>>} listAllToolsFn - Function to list all tools
- * @returns {Promise<Record<string, { tools: Tool[] }>>} Object mapping server names to matching tools
+ * @param {() => Promise<Record<string, { tools: ToolSummary[] }>>} listAllToolsFn - Function to list all tools
+ * @returns {Promise<Record<string, { tools: ToolSummary[] }>>} Object mapping server names to matching tools
  *
  * @example
  * ```typescript
@@ -78,8 +78,8 @@ export declare function findToolsInServer(serverName: string, pattern: string, s
  * ```
  */
 export declare function findTools(pattern: string, searchIn: "name" | "description" | "both" | undefined, caseSensitive: boolean | undefined, listAllToolsFn: () => Promise<Record<string, {
-    tools: Tool[];
+    tools: ToolSummary[];
 }>>): Promise<Record<string, {
-    tools: Tool[];
+    tools: ToolSummary[];
 }>>;
 //# sourceMappingURL=tool-search.d.ts.map

package/dist/server/src/services/hub-tools/tool-search.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool-search.d.ts","sourceRoot":"","sources":["../../../../../src/services/hub-tools/tool-search.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,8BAA8B,CAAC;AAEzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,EAAE,MAAM,GAAG,aAAa,GAAG,MAAM,CAAC;IAC3C,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,WAAW,CAC/B,OAAO,EAAE,MAAM,EACf,QAAQ,GAAE,MAAM,GAAG,aAAa,GAAG,MAAe,EAClD,aAAa,GAAE,OAAe,GAC7B,OAAO,CAAC,MAAM,EAAE,CAAC,CAYnB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,iBAAiB,CACrC,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,EACf,QAAQ,GAAE,MAAM,GAAG,aAAa,GAAG,MAAe,EAClD,aAAa,GAAE,OAAe,EAC9B,cAAc,CAAC,EAAE,cAAc,GAC9B,OAAO,CAAC;IACT,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,IAAI,EAAE,CAAC;CACf,CAAC,CAqBD;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,SAAS,CAC7B,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GAAG,aAAa,GAAG,MAAM,YAAS,EAClD,aAAa,EAAE,OAAO,YAAQ,EAC9B,cAAc,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,IAAI,EAAE,CAAA;CAAE,CAAC,CAAC,GAC/D,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,IAAI,EAAE,CAAA;CAAE,CAAC,CAAC,CAsB5C"}
+{"version":3,"file":"tool-search.d.ts","sourceRoot":"","sources":["../../../../../src/services/hub-tools/tool-search.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAEhE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,EAAE,MAAM,GAAG,aAAa,GAAG,MAAM,CAAC;IAC3C,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,WAAW,CAC/B,OAAO,EAAE,MAAM,EACf,QAAQ,GAAE,MAAM,GAAG,aAAa,GAAG,MAAe,EAClD,aAAa,GAAE,OAAe,GAC7B,OAAO,CAAC,MAAM,EAAE,CAAC,CAYnB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,iBAAiB,CACrC,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,EACf,QAAQ,GAAE,MAAM,GAAG,aAAa,GAAG,MAAe,EAClD,aAAa,GAAE,OAAe,EAC9B,cAAc,CAAC,EAAE,cAAc,GAC9B,OAAO,CAAC;IACT,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,WAAW,EAAE,CAAC;CACtB,CAAC,CA4BD;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,SAAS,CAC7B,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,GAAG,aAAa,GAAG,MAAM,YAAS,EAClD,aAAa,EAAE,OAAO,YAAQ,EAC9B,cAAc,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,WAAW,EAAE,CAAA;CAAE,CAAC,CAAC,GACtE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,WAAW,EAAE,CAAA;CAAE,CAAC,CAAC,CAsBnD"}

package/dist/server/src/services/hub-tools/tool-search.js

@@ -47,7 +47,7 @@ export async function findServers(pattern, searchIn = 'both', caseSensitive = fa
  * @param {'name' | 'description' | 'both'} [searchIn='both'] - Where to perform the search
  * @param {boolean} [caseSensitive=false] - Whether the search should be case-sensitive
  * @param {RequestOptions} [requestOptions] - Optional request options for instance selection
- * @returns {Promise<{ serverName: string; tools: Tool[] }>} Object containing server name and matching tools
+ * @returns {Promise<{ serverName: string; tools: ToolSummary[] }>} Object containing server name and matching tools
  * @throws {Error} If the specified server is not found or not connected
  *
  * @example
@@ -68,9 +68,15 @@ export async function findToolsInServer(serverName, pattern, searchIn = 'both',
         const matchDescription = searchIn !== 'name' && tool.description && regex.test(tool.description);
         return matchName || matchDescription;
     });
+    // Convert to ToolSummary format
+    const toolSummaries = matchingTools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        serverName: serverName
+    }));
     return {
         serverName: serverName,
-        tools: matchingTools
+        tools: toolSummaries
     };
 }
 /**
@@ -84,8 +90,8 @@ export async function findToolsInServer(serverName, pattern, searchIn = 'both',
  * @param {string} pattern - Regex pattern to search for in tool names and descriptions
  * @param {'name' | 'description' | 'both'} [searchIn='both'] - Where to perform the search
  * @param {boolean} [caseSensitive=false] - Whether the search should be case-sensitive
- * @param {() => Promise<Record<string, { tools: Tool[] }>>} listAllToolsFn - Function to list all tools
- * @returns {Promise<Record<string, { tools: Tool[] }>>} Object mapping server names to matching tools
+ * @param {() => Promise<Record<string, { tools: ToolSummary[] }>>} listAllToolsFn - Function to list all tools
+ * @returns {Promise<Record<string, { tools: ToolSummary[] }>>} Object mapping server names to matching tools
  *
  * @example
  * ```typescript

package/dist/server/src/services/hub-tools/types.d.ts

@@ -1,4 +1,4 @@
-import type { ServerConfig, ServerInstanceConfig } from '../../config/config.schema.js';
+import type { ServerConfig } from '../../config/config.schema.js';
 /**
  * Configuration options for server instance selection in multi-instance scenarios.
  *
@@ -30,7 +30,7 @@ export interface RequestOptions {
 export type ServerInstanceInfo = {
     name: string;
     config: ServerConfig;
-    instance: ServerInstanceConfig & Record<string, unknown>;
+    instance: Record<string, unknown>;
 };
 /**
  * Type guard return type.

package/dist/server/src/services/hub-tools/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/services/hub-tools/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAEnF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,cAAc;IAC7B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAG/B;AAED;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,YAAY,CAAC;IACrB,QAAQ,EAAE,oBAAoB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC1D,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,YAAY,CAAA;CAAE,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/services/hub-tools/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,cAAc;IAC7B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAG/B;AAED;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,YAAY,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,YAAY,CAAA;CAAE,CAAC"}