@mozilla-ai/mcpd 0.0.1 → 0.0.2

package/dist/index.mjs

@@ -119,49 +119,103 @@ function createCache(options = {}) {
 class ServersNamespace {
   #performCall;
   #getTools;
+  #generatePrompt;
+  #getPrompts;
+  #getResources;
+  #getResourceTemplates;
+  #readResource;
   /**
    * Initialize the ServersNamespace with injected functions.
    *
-   * @param performCall - Function to execute tool calls
-   * @param getTools - Function to get tool schemas
+   * @param options - Configuration object
+   * @param options.performCall - Function to execute tool calls
+   * @param options.getTools - Function to get tool schemas
+   * @param options.generatePrompt - Function to generate prompts
+   * @param options.getPrompts - Function to get prompt schemas
+   * @param options.getResources - Function to get resources
+   * @param options.getResourceTemplates - Function to get resource templates
+   * @param options.readResource - Function to read resource content
    */
-  constructor(performCall, getTools) {
+  constructor({
+    performCall,
+    getTools,
+    generatePrompt,
+    getPrompts,
+    getResources,
+    getResourceTemplates,
+    readResource
+  }) {
     this.#performCall = performCall;
     this.#getTools = getTools;
+    this.#generatePrompt = generatePrompt;
+    this.#getPrompts = getPrompts;
+    this.#getResources = getResources;
+    this.#getResourceTemplates = getResourceTemplates;
+    this.#readResource = readResource;
     return new Proxy(this, {
       get: (target, serverName) => {
         if (typeof serverName !== "string") {
           return void 0;
         }
-        return new Server(target.#performCall, target.#getTools, serverName);
+        return new Server(
+          target.#performCall,
+          target.#getTools,
+          target.#generatePrompt,
+          target.#getPrompts,
+          target.#getResources,
+          target.#getResourceTemplates,
+          target.#readResource,
+          serverName
+        );
       }
     });
   }
 }
 class Server {
   tools;
+  prompts;
   #performCall;
   #getTools;
+  #generatePrompt;
+  #getPrompts;
+  #getResources;
+  #getResourceTemplates;
+  #readResource;
   #serverName;
   /**
    * Initialize a Server for a specific server.
    *
    * @param performCall - Function to execute tool calls
    * @param getTools - Function to get tool schemas
+   * @param generatePrompt - Function to generate prompts
+   * @param getPrompts - Function to get prompt schemas
+   * @param getResources - Function to get resources
+   * @param getResourceTemplates - Function to get resource templates
+   * @param readResource - Function to read resource content
    * @param serverName - The name of the MCP server
    */
-  constructor(performCall, getTools, serverName) {
+  constructor(performCall, getTools, generatePrompt, getPrompts, getResources, getResourceTemplates, readResource, serverName) {
     this.#performCall = performCall;
     this.#getTools = getTools;
+    this.#generatePrompt = generatePrompt;
+    this.#getPrompts = getPrompts;
+    this.#getResources = getResources;
+    this.#getResourceTemplates = getResourceTemplates;
+    this.#readResource = readResource;
     this.#serverName = serverName;
     this.tools = new ToolsNamespace(
       this.#performCall,
       this.#getTools,
       this.#serverName
     );
+    this.prompts = new PromptsNamespace(
+      this.#generatePrompt,
+      this.#getPrompts,
+      this.#serverName
+    );
   }
   /**
-   * List all tools available on this server.
+   * Get all tools available on this server.
    *
    * @returns Array of tool schemas
    * @throws {ServerNotFoundError} If the server doesn't exist
@@ -169,13 +223,13 @@ class Server {
    *
    * @example
    * ```typescript
-   * const tools = await client.servers.time.listTools();
+   * const tools = await client.servers.time.getTools();
    * for (const tool of tools) {
    *   console.log(`${tool.name}: ${tool.description}`);
    * }
    * ```
    */
-  async listTools() {
+  async getTools() {
     return this.#getTools(this.#serverName);
   }
   /**
@@ -183,8 +237,13 @@ class Server {
    *
    * The tool name must match exactly as returned by the server.
    *
+   * This method is designed as a safe boolean predicate - it catches all errors
+   * (ServerNotFoundError, ServerUnhealthyError, ConnectionError, etc.) and returns
+   * false rather than throwing. This makes it safe to use in conditional checks
+   * without requiring error handling.
+   *
    * @param toolName - The exact name of the tool to check
-   * @returns True if the tool exists, false otherwise
+   * @returns True if the tool exists, false otherwise (including on errors)
    *
    * @example
    * ```typescript
@@ -228,13 +287,192 @@ class Server {
     const tool = tools.find((t) => t.name === toolName);
     if (!tool) {
       throw new ToolNotFoundError(
-        `Tool '${toolName}' not found on server '${this.#serverName}'. Use client.servers.${this.#serverName}.listTools() to see available tools.`,
+        `Tool '${toolName}' not found on server '${this.#serverName}'. Use client.servers.${this.#serverName}.getTools() to see available tools.`,
         this.#serverName,
         toolName
       );
     }
     return this.#performCall(this.#serverName, toolName, args);
   }
+  /**
+   * Get all prompts available on this server.
+   *
+   * Note: This method is marked `async` for consistency with other server methods,
+   * even though it doesn't directly await. This maintains a uniform async interface
+   * and allows for future enhancements without breaking the API contract.
+   *
+   * @returns Array of prompt schemas
+   * @throws {ServerNotFoundError} If the server doesn't exist
+   * @throws {ServerUnhealthyError} If the server is unhealthy
+   *
+   * @example
+   * ```typescript
+   * const prompts = await client.servers.github.getPrompts();
+   * for (const prompt of prompts) {
+   *   console.log(`${prompt.name}: ${prompt.description}`);
+   * }
+   * ```
+   */
+  async getPrompts() {
+    return this.#getPrompts(this.#serverName);
+  }
+  /**
+   * Check if a prompt exists on this server.
+   *
+   * The prompt name must match exactly as returned by the server.
+   *
+   * This method is designed as a safe boolean predicate - it catches all errors
+   * (ServerNotFoundError, ServerUnhealthyError, ConnectionError, etc.) and returns
+   * false rather than throwing. This makes it safe to use in conditional checks
+   * without requiring error handling.
+   *
+   * @param promptName - The exact name of the prompt to check
+   * @returns True if the prompt exists, false otherwise (including on errors)
+   *
+   * @example
+   * ```typescript
+   * if (await client.servers.github.hasPrompt('create_pr')) {
+   *   const result = await client.servers.github.generatePrompt('create_pr', { title: 'Fix bug' });
+   * }
+   * ```
+   */
+  async hasPrompt(promptName) {
+    try {
+      const prompts = await this.#getPrompts(this.#serverName);
+      return prompts.some((p) => p.name === promptName);
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Generate a prompt by name with the given arguments.
+   *
+   * This method is useful for programmatic prompt generation when the prompt name
+   * is in a variable. The prompt name must match exactly as returned by the server.
+   *
+   * @param promptName - The exact name of the prompt to generate
+   * @param args - The arguments to pass to the prompt template
+   * @returns The generated prompt response
+   * @throws {ToolNotFoundError} If the prompt doesn't exist on the server
+   *
+   * @example
+   * ```typescript
+   * // Call with explicit method (useful for dynamic prompt names):
+   * const promptName = 'create_pr';
+   * await client.servers.github.generatePrompt(promptName, { title: 'Fix bug' });
+   *
+   * // Or with dynamic server name:
+   * const serverName = 'github';
+   * await client.servers[serverName].generatePrompt(promptName, { title: 'Fix bug' });
+   * ```
+   */
+  async generatePrompt(promptName, args) {
+    const prompts = await this.#getPrompts(this.#serverName);
+    const prompt = prompts.find((p) => p.name === promptName);
+    if (!prompt) {
+      throw new ToolNotFoundError(
+        `Prompt '${promptName}' not found on server '${this.#serverName}'. Use client.servers.${this.#serverName}.getPrompts() to see available prompts.`,
+        this.#serverName,
+        promptName
+      );
+    }
+    return this.#generatePrompt(this.#serverName, promptName, args);
+  }
+  /**
+   * Get all resources available on this server.
+   *
+   * Note: This method is marked `async` for consistency with other server methods,
+   * even though it doesn't directly await. This maintains a uniform async interface
+   * and allows for future enhancements without breaking the API contract.
+   *
+   * @returns Array of resource schemas with original names
+   * @throws {ServerNotFoundError} If the server doesn't exist
+   * @throws {ServerUnhealthyError} If the server is unhealthy
+   *
+   * @example
+   * ```typescript
+   * const resources = await client.servers.github.getResources();
+   * for (const resource of resources) {
+   *   console.log(`${resource.name}: ${resource.uri}`);
+   * }
+   * ```
+   */
+  async getResources() {
+    return this.#getResources(this.#serverName);
+  }
+  /**
+   * Get all resource templates available on this server.
+   *
+   * Note: This method is marked `async` for consistency with other server methods,
+   * even though it doesn't directly await. This maintains a uniform async interface
+   * and allows for future enhancements without breaking the API contract.
+   *
+   * @returns Array of resource template schemas with original names
+   * @throws {ServerNotFoundError} If the server doesn't exist
+   * @throws {ServerUnhealthyError} If the server is unhealthy
+   *
+   * @example
+   * ```typescript
+   * const templates = await client.servers.github.getResourceTemplates();
+   * for (const template of templates) {
+   *   console.log(`${template.name}: ${template.uriTemplate}`);
+   * }
+   * ```
+   */
+  async getResourceTemplates() {
+    return this.#getResourceTemplates(this.#serverName);
+  }
+  /**
+   * Check if a resource exists on this server.
+   *
+   * The resource URI must match exactly as returned by the server.
+   *
+   * This method is designed as a safe boolean predicate - it catches all errors
+   * (ServerNotFoundError, ServerUnhealthyError, ConnectionError, etc.) and returns
+   * false rather than throwing. This makes it safe to use in conditional checks
+   * without requiring error handling.
+   *
+   * @param uri - The exact URI of the resource to check
+   * @returns True if the resource exists, false otherwise (including on errors)
+   *
+   * @example
+   * ```typescript
+   * if (await client.servers.github.hasResource('file:///repo/README.md')) {
+   *   const content = await client.servers.github.readResource('file:///repo/README.md');
+   * }
+   * ```
+   */
+  async hasResource(uri) {
+    try {
+      const resources = await this.#getResources(this.#serverName);
+      return resources.some((r) => r.uri === uri);
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Read resource content by URI from this server.
+   *
+   * @param uri - The resource URI
+   * @returns Array of resource contents (text or blob)
+   * @throws {ServerNotFoundError} If the server doesn't exist
+   * @throws {ServerUnhealthyError} If the server is unhealthy
+   *
+   * @example
+   * ```typescript
+   * const contents = await client.servers.github.readResource('file:///repo/README.md');
+   * for (const content of contents) {
+   *   if (content.text) {
+   *     console.log(content.text);
+   *   } else if (content.blob) {
+   *     console.log('Binary content:', content.blob.substring(0, 50) + '...');
+   *   }
+   * }
+   * ```
+   */
+  async readResource(uri) {
+    return this.#readResource(this.#serverName, uri);
+  }
 }
 class ToolsNamespace {
   #performCall;
@@ -262,7 +500,7 @@ class ToolsNamespace {
           const tool = tools.find((t) => t.name === toolName);
           if (!tool) {
             throw new ToolNotFoundError(
-              `Tool '${toolName}' not found on server '${target.#serverName}'. Use client.servers.${target.#serverName}.listTools() to see available tools.`,
+              `Tool '${toolName}' not found on server '${target.#serverName}'. Use client.servers.${target.#serverName}.getTools() to see available tools.`,
               target.#serverName,
               toolName
             );
@@ -273,6 +511,53 @@ class ToolsNamespace {
     });
   }
 }
+class PromptsNamespace {
+  #generatePrompt;
+  #getPrompts;
+  #serverName;
+  /**
+   * Initialize a PromptsNamespace for a specific server.
+   *
+   * @param generatePrompt - Function to generate prompts
+   * @param getPrompts - Function to get prompt schemas
+   * @param serverName - The name of the MCP server
+   */
+  constructor(generatePrompt, getPrompts, serverName) {
+    this.#generatePrompt = generatePrompt;
+    this.#getPrompts = getPrompts;
+    this.#serverName = serverName;
+    return new Proxy(this, {
+      get: (target, prop) => {
+        if (typeof prop !== "string") {
+          return void 0;
+        }
+        return async (args) => {
+          const promptName = prop;
+          const prompt = await target.#getPromptByName(promptName);
+          if (!prompt) {
+            throw new ToolNotFoundError(
+              `Prompt '${promptName}' not found on server '${target.#serverName}'. Use client.servers.${target.#serverName}.getPrompts() to see available prompts.`,
+              target.#serverName,
+              promptName
+            );
+          }
+          return target.#generatePrompt(target.#serverName, promptName, args);
+        };
+      }
+    });
+  }
+  /**
+   * Helper method to find a prompt by name on this server.
+   *
+   * @param promptName - The exact name of the prompt to find
+   * @returns The prompt if found, undefined otherwise
+   * @internal
+   */
+  async #getPromptByName(promptName) {
+    const prompts = await this.#getPrompts(this.#serverName);
+    return prompts.find((p) => p.name === promptName);
+  }
+}
 class TypeConverter {
   /**
    * Convert JSON schema types to JavaScript type names.
@@ -666,10 +951,27 @@ const API_PATHS = {
   // Tools
   SERVER_TOOLS: (serverName) => `${SERVERS_BASE}/${encodeURIComponent(serverName)}/tools`,
   TOOL_CALL: (serverName, toolName) => `${SERVERS_BASE}/${encodeURIComponent(serverName)}/tools/${encodeURIComponent(toolName)}`,
+  // Prompts
+  SERVER_PROMPTS: (serverName, cursor) => {
+    const base = `${SERVERS_BASE}/${encodeURIComponent(serverName)}/prompts`;
+    return cursor ? `${base}?cursor=${encodeURIComponent(cursor)}` : base;
+  },
+  PROMPT_GET_GENERATED: (serverName, promptName) => `${SERVERS_BASE}/${encodeURIComponent(serverName)}/prompts/${encodeURIComponent(promptName)}`,
+  // Resources
+  SERVER_RESOURCES: (serverName, cursor) => {
+    const base = `${SERVERS_BASE}/${encodeURIComponent(serverName)}/resources`;
+    return cursor ? `${base}?cursor=${encodeURIComponent(cursor)}` : base;
+  },
+  SERVER_RESOURCE_TEMPLATES: (serverName, cursor) => {
+    const base = `${SERVERS_BASE}/${encodeURIComponent(serverName)}/resources/templates`;
+    return cursor ? `${base}?cursor=${encodeURIComponent(cursor)}` : base;
+  },
+  RESOURCE_CONTENT: (serverName, uri) => `${SERVERS_BASE}/${encodeURIComponent(serverName)}/resources/content?uri=${encodeURIComponent(uri)}`,
   // Health
   HEALTH_ALL: HEALTH_SERVERS_BASE,
   HEALTH_SERVER: (serverName) => `${HEALTH_SERVERS_BASE}/${encodeURIComponent(serverName)}`
 };
+const SERVER_HEALTH_CACHE_MAXSIZE = 100;
 class McpdClient {
   #endpoint;
   #apiKey;
@@ -696,17 +998,18 @@ class McpdClient {
     this.#timeout = options.timeout ?? 3e4;
     const healthCacheTtlMs = (options.healthCacheTtl ?? 10) * 1e3;
     this.#serverHealthCache = createCache({
-      max: 100,
-      // TODO: Extract to const like Python SDK see:
-      //  _SERVER_HEALTH_CACHE_MAXSIZE: int = 100
-      // """Maximum number of server health entries to cache.
-      // Prevents unbounded memory growth while allowing legitimate large-scale monitoring."""
+      max: SERVER_HEALTH_CACHE_MAXSIZE,
       ttl: healthCacheTtlMs
     });
-    this.servers = new ServersNamespace(
-      this.#performCall.bind(this),
-      this.#getToolsByServer.bind(this)
-    );
+    this.servers = new ServersNamespace({
+      performCall: this.#performCall.bind(this),
+      getTools: this.#getToolsByServer.bind(this),
+      generatePrompt: this.#generatePromptInternal.bind(this),
+      getPrompts: this.#getPromptsByServer.bind(this),
+      getResources: this.#getResourcesByServer.bind(this),
+      getResourceTemplates: this.#getResourceTemplatesByServer.bind(this),
+      readResource: this.#readResourceByServer.bind(this)
+    });
     this.#functionBuilder = new FunctionBuilder(this.#performCall.bind(this));
   }
   /**
@@ -741,6 +1044,7 @@ class McpdClient {
         try {
           errorModel = JSON.parse(body);
         } catch {
+          errorModel = null;
         }
         if (errorModel && errorModel.detail) {
           const errorDetails = errorModel.errors?.map((e) => `${e.location}: ${e.message}`).join("; ");
@@ -805,78 +1109,6 @@ class McpdClient {
   async listServers() {
     return await this.#request(API_PATHS.SERVERS);
   }
-  /**
-   * Get tool schemas from all (or specific) MCP servers with transformed names.
-   *
-   * IMPORTANT: Tool names are transformed to `serverName__toolName` format to:
-   * 1. Prevent naming clashes when aggregating tools from multiple servers
-   * 2. Identify which server each tool belongs to
-   *
-   * This method automatically filters out unhealthy servers by checking their health
-   * status before fetching tools. Unhealthy servers are silently skipped to ensure
-   * the method returns quickly without waiting for timeouts on failed servers.
-   *
-   * Tool fetches from multiple servers are executed concurrently for optimal performance.
-   *
-   * This is useful for:
-   * - MCP servers that aggregate and re-expose tools from multiple upstream servers
-   * - Tool inspection and discovery across all servers
-   * - Custom tooling that needs raw MCP tool schemas
-   *
-   * @param options - Optional configuration
-   * @param options.servers - Array of server names to include. If not specified, includes all servers.
-   * @returns Array of tool schemas with transformed names (serverName__toolName). Only includes tools from healthy servers.
-   * @throws {ConnectionError} If unable to connect to the mcpd daemon
-   * @throws {TimeoutError} If requests to the daemon time out
-   * @throws {AuthenticationError} If API key authentication fails
-   * @throws {McpdError} If health check or initial server listing fails
-   *
-   * @example
-   * ```typescript
-   * // Get all tools from all servers
-   * const allTools = await client.getToolSchemas();
-   * // Returns: [
-   * //   { name: "time__get_current_time", description: "...", ... },
-   * //   { name: "fetch__fetch_url", description: "...", ... }
-   * // ]
-   *
-   * // Get tools from specific servers only
-   * const someTools = await client.getToolSchemas({ servers: ['time', 'fetch'] });
-   *
-   * // Original tool name "get_current_time" becomes "time__get_current_time"
-   * // This prevents clashes if multiple servers have tools with the same name
-   * ```
-   */
-  async getToolSchemas(options) {
-    const { servers } = options || {};
-    const serverNames = servers && servers.length > 0 ? servers : await this.listServers();
-    const healthMap = await this.getServerHealth();
-    const healthyServers = serverNames.filter((name) => {
-      const health = healthMap[name];
-      return health && HealthStatusHelpers.isHealthy(health.status);
-    });
-    const results = await Promise.allSettled(
-      healthyServers.map(async (serverName) => ({
-        serverName,
-        tools: await this.#getToolsByServer(serverName)
-      }))
-    );
-    const allTools = [];
-    for (const result of results) {
-      if (result.status === "fulfilled") {
-        const { serverName, tools } = result.value;
-        for (const tool of tools) {
-          allTools.push({
-            ...tool,
-            name: `${serverName}__${tool.name}`
-          });
-        }
-      } else {
-        console.warn(`Failed to get tools for server:`, result.reason);
-      }
-    }
-    return allTools;
-  }
   /**
    * Internal method to get tool schemas for a server.
    * Used by dependency injection for ServersNamespace and internally for getAgentTools.
@@ -902,6 +1134,132 @@ class McpdClient {
     }
     return response.tools;
   }
+  /**
+   * Internal method to get prompt schemas for a server.
+   * Used internally for getPromptSchemas.
+   *
+   * @param serverName - Server name to get prompts for
+   * @param cursor - Optional cursor for pagination
+   * @returns Prompt schemas for the specified server
+   * @throws {ServerNotFoundError} If the specified server doesn't exist
+   * @throws {ServerUnhealthyError} If the server is not healthy
+   * @throws {ConnectionError} If unable to connect to the mcpd daemon
+   * @throws {TimeoutError} If the request times out
+   * @throws {McpdError} If the request fails
+   * @internal
+   */
+  async #getPromptsByServer(serverName, cursor) {
+    try {
+      await this.#ensureServerHealthy(serverName);
+      const path = API_PATHS.SERVER_PROMPTS(serverName, cursor);
+      const response = await this.#request(path);
+      return response.prompts || [];
+    } catch (error) {
+      if (error instanceof McpdError && error.message.includes("501") && error.message.includes("Not Implemented")) {
+        return [];
+      }
+      throw error;
+    }
+  }
+  /**
+   * Internal method to generate a prompt on a server.
+   *
+   * This method is used internally by:
+   * - PromptsNamespace (via dependency injection)
+   * - Server.generatePrompt() (via dependency injection)
+   *
+   * @param serverName - The name of the server
+   * @param promptName - The exact name of the prompt
+   * @param args - The prompt arguments
+   * @returns The generated prompt response
+   * @internal
+   */
+  async #generatePromptInternal(serverName, promptName, args) {
+    await this.#ensureServerHealthy(serverName);
+    const path = API_PATHS.PROMPT_GET_GENERATED(serverName, promptName);
+    const requestBody = {
+      arguments: args || {}
+    };
+    const response = await this.#request(path, {
+      method: "POST",
+      body: JSON.stringify(requestBody)
+    });
+    return response;
+  }
+  /**
+   * Internal method to get resource schemas for a server.
+   * Used internally for getResources and by dependency injection for ServersNamespace.
+   *
+   * @param serverName - Server name to get resources for
+   * @param cursor - Optional cursor for pagination
+   * @returns Resource schemas for the specified server
+   * @throws {ServerNotFoundError} If the specified server doesn't exist
+   * @throws {ServerUnhealthyError} If the server is not healthy
+   * @throws {ConnectionError} If unable to connect to the mcpd daemon
+   * @throws {TimeoutError} If the request times out
+   * @throws {McpdError} If the request fails
+   * @internal
+   */
+  async #getResourcesByServer(serverName, cursor) {
+    try {
+      await this.#ensureServerHealthy(serverName);
+      const path = API_PATHS.SERVER_RESOURCES(serverName, cursor);
+      const response = await this.#request(path);
+      return response.resources || [];
+    } catch (error) {
+      if (error instanceof McpdError && error.message.includes("501") && error.message.includes("Not Implemented")) {
+        return [];
+      }
+      throw error;
+    }
+  }
+  /**
+   * Internal method to get resource template schemas for a server.
+   * Used internally for getResourceTemplates and by dependency injection for ServersNamespace.
+   *
+   * @param serverName - Server name to get resource templates for
+   * @param cursor - Optional cursor for pagination
+   * @returns Resource template schemas for the specified server
+   * @throws {ServerNotFoundError} If the specified server doesn't exist
+   * @throws {ServerUnhealthyError} If the server is not healthy
+   * @throws {ConnectionError} If unable to connect to the mcpd daemon
+   * @throws {TimeoutError} If the request times out
+   * @throws {McpdError} If the request fails
+   * @internal
+   */
+  async #getResourceTemplatesByServer(serverName, cursor) {
+    try {
+      await this.#ensureServerHealthy(serverName);
+      const path = API_PATHS.SERVER_RESOURCE_TEMPLATES(serverName, cursor);
+      const response = await this.#request(path);
+      return response.templates || [];
+    } catch (error) {
+      if (error instanceof McpdError && error.message.includes("501") && error.message.includes("Not Implemented")) {
+        return [];
+      }
+      throw error;
+    }
+  }
+  /**
+   * Internal method to read resource content from a server.
+   * Used by dependency injection for ServersNamespace.
+   *
+   * @param serverName - Server name to read resource from
+   * @param uri - The resource URI
+   * @returns Array of resource contents (text or blob)
+   * @throws {ServerNotFoundError} If the specified server doesn't exist
+   * @throws {ServerUnhealthyError} If the server is not healthy
+   * @throws {ConnectionError} If unable to connect to the mcpd daemon
+   * @throws {TimeoutError} If the request times out
+   * @throws {McpdError} If the request fails
+   * @internal
+   */
+  async #readResourceByServer(serverName, uri) {
+    await this.#ensureServerHealthy(serverName);
+    const path = API_PATHS.RESOURCE_CONTENT(serverName, uri);
+    const response = await this.#request(path);
+    return response || [];
+  }
   async getServerHealth(serverName) {
     if (serverName) {
       const cacheKey = `health:${serverName}`;
@@ -989,13 +1347,28 @@ class McpdClient {
     }
   }
   /**
-   * Internal method to perform a tool call on a server.
+   * Get list of healthy servers from optional server names.
+   *
+   * This helper fetches server names (if not provided) and filters to only healthy servers.
+   * Used by getToolSchemas(), getPrompts(), and agentTools() to avoid timeouts on failed servers.
    *
-   * ⚠️ This method is truly private and cannot be accessed by SDK consumers.
-   * Use the fluent API instead: `client.servers.foo.tools.bar(args)`
+   * @param servers - Optional array of server names. If not provided, fetches all servers.
+   * @returns Array of healthy server names
+   * @internal
+   */
+  async #getHealthyServers(servers) {
+    const serverNames = servers && servers.length > 0 ? servers : await this.listServers();
+    const healthMap = await this.getServerHealth();
+    return serverNames.filter((name) => {
+      const health = healthMap[name];
+      return health && HealthStatusHelpers.isHealthy(health.status);
+    });
+  }
+  /**
+   * Internal method to perform a tool call on a server.
    *
    * This method is used internally by:
-   * - ToolsProxy (via dependency injection)
+   * - ToolsNamespace (via dependency injection)
    * - FunctionBuilder (via dependency injection)
    *
    * @param serverName - The name of the server
@@ -1070,33 +1443,22 @@ class McpdClient {
    * @internal
    */
   async agentTools(servers) {
-    const serverNames = servers && servers.length > 0 ? servers : await this.listServers();
-    const healthMap = await this.getServerHealth();
-    const healthyServers = serverNames.filter((name) => {
-      const health = healthMap[name];
-      return health && HealthStatusHelpers.isHealthy(health.status);
-    });
+    const healthyServers = await this.#getHealthyServers(servers);
     const results = await Promise.allSettled(
       healthyServers.map(async (serverName) => ({
         serverName,
         tools: await this.#getToolsByServer(serverName)
       }))
     );
-    const agentTools = [];
-    for (const result of results) {
-      if (result.status === "fulfilled") {
-        const { serverName, tools } = result.value;
-        for (const toolSchema of tools) {
-          const func = this.#functionBuilder.createFunctionFromSchema(
-            toolSchema,
-            serverName
-          );
-          agentTools.push(func);
-        }
-      } else {
-        console.warn(`Failed to get tools for server:`, result.reason);
-      }
-    }
+    const agentTools = results.filter((result) => result.status === "fulfilled").flatMap((result) => {
+      const { serverName, tools } = result.value;
+      return tools.map(
+        (toolSchema) => this.#functionBuilder.createFunctionFromSchema(
+          toolSchema,
+          serverName
+        )
+      );
+    });
     return agentTools;
   }
   async getAgentTools(options = {}) {