@mozilla-ai/mcpd 0.1.3 → 0.1.4

package/dist/index.mjs

@@ -1,1735 +1,1813 @@
 import { LRUCache } from "lru-cache";
 import { z } from "zod";
-const PIPELINE_FLOW_REQUEST = "request";
-const PIPELINE_FLOW_RESPONSE = "response";
-class McpdError extends Error {
-  constructor(message, cause) {
-    super(message);
-    this.name = "McpdError";
-    this.cause = cause;
-    Error.captureStackTrace(this, this.constructor);
-  }
-}
-class ConnectionError extends McpdError {
-  constructor(message, cause) {
-    super(message, cause);
-    this.name = "ConnectionError";
-    Error.captureStackTrace(this, this.constructor);
-  }
-}
-class AuthenticationError extends McpdError {
-  constructor(message, cause) {
-    super(message, cause);
-    this.name = "AuthenticationError";
-    Error.captureStackTrace(this, this.constructor);
-  }
-}
-class ServerNotFoundError extends McpdError {
-  serverName;
-  constructor(message, serverName, cause) {
-    super(message, cause);
-    this.name = "ServerNotFoundError";
-    this.serverName = serverName;
-    Error.captureStackTrace(this, this.constructor);
-  }
-}
-class ServerUnhealthyError extends McpdError {
-  serverName;
-  healthStatus;
-  constructor(message, serverName, healthStatus, cause) {
-    super(message, cause);
-    this.name = "ServerUnhealthyError";
-    this.serverName = serverName;
-    this.healthStatus = healthStatus;
-    Error.captureStackTrace(this, this.constructor);
-  }
-}
-class ToolNotFoundError extends McpdError {
-  serverName;
-  toolName;
-  constructor(message, serverName, toolName, cause) {
-    super(message, cause);
-    this.name = "ToolNotFoundError";
-    this.serverName = serverName;
-    this.toolName = toolName;
-    Error.captureStackTrace(this, this.constructor);
-  }
-}
-class ToolExecutionError extends McpdError {
-  serverName;
-  toolName;
-  errorModel;
-  constructor(message, serverName, toolName, errorModel, cause) {
-    super(message, cause);
-    this.name = "ToolExecutionError";
-    this.serverName = serverName;
-    this.toolName = toolName;
-    this.errorModel = errorModel;
-    Error.captureStackTrace(this, this.constructor);
-  }
-}
-class ValidationError extends McpdError {
-  validationErrors;
-  constructor(message, validationErrors, cause) {
-    super(message, cause);
-    this.name = "ValidationError";
-    this.validationErrors = validationErrors || [];
-    Error.captureStackTrace(this, this.constructor);
-  }
-}
-class TimeoutError extends McpdError {
-  operation;
-  timeout;
-  constructor(message, operation, timeout, cause) {
-    super(message, cause);
-    this.name = "TimeoutError";
-    this.operation = operation;
-    this.timeout = timeout;
-    Error.captureStackTrace(this, this.constructor);
-  }
-}
-class PipelineError extends McpdError {
-  serverName;
-  operation;
-  pipelineFlow;
-  constructor(message, serverName, operation, pipelineFlow, cause) {
-    super(message, cause);
-    this.name = "PipelineError";
-    this.serverName = serverName;
-    this.operation = operation;
-    this.pipelineFlow = pipelineFlow;
-    Error.captureStackTrace(this, this.constructor);
-  }
-}
-var HealthStatus = /* @__PURE__ */ ((HealthStatus2) => {
-  HealthStatus2["OK"] = "ok";
-  HealthStatus2["TIMEOUT"] = "timeout";
-  HealthStatus2["UNREACHABLE"] = "unreachable";
-  HealthStatus2["UNKNOWN"] = "unknown";
-  return HealthStatus2;
-})(HealthStatus || {});
-const HealthStatusHelpers = {
-  /**
-   * Check if the given health status is a transient error state.
-   */
-  isTransient(status) {
-    return status === "timeout" || status === "unknown";
-  },
-  /**
-   * Check if the given status string represents a healthy state.
-   */
-  isHealthy(status) {
-    return status === "ok";
-  }
+//#region src/errors.ts
+/**
+* Pipeline flow constant for request processing failures.
+*/
+var PIPELINE_FLOW_REQUEST = "request";
+/**
+* Pipeline flow constant for response processing failures.
+*/
+var PIPELINE_FLOW_RESPONSE = "response";
+/**
+* Base exception for all mcpd SDK errors.
+*
+* This exception wraps all errors that occur during interaction with the mcpd daemon,
+* including network failures, authentication errors, server errors, and tool execution
+* failures. The original exception is preserved via the cause property for debugging.
+*/
+var McpdError = class extends Error {
+	constructor(message, cause) {
+		super(message);
+		this.name = "McpdError";
+		this.cause = cause;
+		Error.captureStackTrace(this, this.constructor);
+	}
+};
+/**
+* Raised when unable to connect to the mcpd daemon.
+*
+* This typically indicates that:
+* - The mcpd daemon is not running
+* - The endpoint URL is incorrect
+* - Network connectivity issues
+* - Firewall blocking the connection
+*/
+var ConnectionError = class extends McpdError {
+	constructor(message, cause) {
+		super(message, cause);
+		this.name = "ConnectionError";
+		Error.captureStackTrace(this, this.constructor);
+	}
+};
+/**
+* Raised when authentication with the mcpd daemon fails.
+*
+* This indicates that:
+* - The API key is invalid or expired
+* - The API key is missing but required
+* - The authentication method is not supported
+*/
+var AuthenticationError = class extends McpdError {
+	constructor(message, cause) {
+		super(message, cause);
+		this.name = "AuthenticationError";
+		Error.captureStackTrace(this, this.constructor);
+	}
+};
+/**
+* Raised when a specified MCP server doesn't exist.
+*
+* This error occurs when trying to access a server that:
+* - Is not configured in the mcpd daemon
+* - Has been removed or renamed
+* - Is temporarily unavailable
+*/
+var ServerNotFoundError = class extends McpdError {
+	serverName;
+	constructor(message, serverName, cause) {
+		super(message, cause);
+		this.name = "ServerNotFoundError";
+		this.serverName = serverName;
+		Error.captureStackTrace(this, this.constructor);
+	}
+};
+/**
+* Raised when a specified MCP server is not healthy.
+*
+* This indicates that the server exists but is currently unhealthy:
+* - The server is down or unreachable
+* - Timeout occurred while checking health
+* - No health data is available for the server
+*/
+var ServerUnhealthyError = class extends McpdError {
+	serverName;
+	healthStatus;
+	constructor(message, serverName, healthStatus, cause) {
+		super(message, cause);
+		this.name = "ServerUnhealthyError";
+		this.serverName = serverName;
+		this.healthStatus = healthStatus;
+		Error.captureStackTrace(this, this.constructor);
+	}
+};
+/**
+* Raised when a specified tool doesn't exist on a server.
+*
+* This error occurs when trying to call a tool that:
+* - Doesn't exist on the specified server
+* - Has been removed or renamed
+* - Is temporarily unavailable
+*/
+var ToolNotFoundError = class extends McpdError {
+	serverName;
+	toolName;
+	constructor(message, serverName, toolName, cause) {
+		super(message, cause);
+		this.name = "ToolNotFoundError";
+		this.serverName = serverName;
+		this.toolName = toolName;
+		Error.captureStackTrace(this, this.constructor);
+	}
+};
+/**
+* Raised when a tool execution fails on the server side.
+*
+* This indicates that the tool was found and called, but failed during execution:
+* - Invalid parameters provided
+* - Server-side error during tool execution
+* - Tool returned an error response
+* - Timeout during tool execution
+*/
+var ToolExecutionError = class extends McpdError {
+	serverName;
+	toolName;
+	errorModel;
+	constructor(message, serverName, toolName, errorModel, cause) {
+		super(message, cause);
+		this.name = "ToolExecutionError";
+		this.serverName = serverName;
+		this.toolName = toolName;
+		this.errorModel = errorModel;
+		Error.captureStackTrace(this, this.constructor);
+	}
+};
+/**
+* Raised when input validation fails.
+*
+* This occurs when:
+* - Required parameters are missing
+* - Parameter types don't match the schema
+* - Parameter values don't meet constraints
+*/
+var ValidationError = class extends McpdError {
+	validationErrors;
+	constructor(message, validationErrors, cause) {
+		super(message, cause);
+		this.name = "ValidationError";
+		this.validationErrors = validationErrors || [];
+		Error.captureStackTrace(this, this.constructor);
+	}
 };
+/**
+* Raised when an operation times out.
+*
+* This can occur during:
+* - Long-running tool executions
+* - Slow network connections
+* - Unresponsive mcpd daemon
+*/
+var TimeoutError = class extends McpdError {
+	operation;
+	timeout;
+	constructor(message, operation, timeout, cause) {
+		super(message, cause);
+		this.name = "TimeoutError";
+		this.operation = operation;
+		this.timeout = timeout;
+		Error.captureStackTrace(this, this.constructor);
+	}
+};
+/**
+* Raised when required pipeline processing fails.
+*
+* This indicates that required processing failed in the mcpd pipeline.
+* The error occurs when a required plugin (such as authentication, validation,
+* audit logging, monitoring, or response transformation) fails during request
+* or response processing.
+*
+* Pipeline Flow Distinction:
+* - **response-pipeline-failure**: The upstream request was processed (the tool
+*   was called), but results cannot be returned due to a required response
+*   processing step failure. Note: This does not indicate whether the tool
+*   itself succeeded or failed - only that the response cannot be delivered.
+*
+* - **request-pipeline-failure**: The request was rejected before reaching the
+*   upstream server due to a required request processing step failure (such as
+*   authentication, authorization, validation, or rate limiting plugin failure).
+*
+* This typically indicates a problem with a plugin or an external system
+* that a plugin depends on (e.g., audit service, authentication provider).
+* Retrying is unlikely to help as this usually indicates a configuration
+* or dependency problem rather than a transient failure.
+*
+* @example
+* ```typescript
+* import { McpdClient, PipelineError } from '@mozilla-ai/mcpd';
+*
+* const client = new McpdClient({ apiEndpoint: 'http://localhost:8090' });
+*
+* try {
+*   const result = await client.servers.time.tools.get_current_time();
+* } catch (error) {
+*   if (error instanceof PipelineError) {
+*     console.log(`Pipeline failure: ${error.message}`);
+*     console.log(`Flow: ${error.pipelineFlow}`);
+*
+*     if (error.pipelineFlow === 'response') {
+*       console.log('Tool was called but results cannot be delivered');
+*     } else {
+*       console.log('Request was rejected by pipeline');
+*       console.log('Check authentication, authorization, or rate limiting');
+*     }
+*   }
+* }
+* ```
+*
+* @remarks
+* This exception indicates a problem with a plugin or its dependencies, not
+* with your request or the tool itself.
+*/
+var PipelineError = class extends McpdError {
+	serverName;
+	operation;
+	pipelineFlow;
+	constructor(message, serverName, operation, pipelineFlow, cause) {
+		super(message, cause);
+		this.name = "PipelineError";
+		this.serverName = serverName;
+		this.operation = operation;
+		this.pipelineFlow = pipelineFlow;
+		Error.captureStackTrace(this, this.constructor);
+	}
+};
+//#endregion
+//#region src/types.ts
+/**
+* Enumeration of possible MCP server health statuses.
+*/
+var HealthStatus = /* @__PURE__ */ function(HealthStatus) {
+	HealthStatus["OK"] = "ok";
+	HealthStatus["TIMEOUT"] = "timeout";
+	HealthStatus["UNREACHABLE"] = "unreachable";
+	HealthStatus["UNKNOWN"] = "unknown";
+	return HealthStatus;
+}({});
+/**
+* Helper functions for HealthStatus.
+*/
+var HealthStatusHelpers = {
+	/**
+	* Check if the given health status is a transient error state.
+	*/
+	isTransient(status) {
+		return status === "timeout" || status === "unknown";
+	},
+	/**
+	* Check if the given status string represents a healthy state.
+	*/
+	isHealthy(status) {
+		return status === "ok";
+	}
+};
+//#endregion
+//#region src/utils/cache.ts
+/**
+* Cache utilities for the mcpd SDK.
+*/
+/**
+* Creates a new LRU cache with TTL support.
+*
+* @param options - Cache configuration options
+* @returns A configured LRU cache instance
+*/
 function createCache(options = {}) {
-  return new LRUCache({
-    max: options.max ?? 100,
-    ttl: options.ttl ?? 1e4,
-    // Default 10 seconds
-    updateAgeOnGet: false,
-    updateAgeOnHas: false
-  });
-}
-class ServersNamespace {
-  #performCall;
-  #getTools;
-  #generatePrompt;
-  #getPrompts;
-  #getResources;
-  #getResourceTemplates;
-  #readResource;
-  /**
-   * Initialize the ServersNamespace with injected functions.
-   *
-   * @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,
-    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,
-          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, 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
-    );
-  }
-  /**
-   * Get all tools available on this server.
-   *
-   * @returns Array of tool schemas
-   * @throws {ServerNotFoundError} If the server doesn't exist
-   * @throws {ServerUnhealthyError} If the server is unhealthy
-   *
-   * @example
-   * ```typescript
-   * const tools = await client.servers.time.getTools();
-   * for (const tool of tools) {
-   *   console.log(`${tool.name}: ${tool.description}`);
-   * }
-   * ```
-   */
-  async getTools() {
-    return this.#getTools(this.#serverName);
-  }
-  /**
-   * Check if a tool exists on this 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 (including on errors)
-   *
-   * @example
-   * ```typescript
-   * if (await client.servers.time.hasTool('get_current_time')) {
-   *   const result = await client.servers.time.callTool('get_current_time', { timezone: 'UTC' });
-   * }
-   * ```
-   */
-  async hasTool(toolName) {
-    try {
-      const tools = await this.#getTools(this.#serverName);
-      return tools.some((t) => t.name === toolName);
-    } catch {
-      return false;
-    }
-  }
-  /**
-   * Call a tool by name with the given arguments.
-   *
-   * This method is useful for programmatic tool invocation when the tool name
-   * is in a variable. The tool name must match exactly as returned by the server.
-   *
-   * @param toolName - The exact name of the tool to call
-   * @param args - The arguments to pass to the tool
-   * @returns The tool's response
-   * @throws {ToolNotFoundError} If the tool doesn't exist on the server
-   *
-   * @example
-   * ```typescript
-   * // Call with explicit method (useful for dynamic tool names):
-   * const toolName = 'get_current_time';
-   * await client.servers.time.callTool(toolName, { timezone: 'UTC' });
-   *
-   * // Or with dynamic server name:
-   * const serverName = 'time';
-   * await client.servers[serverName].callTool(toolName, { timezone: 'UTC' });
-   * ```
-   */
-  async callTool(toolName, args) {
-    const tools = await this.#getTools(this.#serverName);
-    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}.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;
-  #getTools;
-  #serverName;
-  /**
-   * Initialize a ToolsNamespace for a specific server.
-   *
-   * @param performCall - Function to execute tool calls
-   * @param getTools - Function to get tool schemas
-   * @param serverName - The name of the MCP server
-   */
-  constructor(performCall, getTools, serverName) {
-    this.#performCall = performCall;
-    this.#getTools = getTools;
-    this.#serverName = serverName;
-    return new Proxy(this, {
-      get: (target, prop) => {
-        if (typeof prop !== "string") {
-          return void 0;
-        }
-        return async (args) => {
-          const toolName = prop;
-          const tools = await target.#getTools(target.#serverName);
-          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}.getTools() to see available tools.`,
-              target.#serverName,
-              toolName
-            );
-          }
-          return target.#performCall(target.#serverName, toolName, args);
-        };
-      }
-    });
-  }
-}
-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.
-   *
-   * Maps JSON Schema types to their JavaScript equivalents:
-   * - "string" → "string"
-   * - "integer" → "number"
-   * - "number" → "number"
-   * - "boolean" → "boolean"
-   * - "array" → "array"
-   * - "object" → "object"
-   * - "null" → "null"
-   * - unknown types → "any"
-   */
-  static jsonTypeToJavaScriptType(jsonType, schemaDef) {
-    switch (jsonType) {
-      case "string":
-        if (schemaDef.enum && Array.isArray(schemaDef.enum)) {
-          return "string";
-        }
-        return "string";
-      case "number":
-      case "integer":
-        return "number";
-      case "boolean":
-        return "boolean";
-      case "array":
-        return "array";
-      case "object":
-        return "object";
-      case "null":
-        return "null";
-      default:
-        return "any";
-    }
-  }
-  /**
-   * Parse a schema definition and return the appropriate JavaScript type name.
-   */
-  static parseSchemaType(schemaDef) {
-    if (schemaDef.anyOf && Array.isArray(schemaDef.anyOf)) {
-      const firstType = schemaDef.anyOf[0];
-      if (firstType && typeof firstType === "object" && firstType.type) {
-        return this.jsonTypeToJavaScriptType(firstType.type, firstType);
-      }
-      return "any";
-    }
-    if (schemaDef.type) {
-      return this.jsonTypeToJavaScriptType(schemaDef.type, schemaDef);
-    }
-    return "any";
-  }
-  /**
-   * Get a human-readable description of the expected type.
-   */
-  static getTypeDescription(schemaDef) {
-    const baseType = this.parseSchemaType(schemaDef);
-    if (schemaDef.enum && Array.isArray(schemaDef.enum)) {
-      return `one of: ${schemaDef.enum.map((v) => JSON.stringify(v)).join(", ")}`;
-    }
-    if (schemaDef.type === "array" && schemaDef.items) {
-      const itemType = this.parseSchemaType(schemaDef.items);
-      return `array of ${itemType}`;
-    }
-    return baseType;
-  }
-  /**
-   * Validate a value against a JSON schema type.
-   * Returns true if valid, false otherwise.
-   */
-  static validateValue(value, schemaDef) {
-    if (value === null || value === void 0) {
-      return schemaDef.type === "null" || (schemaDef.anyOf?.some((s) => s.type === "null") ?? false);
-    }
-    if (schemaDef.enum && Array.isArray(schemaDef.enum)) {
-      return schemaDef.enum.includes(value);
-    }
-    if (schemaDef.anyOf && Array.isArray(schemaDef.anyOf)) {
-      return schemaDef.anyOf.some(
-        (subSchema) => this.validateValue(value, subSchema)
-      );
-    }
-    if (!schemaDef.type) {
-      return true;
-    }
-    switch (schemaDef.type) {
-      case "string":
-        return typeof value === "string";
-      case "number":
-        return typeof value === "number" && isFinite(value);
-      case "integer":
-        return typeof value === "number" && Number.isInteger(value);
-      case "boolean":
-        return typeof value === "boolean";
-      case "array":
-        if (!Array.isArray(value)) return false;
-        if (schemaDef.items) {
-          return value.every(
-            (item) => this.validateValue(item, schemaDef.items)
-          );
-        }
-        return true;
-      case "object":
-        return typeof value === "object" && value !== null && !Array.isArray(value);
-      case "null":
-        return value === null;
-      default:
-        return true;
-    }
-  }
+	return new LRUCache({
+		max: options.max ?? 100,
+		ttl: options.ttl ?? 1e4,
+		updateAgeOnGet: false,
+		updateAgeOnHas: false
+	});
 }
-class FunctionBuilder {
-  #performCall;
-  #functionCache = /* @__PURE__ */ new Map();
-  /**
-   * Initialize a FunctionBuilder with an injected function.
-   *
-   * @param performCall - Function to execute tool calls
-   */
-  constructor(performCall) {
-    this.#performCall = performCall;
-  }
-  /**
-   * Convert JSON schema to Zod schema.
-   */
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  #jsonSchemaToZod(jsonSchema) {
-    if (!jsonSchema || typeof jsonSchema !== "object") {
-      return z.object({});
-    }
-    switch (jsonSchema.type) {
-      case "string":
-        return z.string();
-      case "number":
-        return z.number();
-      case "integer":
-        return z.number().int();
-      case "boolean":
-        return z.boolean();
-      case "array":
-        return z.array(
-          jsonSchema.items ? this.#jsonSchemaToZod(jsonSchema.items) : z.any()
-        );
-      case "object":
-        if (jsonSchema.properties) {
-          const propertyKeys = Object.keys(jsonSchema.properties);
-          if (propertyKeys.length > 0) {
-            const shape = {};
-            const required = new Set(jsonSchema.required || []);
-            for (const [key, value] of Object.entries(jsonSchema.properties)) {
-              let schema = this.#jsonSchemaToZod(value);
-              if (!required.has(key)) {
-                schema = schema.nullable().optional();
-              }
-              shape[key] = schema;
-            }
-            return z.object(shape);
-          }
-        }
-        return z.object({});
-      default:
-        if (jsonSchema.properties) {
-          const propertyKeys = Object.keys(jsonSchema.properties);
-          if (propertyKeys.length > 0) {
-            const shape = {};
-            const required = new Set(jsonSchema.required || []);
-            for (const [key, value] of Object.entries(jsonSchema.properties)) {
-              let schema = this.#jsonSchemaToZod(value);
-              if (!required.has(key)) {
-                schema = schema.nullable().optional();
-              }
-              shape[key] = schema;
-            }
-            return z.object(shape);
-          }
-        }
-        return z.object({});
-    }
-  }
-  /**
-   * Convert a string into a safe JavaScript identifier.
-   *
-   * This method sanitizes arbitrary strings (like server names or tool names) to create
-   * valid JavaScript identifiers that can be used as function names.
-   * It replaces non-word characters and handles edge cases like leading digits.
-   *
-   * @param name - The string to convert into a safe identifier
-   * @returns A string that is a valid JavaScript identifier
-   */
-  safeName(name) {
-    return name.replace(/\W|^(?=\d)/g, "_");
-  }
-  /**
-   * Generate a unique function name from server and tool names.
-   *
-   * This method creates a qualified function name by combining the server name
-   * and tool name with a double underscore separator. Both names are sanitized
-   * using safeName() to ensure the result is a valid JavaScript identifier.
-   *
-   * @param serverName - The name of the MCP server hosting the tool
-   * @param schemaName - The name of the tool from the schema definition
-   * @returns A qualified function name in the format "{safe_server}__{safe_tool}"
-   */
-  functionName(serverName, schemaName) {
-    return `${this.safeName(serverName)}__${this.safeName(schemaName)}`;
-  }
-  /**
-   * Create a callable JavaScript function from an MCP tool's JSON Schema definition.
-   *
-   * This method generates a self-contained, callable function that validates parameters
-   * and executes the corresponding MCP tool. The function includes proper parameter
-   * validation and comprehensive metadata based on the tool's JSON Schema.
-   *
-   * Generated functions are cached for performance. If a function for the same
-   * server/tool combination already exists in the cache, it returns the cached function.
-   *
-   * @param schema - The MCP tool's JSON Schema definition
-   * @param serverName - The name of the MCP server hosting this tool
-   * @returns A callable JavaScript function with metadata
-   */
-  createFunctionFromSchema(schema, serverName) {
-    const cacheKey = `${serverName}__${schema.name}`;
-    if (this.#functionCache.has(cacheKey)) {
-      return this.#functionCache.get(cacheKey);
-    }
-    try {
-      const generatedFunction = this.buildFunction(schema, serverName);
-      this.#functionCache.set(cacheKey, generatedFunction);
-      return generatedFunction;
-    } catch (error) {
-      throw new McpdError(
-        `Error creating function ${cacheKey}: ${error.message}`,
-        error
-      );
-    }
-  }
-  /**
-   * Build the actual function from the schema.
-   *
-   * @param schema - The tool schema
-   * @param serverName - The server name
-   * @returns The generated function with metadata
-   */
-  buildFunction(schema, serverName) {
-    const inputSchema = schema.inputSchema || {};
-    const properties = inputSchema.properties || {};
-    const required = new Set(inputSchema.required || []);
-    const implementation = async (...args) => {
-      let params = {};
-      if (args.length === 1 && typeof args[0] === "object" && args[0] !== null && !Array.isArray(args[0])) {
-        params = args[0];
-      } else {
-        const propertyNames = Object.keys(properties);
-        for (let i = 0; i < args.length && i < propertyNames.length; i++) {
-          const propertyName = propertyNames[i];
-          if (propertyName) {
-            params[propertyName] = args[i];
-          }
-        }
-      }
-      const missingParams = [];
-      for (const paramName of required) {
-        if (!(paramName in params) || params[paramName] === null || params[paramName] === void 0) {
-          missingParams.push(paramName);
-        }
-      }
-      if (missingParams.length > 0) {
-        throw new ValidationError(
-          `Missing required parameters: ${missingParams.join(", ")}`,
-          missingParams
-        );
-      }
-      const validationErrors = [];
-      for (const [paramName, paramValue] of Object.entries(params)) {
-        const paramSchema = properties[paramName];
-        if (paramValue !== null && paramValue !== void 0 && paramSchema) {
-          if (!TypeConverter.validateValue(paramValue, paramSchema)) {
-            const expectedType = TypeConverter.getTypeDescription(paramSchema);
-            validationErrors.push(
-              `Parameter '${paramName}' should be ${expectedType}, got ${typeof paramValue}`
-            );
-          }
-        }
-      }
-      if (validationErrors.length > 0) {
-        throw new ValidationError(
-          `Parameter validation failed: ${validationErrors.join("; ")}`,
-          validationErrors
-        );
-      }
-      const cleanParams = {};
-      for (const [key, value] of Object.entries(params)) {
-        if (value !== null && value !== void 0) {
-          cleanParams[key] = value;
-        }
-      }
-      return this.#performCall(serverName, schema.name, cleanParams);
-    };
-    const invoke = async (args) => {
-      return implementation(args);
-    };
-    const execute = async (args) => {
-      return implementation(args);
-    };
-    const zodSchema = this.#jsonSchemaToZod(inputSchema);
-    const qualifiedName = this.functionName(serverName, schema.name);
-    const docstring = this.createDocstring(schema);
-    const agentFunction = implementation;
-    Object.defineProperty(agentFunction, "name", {
-      value: qualifiedName,
-      writable: false,
-      enumerable: true,
-      configurable: true
-    });
-    agentFunction.description = schema.description || docstring.split("\n")[0] || "No description provided";
-    agentFunction.schema = zodSchema;
-    agentFunction.invoke = invoke;
-    agentFunction.lc_namespace = ["mcpd", "tools"];
-    agentFunction.returnDirect = false;
-    agentFunction.inputSchema = zodSchema;
-    agentFunction.execute = execute;
-    agentFunction._schema = schema;
-    agentFunction._serverName = serverName;
-    agentFunction._toolName = schema.name;
-    return agentFunction;
-  }
-  /**
-   * Generate a comprehensive docstring for the dynamically created function.
-   *
-   * This method builds a properly formatted docstring that includes the
-   * tool's description, parameter documentation with optional/required status,
-   * return value information, and exception documentation.
-   *
-   * @param schema - The MCP tool's JSON Schema definition
-   * @returns A multi-line string containing the complete docstring text
-   */
-  createDocstring(schema) {
-    const description = schema.description || "No description provided";
-    const inputSchema = schema.inputSchema || {};
-    const properties = inputSchema.properties || {};
-    const required = new Set(inputSchema.required || []);
-    const docstringParts = [description];
-    if (Object.keys(properties).length > 0) {
-      docstringParts.push("");
-      docstringParts.push("Parameters:");
-      for (const [paramName, paramInfo] of Object.entries(properties)) {
-        const isRequired = required.has(paramName);
-        const paramDesc = paramInfo.description || "No description provided";
-        const paramType = TypeConverter.getTypeDescription(paramInfo);
-        const requiredText = isRequired ? "" : " (optional)";
-        docstringParts.push(
-          `  ${paramName} (${paramType}): ${paramDesc}${requiredText}`
-        );
-      }
-    }
-    docstringParts.push("");
-    docstringParts.push("Returns:");
-    docstringParts.push("  Promise<any>: Function execution result");
-    docstringParts.push("");
-    docstringParts.push("Throws:");
-    docstringParts.push(
-      "  ValidationError: If required parameters are missing or invalid"
-    );
-    docstringParts.push("  McpdError: If the API call fails");
-    return docstringParts.join("\n");
-  }
-  /**
-   * Clear the function cache.
-   *
-   * This method clears all cached generated functions, forcing them to be
-   * regenerated on the next call to createFunctionFromSchema().
-   */
-  clearCache() {
-    this.#functionCache.clear();
-  }
-  /**
-   * Get the current cache size.
-   *
-   * @returns The number of functions currently cached
-   */
-  getCacheSize() {
-    return this.#functionCache.size;
-  }
-  /**
-   * Get all cached functions.
-   *
-   * @returns Array of all cached agent functions, or empty array if cache is empty
-   */
-  getCachedFunctions() {
-    return Array.from(this.#functionCache.values());
-  }
-}
-const API_BASE = "/api/v1";
-const SERVERS_BASE = `${API_BASE}/servers`;
-const HEALTH_SERVERS_BASE = `${API_BASE}/health/servers`;
-const API_PATHS = {
-  // Server management
-  SERVERS: SERVERS_BASE,
-  // 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)}`
+//#endregion
+//#region src/dynamicCaller.ts
+/**
+* Dynamic tool invocation for mcpd client.
+*
+* This module provides the ServersNamespace, Server, and ToolsNamespace classes
+* that enable natural JavaScript syntax for calling MCP tools, such as:
+*     client.servers.time.tools.get_current_time(args)
+*
+* The dynamic calling system uses JavaScript's Proxy to create
+* a fluent interface that resolves server and tool names at runtime.
+*
+* Naming convention:
+* - *Namespace classes use Proxy for dynamic property access
+* - Server is a concrete class representing one MCP server
+*/
+/**
+* Namespace for accessing MCP servers via proxy.
+*
+* This class provides the `client.servers.*` namespace, allowing you to access
+* servers and their tools with natural JavaScript syntax.
+*
+* @example
+* ```typescript
+* const client = new McpdClient({ apiEndpoint: 'http://localhost:8090' });
+*
+* // Access tools through the servers namespace
+* const result = await client.servers.time.tools.get_current_time({ timezone: "UTC" });
+*
+* // Check if a tool exists
+* if (await client.servers.time.hasTool("get_current_time")) {
+*   // ...
+* }
+* ```
+*/
+var ServersNamespace = class {
+	#performCall;
+	#getTools;
+	#generatePrompt;
+	#getPrompts;
+	#getResources;
+	#getResourceTemplates;
+	#readResource;
+	/**
+	* Initialize the ServersNamespace with injected functions.
+	*
+	* @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, 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;
+			return new Server(target.#performCall, target.#getTools, target.#generatePrompt, target.#getPrompts, target.#getResources, target.#getResourceTemplates, target.#readResource, serverName);
+		} });
+	}
+};
+/**
+* Represents a specific MCP server, providing access to its tools and operations.
+*
+* This class represents a specific MCP server and provides access to its tools
+* through the `.tools` namespace, as well as server-level operations like listing tools.
+*
+* @example
+* ```typescript
+* // Server is created when you access a server:
+* const timeServer = client.servers.time; // Returns Server(...)
+*
+* // List available tools
+* const tools = await timeServer.getTools();
+*
+* // Call tools through the .tools namespace:
+* await timeServer.tools.get_current_time({ timezone: "UTC" })
+* ```
+*/
+var Server = class {
+	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, 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);
+	}
+	/**
+	* Get all tools available on this server.
+	*
+	* @returns Array of tool schemas
+	* @throws {ServerNotFoundError} If the server doesn't exist
+	* @throws {ServerUnhealthyError} If the server is unhealthy
+	*
+	* @example
+	* ```typescript
+	* const tools = await client.servers.time.getTools();
+	* for (const tool of tools) {
+	*   console.log(`${tool.name}: ${tool.description}`);
+	* }
+	* ```
+	*/
+	async getTools() {
+		return this.#getTools(this.#serverName);
+	}
+	/**
+	* Check if a tool exists on this 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 (including on errors)
+	*
+	* @example
+	* ```typescript
+	* if (await client.servers.time.hasTool('get_current_time')) {
+	*   const result = await client.servers.time.callTool('get_current_time', { timezone: 'UTC' });
+	* }
+	* ```
+	*/
+	async hasTool(toolName) {
+		try {
+			return (await this.#getTools(this.#serverName)).some((t) => t.name === toolName);
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Call a tool by name with the given arguments.
+	*
+	* This method is useful for programmatic tool invocation when the tool name
+	* is in a variable. The tool name must match exactly as returned by the server.
+	*
+	* @param toolName - The exact name of the tool to call
+	* @param args - The arguments to pass to the tool
+	* @returns The tool's response
+	* @throws {ToolNotFoundError} If the tool doesn't exist on the server
+	*
+	* @example
+	* ```typescript
+	* // Call with explicit method (useful for dynamic tool names):
+	* const toolName = 'get_current_time';
+	* await client.servers.time.callTool(toolName, { timezone: 'UTC' });
+	*
+	* // Or with dynamic server name:
+	* const serverName = 'time';
+	* await client.servers[serverName].callTool(toolName, { timezone: 'UTC' });
+	* ```
+	*/
+	async callTool(toolName, args) {
+		if (!(await this.#getTools(this.#serverName)).find((t) => t.name === toolName)) throw new ToolNotFoundError(`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 {
+			return (await this.#getPrompts(this.#serverName)).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) {
+		if (!(await this.#getPrompts(this.#serverName)).find((p) => p.name === promptName)) 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 {
+			return (await this.#getResources(this.#serverName)).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);
+	}
+};
+/**
+* Namespace for accessing tools on a specific MCP server via proxy.
+*
+* This class provides the `.tools` namespace for a server, allowing you to call
+* tools as if they were methods. All tool names must match exactly as returned
+* by the MCP server.
+*
+* NOTE: Use `client.servers.foo.callTool()` and `client.servers.foo.hasTool()`
+* instead of putting them in the `.tools` namespace to avoid collisions with
+* actual tools named "callTool" or "hasTool".
+*
+* @example
+* ```typescript
+* // Call tools via .tools namespace with static names
+* const result = await client.servers.time.tools.get_current_time({ timezone: "UTC" });
+* ```
+*/
+var ToolsNamespace = class {
+	#performCall;
+	#getTools;
+	#serverName;
+	/**
+	* Initialize a ToolsNamespace for a specific server.
+	*
+	* @param performCall - Function to execute tool calls
+	* @param getTools - Function to get tool schemas
+	* @param serverName - The name of the MCP server
+	*/
+	constructor(performCall, getTools, serverName) {
+		this.#performCall = performCall;
+		this.#getTools = getTools;
+		this.#serverName = serverName;
+		return new Proxy(this, { get: (target, prop) => {
+			if (typeof prop !== "string") return;
+			return async (args) => {
+				const toolName = prop;
+				if (!(await target.#getTools(target.#serverName)).find((t) => t.name === toolName)) throw new ToolNotFoundError(`Tool '${toolName}' not found on server '${target.#serverName}'. Use client.servers.${target.#serverName}.getTools() to see available tools.`, target.#serverName, toolName);
+				return target.#performCall(target.#serverName, toolName, args);
+			};
+		} });
+	}
+};
+/**
+* Namespace for accessing prompts on a specific MCP server via proxy.
+*
+* This class provides the `.prompts` namespace for a server, allowing you to generate
+* prompts as if they were methods. All prompt names must match exactly as returned
+* by the MCP server.
+*
+* NOTE: Use `client.servers.foo.generatePrompt()` and `client.servers.foo.hasPrompt()`
+* instead of putting them in the `.prompts` namespace to avoid collisions with
+* actual prompts named "generatePrompt" or "hasPrompt".
+*
+* @example
+* ```typescript
+* // Generate prompts via .prompts namespace with static names
+* const result = await client.servers.github.prompts.create_pr({
+*   title: "Fix bug",
+*   description: "Fixed auth issue"
+* });
+* ```
+*/
+var PromptsNamespace = class {
+	#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;
+			return async (args) => {
+				const promptName = prop;
+				if (!await target.#getPromptByName(promptName)) 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) {
+		return (await this.#getPrompts(this.#serverName)).find((p) => p.name === promptName);
+	}
 };
-const LogLevels = {
-  OFF: "off"
+//#endregion
+//#region src/utils/typeConverter.ts
+/**
+* Maps JSON Schema types to JavaScript/TypeScript types.
+*/
+var TypeConverter = class {
+	/**
+	* Convert JSON schema types to JavaScript type names.
+	*
+	* Maps JSON Schema types to their JavaScript equivalents:
+	* - "string" → "string"
+	* - "integer" → "number"
+	* - "number" → "number"
+	* - "boolean" → "boolean"
+	* - "array" → "array"
+	* - "object" → "object"
+	* - "null" → "null"
+	* - unknown types → "any"
+	*/
+	static jsonTypeToJavaScriptType(jsonType, schemaDef) {
+		switch (jsonType) {
+			case "string":
+				if (schemaDef.enum && Array.isArray(schemaDef.enum)) return "string";
+				return "string";
+			case "number":
+			case "integer": return "number";
+			case "boolean": return "boolean";
+			case "array": return "array";
+			case "object": return "object";
+			case "null": return "null";
+			default: return "any";
+		}
+	}
+	/**
+	* Parse a schema definition and return the appropriate JavaScript type name.
+	*/
+	static parseSchemaType(schemaDef) {
+		if (schemaDef.anyOf && Array.isArray(schemaDef.anyOf)) {
+			const firstType = schemaDef.anyOf[0];
+			if (firstType && typeof firstType === "object" && firstType.type) return this.jsonTypeToJavaScriptType(firstType.type, firstType);
+			return "any";
+		}
+		if (schemaDef.type) return this.jsonTypeToJavaScriptType(schemaDef.type, schemaDef);
+		return "any";
+	}
+	/**
+	* Get a human-readable description of the expected type.
+	*/
+	static getTypeDescription(schemaDef) {
+		const baseType = this.parseSchemaType(schemaDef);
+		if (schemaDef.enum && Array.isArray(schemaDef.enum)) return `one of: ${schemaDef.enum.map((v) => JSON.stringify(v)).join(", ")}`;
+		if (schemaDef.type === "array" && schemaDef.items) return `array of ${this.parseSchemaType(schemaDef.items)}`;
+		return baseType;
+	}
+	/**
+	* Validate a value against a JSON schema type.
+	* Returns true if valid, false otherwise.
+	*/
+	static validateValue(value, schemaDef) {
+		if (value === null || value === void 0) return schemaDef.type === "null" || (schemaDef.anyOf?.some((s) => s.type === "null") ?? false);
+		if (schemaDef.enum && Array.isArray(schemaDef.enum)) return schemaDef.enum.includes(value);
+		if (schemaDef.anyOf && Array.isArray(schemaDef.anyOf)) return schemaDef.anyOf.some((subSchema) => this.validateValue(value, subSchema));
+		if (!schemaDef.type) return true;
+		switch (schemaDef.type) {
+			case "string": return typeof value === "string";
+			case "number": return typeof value === "number" && isFinite(value);
+			case "integer": return typeof value === "number" && Number.isInteger(value);
+			case "boolean": return typeof value === "boolean";
+			case "array":
+				if (!Array.isArray(value)) return false;
+				if (schemaDef.items) return value.every((item) => this.validateValue(item, schemaDef.items));
+				return true;
+			case "object": return typeof value === "object" && value !== null && !Array.isArray(value);
+			case "null": return value === null;
+			default: return true;
+		}
+	}
 };
-const ranks = {
-  trace: 5,
-  debug: 10,
-  info: 20,
-  warn: 30,
-  error: 40,
-  off: 1e3
+//#endregion
+//#region src/functionBuilder.ts
+/**
+* Function generation from MCP tool schemas.
+*
+* This module provides the FunctionBuilder class that dynamically generates
+* callable JavaScript functions from MCP tool JSON Schema definitions. These
+* functions can be used with AI agent frameworks and include proper parameter
+* validation and comprehensive metadata.
+*
+* The generated functions are self-contained and cached for performance.
+*/
+/**
+* Builds callable JavaScript functions from MCP tool JSON schemas.
+*
+* This class generates self-contained functions that can be used with AI agent
+* frameworks. The generated functions include parameter validation and
+* comprehensive metadata based on the tool's JSON Schema definition.
+*
+* The generated functions are cached for performance, with cache invalidation
+* controlled by the owning McpdClient via clearCache().
+*/
+var FunctionBuilder = class {
+	#performCall;
+	#functionCache = /* @__PURE__ */ new Map();
+	/**
+	* Initialize a FunctionBuilder with an injected function.
+	*
+	* @param performCall - Function to execute tool calls
+	*/
+	constructor(performCall) {
+		this.#performCall = performCall;
+	}
+	/**
+	* Convert JSON schema to Zod schema.
+	*/
+	#jsonSchemaToZod(jsonSchema) {
+		if (!jsonSchema || typeof jsonSchema !== "object") return z.object({});
+		switch (jsonSchema.type) {
+			case "string": return z.string();
+			case "number": return z.number();
+			case "integer": return z.number().int();
+			case "boolean": return z.boolean();
+			case "array": return z.array(jsonSchema.items ? this.#jsonSchemaToZod(jsonSchema.items) : z.any());
+			case "object":
+				if (jsonSchema.properties) {
+					if (Object.keys(jsonSchema.properties).length > 0) {
+						const shape = {};
+						const required = new Set(jsonSchema.required || []);
+						for (const [key, value] of Object.entries(jsonSchema.properties)) {
+							let schema = this.#jsonSchemaToZod(value);
+							if (!required.has(key)) schema = schema.nullable().optional();
+							shape[key] = schema;
+						}
+						return z.object(shape);
+					}
+				}
+				return z.object({});
+			default:
+				if (jsonSchema.properties) {
+					if (Object.keys(jsonSchema.properties).length > 0) {
+						const shape = {};
+						const required = new Set(jsonSchema.required || []);
+						for (const [key, value] of Object.entries(jsonSchema.properties)) {
+							let schema = this.#jsonSchemaToZod(value);
+							if (!required.has(key)) schema = schema.nullable().optional();
+							shape[key] = schema;
+						}
+						return z.object(shape);
+					}
+				}
+				return z.object({});
+		}
+	}
+	/**
+	* Convert a string into a safe JavaScript identifier.
+	*
+	* This method sanitizes arbitrary strings (like server names or tool names) to create
+	* valid JavaScript identifiers that can be used as function names.
+	* It replaces non-word characters and handles edge cases like leading digits.
+	*
+	* @param name - The string to convert into a safe identifier
+	* @returns A string that is a valid JavaScript identifier
+	*/
+	safeName(name) {
+		return name.replace(/\W|^(?=\d)/g, "_");
+	}
+	/**
+	* Generate a unique function name from server and tool names.
+	*
+	* This method creates a qualified function name by combining the server name
+	* and tool name with a double underscore separator. Both names are sanitized
+	* using safeName() to ensure the result is a valid JavaScript identifier.
+	*
+	* @param serverName - The name of the MCP server hosting the tool
+	* @param schemaName - The name of the tool from the schema definition
+	* @returns A qualified function name in the format "{safe_server}__{safe_tool}"
+	*/
+	functionName(serverName, schemaName) {
+		return `${this.safeName(serverName)}__${this.safeName(schemaName)}`;
+	}
+	/**
+	* Create a callable JavaScript function from an MCP tool's JSON Schema definition.
+	*
+	* This method generates a self-contained, callable function that validates parameters
+	* and executes the corresponding MCP tool. The function includes proper parameter
+	* validation and comprehensive metadata based on the tool's JSON Schema.
+	*
+	* Generated functions are cached for performance. If a function for the same
+	* server/tool combination already exists in the cache, it returns the cached function.
+	*
+	* @param schema - The MCP tool's JSON Schema definition
+	* @param serverName - The name of the MCP server hosting this tool
+	* @returns A callable JavaScript function with metadata
+	*/
+	createFunctionFromSchema(schema, serverName) {
+		const cacheKey = `${serverName}__${schema.name}`;
+		if (this.#functionCache.has(cacheKey)) return this.#functionCache.get(cacheKey);
+		try {
+			const generatedFunction = this.buildFunction(schema, serverName);
+			this.#functionCache.set(cacheKey, generatedFunction);
+			return generatedFunction;
+		} catch (error) {
+			throw new McpdError(`Error creating function ${cacheKey}: ${error.message}`, error);
+		}
+	}
+	/**
+	* Build the actual function from the schema.
+	*
+	* @param schema - The tool schema
+	* @param serverName - The server name
+	* @returns The generated function with metadata
+	*/
+	buildFunction(schema, serverName) {
+		const inputSchema = schema.inputSchema || {};
+		const properties = inputSchema.properties || {};
+		const required = new Set(inputSchema.required || []);
+		const implementation = async (...args) => {
+			let params = {};
+			if (args.length === 1 && typeof args[0] === "object" && args[0] !== null && !Array.isArray(args[0])) params = args[0];
+			else {
+				const propertyNames = Object.keys(properties);
+				for (let i = 0; i < args.length && i < propertyNames.length; i++) {
+					const propertyName = propertyNames[i];
+					if (propertyName) params[propertyName] = args[i];
+				}
+			}
+			const missingParams = [];
+			for (const paramName of required) if (!(paramName in params) || params[paramName] === null || params[paramName] === void 0) missingParams.push(paramName);
+			if (missingParams.length > 0) throw new ValidationError(`Missing required parameters: ${missingParams.join(", ")}`, missingParams);
+			const validationErrors = [];
+			for (const [paramName, paramValue] of Object.entries(params)) {
+				const paramSchema = properties[paramName];
+				if (paramValue !== null && paramValue !== void 0 && paramSchema) {
+					if (!TypeConverter.validateValue(paramValue, paramSchema)) {
+						const expectedType = TypeConverter.getTypeDescription(paramSchema);
+						validationErrors.push(`Parameter '${paramName}' should be ${expectedType}, got ${typeof paramValue}`);
+					}
+				}
+			}
+			if (validationErrors.length > 0) throw new ValidationError(`Parameter validation failed: ${validationErrors.join("; ")}`, validationErrors);
+			const cleanParams = {};
+			for (const [key, value] of Object.entries(params)) if (value !== null && value !== void 0) cleanParams[key] = value;
+			return this.#performCall(serverName, schema.name, cleanParams);
+		};
+		const invoke = async (args) => {
+			return implementation(args);
+		};
+		const execute = async (args) => {
+			return implementation(args);
+		};
+		const zodSchema = this.#jsonSchemaToZod(inputSchema);
+		const qualifiedName = this.functionName(serverName, schema.name);
+		const docstring = this.createDocstring(schema);
+		const agentFunction = implementation;
+		Object.defineProperty(agentFunction, "name", {
+			value: qualifiedName,
+			writable: false,
+			enumerable: true,
+			configurable: true
+		});
+		agentFunction.description = schema.description || docstring.split("\n")[0] || "No description provided";
+		agentFunction.schema = zodSchema;
+		agentFunction.invoke = invoke;
+		agentFunction.lc_namespace = ["mcpd", "tools"];
+		agentFunction.returnDirect = false;
+		agentFunction.inputSchema = zodSchema;
+		agentFunction.execute = execute;
+		agentFunction._schema = schema;
+		agentFunction._serverName = serverName;
+		agentFunction._toolName = schema.name;
+		return agentFunction;
+	}
+	/**
+	* Generate a comprehensive docstring for the dynamically created function.
+	*
+	* This method builds a properly formatted docstring that includes the
+	* tool's description, parameter documentation with optional/required status,
+	* return value information, and exception documentation.
+	*
+	* @param schema - The MCP tool's JSON Schema definition
+	* @returns A multi-line string containing the complete docstring text
+	*/
+	createDocstring(schema) {
+		const description = schema.description || "No description provided";
+		const inputSchema = schema.inputSchema || {};
+		const properties = inputSchema.properties || {};
+		const required = new Set(inputSchema.required || []);
+		const docstringParts = [description];
+		if (Object.keys(properties).length > 0) {
+			docstringParts.push("");
+			docstringParts.push("Parameters:");
+			for (const [paramName, paramInfo] of Object.entries(properties)) {
+				const isRequired = required.has(paramName);
+				const paramDesc = paramInfo.description || "No description provided";
+				const paramType = TypeConverter.getTypeDescription(paramInfo);
+				const requiredText = isRequired ? "" : " (optional)";
+				docstringParts.push(`  ${paramName} (${paramType}): ${paramDesc}${requiredText}`);
+			}
+		}
+		docstringParts.push("");
+		docstringParts.push("Returns:");
+		docstringParts.push("  Promise<any>: Function execution result");
+		docstringParts.push("");
+		docstringParts.push("Throws:");
+		docstringParts.push("  ValidationError: If required parameters are missing or invalid");
+		docstringParts.push("  McpdError: If the API call fails");
+		return docstringParts.join("\n");
+	}
+	/**
+	* Clear the function cache.
+	*
+	* This method clears all cached generated functions, forcing them to be
+	* regenerated on the next call to createFunctionFromSchema().
+	*/
+	clearCache() {
+		this.#functionCache.clear();
+	}
+	/**
+	* Get the current cache size.
+	*
+	* @returns The number of functions currently cached
+	*/
+	getCacheSize() {
+		return this.#functionCache.size;
+	}
+	/**
+	* Get all cached functions.
+	*
+	* @returns Array of all cached agent functions, or empty array if cache is empty
+	*/
+	getCachedFunctions() {
+		return Array.from(this.#functionCache.values());
+	}
+};
+//#endregion
+//#region src/apiPaths.ts
+/**
+* Centralized API path constants for mcpd daemon endpoints.
+*/
+var API_BASE = "/api/v1";
+var SERVERS_BASE = `${API_BASE}/servers`;
+var HEALTH_SERVERS_BASE = `${API_BASE}/health/servers`;
+var API_PATHS = {
+	SERVERS: SERVERS_BASE,
+	SERVER_TOOLS: (serverName) => `${SERVERS_BASE}/${encodeURIComponent(serverName)}/tools`,
+	TOOL_CALL: (serverName, toolName) => `${SERVERS_BASE}/${encodeURIComponent(serverName)}/tools/${encodeURIComponent(toolName)}`,
+	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)}`,
+	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_ALL: HEALTH_SERVERS_BASE,
+	HEALTH_SERVER: (serverName) => `${HEALTH_SERVERS_BASE}/${encodeURIComponent(serverName)}`
+};
+//#endregion
+//#region src/logger.ts
+/**
+* Internal logging infrastructure for the mcpd SDK.
+*
+* This module provides a logging shim controlled by the MCPD_LOG_LEVEL environment
+* variable.
+*
+* Logging is disabled by default.
+*
+* NOTE: It is recommended that you only enable MCPD_LOG_LEVEL in non-MCP-server contexts.
+* MCP servers using stdio transport for JSON-RPC communication should avoid enabling logging
+* to avoid contaminating stdout/stderr.
+*/
+/**
+* Valid {@link LogLevel} values for MCPD_LOG_LEVEL environment variable.
+*/
+var LogLevels = {
+	TRACE: "trace",
+	DEBUG: "debug",
+	INFO: "info",
+	WARN: "warn",
+	ERROR: "error",
+	OFF: "off"
+};
+var ranks = {
+	trace: 5,
+	debug: 10,
+	info: 20,
+	warn: 30,
+	error: 40,
+	off: 1e3
 };
 function resolve(raw) {
-  const candidate = raw?.toLowerCase();
-  return candidate && candidate in ranks ? candidate : LogLevels.OFF;
+	const candidate = raw?.toLowerCase();
+	return candidate && candidate in ranks ? candidate : LogLevels.OFF;
 }
 function getLevel() {
-  return resolve(
-    typeof process !== "undefined" ? process.env.MCPD_LOG_LEVEL : void 0
-  );
+	return resolve(typeof process !== "undefined" ? process.env.MCPD_LOG_LEVEL : void 0);
 }
 function defaultLogger() {
-  return {
-    trace: (...args) => {
-      const lvl = getLevel();
-      if (lvl !== LogLevels.OFF && ranks[lvl] <= ranks.trace)
-        console.trace(...args);
-    },
-    debug: (...args) => {
-      const lvl = getLevel();
-      if (lvl !== LogLevels.OFF && ranks[lvl] <= ranks.debug)
-        console.debug(...args);
-    },
-    info: (...args) => {
-      const lvl = getLevel();
-      if (lvl !== LogLevels.OFF && ranks[lvl] <= ranks.info)
-        console.info(...args);
-    },
-    warn: (...args) => {
-      const lvl = getLevel();
-      if (lvl !== LogLevels.OFF && ranks[lvl] <= ranks.warn)
-        console.warn(...args);
-    },
-    error: (...args) => {
-      const lvl = getLevel();
-      if (lvl !== LogLevels.OFF && ranks[lvl] <= ranks.error)
-        console.error(...args);
-    }
-  };
+	return {
+		trace: (...args) => {
+			const lvl = getLevel();
+			if (lvl !== LogLevels.OFF && ranks[lvl] <= ranks.trace) console.trace(...args);
+		},
+		debug: (...args) => {
+			const lvl = getLevel();
+			if (lvl !== LogLevels.OFF && ranks[lvl] <= ranks.debug) console.debug(...args);
+		},
+		info: (...args) => {
+			const lvl = getLevel();
+			if (lvl !== LogLevels.OFF && ranks[lvl] <= ranks.info) console.info(...args);
+		},
+		warn: (...args) => {
+			const lvl = getLevel();
+			if (lvl !== LogLevels.OFF && ranks[lvl] <= ranks.warn) console.warn(...args);
+		},
+		error: (...args) => {
+			const lvl = getLevel();
+			if (lvl !== LogLevels.OFF && ranks[lvl] <= ranks.error) console.error(...args);
+		}
+	};
 }
+/**
+* Create a logger, optionally using a custom implementation.
+*
+* This function allows SDK users to inject their own logger implementation.
+* Supports partial implementations - any omitted methods will fall back to the
+* default logger, which respects the MCPD_LOG_LEVEL environment variable.
+*
+* @param impl - Custom Logger implementation or partial implementation.
+*               If not provided, uses default logger controlled by MCPD_LOG_LEVEL.
+*               If partially provided, custom methods are used and omitted methods
+*               fall back to default logger (which respects MCPD_LOG_LEVEL).
+* @returns A Logger instance with all methods implemented.
+*
+* @example
+* ```typescript
+* // Use default logger (controlled by MCPD_LOG_LEVEL).
+* const logger = createLogger();
+*
+* // Partial logger: custom warn/error, default (MCPD_LOG_LEVEL-aware) for others.
+* const logger = createLogger({
+*   warn: (msg) => myCustomLogger.warning(msg),
+*   error: (msg) => myCustomLogger.error(msg),
+*   // trace, debug, info fall back to default logger (respects MCPD_LOG_LEVEL)
+* });
+* ```
+*/
 function createLogger(impl) {
-  const base = defaultLogger();
-  return {
-    trace: impl?.trace ?? base.trace,
-    debug: impl?.debug ?? base.debug,
-    info: impl?.info ?? base.info,
-    warn: impl?.warn ?? base.warn,
-    error: impl?.error ?? base.error
-  };
+	const base = defaultLogger();
+	return {
+		trace: impl?.trace ?? base.trace,
+		debug: impl?.debug ?? base.debug,
+		info: impl?.info ?? base.info,
+		warn: impl?.warn ?? base.warn,
+		error: impl?.error ?? base.error
+	};
 }
-const REQUEST_TIMEOUT_SECONDS = 30;
-const SERVER_HEALTH_CACHE_TTL_SECONDS = 10;
-const SERVER_HEALTH_CACHE_MAXSIZE = 100;
-const TOOL_SEPARATOR = "__";
-const MCPD_ERROR_TYPE_HEADER = "Mcpd-Error-Type";
-const PIPELINE_ERROR_FLOWS = {
-  "request-pipeline-failure": PIPELINE_FLOW_REQUEST,
-  "response-pipeline-failure": PIPELINE_FLOW_RESPONSE
+//#endregion
+//#region src/client.ts
+/**
+* Default timeout for API requests to mcpd, in seconds.
+*/
+var REQUEST_TIMEOUT_SECONDS = 30;
+/**
+* Default TTL for server health cache entries, in seconds.
+*
+* @remarks
+* Used to avoid excessive health check requests while keeping data reasonably fresh.
+*/
+var SERVER_HEALTH_CACHE_TTL_SECONDS = 10;
+/**
+* Maximum number of server health entries to cache.
+* Prevents unbounded memory growth while allowing legitimate large-scale monitoring.
+*/
+var SERVER_HEALTH_CACHE_MAXSIZE = 100;
+/**
+* Separator used between server name and tool name in qualified tool names.
+* Format: `{serverName}{TOOL_SEPARATOR}{toolName}`
+* Example: "time__get_current_time" where "time" is server and "get_current_time" is tool.
+*/
+var TOOL_SEPARATOR = "__";
+/**
+* Header name for mcpd pipeline error type.
+*/
+var MCPD_ERROR_TYPE_HEADER = "Mcpd-Error-Type";
+/**
+* Maps mcpd error type header values to pipeline flows.
+*/
+var PIPELINE_ERROR_FLOWS = {
+	"request-pipeline-failure": PIPELINE_FLOW_REQUEST,
+	"response-pipeline-failure": PIPELINE_FLOW_RESPONSE
 };
-class McpdClient {
-  #endpoint;
-  #apiKey;
-  #timeout;
-  #serverHealthCache;
-  #functionBuilder;
-  #logger;
-  #cacheableExceptions = /* @__PURE__ */ new Set([
-    ServerNotFoundError,
-    ServerUnhealthyError,
-    AuthenticationError
-  ]);
-  /**
-   * Namespace for accessing MCP servers and their tools.
-   */
-  servers;
-  /**
-   * Initialize a new McpdClient instance.
-   *
-   * @param options - Configuration options for the client
-   */
-  constructor(options) {
-    const toMs = (s) => s * 1e3;
-    this.#endpoint = options.apiEndpoint.replace(/\/$/, "");
-    this.#apiKey = options.apiKey;
-    this.#timeout = options.timeout ?? toMs(REQUEST_TIMEOUT_SECONDS);
-    const healthCacheTtlMs = toMs(
-      options.healthCacheTtl ?? SERVER_HEALTH_CACHE_TTL_SECONDS
-    );
-    this.#serverHealthCache = createCache({
-      max: SERVER_HEALTH_CACHE_MAXSIZE,
-      ttl: healthCacheTtlMs
-    });
-    this.#logger = createLogger(options.logger);
-    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));
-  }
-  /**
-   * Make an HTTP request to the mcpd daemon.
-   *
-   * @param path - The API path (e.g., '/servers', '/servers/{server_name}/tools')
-   * @param options - Request options
-   *
-   * @returns The JSON response from the daemon
-   *
-   * @throws {AuthenticationError} If API key was present and authentication fails
-   * @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 #request(path, options = {}) {
-    const url = `${this.#endpoint}${path}`;
-    const headers = {
-      "Content-Type": "application/json",
-      ...options.headers || {}
-    };
-    if (this.#apiKey) {
-      headers["Authorization"] = `Bearer ${this.#apiKey}`;
-    }
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), this.#timeout);
-    try {
-      const response = await fetch(url, {
-        ...options,
-        headers,
-        signal: controller.signal
-      });
-      clearTimeout(timeoutId);
-      if (!response.ok) {
-        const body = await response.text();
-        let errorModel = null;
-        try {
-          errorModel = JSON.parse(body);
-        } catch {
-          errorModel = null;
-        }
-        if (response.status === 500) {
-          const errorType = response.headers.get(MCPD_ERROR_TYPE_HEADER)?.toLowerCase();
-          const flow = errorType ? PIPELINE_ERROR_FLOWS[errorType] : void 0;
-          if (flow) {
-            const message = errorModel?.detail || body || "Pipeline failure";
-            throw new PipelineError(
-              message,
-              void 0,
-              // serverName - enriched by caller if available.
-              void 0,
-              // operation - enriched by caller if available.
-              flow
-            );
-          }
-        }
-        if (errorModel && errorModel.detail) {
-          const errorDetails = errorModel.errors?.map((e) => `${e.location}: ${e.message}`).join("; ");
-          const fullMessage = errorDetails ? `${errorModel.detail} - ${errorDetails}` : errorModel.detail;
-          if (response.status === 401 || response.status === 403) {
-            throw new AuthenticationError(fullMessage);
-          }
-          throw new McpdError(
-            `${errorModel.title || "Request failed"}: ${fullMessage}`
-          );
-        }
-        if (response.status === 401 || response.status === 403) {
-          throw new AuthenticationError(
-            `Authentication failed: ${response.status} ${response.statusText}`
-          );
-        }
-        throw new McpdError(
-          `Request failed: ${response.status} ${response.statusText} - ${body}`
-        );
-      }
-      try {
-        return await response.json();
-      } catch (error) {
-        throw new McpdError("Failed to parse JSON response", error);
-      }
-    } catch (error) {
-      clearTimeout(timeoutId);
-      if (error.name === "AbortError") {
-        throw new TimeoutError(
-          `Request timed out after ${this.#timeout}ms`,
-          path,
-          this.#timeout
-        );
-      }
-      if (error instanceof TypeError && error.message.includes("fetch")) {
-        throw new ConnectionError(
-          `Cannot connect to mcpd daemon at ${this.#endpoint}. Is it running?`,
-          error
-        );
-      }
-      if (error instanceof McpdError) {
-        throw error;
-      }
-      throw new McpdError(
-        `Request failed: ${error.message}`,
-        error
-      );
-    }
-  }
-  /**
-   * Get a list of all configured MCP servers.
-   *
-   * @returns Array of server names
-   *
-   * @throws {AuthenticationError} If API key was present and authentication fails
-   * @throws {ConnectionError} If unable to connect to the mcpd daemon
-   * @throws {TimeoutError} If the request times out
-   * @throws {McpdError} If the request fails
-   *
-   * @example
-   * ```typescript
-   * const servers = await client.listServers();
-   * console.log(servers); // ['time', 'fetch', 'git']
-   * ```
-   */
-  async listServers() {
-    return await this.#request(API_PATHS.SERVERS);
-  }
-  /**
-   * Get tool schemas for a server.
-   *
-   * @privateRemarks
-   * Used by dependency injection for ServersNamespace and internally for getAgentTools.
-   *
-   * @param serverName - Server name to get tools for
-   *
-   * @returns Tool schemas for the specified server
-   *
-   * @throws {ServerNotFoundError} If the specified server doesn't exist
-   * @throws {ServerUnhealthyError} If the server is not healthy
-   *
-   * @throws {AuthenticationError} If API key was present and authentication fails
-   * @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 #getToolsByServer(serverName) {
-    await this.#ensureServerHealthy(serverName);
-    const path = API_PATHS.SERVER_TOOLS(serverName);
-    const response = await this.#request(path);
-    if (!response.tools) {
-      throw new ServerNotFoundError(
-        `Server '${serverName}' not found`,
-        serverName
-      );
-    }
-    return response.tools;
-  }
-  /**
-   * Get prompt schemas for a server.
-   *
-   * @privateRemarks
-   * Used internally for getPromptSchemas.
-   *
-   * @param serverName - Server name to get prompts for
-   * @param cursor - 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 {AuthenticationError} If API key was present and authentication fails
-   * @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;
-    }
-  }
-  /**
-   * Generate a prompt on a server.
-   *
-   * @privateRemarks
-   * 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
-   *
-   * @throws {AuthenticationError} If API key was present and authentication fails
-   * @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 #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;
-  }
-  /**
-   * Get resource schemas for a server.
-   *
-   * @privateRemarks
-   * Used internally for getResources and by dependency injection for ServersNamespace.
-   *
-   * @param serverName - Server name to get resources for
-   * @param cursor - 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 {AuthenticationError} If API key was present and authentication fails
-   * @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;
-    }
-  }
-  /**
-   * Get resource template schemas for a server.
-   *
-   * @privateRemarks
-   * Used internally for getResourceTemplates and by dependency injection for ServersNamespace.
-   *
-   * @param serverName - Server name to get resource templates for
-   * @param cursor - 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 {AuthenticationError} If API key was present and authentication fails
-   * @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;
-    }
-  }
-  /**
-   * Read resource content from a server.
-   *
-   * @privateRemarks
-   * 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 {AuthenticationError} If API key was present and authentication fails
-   * @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}`;
-      const cached = this.#serverHealthCache.get(cacheKey);
-      if (cached !== void 0) {
-        if (cached instanceof Error) {
-          throw cached;
-        }
-        return cached;
-      }
-      try {
-        const path = API_PATHS.HEALTH_SERVER(serverName);
-        const health = await this.#request(path);
-        this.#serverHealthCache.set(cacheKey, health);
-        return health;
-      } catch (error) {
-        if (error instanceof Error) {
-          for (const errorType of this.#cacheableExceptions) {
-            if (error instanceof errorType) {
-              this.#serverHealthCache.set(cacheKey, error);
-              break;
-            }
-          }
-        }
-        throw error;
-      }
-    } else {
-      const response = await this.#request(
-        API_PATHS.HEALTH_ALL
-      );
-      const healthMap = {};
-      for (const server of response.servers) {
-        healthMap[server.name] = server;
-        const cacheKey = `health:${server.name}`;
-        this.#serverHealthCache.set(cacheKey, server);
-      }
-      return healthMap;
-    }
-  }
-  /**
-   * Check if a specific server is healthy.
-   *
-   * @param serverName - The name of the server to check
-   *
-   * @returns True if the server is healthy, false otherwise
-   *
-   * @throws {AuthenticationError} If API key was present and authentication fails
-   * @throws {ConnectionError} If unable to connect to the mcpd daemon
-   * @throws {TimeoutError} If the request times out
-   * @throws {McpdError} If the request fails
-   *
-   * @example
-   * ```typescript
-   * if (await client.isServerHealthy('time')) {
-   *   const time = await client.servers.time.get_current_time();
-   * }
-   * ```
-   */
-  async isServerHealthy(serverName) {
-    try {
-      const health = await this.getServerHealth(serverName);
-      return HealthStatusHelpers.isHealthy(health.status);
-    } catch (error) {
-      if (error instanceof ServerNotFoundError) {
-        return false;
-      }
-      throw error;
-    }
-  }
-  /**
-   * Ensure a server is healthy before performing an operation.
-   *
-   * @param serverName - The name of the server to check
-   *
-   * @throws {ServerNotFoundError} If the server doesn't exist
-   * @throws {ServerUnhealthyError} If the server is not healthy
-   *
-   * @throws {AuthenticationError} If API key was present and authentication fails
-   * @throws {ConnectionError} If unable to connect to the mcpd daemon
-   * @throws {TimeoutError} If the request times out
-   * @throws {McpdError} If the request fails
-   */
-  async #ensureServerHealthy(serverName) {
-    const health = await this.getServerHealth(serverName);
-    if (!health) {
-      throw new ServerNotFoundError(
-        `Server '${serverName}' not found`,
-        serverName
-      );
-    }
-    if (!HealthStatusHelpers.isHealthy(health.status)) {
-      throw new ServerUnhealthyError(
-        `Server '${serverName}' is not healthy: ${health.status}`,
-        serverName,
-        health.status
-      );
-    }
-  }
-  /**
-   * Get list of healthy servers.
-   *
-   * @remarks
-   * If logging is enabled, warnings are logged for servers that do not exist or are unhealthy.
-   *
-   * @param servers - List of server names to use for health checking.
-   *                  If not provided, or empty, checks health for all servers.
-   *
-   * @returns List of server names with 'ok' health status.
-   *
-   * @throws {AuthenticationError} If API key was present and authentication fails
-   * @throws {ConnectionError} If unable to connect to the mcpd daemon
-   * @throws {TimeoutError} If the request times out
-   * @throws {McpdError} If the request fails
-   */
-  async #getHealthyServers(servers) {
-    const serverNames = servers?.length ? servers : await this.listServers();
-    const healthMap = await this.getServerHealth();
-    return serverNames.filter((name) => {
-      const health = healthMap[name];
-      if (!health) {
-        this.#logger.warn(`Skipping non-existent server '${name}'`);
-        return false;
-      }
-      if (!HealthStatusHelpers.isHealthy(health.status)) {
-        this.#logger.warn(
-          `Skipping unhealthy server '${name}' with status '${health.status}'`
-        );
-        return false;
-      }
-      return true;
-    });
-  }
-  /**
-   * Perform a tool call on a server.
-   *
-   * @privateRemarks
-   * Used internally by:
-   * - ToolsNamespace (via dependency injection)
-   * - FunctionBuilder (via dependency injection)
-   *
-   * @param serverName - The name of the server
-   * @param toolName - The exact name of the tool
-   * @param args - The tool arguments
-   *
-   * @returns The tool's response
-   *
-   * @throws {ToolExecutionError} If the tool execution fails
-   *
-   * @throws {AuthenticationError} If API key was present and authentication fails
-   * @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 #performCall(serverName, toolName, args) {
-    const path = API_PATHS.TOOL_CALL(serverName, toolName);
-    try {
-      const response = await this.#request(path, {
-        method: "POST",
-        body: JSON.stringify(args || {})
-      });
-      if (typeof response === "string") {
-        try {
-          return JSON.parse(response);
-        } catch {
-          return response;
-        }
-      }
-      return response;
-    } catch (error) {
-      if (error instanceof PipelineError) {
-        throw new PipelineError(
-          error.message,
-          serverName,
-          `${serverName}.${toolName}`,
-          error.pipelineFlow,
-          error.cause
-        );
-      }
-      if (error instanceof McpdError) {
-        throw error;
-      }
-      throw new ToolExecutionError(
-        `Failed to execute tool '${toolName}' on server '${serverName}': ${error.message}`,
-        serverName,
-        toolName,
-        void 0,
-        error
-      );
-    }
-  }
-  /**
-   * Clear the cached agent tools functions.
-   * This should be called when the tool schemas might have changed.
-   */
-  clearAgentToolsCache() {
-    this.#functionBuilder.clearCache();
-  }
-  /**
-   * Clear the server health cache.
-   * This forces fresh health checks on the next getServerHealth() or isServerHealthy() call.
-   */
-  clearServerHealthCache() {
-    this.#serverHealthCache.clear();
-  }
-  /**
-   * Fetch and cache callable functions from all healthy servers.
-   *
-   * This method queries all healthy servers and creates self-contained, callable functions
-   * that can be passed to AI agent frameworks. Each function includes its schema
-   * as metadata and handles the MCP communication internally.
-   *
-   * Unhealthy servers are automatically filtered out and skipped (with optional warnings
-   * when logging is enabled) to ensure the method returns quickly without waiting for timeouts.
-   *
-   * Tool fetches from multiple servers are executed concurrently for optimal performance.
-   * Functions are cached indefinitely until explicitly cleared.
-   *
-   * @returns Array of callable functions with metadata from all healthy servers.
-   *
-   * @throws {AuthenticationError} If API key was present and authentication fails
-   * @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 #agentTools() {
-    const cachedFunctions = this.#functionBuilder.getCachedFunctions();
-    if (cachedFunctions.length > 0) {
-      return cachedFunctions;
-    }
-    const healthyServers = await this.#getHealthyServers();
-    const results = await Promise.allSettled(
-      healthyServers.map(async (serverName) => ({
-        serverName,
-        tools: await this.#getToolsByServer(serverName)
-      }))
-    );
-    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 = {}) {
-    const { servers, tools, format = "array", refreshCache = false } = options;
-    if (refreshCache) this.#functionBuilder.clearCache();
-    const allTools = await this.#agentTools();
-    const filteredTools = allTools.filter((tool) => !servers || servers.includes(tool._serverName)).filter((tool) => !tools || this.#matchesToolFilter(tool, tools));
-    const formatters = {
-      array: (t) => t,
-      object: (t) => Object.fromEntries(t.map((tool) => [tool.name, tool])),
-      map: (t) => new Map(t.map((tool) => [tool.name, tool]))
-    };
-    return formatters[format](filteredTools);
-  }
-  /**
-   * Check if a tool matches the tool filter.
-   *
-   * Supports two formats:
-   * - Raw tool name: "get_current_time" (matches across all servers)
-   * - Server-prefixed: "time__get_current_time" (matches specific server + tool)
-   *
-   * @remarks
-   * When a filter contains "__", it's first checked as server-prefixed (exact match).
-   * If that fails, it's checked as a raw tool name. This handles tools whose names
-   * contain "__" (e.g., "my__special__tool").
-   *
-   * @param tool The tool to match.
-   * @param tools List of tool names to match against.
-   *
-   * @returns True if a match is found in tools, based on the predicate.
-   *
-   * @internal
-   */
-  #matchesToolFilter(tool, tools) {
-    return tools.some((filterItem) => {
-      if (filterItem.indexOf(TOOL_SEPARATOR) === -1) {
-        return filterItem === tool._toolName;
-      }
-      return filterItem === tool.name || filterItem === tool._toolName;
-    });
-  }
-}
-export {
-  AuthenticationError,
-  ConnectionError,
-  HealthStatus,
-  HealthStatusHelpers,
-  McpdClient,
-  McpdError,
-  PIPELINE_FLOW_REQUEST,
-  PIPELINE_FLOW_RESPONSE,
-  PipelineError,
-  ServerNotFoundError,
-  ServerUnhealthyError,
-  TimeoutError,
-  ToolExecutionError,
-  ToolNotFoundError,
-  ValidationError
+/**
+* Client for interacting with MCP (Model Context Protocol) servers through an mcpd daemon.
+*
+* The McpdClient provides a high-level interface to discover, inspect, and invoke tools
+* exposed by MCP servers running behind an mcpd daemon proxy/gateway.
+*
+* Thread Safety:
+*     This client is safe to use from multiple async contexts. The internal health
+*     check cache is protected by the LRUCache implementation.
+*
+* @example
+* ```typescript
+* import { McpdClient } from '@mozilla-ai/mcpd';
+*
+* // Initialize client
+* const client = new McpdClient({
+*   apiEndpoint: 'http://localhost:8090',
+*   apiKey: 'optional-key',
+*   healthCacheTtl: 10,
+* });
+*
+* // List available servers
+* const servers = await client.listServers();
+* console.log(servers); // ['time', 'fetch', 'git']
+*
+* // Invoke a tool dynamically
+* const result = await client.servers.time.get_current_time({ timezone: 'UTC' });
+* console.log(result); // { time: '2024-01-15T10:30:00Z' }
+* ```
+*/
+var McpdClient = class {
+	#endpoint;
+	#apiKey;
+	#timeout;
+	#serverHealthCache;
+	#functionBuilder;
+	#logger;
+	#cacheableExceptions = new Set([
+		ServerNotFoundError,
+		ServerUnhealthyError,
+		AuthenticationError
+	]);
+	/**
+	* Namespace for accessing MCP servers and their tools.
+	*/
+	servers;
+	/**
+	* Initialize a new McpdClient instance.
+	*
+	* @param options - Configuration options for the client
+	*/
+	constructor(options) {
+		const toMs = (s) => s * 1e3;
+		this.#endpoint = options.apiEndpoint.replace(/\/$/, "");
+		this.#apiKey = options.apiKey;
+		this.#timeout = options.timeout ?? toMs(REQUEST_TIMEOUT_SECONDS);
+		const healthCacheTtlMs = toMs(options.healthCacheTtl ?? SERVER_HEALTH_CACHE_TTL_SECONDS);
+		this.#serverHealthCache = createCache({
+			max: SERVER_HEALTH_CACHE_MAXSIZE,
+			ttl: healthCacheTtlMs
+		});
+		this.#logger = createLogger(options.logger);
+		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));
+	}
+	/**
+	* Make an HTTP request to the mcpd daemon.
+	*
+	* @param path - The API path (e.g., '/servers', '/servers/{server_name}/tools')
+	* @param options - Request options
+	*
+	* @returns The JSON response from the daemon
+	*
+	* @throws {AuthenticationError} If API key was present and authentication fails
+	* @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 #request(path, options = {}) {
+		const url = `${this.#endpoint}${path}`;
+		const headers = {
+			"Content-Type": "application/json",
+			...options.headers || {}
+		};
+		if (this.#apiKey) headers["Authorization"] = `Bearer ${this.#apiKey}`;
+		const controller = new AbortController();
+		const timeoutId = setTimeout(() => controller.abort(), this.#timeout);
+		try {
+			const response = await fetch(url, {
+				...options,
+				headers,
+				signal: controller.signal
+			});
+			clearTimeout(timeoutId);
+			if (!response.ok) {
+				const body = await response.text();
+				let errorModel = null;
+				try {
+					errorModel = JSON.parse(body);
+				} catch {
+					errorModel = null;
+				}
+				if (response.status === 500) {
+					const errorType = response.headers.get(MCPD_ERROR_TYPE_HEADER)?.toLowerCase();
+					const flow = errorType ? PIPELINE_ERROR_FLOWS[errorType] : void 0;
+					if (flow) throw new PipelineError(errorModel?.detail || body || "Pipeline failure", void 0, void 0, flow);
+				}
+				if (errorModel && errorModel.detail) {
+					const errorDetails = errorModel.errors?.map((e) => `${e.location}: ${e.message}`).join("; ");
+					const fullMessage = errorDetails ? `${errorModel.detail} - ${errorDetails}` : errorModel.detail;
+					if (response.status === 401 || response.status === 403) throw new AuthenticationError(fullMessage);
+					throw new McpdError(`${errorModel.title || "Request failed"}: ${fullMessage}`);
+				}
+				if (response.status === 401 || response.status === 403) throw new AuthenticationError(`Authentication failed: ${response.status} ${response.statusText}`);
+				throw new McpdError(`Request failed: ${response.status} ${response.statusText} - ${body}`);
+			}
+			try {
+				return await response.json();
+			} catch (error) {
+				throw new McpdError("Failed to parse JSON response", error);
+			}
+		} catch (error) {
+			clearTimeout(timeoutId);
+			if (error.name === "AbortError") throw new TimeoutError(`Request timed out after ${this.#timeout}ms`, path, this.#timeout);
+			if (error instanceof TypeError && error.message.includes("fetch")) throw new ConnectionError(`Cannot connect to mcpd daemon at ${this.#endpoint}. Is it running?`, error);
+			if (error instanceof McpdError) throw error;
+			throw new McpdError(`Request failed: ${error.message}`, error);
+		}
+	}
+	/**
+	* Get a list of all configured MCP servers.
+	*
+	* @returns Array of server names
+	*
+	* @throws {AuthenticationError} If API key was present and authentication fails
+	* @throws {ConnectionError} If unable to connect to the mcpd daemon
+	* @throws {TimeoutError} If the request times out
+	* @throws {McpdError} If the request fails
+	*
+	* @example
+	* ```typescript
+	* const servers = await client.listServers();
+	* console.log(servers); // ['time', 'fetch', 'git']
+	* ```
+	*/
+	async listServers() {
+		return await this.#request(API_PATHS.SERVERS);
+	}
+	/**
+	* Get tool schemas for a server.
+	*
+	* @privateRemarks
+	* Used by dependency injection for ServersNamespace and internally for getAgentTools.
+	*
+	* @param serverName - Server name to get tools for
+	*
+	* @returns Tool schemas for the specified server
+	*
+	* @throws {ServerNotFoundError} If the specified server doesn't exist
+	* @throws {ServerUnhealthyError} If the server is not healthy
+	*
+	* @throws {AuthenticationError} If API key was present and authentication fails
+	* @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 #getToolsByServer(serverName) {
+		await this.#ensureServerHealthy(serverName);
+		const path = API_PATHS.SERVER_TOOLS(serverName);
+		const response = await this.#request(path);
+		if (!response.tools) throw new ServerNotFoundError(`Server '${serverName}' not found`, serverName);
+		return response.tools;
+	}
+	/**
+	* Get prompt schemas for a server.
+	*
+	* @privateRemarks
+	* Used internally for getPromptSchemas.
+	*
+	* @param serverName - Server name to get prompts for
+	* @param cursor - 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 {AuthenticationError} If API key was present and authentication fails
+	* @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);
+			return (await this.#request(path)).prompts || [];
+		} catch (error) {
+			if (error instanceof McpdError && error.message.includes("501") && error.message.includes("Not Implemented")) return [];
+			throw error;
+		}
+	}
+	/**
+	* Generate a prompt on a server.
+	*
+	* @privateRemarks
+	* 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
+	*
+	* @throws {AuthenticationError} If API key was present and authentication fails
+	* @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 #generatePromptInternal(serverName, promptName, args) {
+		await this.#ensureServerHealthy(serverName);
+		const path = API_PATHS.PROMPT_GET_GENERATED(serverName, promptName);
+		const requestBody = { arguments: args || {} };
+		return await this.#request(path, {
+			method: "POST",
+			body: JSON.stringify(requestBody)
+		});
+	}
+	/**
+	* Get resource schemas for a server.
+	*
+	* @privateRemarks
+	* Used internally for getResources and by dependency injection for ServersNamespace.
+	*
+	* @param serverName - Server name to get resources for
+	* @param cursor - 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 {AuthenticationError} If API key was present and authentication fails
+	* @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);
+			return (await this.#request(path)).resources || [];
+		} catch (error) {
+			if (error instanceof McpdError && error.message.includes("501") && error.message.includes("Not Implemented")) return [];
+			throw error;
+		}
+	}
+	/**
+	* Get resource template schemas for a server.
+	*
+	* @privateRemarks
+	* Used internally for getResourceTemplates and by dependency injection for ServersNamespace.
+	*
+	* @param serverName - Server name to get resource templates for
+	* @param cursor - 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 {AuthenticationError} If API key was present and authentication fails
+	* @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);
+			return (await this.#request(path)).templates || [];
+		} catch (error) {
+			if (error instanceof McpdError && error.message.includes("501") && error.message.includes("Not Implemented")) return [];
+			throw error;
+		}
+	}
+	/**
+	* Read resource content from a server.
+	*
+	* @privateRemarks
+	* 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 {AuthenticationError} If API key was present and authentication fails
+	* @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);
+		return await this.#request(path) || [];
+	}
+	async getServerHealth(serverName) {
+		if (serverName) {
+			const cacheKey = `health:${serverName}`;
+			const cached = this.#serverHealthCache.get(cacheKey);
+			if (cached !== void 0) {
+				if (cached instanceof Error) throw cached;
+				return cached;
+			}
+			try {
+				const path = API_PATHS.HEALTH_SERVER(serverName);
+				const health = await this.#request(path);
+				this.#serverHealthCache.set(cacheKey, health);
+				return health;
+			} catch (error) {
+				if (error instanceof Error) {
+					for (const errorType of this.#cacheableExceptions) if (error instanceof errorType) {
+						this.#serverHealthCache.set(cacheKey, error);
+						break;
+					}
+				}
+				throw error;
+			}
+		} else {
+			const response = await this.#request(API_PATHS.HEALTH_ALL);
+			const healthMap = {};
+			for (const server of response.servers) {
+				healthMap[server.name] = server;
+				const cacheKey = `health:${server.name}`;
+				this.#serverHealthCache.set(cacheKey, server);
+			}
+			return healthMap;
+		}
+	}
+	/**
+	* Check if a specific server is healthy.
+	*
+	* @param serverName - The name of the server to check
+	*
+	* @returns True if the server is healthy, false otherwise
+	*
+	* @throws {AuthenticationError} If API key was present and authentication fails
+	* @throws {ConnectionError} If unable to connect to the mcpd daemon
+	* @throws {TimeoutError} If the request times out
+	* @throws {McpdError} If the request fails
+	*
+	* @example
+	* ```typescript
+	* if (await client.isServerHealthy('time')) {
+	*   const time = await client.servers.time.get_current_time();
+	* }
+	* ```
+	*/
+	async isServerHealthy(serverName) {
+		try {
+			const health = await this.getServerHealth(serverName);
+			return HealthStatusHelpers.isHealthy(health.status);
+		} catch (error) {
+			if (error instanceof ServerNotFoundError) return false;
+			throw error;
+		}
+	}
+	/**
+	* Ensure a server is healthy before performing an operation.
+	*
+	* @param serverName - The name of the server to check
+	*
+	* @throws {ServerNotFoundError} If the server doesn't exist
+	* @throws {ServerUnhealthyError} If the server is not healthy
+	*
+	* @throws {AuthenticationError} If API key was present and authentication fails
+	* @throws {ConnectionError} If unable to connect to the mcpd daemon
+	* @throws {TimeoutError} If the request times out
+	* @throws {McpdError} If the request fails
+	*/
+	async #ensureServerHealthy(serverName) {
+		const health = await this.getServerHealth(serverName);
+		if (!health) throw new ServerNotFoundError(`Server '${serverName}' not found`, serverName);
+		if (!HealthStatusHelpers.isHealthy(health.status)) throw new ServerUnhealthyError(`Server '${serverName}' is not healthy: ${health.status}`, serverName, health.status);
+	}
+	/**
+	* Get list of healthy servers.
+	*
+	* @remarks
+	* If logging is enabled, warnings are logged for servers that do not exist or are unhealthy.
+	*
+	* @param servers - List of server names to use for health checking.
+	*                  If not provided, or empty, checks health for all servers.
+	*
+	* @returns List of server names with 'ok' health status.
+	*
+	* @throws {AuthenticationError} If API key was present and authentication fails
+	* @throws {ConnectionError} If unable to connect to the mcpd daemon
+	* @throws {TimeoutError} If the request times out
+	* @throws {McpdError} If the request fails
+	*/
+	async #getHealthyServers(servers) {
+		const serverNames = servers?.length ? servers : await this.listServers();
+		const healthMap = await this.getServerHealth();
+		return serverNames.filter((name) => {
+			const health = healthMap[name];
+			if (!health) {
+				this.#logger.warn(`Skipping non-existent server '${name}'`);
+				return false;
+			}
+			if (!HealthStatusHelpers.isHealthy(health.status)) {
+				this.#logger.warn(`Skipping unhealthy server '${name}' with status '${health.status}'`);
+				return false;
+			}
+			return true;
+		});
+	}
+	/**
+	* Perform a tool call on a server.
+	*
+	* @privateRemarks
+	* Used internally by:
+	* - ToolsNamespace (via dependency injection)
+	* - FunctionBuilder (via dependency injection)
+	*
+	* @param serverName - The name of the server
+	* @param toolName - The exact name of the tool
+	* @param args - The tool arguments
+	*
+	* @returns The tool's response
+	*
+	* @throws {ToolExecutionError} If the tool execution fails
+	*
+	* @throws {AuthenticationError} If API key was present and authentication fails
+	* @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 #performCall(serverName, toolName, args) {
+		const path = API_PATHS.TOOL_CALL(serverName, toolName);
+		try {
+			const response = await this.#request(path, {
+				method: "POST",
+				body: JSON.stringify(args || {})
+			});
+			if (typeof response === "string") try {
+				return JSON.parse(response);
+			} catch {
+				return response;
+			}
+			return response;
+		} catch (error) {
+			if (error instanceof PipelineError) throw new PipelineError(error.message, serverName, `${serverName}.${toolName}`, error.pipelineFlow, error.cause);
+			if (error instanceof McpdError) throw error;
+			throw new ToolExecutionError(`Failed to execute tool '${toolName}' on server '${serverName}': ${error.message}`, serverName, toolName, void 0, error);
+		}
+	}
+	/**
+	* Clear the cached agent tools functions.
+	* This should be called when the tool schemas might have changed.
+	*/
+	clearAgentToolsCache() {
+		this.#functionBuilder.clearCache();
+	}
+	/**
+	* Clear the server health cache.
+	* This forces fresh health checks on the next getServerHealth() or isServerHealthy() call.
+	*/
+	clearServerHealthCache() {
+		this.#serverHealthCache.clear();
+	}
+	/**
+	* Fetch and cache callable functions from all healthy servers.
+	*
+	* This method queries all healthy servers and creates self-contained, callable functions
+	* that can be passed to AI agent frameworks. Each function includes its schema
+	* as metadata and handles the MCP communication internally.
+	*
+	* Unhealthy servers are automatically filtered out and skipped (with optional warnings
+	* when logging is enabled) to ensure the method returns quickly without waiting for timeouts.
+	*
+	* Tool fetches from multiple servers are executed concurrently for optimal performance.
+	* Functions are cached indefinitely until explicitly cleared.
+	*
+	* @returns Array of callable functions with metadata from all healthy servers.
+	*
+	* @throws {AuthenticationError} If API key was present and authentication fails
+	* @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 #agentTools() {
+		const cachedFunctions = this.#functionBuilder.getCachedFunctions();
+		if (cachedFunctions.length > 0) return cachedFunctions;
+		const healthyServers = await this.#getHealthyServers();
+		return (await Promise.allSettled(healthyServers.map(async (serverName) => ({
+			serverName,
+			tools: await this.#getToolsByServer(serverName)
+		})))).filter((result) => result.status === "fulfilled").flatMap((result) => {
+			const { serverName, tools } = result.value;
+			return tools.map((toolSchema) => this.#functionBuilder.createFunctionFromSchema(toolSchema, serverName));
+		});
+	}
+	async getAgentTools(options = {}) {
+		const { servers, tools, format = "array", refreshCache = false } = options;
+		if (refreshCache) this.#functionBuilder.clearCache();
+		const filteredTools = (await this.#agentTools()).filter((tool) => !servers || servers.includes(tool._serverName)).filter((tool) => !tools || this.#matchesToolFilter(tool, tools));
+		return {
+			array: (t) => t,
+			object: (t) => Object.fromEntries(t.map((tool) => [tool.name, tool])),
+			map: (t) => new Map(t.map((tool) => [tool.name, tool]))
+		}[format](filteredTools);
+	}
+	/**
+	* Check if a tool matches the tool filter.
+	*
+	* Supports two formats:
+	* - Raw tool name: "get_current_time" (matches across all servers)
+	* - Server-prefixed: "time__get_current_time" (matches specific server + tool)
+	*
+	* @remarks
+	* When a filter contains "__", it's first checked as server-prefixed (exact match).
+	* If that fails, it's checked as a raw tool name. This handles tools whose names
+	* contain "__" (e.g., "my__special__tool").
+	*
+	* @param tool The tool to match.
+	* @param tools List of tool names to match against.
+	*
+	* @returns True if a match is found in tools, based on the predicate.
+	*
+	* @internal
+	*/
+	#matchesToolFilter(tool, tools) {
+		return tools.some((filterItem) => {
+			if (filterItem.indexOf(TOOL_SEPARATOR) === -1) return filterItem === tool._toolName;
+			return filterItem === tool.name || filterItem === tool._toolName;
+		});
+	}
 };
-//# sourceMappingURL=index.mjs.map
+//#endregion
+export { AuthenticationError, ConnectionError, HealthStatus, HealthStatusHelpers, McpdClient, McpdError, PIPELINE_FLOW_REQUEST, PIPELINE_FLOW_RESPONSE, PipelineError, ServerNotFoundError, ServerUnhealthyError, TimeoutError, ToolExecutionError, ToolNotFoundError, ValidationError };
+
+//# sourceMappingURL=index.mjs.map