@mozilla-ai/mcpd 0.0.1

package/dist/client.d.ts

@@ -0,0 +1,231 @@
+import { McpdClientOptions, ServerHealth, Tool } from './types';
+import { ServersNamespace } from './dynamicCaller';
+import { AgentFunction } from './functionBuilder';
+/**
+ * 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,
+ *   serverCacheTtl: 60
+ * });
+ *
+ * // 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' }
+ * ```
+ */
+export declare class McpdClient {
+    #private;
+    /**
+     * Namespace for accessing MCP servers and their tools.
+     */
+    readonly servers: ServersNamespace;
+    /**
+     * Initialize a new McpdClient instance.
+     *
+     * @param options - Configuration options for the client
+     */
+    constructor(options: McpdClientOptions);
+    /**
+     * Get a list of all configured MCP servers.
+     *
+     * @returns Array of server names
+     * @throws {McpdError} If the request fails
+     *
+     * @example
+     * ```typescript
+     * const servers = await client.listServers();
+     * console.log(servers); // ['time', 'fetch', 'git']
+     * ```
+     */
+    listServers(): Promise<string[]>;
+    /**
+     * Get tool schemas from all (or specific) MCP servers with transformed names.
+     *
+     * IMPORTANT: Tool names are transformed to `serverName__toolName` format to:
+     * 1. Prevent naming clashes when aggregating tools from multiple servers
+     * 2. Identify which server each tool belongs to
+     *
+     * This method automatically filters out unhealthy servers by checking their health
+     * status before fetching tools. Unhealthy servers are silently skipped to ensure
+     * the method returns quickly without waiting for timeouts on failed servers.
+     *
+     * Tool fetches from multiple servers are executed concurrently for optimal performance.
+     *
+     * This is useful for:
+     * - MCP servers that aggregate and re-expose tools from multiple upstream servers
+     * - Tool inspection and discovery across all servers
+     * - Custom tooling that needs raw MCP tool schemas
+     *
+     * @param options - Optional configuration
+     * @param options.servers - Array of server names to include. If not specified, includes all servers.
+     * @returns Array of tool schemas with transformed names (serverName__toolName). Only includes tools from healthy servers.
+     * @throws {ConnectionError} If unable to connect to the mcpd daemon
+     * @throws {TimeoutError} If requests to the daemon time out
+     * @throws {AuthenticationError} If API key authentication fails
+     * @throws {McpdError} If health check or initial server listing fails
+     *
+     * @example
+     * ```typescript
+     * // Get all tools from all servers
+     * const allTools = await client.getToolSchemas();
+     * // Returns: [
+     * //   { name: "time__get_current_time", description: "...", ... },
+     * //   { name: "fetch__fetch_url", description: "...", ... }
+     * // ]
+     *
+     * // Get tools from specific servers only
+     * const someTools = await client.getToolSchemas({ servers: ['time', 'fetch'] });
+     *
+     * // Original tool name "get_current_time" becomes "time__get_current_time"
+     * // This prevents clashes if multiple servers have tools with the same name
+     * ```
+     */
+    getToolSchemas(options?: {
+        servers?: string[];
+    }): Promise<Tool[]>;
+    /**
+     * Get health information for one or all servers.
+     *
+     * @param serverName - Optional server name to get health for
+     * @returns Health information for the specified server or all servers
+     * @throws {ServerNotFoundError} If the specified server doesn't exist
+     * @throws {McpdError} If the request fails
+     *
+     * @example
+     * ```typescript
+     * // Get health for all servers
+     * const allHealth = await client.getServerHealth();
+     * console.log(allHealth); // { time: { status: 'ok' }, fetch: { status: 'ok' } }
+     *
+     * // Get health for a specific server
+     * const timeHealth = await client.getServerHealth('time');
+     * console.log(timeHealth); // { status: 'ok' }
+     * ```
+     */
+    getServerHealth(): Promise<Record<string, ServerHealth>>;
+    getServerHealth(serverName: string): Promise<ServerHealth>;
+    /**
+     * 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
+     *
+     * @example
+     * ```typescript
+     * if (await client.isServerHealthy('time')) {
+     *   const time = await client.servers.time.get_current_time();
+     * }
+     * ```
+     */
+    isServerHealthy(serverName: string): Promise<boolean>;
+    /**
+     * Clear the cached agent tools functions.
+     * This should be called when the tool schemas might have changed.
+     */
+    clearAgentToolsCache(): void;
+    /**
+     * Clear the server health cache.
+     * This forces fresh health checks on the next getServerHealth() or isServerHealthy() call.
+     */
+    clearServerHealthCache(): void;
+    /**
+     * Generate callable functions for use with AI agent frameworks (internal).
+     *
+     * This method queries 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.
+     *
+     * This method automatically filters out unhealthy servers by checking their health
+     * status before fetching tools. Unhealthy servers are silently skipped to ensure
+     * the method returns quickly without waiting for timeouts on failed servers.
+     *
+     * Tool fetches from multiple servers are executed concurrently for optimal performance.
+     *
+     * @param servers - Optional list of server names to include. If not specified, includes all servers.
+     * @returns Array of callable functions with metadata. Only includes tools from healthy servers.
+     *
+     * @throws {ConnectionError} If unable to connect to the mcpd daemon
+     * @throws {TimeoutError} If requests to the daemon time out
+     * @throws {AuthenticationError} If API key authentication fails
+     * @throws {McpdError} If unable to retrieve health status, server list, or generate functions
+     * @internal
+     */
+    agentTools(servers?: string[]): Promise<AgentFunction[]>;
+    /**
+     * Generate callable functions for use with AI agent frameworks.
+     *
+     * This method queries 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.
+     *
+     * This method automatically filters out unhealthy servers by checking their health
+     * status before fetching tools. Unhealthy servers are silently skipped to ensure
+     * the method returns quickly without waiting for timeouts on failed servers.
+     *
+     * Tool fetches from multiple servers are executed concurrently for optimal performance.
+     *
+     * The generated functions are cached for performance. Use clearAgentToolsCache()
+     * to force regeneration if servers or tools have changed.
+     *
+     * @param options - Options for generating agent tools (format and server filtering)
+     * @returns Functions in the requested format (array, object, or map). Only includes tools from healthy servers.
+     *
+     * @throws {ConnectionError} If unable to connect to the mcpd daemon
+     * @throws {TimeoutError} If requests to the daemon time out
+     * @throws {AuthenticationError} If API key authentication fails
+     * @throws {McpdError} If unable to retrieve health status, server list, or generate functions
+     *
+     * @example
+     * ```typescript
+     * // Get all tools from all servers (default array format)
+     * const tools = await client.getAgentTools();
+     * console.log(`Generated ${tools.length} callable tools`);
+     *
+     * // Get tools from specific servers
+     * const tools = await client.getAgentTools({ servers: ['time', 'fetch'] });
+     *
+     * // Use with LangChain JS (array format)
+     * const langchainTools = await client.getAgentTools({ format: 'array' });
+     * const agent = await createOpenAIToolsAgent({ llm, tools: langchainTools, prompt });
+     *
+     * // Use with Vercel AI SDK (object format) from specific servers
+     * const vercelTools = await client.getAgentTools({
+     *   servers: ['time'],
+     *   format: 'object'
+     * });
+     * const result = await generateText({ model, tools: vercelTools, prompt });
+     * ```
+     */
+    getAgentTools(options?: {
+        format?: "array";
+        servers?: string[];
+    }): Promise<AgentFunction[]>;
+    getAgentTools(options: {
+        format: "object";
+        servers?: string[];
+    }): Promise<Record<string, AgentFunction>>;
+    getAgentTools(options: {
+        format: "map";
+        servers?: string[];
+    }): Promise<Map<string, AgentFunction>>;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAYH,OAAO,EAEL,iBAAiB,EACjB,YAAY,EACZ,IAAI,EAKL,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,EAAmB,KAAK,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAGxE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,qBAAa,UAAU;;IAYrB;;OAEG;IACH,SAAgB,OAAO,EAAE,gBAAgB,CAAC;IAE1C;;;;OAIG;gBACS,OAAO,EAAE,iBAAiB;IAgJtC;;;;;;;;;;;OAWG;IACG,WAAW,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAItC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyCG;IACG,cAAc,CAAC,OAAO,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;IA2EvE;;;;;;;;;;;;;;;;;;OAkBG;IACG,eAAe,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IACxD,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IAoDhE;;;;;;;;;;;;OAYG;IACG,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAiG3D;;;OAGG;IACH,oBAAoB,IAAI,IAAI;IAI5B;;;OAGG;IACH,sBAAsB,IAAI,IAAI;IAI9B;;;;;;;;;;;;;;;;;;;;;OAqBG;IACG,UAAU,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC;IA2C9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4CG;IACG,aAAa,CAAC,OAAO,CAAC,EAAE;QAC5B,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;KACpB,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC;IACtB,aAAa,CAAC,OAAO,EAAE;QAC3B,MAAM,EAAE,QAAQ,CAAC;QACjB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;KACpB,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IACpC,aAAa,CAAC,OAAO,EAAE;QAC3B,MAAM,EAAE,KAAK,CAAC;QACd,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;KACpB,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;CAwBxC"}

package/dist/dynamicCaller.d.ts

@@ -0,0 +1,146 @@
+import { Tool, PerformCallFn, GetToolsFn } from './types';
+/**
+ * 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")) {
+ *   // ...
+ * }
+ * ```
+ */
+export declare class ServersNamespace {
+    #private;
+    [serverName: string]: Server;
+    /**
+     * Initialize the ServersNamespace with injected functions.
+     *
+     * @param performCall - Function to execute tool calls
+     * @param getTools - Function to get tool schemas
+     */
+    constructor(performCall: PerformCallFn, getTools: GetToolsFn);
+}
+/**
+ * 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.listTools();
+ *
+ * // Call tools through the .tools namespace:
+ * await timeServer.tools.get_current_time({ timezone: "UTC" })
+ * ```
+ */
+export declare class Server {
+    #private;
+    readonly tools: ToolsNamespace;
+    /**
+     * Initialize a Server 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: PerformCallFn, getTools: GetToolsFn, serverName: string);
+    /**
+     * List 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.listTools();
+     * for (const tool of tools) {
+     *   console.log(`${tool.name}: ${tool.description}`);
+     * }
+     * ```
+     */
+    listTools(): Promise<Tool[]>;
+    /**
+     * Check if a tool exists on this server.
+     *
+     * The tool name must match exactly as returned by the server.
+     *
+     * @param toolName - The exact name of the tool to check
+     * @returns True if the tool exists, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (await client.servers.time.hasTool('get_current_time')) {
+     *   const result = await client.servers.time.callTool('get_current_time', { timezone: 'UTC' });
+     * }
+     * ```
+     */
+    hasTool(toolName: string): Promise<boolean>;
+    /**
+     * 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' });
+     * ```
+     */
+    callTool(toolName: string, args?: Record<string, unknown>): Promise<unknown>;
+}
+/**
+ * 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" });
+ * ```
+ */
+export declare class ToolsNamespace {
+    #private;
+    [toolName: string]: (args?: Record<string, unknown>) => Promise<unknown>;
+    /**
+     * 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: PerformCallFn, getTools: GetToolsFn, serverName: string);
+}
+//# sourceMappingURL=dynamicCaller.d.ts.map

package/dist/dynamicCaller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamicCaller.d.ts","sourceRoot":"","sources":["../src/dynamicCaller.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAGH,OAAO,KAAK,EAAE,IAAI,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAE/D;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,gBAAgB;;IAC3B,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAAC;IAK7B;;;;;OAKG;gBACS,WAAW,EAAE,aAAa,EAAE,QAAQ,EAAE,UAAU;CAc7D;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,MAAM;;IACjB,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;IAM/B;;;;;;OAMG;gBAED,WAAW,EAAE,aAAa,EAC1B,QAAQ,EAAE,UAAU,EACpB,UAAU,EAAE,MAAM;IAcpB;;;;;;;;;;;;;;OAcG;IACG,SAAS,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;IAIlC;;;;;;;;;;;;;;OAcG;IACG,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IASjD;;;;;;;;;;;;;;;;;;;;;OAqBG;IACG,QAAQ,CACZ,QAAQ,EAAE,MAAM,EAChB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,OAAO,CAAC,OAAO,CAAC;CAiBpB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,cAAc;;IACzB,CAAC,QAAQ,EAAE,MAAM,GAAG,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAMzE;;;;;;OAMG;gBAED,WAAW,EAAE,aAAa,EAC1B,QAAQ,EAAE,UAAU,EACpB,UAAU,EAAE,MAAM;CAoCrB"}

package/dist/errors.d.ts

@@ -0,0 +1,113 @@
+import { ErrorModel } from './types';
+/**
+ * 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.
+ */
+export declare class McpdError extends Error {
+    constructor(message: string, cause?: Error);
+}
+/**
+ * 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
+ */
+export declare class ConnectionError extends McpdError {
+    constructor(message: string, cause?: Error);
+}
+/**
+ * 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
+ */
+export declare class AuthenticationError extends McpdError {
+    constructor(message: string, cause?: Error);
+}
+/**
+ * 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
+ */
+export declare class ServerNotFoundError extends McpdError {
+    readonly serverName: string | undefined;
+    constructor(message: string, serverName?: string, cause?: Error);
+}
+/**
+ * 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
+ */
+export declare class ServerUnhealthyError extends McpdError {
+    readonly serverName: string;
+    readonly healthStatus: string;
+    constructor(message: string, serverName: string, healthStatus: string, cause?: Error);
+}
+/**
+ * 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
+ */
+export declare class ToolNotFoundError extends McpdError {
+    readonly serverName: string | undefined;
+    readonly toolName: string | undefined;
+    constructor(message: string, serverName?: string, toolName?: string, cause?: Error);
+}
+/**
+ * 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
+ */
+export declare class ToolExecutionError extends McpdError {
+    readonly serverName: string | undefined;
+    readonly toolName: string | undefined;
+    readonly errorModel: ErrorModel | undefined;
+    constructor(message: string, serverName?: string, toolName?: string, errorModel?: ErrorModel, cause?: Error);
+}
+/**
+ * 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
+ */
+export declare class ValidationError extends McpdError {
+    readonly validationErrors: string[];
+    constructor(message: string, validationErrors?: string[], cause?: Error);
+}
+/**
+ * Raised when an operation times out.
+ *
+ * This can occur during:
+ * - Long-running tool executions
+ * - Slow network connections
+ * - Unresponsive mcpd daemon
+ */
+export declare class TimeoutError extends McpdError {
+    readonly operation: string | undefined;
+    readonly timeout: number | undefined;
+    constructor(message: string, operation?: string, timeout?: number, cause?: Error);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAE1C;;;;;;GAMG;AACH,qBAAa,SAAU,SAAQ,KAAK;gBACtB,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK;CAM3C;AAED;;;;;;;;GAQG;AACH,qBAAa,eAAgB,SAAQ,SAAS;gBAChC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK;CAK3C;AAED;;;;;;;GAOG;AACH,qBAAa,mBAAoB,SAAQ,SAAS;gBACpC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK;CAK3C;AAED;;;;;;;GAOG;AACH,qBAAa,mBAAoB,SAAQ,SAAS;IAChD,SAAgB,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;gBAEnC,OAAO,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,KAAK;CAMhE;AAED;;;;;;;GAOG;AACH,qBAAa,oBAAqB,SAAQ,SAAS;IACjD,SAAgB,UAAU,EAAE,MAAM,CAAC;IACnC,SAAgB,YAAY,EAAE,MAAM,CAAC;gBAGnC,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,EACpB,KAAK,CAAC,EAAE,KAAK;CAQhB;AAED;;;;;;;GAOG;AACH,qBAAa,iBAAkB,SAAQ,SAAS;IAC9C,SAAgB,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/C,SAAgB,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;gBAG3C,OAAO,EAAE,MAAM,EACf,UAAU,CAAC,EAAE,MAAM,EACnB,QAAQ,CAAC,EAAE,MAAM,EACjB,KAAK,CAAC,EAAE,KAAK;CAQhB;AAED;;;;;;;;GAQG;AACH,qBAAa,kBAAmB,SAAQ,SAAS;IAC/C,SAAgB,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/C,SAAgB,QAAQ,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7C,SAAgB,UAAU,EAAE,UAAU,GAAG,SAAS,CAAC;gBAGjD,OAAO,EAAE,MAAM,EACf,UAAU,CAAC,EAAE,MAAM,EACnB,QAAQ,CAAC,EAAE,MAAM,EACjB,UAAU,CAAC,EAAE,UAAU,EACvB,KAAK,CAAC,EAAE,KAAK;CAShB;AAED;;;;;;;GAOG;AACH,qBAAa,eAAgB,SAAQ,SAAS;IAC5C,SAAgB,gBAAgB,EAAE,MAAM,EAAE,CAAC;gBAE/B,OAAO,EAAE,MAAM,EAAE,gBAAgB,CAAC,EAAE,MAAM,EAAE,EAAE,KAAK,CAAC,EAAE,KAAK;CAMxE;AAED;;;;;;;GAOG;AACH,qBAAa,YAAa,SAAQ,SAAS;IACzC,SAAgB,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9C,SAAgB,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;gBAG1C,OAAO,EAAE,MAAM,EACf,SAAS,CAAC,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,MAAM,EAChB,KAAK,CAAC,EAAE,KAAK;CAQhB"}

package/dist/functionBuilder.d.ts

@@ -0,0 +1,110 @@
+import { z } from 'zod';
+import { Tool, PerformCallFn } from './types';
+/**
+ * Interface for generated agent functions with metadata.
+ * Compatible with both LangChain JS and Vercel AI SDK without conversion.
+ */
+export interface AgentFunction {
+    (...args: unknown[]): Promise<unknown>;
+    name: string;
+    description: string;
+    schema: z.ZodSchema<any>;
+    invoke: (args: unknown) => Promise<unknown>;
+    lc_namespace: string[];
+    returnDirect: boolean;
+    inputSchema: z.ZodSchema<any>;
+    execute: (args: unknown) => Promise<unknown>;
+    _schema: Tool;
+    _serverName: string;
+    _toolName: string;
+}
+/**
+ * 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().
+ */
+export declare class FunctionBuilder {
+    #private;
+    /**
+     * Initialize a FunctionBuilder with an injected function.
+     *
+     * @param performCall - Function to execute tool calls
+     */
+    constructor(performCall: PerformCallFn);
+    /**
+     * 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
+     */
+    private safeName;
+    /**
+     * 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}"
+     */
+    private functionName;
+    /**
+     * 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: Tool, serverName: string): AgentFunction;
+    /**
+     * Build the actual function from the schema.
+     *
+     * @param schema - The tool schema
+     * @param serverName - The server name
+     * @returns The generated function with metadata
+     */
+    private buildFunction;
+    /**
+     * 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
+     */
+    private createDocstring;
+    /**
+     * Clear the function cache.
+     *
+     * This method clears all cached generated functions, forcing them to be
+     * regenerated on the next call to createFunctionFromSchema().
+     */
+    clearCache(): void;
+    /**
+     * Get the current cache size.
+     *
+     * @returns The number of functions currently cached
+     */
+    getCacheSize(): number;
+}
+//# sourceMappingURL=functionBuilder.d.ts.map

package/dist/functionBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"functionBuilder.d.ts","sourceRoot":"","sources":["../src/functionBuilder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,IAAI,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAGnD;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAGvC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IAIpB,MAAM,EAAE,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;IACzB,MAAM,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC5C,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,YAAY,EAAE,OAAO,CAAC;IAItB,WAAW,EAAE,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;IAC9B,OAAO,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAG7C,OAAO,EAAE,IAAI,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;GASG;AACH,qBAAa,eAAe;;IAI1B;;;;OAIG;gBACS,WAAW,EAAE,aAAa;IA2EtC;;;;;;;;;OASG;IACH,OAAO,CAAC,QAAQ;IAKhB;;;;;;;;;;OAUG;IACH,OAAO,CAAC,YAAY;IAIpB;;;;;;;;;;;;;OAaG;IACH,wBAAwB,CAAC,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,GAAG,aAAa;IAoBzE;;;;;;OAMG;IACH,OAAO,CAAC,aAAa;IAoIrB;;;;;;;;;OASG;IACH,OAAO,CAAC,eAAe;IAoCvB;;;;;OAKG;IACH,UAAU,IAAI,IAAI;IAIlB;;;;OAIG;IACH,YAAY,IAAI,MAAM;CAGvB"}

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * mcpd JavaScript/TypeScript SDK.
+ *
+ * A JavaScript/TypeScript SDK for interacting with the mcpd daemon, which manages
+ * Model Context Protocol (MCP) servers and enables seamless tool execution
+ * through natural JavaScript syntax.
+ *
+ * This package provides:
+ * - McpdClient: Main client for server management and tool execution
+ * - Dynamic calling: Natural syntax like client.servers.time.get_current_time(args)
+ * - Agent-ready functions: Generate callable functions via getAgentTools() for AI frameworks
+ * - Type-safe function generation: Create callable functions from tool schemas
+ * - Comprehensive error handling: Detailed exceptions for different failure modes
+ *
+ * @packageDocumentation
+ */
+export { McpdClient } from './client';
+export { McpdError, AuthenticationError, ConnectionError, ServerNotFoundError, ServerUnhealthyError, TimeoutError, ToolExecutionError, ToolNotFoundError, ValidationError, } from './errors';
+export { HealthStatus, HealthStatusHelpers, type JsonSchema, type Tool, type Tools, type ToolAnnotations, type ServerHealth, type ToolsResponse, type HealthResponse, type McpdClientOptions, type ErrorDetail, type ErrorModel, type ToolFormat, type AgentToolsOptions, type Resource, type Resources, type ResourceContent, type ResourceTemplate, type ResourceTemplates, type Prompt, type PromptArgument, type Prompts, type PromptMessage, type PromptGenerateArguments, type GeneratePromptResponseBody, } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAGtC,OAAO,EACL,SAAS,EACT,mBAAmB,EACnB,eAAe,EACf,mBAAmB,EACnB,oBAAoB,EACpB,YAAY,EACZ,kBAAkB,EAClB,iBAAiB,EACjB,eAAe,GAChB,MAAM,UAAU,CAAC;AAGlB,OAAO,EACL,YAAY,EACZ,mBAAmB,EACnB,KAAK,UAAU,EACf,KAAK,IAAI,EACT,KAAK,KAAK,EACV,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,KAAK,WAAW,EAChB,KAAK,UAAU,EACf,KAAK,UAAU,EACf,KAAK,iBAAiB,EACtB,KAAK,QAAQ,EACb,KAAK,SAAS,EACd,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACtB,KAAK,MAAM,EACX,KAAK,cAAc,EACnB,KAAK,OAAO,EACZ,KAAK,aAAa,EAClB,KAAK,uBAAuB,EAC5B,KAAK,0BAA0B,GAChC,MAAM,SAAS,CAAC"}