@yourgpt/copilot-sdk 2.0.1 → 2.0.2-beta.2

package/dist/mcp/index.d.ts

@@ -0,0 +1,779 @@
+import { M as MCPClientConfig, a as MCPClientEvents, b as MCPClientState, c as MCPToolCallResult, d as MCPToolDefinition, e as MCPServerInfo, f as MCPServerCapabilities, g as MCPConnectionState, J as JsonRpcRequest, h as JsonRpcNotification, i as JsonRpcMessage, j as JsonRpcResponse, k as MCPClientInfo, l as MCPClientCapabilities, m as MCPInitializeParams, n as MCPToolCallParams } from '../types-Cizh9K_f.js';
+export { I as JSON_RPC_ERROR_CODES, t as JsonRpcError, C as MCPElicitationOption, A as MCPElicitationRequest, B as MCPElicitationResponse, G as MCPError, q as MCPHttpTransportConfig, x as MCPImageContent, y as MCPResourceContent, r as MCPSSETransportConfig, s as MCPStdioTransportConfig, w as MCPTextContent, u as MCPToolInputSchema, v as MCPToolResultContent, p as MCPTransportConfig, o as MCPTransportType, z as MCPUIContent, H as MCP_PROTOCOL_VERSION, U as UseMCPClientConfig, D as UseMCPClientReturn, E as UseMCPToolsConfig, F as UseMCPToolsReturn } from '../types-Cizh9K_f.js';
+import { T as ToolDefinition } from '../tools-DDWrco4h.js';
+export { D as DEFAULT_MCP_UI_SANDBOX, f as MCPUIActionIntent, n as MCPUIFrameProps, d as MCPUIIntent, l as MCPUIIntentContext, k as MCPUIIntentHandler, i as MCPUILinkIntent, j as MCPUIMessage, h as MCPUINotifyIntent, g as MCPUIPromptIntent, M as MCPUIResource, a as MCPUIResourceContent, c as MCPUIResourceMetadata, b as MCPUIResourceMimeType, e as MCPUIToolIntent, R as RESTRICTED_MCP_UI_SANDBOX, U as UseMCPUIIntentsConfig, m as UseMCPUIIntentsReturn, p as isMCPUIIntent, q as isMCPUIMessage, o as isMCPUIResourceContent, r as parseMCPUIMessage } from '../types-B20VCJXL.js';
+
+/**
+ * MCP Client
+ *
+ * The core client class for connecting to MCP servers and managing
+ * tools, resources, and the connection lifecycle.
+ */
+
+/**
+ * MCP Client
+ *
+ * Provides a simple interface for connecting to MCP servers and using their tools.
+ *
+ * @example
+ * ```typescript
+ * const client = new MCPClient({
+ *   name: "github",
+ *   transport: "http",
+ *   url: "https://mcp.github.com",
+ *   headers: { Authorization: `Bearer ${token}` },
+ * });
+ *
+ * await client.connect();
+ * const tools = client.toToolDefinitions();
+ * const result = await client.callTool("create_issue", { title: "Bug" });
+ * await client.disconnect();
+ * ```
+ */
+declare class MCPClient {
+    private config;
+    private transport?;
+    private rpcHandler;
+    private state;
+    private events;
+    private toolAdapter;
+    constructor(config: MCPClientConfig, events?: MCPClientEvents);
+    /**
+     * Get the current client state
+     */
+    getState(): Readonly<MCPClientState>;
+    /**
+     * Get the client name
+     */
+    getName(): string;
+    /**
+     * Check if client is connected
+     */
+    isConnected(): boolean;
+    /**
+     * Connect to the MCP server
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the MCP server
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Call an MCP tool
+     */
+    callTool(name: string, args?: Record<string, unknown>): Promise<MCPToolCallResult>;
+    /**
+     * Refresh the list of available tools
+     */
+    refreshTools(): Promise<MCPToolDefinition[]>;
+    /**
+     * Convert MCP tools to ToolDefinition format for use with CopilotProvider
+     */
+    toToolDefinitions(options?: {
+        prefixToolNames?: boolean;
+        serverLocation?: boolean;
+    }): ToolDefinition[];
+    /**
+     * Get the list of MCP tools
+     */
+    getTools(): MCPToolDefinition[];
+    /**
+     * Get server info
+     */
+    getServerInfo(): MCPServerInfo | undefined;
+    /**
+     * Get server capabilities
+     */
+    getServerCapabilities(): MCPServerCapabilities | undefined;
+    /**
+     * Ping the server to check connectivity
+     */
+    ping(): Promise<boolean>;
+    /**
+     * Create transport based on config
+     */
+    private createTransport;
+    /**
+     * Perform MCP initialization handshake
+     */
+    private initialize;
+    /**
+     * Send a JSON-RPC request and wait for response
+     */
+    private request;
+    /**
+     * Send a JSON-RPC notification (no response expected)
+     */
+    private notify;
+    /**
+     * Handle incoming JSON-RPC message
+     */
+    private handleMessage;
+    /**
+     * Handle server notification
+     */
+    private handleNotification;
+    /**
+     * Handle server-initiated request (e.g., elicitation)
+     */
+    private handleServerRequest;
+    /**
+     * Handle transport error
+     */
+    private handleError;
+    /**
+     * Handle transport close
+     */
+    private handleClose;
+    /**
+     * Update connection state
+     */
+    private setConnectionState;
+    /**
+     * Ensure client is connected
+     */
+    private ensureConnected;
+}
+/**
+ * Create an MCP client
+ *
+ * Factory function for creating MCPClient instances.
+ *
+ * @example
+ * ```typescript
+ * const client = createMCPClient({
+ *   name: "github",
+ *   transport: "http",
+ *   url: "https://mcp.github.com",
+ * });
+ *
+ * await client.connect();
+ * const tools = client.toToolDefinitions();
+ * ```
+ */
+declare function createMCPClient(config: MCPClientConfig, events?: MCPClientEvents): MCPClient;
+
+/**
+ * MCP Client Manager configuration for a single client
+ */
+interface MCPManagedClientConfig extends MCPClientConfig {
+    /** Enable this client (default: true) */
+    enabled?: boolean;
+}
+/**
+ * MCP Client Manager events
+ */
+interface MCPClientManagerEvents {
+    /** Called when any client's connection state changes */
+    onConnectionStateChange?: (clientName: string, state: MCPConnectionState) => void;
+    /** Called when any client's tools change */
+    onToolsChange?: (clientName: string, tools: MCPToolDefinition[]) => void;
+    /** Called when any client encounters an error */
+    onError?: (clientName: string, error: Error) => void;
+    /** Called when all clients are connected */
+    onAllConnected?: () => void;
+    /** Called when all clients are disconnected */
+    onAllDisconnected?: () => void;
+}
+/**
+ * Aggregated state for all managed clients
+ */
+interface MCPClientManagerState {
+    /** Individual client states */
+    clients: Record<string, MCPClientState>;
+    /** All tools from all connected clients */
+    allTools: MCPToolDefinition[];
+    /** Whether all enabled clients are connected */
+    allConnected: boolean;
+    /** Whether any client is connecting */
+    anyConnecting: boolean;
+    /** Whether any client has an error */
+    anyError: boolean;
+    /** Total number of tools across all clients */
+    totalToolCount: number;
+}
+/**
+ * MCP Client Manager
+ *
+ * Manages multiple MCP client connections for scenarios where you need
+ * to connect to multiple MCP servers simultaneously.
+ *
+ * @example
+ * ```typescript
+ * const manager = new MCPClientManager([
+ *   { name: "github", transport: "http", url: "https://mcp.github.com" },
+ *   { name: "slack", transport: "http", url: "https://mcp.slack.com" },
+ *   { name: "filesystem", transport: "stdio", command: "npx", args: ["-y", "@anthropic/filesystem-mcp-server"] },
+ * ]);
+ *
+ * await manager.connectAll();
+ *
+ * // Get all tools from all clients
+ * const tools = manager.getAllToolDefinitions();
+ *
+ * // Call a tool on a specific client
+ * const result = await manager.callTool("github", "create_issue", { title: "Bug" });
+ *
+ * await manager.disconnectAll();
+ * ```
+ */
+declare class MCPClientManager {
+    private clients;
+    private configs;
+    private events;
+    constructor(configs: MCPManagedClientConfig[], events?: MCPClientManagerEvents);
+    /**
+     * Get the current aggregated state
+     */
+    getState(): MCPClientManagerState;
+    /**
+     * Connect all enabled clients
+     */
+    connectAll(): Promise<void>;
+    /**
+     * Connect a specific client
+     */
+    connect(name: string): Promise<void>;
+    /**
+     * Disconnect all clients
+     */
+    disconnectAll(): Promise<void>;
+    /**
+     * Disconnect a specific client
+     */
+    disconnect(name: string): Promise<void>;
+    /**
+     * Get a specific client
+     */
+    getClient(name: string): MCPClient | undefined;
+    /**
+     * Get all connected clients
+     */
+    getConnectedClients(): MCPClient[];
+    /**
+     * Get all tool definitions from all connected clients
+     */
+    getAllToolDefinitions(options?: {
+        prefixToolNames?: boolean;
+    }): ToolDefinition[];
+    /**
+     * Get tool definitions from a specific client
+     */
+    getToolDefinitions(name: string, options?: {
+        prefixToolNames?: boolean;
+    }): ToolDefinition[];
+    /**
+     * Call a tool on a specific client
+     */
+    callTool(clientName: string, toolName: string, args?: Record<string, unknown>): Promise<MCPToolCallResult>;
+    /**
+     * Refresh tools for all connected clients
+     */
+    refreshAllTools(): Promise<void>;
+    /**
+     * Check if a specific client is connected
+     */
+    isConnected(name: string): boolean;
+    /**
+     * Create a client with event forwarding
+     */
+    private createClient;
+}
+/**
+ * Create an MCP Client Manager
+ */
+declare function createMCPClientManager(configs: MCPManagedClientConfig[], events?: MCPClientManagerEvents): MCPClientManager;
+
+/**
+ * MCP Transport Types
+ *
+ * Defines the base transport interface and common types.
+ */
+
+/**
+ * MCP transport interface
+ *
+ * All transports (HTTP, SSE, stdio) must implement this interface.
+ */
+interface MCPTransport {
+    /**
+     * Connect the transport
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect the transport
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Send a JSON-RPC message
+     */
+    send(message: JsonRpcRequest | JsonRpcNotification): Promise<void>;
+    /**
+     * Set message handler for incoming messages
+     */
+    onMessage(handler: MessageHandler): void;
+    /**
+     * Set error handler
+     */
+    onError(handler: ErrorHandler): void;
+    /**
+     * Set close handler
+     */
+    onClose(handler: CloseHandler): void;
+    /**
+     * Check if transport is connected
+     */
+    isConnected(): boolean;
+}
+/**
+ * Message handler callback
+ */
+type MessageHandler = (message: JsonRpcMessage) => void;
+/**
+ * Error handler callback
+ */
+type ErrorHandler = (error: Error) => void;
+/**
+ * Close handler callback
+ */
+type CloseHandler = () => void;
+/**
+ * Base transport options
+ */
+interface TransportOptions {
+    /** Request timeout in milliseconds */
+    timeout?: number;
+}
+/**
+ * HTTP transport options
+ */
+interface HttpTransportOptions extends TransportOptions {
+    /** Server URL */
+    url: string;
+    /** Custom headers */
+    headers?: Record<string, string>;
+    /** Session ID (managed internally) */
+    sessionId?: string;
+}
+/**
+ * SSE transport options
+ */
+interface SSETransportOptions extends TransportOptions {
+    /** Server URL */
+    url: string;
+    /** Custom headers */
+    headers?: Record<string, string>;
+}
+/**
+ * Stdio transport options
+ */
+interface StdioTransportOptions extends TransportOptions {
+    /** Command to execute */
+    command: string;
+    /** Command arguments */
+    args?: string[];
+    /** Environment variables */
+    env?: Record<string, string>;
+    /** Working directory */
+    cwd?: string;
+}
+/**
+ * Abstract base transport class
+ *
+ * Provides common functionality for all transports.
+ */
+declare abstract class BaseTransport implements MCPTransport {
+    protected messageHandler?: MessageHandler;
+    protected errorHandler?: ErrorHandler;
+    protected closeHandler?: CloseHandler;
+    protected connected: boolean;
+    abstract connect(): Promise<void>;
+    abstract disconnect(): Promise<void>;
+    abstract send(message: JsonRpcRequest | JsonRpcNotification): Promise<void>;
+    onMessage(handler: MessageHandler): void;
+    onError(handler: ErrorHandler): void;
+    onClose(handler: CloseHandler): void;
+    isConnected(): boolean;
+    /**
+     * Emit a message to the handler
+     */
+    protected emitMessage(message: JsonRpcMessage): void;
+    /**
+     * Emit an error to the handler
+     */
+    protected emitError(error: Error): void;
+    /**
+     * Emit close event
+     */
+    protected emitClose(): void;
+}
+
+/**
+ * HTTP Streamable Transport for MCP
+ *
+ * Implements the HTTP Streamable transport as recommended by the MCP specification.
+ * This transport uses HTTP POST requests for sending messages and can handle
+ * streaming responses via SSE when needed.
+ */
+
+/**
+ * HTTP Streamable Transport
+ *
+ * The recommended transport for MCP over HTTP. Supports both request/response
+ * and server-initiated messages via SSE.
+ */
+declare class HttpTransport extends BaseTransport {
+    private url;
+    private headers;
+    private timeout;
+    private sessionId?;
+    private eventSource?;
+    private abortController?;
+    constructor(options: HttpTransportOptions);
+    /**
+     * Connect the HTTP transport
+     *
+     * For HTTP transport, "connecting" means verifying the endpoint is reachable.
+     * The actual session is established during the initialize handshake.
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect the HTTP transport
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Send a JSON-RPC message and handle the response
+     */
+    send(message: JsonRpcRequest | JsonRpcNotification): Promise<void>;
+    /**
+     * Send an HTTP request
+     */
+    private sendRequest;
+    /**
+     * Handle an SSE response stream
+     */
+    private handleSSEResponse;
+    /**
+     * Parse response text into JSON-RPC messages
+     */
+    private parseResponseText;
+    /**
+     * Validate a JSON-RPC message
+     */
+    private isValidJsonRpcMessage;
+    /**
+     * Start listening for server-initiated events via SSE
+     *
+     * This is optional and used when the server supports server-initiated
+     * notifications (e.g., tools/list_changed).
+     */
+    startEventStream(): void;
+    /**
+     * Stop the event stream
+     */
+    stopEventStream(): void;
+    /**
+     * Get the current session ID
+     */
+    getSessionId(): string | undefined;
+    /**
+     * Set the session ID (used after initialization)
+     */
+    setSessionId(sessionId: string): void;
+}
+
+/**
+ * SSE (Server-Sent Events) Transport for MCP
+ *
+ * Implements SSE transport for MCP servers that prefer server-push
+ * communication. Sends requests via HTTP POST and receives responses
+ * and notifications via SSE.
+ */
+
+/**
+ * SSE Transport
+ *
+ * Uses HTTP POST for sending requests and Server-Sent Events for
+ * receiving responses and server-initiated notifications.
+ */
+declare class SSETransport extends BaseTransport {
+    private url;
+    private headers;
+    private timeout;
+    private eventSource?;
+    private messageEndpoint?;
+    private sessionId?;
+    constructor(options: SSETransportOptions);
+    /**
+     * Connect to the SSE endpoint
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the SSE endpoint
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Send a JSON-RPC message via HTTP POST
+     */
+    send(message: JsonRpcRequest | JsonRpcNotification): Promise<void>;
+    /**
+     * Handle an SSE message
+     */
+    private handleSSEMessage;
+    /**
+     * Parse response text into JSON-RPC messages
+     */
+    private parseResponseText;
+    /**
+     * Validate a JSON-RPC message
+     */
+    private isValidJsonRpcMessage;
+    /**
+     * Get the current session ID
+     */
+    getSessionId(): string | undefined;
+}
+
+/**
+ * Stdio Transport for MCP
+ *
+ * Implements stdio transport for local MCP servers.
+ * This transport spawns a child process and communicates via stdin/stdout.
+ *
+ * NOTE: This transport only works in Node.js environments (server-side).
+ * It will not work in browser environments.
+ */
+
+/**
+ * Stdio Transport
+ *
+ * Spawns a local MCP server process and communicates via stdin/stdout
+ * using newline-delimited JSON.
+ *
+ * @example
+ * ```typescript
+ * const transport = new StdioTransport({
+ *   command: "npx",
+ *   args: ["-y", "@anthropic/filesystem-mcp-server", "/path/to/dir"],
+ * });
+ *
+ * await transport.connect();
+ * await transport.send({ jsonrpc: "2.0", method: "initialize", ... });
+ * ```
+ */
+declare class StdioTransport extends BaseTransport {
+    private command;
+    private args;
+    private env?;
+    private cwd?;
+    private process?;
+    private buffer;
+    private spawn?;
+    constructor(options: StdioTransportOptions);
+    /**
+     * Connect by spawning the MCP server process
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect by killing the process
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Send a JSON-RPC message via stdin
+     */
+    send(message: JsonRpcRequest | JsonRpcNotification): Promise<void>;
+    /**
+     * Handle incoming data from stdout
+     */
+    private handleData;
+    /**
+     * Validate a JSON-RPC message
+     */
+    private isValidJsonRpcMessage;
+}
+
+/**
+ * JSON-RPC 2.0 Handler for MCP
+ *
+ * Handles creation, parsing, and validation of JSON-RPC messages.
+ */
+
+/**
+ * JSON-RPC 2.0 Handler
+ *
+ * Manages request/response lifecycle, message creation, and parsing.
+ */
+declare class JsonRpcHandler {
+    private requestId;
+    private pendingRequests;
+    private defaultTimeout;
+    constructor(options?: {
+        timeout?: number;
+    });
+    /**
+     * Generate a unique request ID
+     */
+    generateId(): string;
+    /**
+     * Create a JSON-RPC request
+     */
+    createRequest(method: string, params?: Record<string, unknown>): JsonRpcRequest;
+    /**
+     * Create a JSON-RPC notification (no response expected)
+     */
+    createNotification(method: string, params?: Record<string, unknown>): JsonRpcNotification;
+    /**
+     * Register a pending request and return a promise that resolves when response is received
+     */
+    registerRequest(request: JsonRpcRequest, timeout?: number): Promise<unknown>;
+    /**
+     * Handle an incoming JSON-RPC response
+     */
+    handleResponse(response: JsonRpcResponse): boolean;
+    /**
+     * Parse a JSON-RPC message from string
+     */
+    parse(data: string): JsonRpcMessage;
+    /**
+     * Serialize a JSON-RPC message to string
+     */
+    serialize(message: JsonRpcMessage): string;
+    /**
+     * Validate a JSON-RPC message
+     */
+    isValidMessage(message: unknown): message is JsonRpcMessage;
+    /**
+     * Check if message is a request
+     */
+    isRequest(message: JsonRpcMessage): message is JsonRpcRequest;
+    /**
+     * Check if message is a notification
+     */
+    isNotification(message: JsonRpcMessage): message is JsonRpcNotification;
+    /**
+     * Check if message is a response
+     */
+    isResponse(message: JsonRpcMessage): message is JsonRpcResponse;
+    /**
+     * Cancel all pending requests
+     */
+    cancelAllPending(reason?: string): void;
+    /**
+     * Get number of pending requests
+     */
+    getPendingCount(): number;
+    /**
+     * Check if a specific request is pending
+     */
+    isPending(id: string | number): boolean;
+}
+
+declare const MCP_METHODS: {
+    readonly INITIALIZE: "initialize";
+    readonly INITIALIZED: "notifications/initialized";
+    readonly PING: "ping";
+    readonly TOOLS_LIST: "tools/list";
+    readonly TOOLS_CALL: "tools/call";
+    readonly RESOURCES_LIST: "resources/list";
+    readonly RESOURCES_READ: "resources/read";
+    readonly RESOURCES_SUBSCRIBE: "resources/subscribe";
+    readonly RESOURCES_UNSUBSCRIBE: "resources/unsubscribe";
+    readonly PROMPTS_LIST: "prompts/list";
+    readonly PROMPTS_GET: "prompts/get";
+    readonly TOOLS_LIST_CHANGED: "notifications/tools/list_changed";
+    readonly RESOURCES_LIST_CHANGED: "notifications/resources/list_changed";
+    readonly RESOURCES_UPDATED: "notifications/resources/updated";
+    readonly PROMPTS_LIST_CHANGED: "notifications/prompts/list_changed";
+    readonly ELICITATION_REQUEST: "elicitation/request";
+    readonly ELICITATION_RESPONSE: "elicitation/response";
+    readonly LOGGING_SET_LEVEL: "logging/setLevel";
+    readonly LOGGING_MESSAGE: "notifications/message";
+    readonly CANCEL: "notifications/cancelled";
+};
+/**
+ * Default client info for YourGPT Copilot SDK
+ */
+declare const DEFAULT_CLIENT_INFO: MCPClientInfo;
+/**
+ * Default client capabilities
+ */
+declare const DEFAULT_CLIENT_CAPABILITIES: MCPClientCapabilities;
+/**
+ * Create initialize params
+ */
+declare function createInitializeParams(clientInfo?: Partial<MCPClientInfo>, capabilities?: MCPClientCapabilities): MCPInitializeParams;
+/**
+ * Create tools/list params
+ */
+declare function createToolsListParams(cursor?: string): {
+    cursor?: string;
+};
+/**
+ * Create tools/call params
+ */
+declare function createToolCallParams(name: string, args?: Record<string, unknown>): MCPToolCallParams;
+
+/**
+ * MCP Tool Adapter
+ *
+ * Converts MCP tool definitions to the SDK's ToolDefinition format.
+ */
+
+/**
+ * Options for converting MCP tools to ToolDefinitions
+ */
+interface MCPToolAdapterOptions {
+    /** Prefix tool names with client name */
+    prefix?: boolean;
+    /** Register as server-side tool (default: true for MCP tools) */
+    asServerTool?: boolean;
+    /** Function to call the MCP tool */
+    callTool: (name: string, args?: Record<string, unknown>) => Promise<MCPToolCallResult>;
+}
+/**
+ * MCP Tool Adapter
+ *
+ * Handles conversion between MCP tool format and SDK ToolDefinition format.
+ */
+declare class MCPToolAdapter {
+    private clientName;
+    constructor(clientName: string);
+    /**
+     * Convert an MCP tool to a ToolDefinition
+     */
+    toToolDefinition(mcpTool: MCPToolDefinition, options: MCPToolAdapterOptions): ToolDefinition;
+    /**
+     * Convert multiple MCP tools to ToolDefinitions
+     */
+    toToolDefinitions(mcpTools: MCPToolDefinition[], options: MCPToolAdapterOptions): ToolDefinition[];
+    /**
+     * Convert MCP input schema to SDK ToolInputSchema
+     */
+    private convertInputSchema;
+    /**
+     * Convert MCP schema properties to SDK JSONSchemaProperty format
+     */
+    private convertProperties;
+    /**
+     * Convert a single MCP property to SDK format
+     */
+    private convertProperty;
+    /**
+     * Convert MCP tool result to SDK ToolResponse
+     */
+    private convertResult;
+    /**
+     * Format tool name as a readable title
+     */
+    private formatToolTitle;
+}
+/**
+ * Convert an MCP tool to a ToolDefinition (standalone function)
+ */
+declare function mcpToolToDefinition(clientName: string, mcpTool: MCPToolDefinition, options: MCPToolAdapterOptions): ToolDefinition;
+/**
+ * Convert multiple MCP tools to ToolDefinitions (standalone function)
+ */
+declare function mcpToolsToDefinitions(clientName: string, mcpTools: MCPToolDefinition[], options: MCPToolAdapterOptions): ToolDefinition[];
+
+export { BaseTransport, DEFAULT_CLIENT_CAPABILITIES, DEFAULT_CLIENT_INFO, HttpTransport, type HttpTransportOptions, JsonRpcHandler, JsonRpcMessage, JsonRpcNotification, JsonRpcRequest, JsonRpcResponse, MCPClient, MCPClientCapabilities, MCPClientConfig, MCPClientEvents, MCPClientInfo, MCPClientManager, type MCPClientManagerEvents, type MCPClientManagerState, MCPClientState, MCPConnectionState, type MCPManagedClientConfig, MCPServerCapabilities, MCPServerInfo, MCPToolAdapter, type MCPToolAdapterOptions, MCPToolCallParams, MCPToolCallResult, MCPToolDefinition, type MCPTransport, MCP_METHODS, SSETransport, type SSETransportOptions, StdioTransport, type StdioTransportOptions, createInitializeParams, createMCPClient, createMCPClientManager, createToolCallParams, createToolsListParams, mcpToolToDefinition, mcpToolsToDefinitions };