@mcp-use/client 0.0.0-bootstrap.0 → 2.0.0-beta.1

package/dist/core/base.d.ts

@@ -0,0 +1,418 @@
+import type { OAuthClientProvider } from "@modelcontextprotocol/client";
+import type { BaseConnector } from "../transport/base.js";
+import type { AutoOAuthOptions, MCPClientConfigShape, ServerConfig } from "./config.js";
+import { MCPSession } from "./session.js";
+import type { MCPConnection } from "./session.js";
+/**
+ * Base MCPClient class with shared functionality across all environments.
+ *
+ * This abstract class provides the core client logic for managing MCP servers,
+ * sessions, and configurations. It works in both Node.js and browser environments
+ * by delegating platform-specific operations to concrete implementations.
+ *
+ * Platform-specific implementations (like {@link MCPClient} for Node.js) should
+ * extend this class and override the abstract {@link createConnectorFromConfig}
+ * method to provide environment-specific connector creation.
+ *
+ * @example
+ * ```typescript
+ * // Typically used through concrete implementations
+ * import { MCPClient } from "@mcp-use/client";
+ *
+ * const client = new MCPClient({
+ *   mcpServers: {
+ *     'my-server': {
+ *       command: 'node',
+ *       args: ['server.js']
+ *     }
+ *   }
+ * });
+ * ```
+ *
+ * @see {@link MCPClient} for Node.js-specific implementation
+ * @see {@link MCPSession} for session management
+ */
+export declare abstract class BaseMCPClient {
+    /**
+     * Internal configuration object containing MCP server definitions.
+     * @protected
+     */
+    protected config: MCPClientConfigShape;
+    /**
+     * Map of server names to their active sessions.
+     * @protected
+     */
+    protected sessions: Record<string, MCPSession>;
+    /**
+     * List of server names that have active sessions.
+     * This array is kept in sync with the sessions map and can be used
+     * to iterate over active connections.
+     *
+     * @example
+     * ```typescript
+     * console.log(`Active servers: ${client.activeSessions.join(', ')}`);
+     * ```
+     */
+    activeSessions: string[];
+    /**
+     * Creates a new BaseMCPClient instance.
+     *
+     * @param config - Optional configuration object with MCP server definitions
+     *
+     * @example
+     * ```typescript
+     * const client = new MCPClient({
+     *   mcpServers: {
+     *     'example': {
+     *       command: 'node',
+     *       args: ['server.js']
+     *     }
+     *   }
+     * });
+     * ```
+     */
+    constructor(config?: MCPClientConfigShape);
+    /**
+     * Creates a client instance from a configuration dictionary.
+     *
+     * This static factory method must be implemented by concrete subclasses
+     * to provide proper type information and platform-specific initialization.
+     *
+     * @param _cfg - Configuration dictionary
+     * @returns Client instance
+     * @throws {Error} If called on the base class instead of a concrete implementation
+     *
+     * @example
+     * ```typescript
+     * const client = MCPClient.fromDict({
+     *   mcpServers: {
+     *     'my-server': { command: 'node', args: ['server.js'] }
+     *   }
+     * });
+     * ```
+     */
+    static fromDict(_cfg: MCPClientConfigShape): BaseMCPClient;
+    /**
+     * Adds a new MCP server configuration to the client.
+     *
+     * This method adds or updates a server configuration dynamically without
+     * needing to restart the client. The server can then be used to create
+     * new sessions.
+     *
+     * @param name - Unique name for the server
+     * @param serverConfig - Server configuration object (connector type, command, args, etc.)
+     *
+     * @example
+     * ```typescript
+     * client.addServer('new-server', {
+     *   command: 'python',
+     *   args: ['server.py']
+     * });
+     *
+     * // Now you can create a session
+     * const session = await client.createSession('new-server');
+     * ```
+     *
+     * @see {@link removeServer} for removing servers
+     * @see {@link getServerConfig} for retrieving configurations
+     */
+    addServer(name: string, serverConfig: ServerConfig): void;
+    /**
+     * Removes an MCP server configuration from the client.
+     *
+     * This method removes a server configuration and cleans up any active
+     * sessions associated with that server. If there's an active session,
+     * it will be removed from the active sessions list.
+     *
+     * @param name - Name of the server to remove
+     *
+     * @example
+     * ```typescript
+     * // Remove a server configuration
+     * await client.removeServer('old-server');
+     *
+     * // The server name will no longer appear in getServerNames()
+     * console.log(client.getServerNames()); // 'old-server' is gone
+     * ```
+     *
+     * @see {@link addServer} for adding servers
+     * @see {@link closeSession} for properly closing sessions before removal
+     */
+    removeServer(name: string): Promise<void>;
+    /**
+     * Gets the names of all configured MCP servers.
+     *
+     * @returns Array of server names defined in the configuration
+     *
+     * @example
+     * ```typescript
+     * const serverNames = client.getServerNames();
+     * console.log(`Configured servers: ${serverNames.join(', ')}`);
+     *
+     * // Create sessions for all servers
+     * for (const name of serverNames) {
+     *   await client.createSession(name);
+     * }
+     * ```
+     *
+     * @see {@link activeSessions} for servers with active sessions
+     */
+    getServerNames(): string[];
+    /**
+     * Gets the configuration for a specific MCP server.
+     *
+     * @param name - Name of the server
+     * @returns Server configuration object, or undefined if not found
+     *
+     * @example
+     * ```typescript
+     * const config = client.getServerConfig('my-server');
+     * if (config) {
+     *   console.log(`Command: ${config.command}`);
+     *   console.log(`Args: ${config.args.join(' ')}`);
+     * }
+     * ```
+     *
+     * @see {@link getConfig} for retrieving the entire configuration
+     */
+    getServerConfig(name: string): ServerConfig | undefined;
+    /**
+     * Gets the complete client configuration.
+     *
+     * @returns Complete configuration object including all server definitions
+     *
+     * @example
+     * ```typescript
+     * const config = client.getConfig();
+     * console.log(`Total servers: ${Object.keys(config.mcpServers).length}`);
+     * ```
+     *
+     * @see {@link getServerConfig} for retrieving individual server configurations
+     */
+    getConfig(): MCPClientConfigShape;
+    /**
+     * Creates a connector from server configuration.
+     *
+     * This abstract method must be implemented by platform-specific subclasses
+     * to create the appropriate connector type (Stdio, HTTP, WebSocket, etc.)
+     * based on the server configuration and runtime environment.
+     *
+     * @param serverConfig - Server configuration object
+     * @returns Platform-specific connector instance
+     * @protected
+     */
+    protected abstract createConnectorFromConfig(serverConfig: ServerConfig): BaseConnector | Promise<BaseConnector>;
+    /**
+     * Platform OAuth provider used when an HTTP server has no bearer token /
+     * `authProvider`. Node and browser entries implement this via their
+     * `createOAuthProvider` export.
+     */
+    protected abstract createDefaultOAuthProvider(serverUrl: string, options?: AutoOAuthOptions): Promise<OAuthClientProvider>;
+    /**
+     * Creates a new session for connecting to an MCP server.
+     *
+     * @deprecated Use {@link connect}; modern MCP servers are sessionless.
+     *
+     * This method initializes a connection to the specified server using the
+     * configuration provided during client construction. Sessions manage the
+     * lifecycle of connections and provide methods for calling tools, listing
+     * resources, and more.
+     *
+     * If a session already exists for the server, it will be replaced with a new one.
+     *
+     * @param serverName - The name of the server as defined in the client configuration
+     * @param autoInitialize - Whether to automatically initialize the session (default: true)
+     * @returns A promise that resolves to the created MCPSession instance
+     * @throws {Error} If the server is not found in the configuration
+     *
+     * @example
+     * ```typescript
+     * // Create and initialize a session
+     * const session = await client.createSession('my-server');
+     * const tools = await session.listTools();
+     *
+     * // Create without auto-initialization
+     * const session = await client.createSession('my-server', false);
+     * await session.connect();
+     * await session.initialize();
+     * ```
+     *
+     * @see {@link MCPSession} for session management methods
+     * @see {@link closeSession} for closing sessions
+     * @see {@link getSession} for retrieving existing sessions
+     */
+    createSession(serverName: string, autoInitialize?: boolean): Promise<MCPSession>;
+    /**
+     * Connect to a configured MCP server and return a ready, protocol-neutral
+     * connection.
+     *
+     * The returned connection represents either a legacy sessionful server or a
+     * modern sessionless server uniformly. Inspect {@link MCPConnection.info} for
+     * the negotiated protocol version and normalized server metadata.
+     *
+     * @param serverName - The configured server name.
+     */
+    connect(serverName: string): Promise<MCPConnection>;
+    /**
+     * Creates sessions for all configured MCP servers.
+     *
+     * This is a convenience method that iterates through all servers in the
+     * configuration and creates a session for each one. Sessions are created
+     * sequentially to avoid overwhelming the system.
+     *
+     * @param autoInitialize - Whether to automatically initialize each session (default: true)
+     * @returns A promise that resolves to a map of server names to sessions
+     *
+     * @example
+     * ```typescript
+     * // Create sessions for all configured servers
+     * const sessions = await client.createAllSessions();
+     * console.log(`Created ${Object.keys(sessions).length} sessions`);
+     *
+     * // List tools from all servers
+     * for (const [name, session] of Object.entries(sessions)) {
+     *   const tools = await session.listTools();
+     *   console.log(`${name}: ${tools.length} tools`);
+     * }
+     * ```
+     *
+     * @see {@link createSession} for creating individual sessions
+     * @see {@link closeAllSessions} for closing all sessions
+     */
+    createAllSessions(autoInitialize?: boolean): Promise<Record<string, MCPSession>>;
+    /**
+     * Connect to every configured server sequentially.
+     *
+     * Each result uses the same {@link MCPConnection} API regardless of whether
+     * the negotiated protocol is legacy/sessionful or modern/sessionless.
+     */
+    connectAll(): Promise<Record<string, MCPConnection>>;
+    /**
+     * Retrieves an existing session by server name.
+     *
+     * This method returns null if no session exists, making it safe for
+     * checking session existence without throwing errors.
+     *
+     * @param serverName - Name of the server
+     * @returns The session instance or null if not found
+     *
+     * @example
+     * ```typescript
+     * const session = client.getSession('my-server');
+     * if (session) {
+     *   const tools = await session.listTools();
+     * } else {
+     *   console.log('Session not found, creating...');
+     *   await client.createSession('my-server');
+     * }
+     * ```
+     *
+     * @see {@link requireSession} for getting a session that throws if not found
+     * @see {@link createSession} for creating sessions
+     */
+    getSession(serverName: string): MCPSession | null;
+    /**
+     * Retrieves an existing session by server name, throwing if not found.
+     *
+     * This method is useful when you need to ensure a session exists before
+     * proceeding. It throws a descriptive error if the session is not found.
+     *
+     * @param serverName - Name of the server
+     * @returns The session instance
+     * @throws {Error} If the session is not found
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   const session = client.requireSession('my-server');
+     *   const tools = await session.listTools();
+     * } catch (error) {
+     *   console.error('Session not found:', error.message);
+     * }
+     * ```
+     *
+     * @see {@link getSession} for a null-returning alternative
+     * @see {@link createSession} for creating sessions
+     */
+    requireSession(serverName: string): MCPSession;
+    /**
+     * Gets all active sessions as a map of server names to sessions.
+     *
+     * @returns Map of server names to their active sessions
+     *
+     * @example
+     * ```typescript
+     * const sessions = client.getAllActiveSessions();
+     *
+     * // Iterate over all active sessions
+     * for (const [name, session] of Object.entries(sessions)) {
+     *   console.log(`Server: ${name}`);
+     *   const tools = await session.listTools();
+     *   console.log(`  Tools: ${tools.length}`);
+     * }
+     * ```
+     *
+     * @see {@link activeSessions} for just the list of server names
+     * @see {@link getSession} for retrieving individual sessions
+     */
+    getAllActiveSessions(): Record<string, MCPSession>;
+    /**
+     * Closes a session and cleans up its resources.
+     *
+     * This method gracefully disconnects from the server and removes the
+     * session from the active sessions list. It's safe to call even if
+     * the session doesn't exist.
+     *
+     * @param serverName - Name of the server whose session should be closed
+     *
+     * @example
+     * ```typescript
+     * // Close a specific session
+     * await client.closeSession('my-server');
+     *
+     * // Verify it's closed
+     * console.log(client.activeSessions.includes('my-server')); // false
+     * ```
+     *
+     * @see {@link closeAllSessions} for closing all sessions at once
+     * @see {@link createSession} for creating new sessions
+     */
+    closeSession(serverName: string): Promise<void>;
+    /**
+     * Closes all active sessions and cleans up their resources.
+     *
+     * This method iterates through all sessions and attempts to close each one
+     * gracefully. If any session fails to close, the error is logged but the
+     * method continues to close remaining sessions.
+     *
+     * This is particularly useful for cleanup on application shutdown.
+     *
+     * @example
+     * ```typescript
+     * // Clean shutdown
+     * try {
+     *   await client.closeAllSessions();
+     *   console.log('All sessions closed successfully');
+     * } catch (error) {
+     *   console.error('Error during cleanup:', error);
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Use in application shutdown handler
+     * process.on('SIGINT', async () => {
+     *   console.log('Shutting down...');
+     *   await client.closeAllSessions();
+     *   process.exit(0);
+     * });
+     * ```
+     *
+     * @see {@link closeSession} for closing individual sessions
+     * @see {@link createAllSessions} for creating sessions
+     */
+    closeAllSessions(): Promise<void>;
+    /** Close every active MCP connection. */
+    close(): Promise<void>;
+}
+//# sourceMappingURL=base.d.ts.map

package/dist/core/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../src/core/base.ts"],"names":[],"mappings":"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"}

package/dist/core/browser.d.ts

@@ -0,0 +1,20 @@
+import type { OAuthClientProvider } from "@modelcontextprotocol/client";
+import type { AutoOAuthOptions } from "./config.js";
+import type { BaseConnector } from "../transport/base.js";
+import { BaseMCPClient } from "./base.js";
+export declare class BrowserMCPClient extends BaseMCPClient {
+    /**
+     * Get the mcp-use package version.
+     * Works in all environments (Node.js, browser, Cloudflare Workers, Deno, etc.)
+     */
+    static getPackageVersion(): string;
+    constructor(config?: Record<string, any>);
+    static fromDict(cfg: Record<string, any>): BrowserMCPClient;
+    protected createDefaultOAuthProvider(serverUrl: string, options?: AutoOAuthOptions): Promise<OAuthClientProvider>;
+    /**
+     * Create a connector from server configuration (Browser version)
+     * Supports HTTP connector only
+     */
+    protected createConnectorFromConfig(serverConfig: Record<string, any>): BaseConnector;
+}
+//# sourceMappingURL=browser.d.ts.map

package/dist/core/browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../../src/core/browser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AACxE,OAAO,KAAK,EAAE,gBAAgB,EAAkB,MAAM,aAAa,CAAC;AAEpE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAS1D,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AA4B1C,qBAAa,gBAAiB,SAAQ,aAAa;IACjD;;;OAGG;WACW,iBAAiB,IAAI,MAAM;gBAI7B,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;WAK1B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,gBAAgB;cAIlD,0BAA0B,CACxC,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,gBAAqB,GAC7B,OAAO,CAAC,mBAAmB,CAAC;IAI/B;;;OAGG;IACH,SAAS,CAAC,yBAAyB,CACjC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAChC,aAAa;CAyDjB"}

package/dist/core/config.d.ts

@@ -0,0 +1,149 @@
+import type { ElicitRequestFormParams, ElicitRequestURLParams, ElicitResult, Notification, AuthProvider, OAuthClientInformation, OAuthClientProvider, Root, RequestTypeMap, RequestOptions, ResultTypeMap, ClientOptions, VersionNegotiationMode } from "@modelcontextprotocol/client";
+import type { BaseConnector, ConnectorInitOptions } from "../transport/base.js";
+import type { ClientInfo } from "../transport/http.js";
+/** Params for `sampling/createMessage` (avoids deprecated `CreateMessageRequest`). */
+export type SamplingCreateMessageParams = RequestTypeMap["sampling/createMessage"]["params"];
+/** Result for `sampling/createMessage` (avoids deprecated `CreateMessageResult`). */
+export type SamplingCreateMessageResult = ResultTypeMap["sampling/createMessage"];
+/** Callback for sampling requests (canonical name). */
+export type OnSamplingCallback = (params: SamplingCreateMessageParams) => Promise<SamplingCreateMessageResult>;
+/** Callback for elicitation requests (canonical name). */
+export type OnElicitationCallback = (params: ElicitRequestFormParams | ElicitRequestURLParams) => Promise<ElicitResult>;
+/** Callback for notifications (canonical name). */
+export type OnNotificationCallback = (notification: Notification) => void | Promise<void>;
+/**
+ * Callback options shared by per-server config and global defaults.
+ */
+export interface CallbackConfig {
+    /**
+     * Callback for sampling input.
+     *
+     * @deprecated Sampling is deprecated by the 2026 protocol. Retained for v1
+     * push requests and the v2 `input_required` compatibility window.
+     */
+    onSampling?: OnSamplingCallback;
+    /** Callback for elicitation requests from servers. */
+    onElicitation?: OnElicitationCallback;
+    /** Callback for notifications from servers. */
+    onNotification?: OnNotificationCallback;
+}
+/**
+ * Resolves effective callbacks from per-server and global config.
+ */
+export declare function resolveCallbacks(perServer: CallbackConfig | undefined, globalDefaults: CallbackConfig | undefined): {
+    onSampling?: OnSamplingCallback;
+    onElicitation?: OnElicitationCallback;
+    onNotification?: OnNotificationCallback;
+};
+/**
+ * Base server configuration with common optional fields
+ */
+interface BaseServerConfig extends CallbackConfig {
+    clientInfo?: ClientInfo;
+    /** Initial roots advertised to the server. */
+    roots?: Root[];
+    /** Options forwarded to the official MCP SDK Client. */
+    clientOptions?: ClientOptions;
+    /** Default timeout/cancellation options for requests. */
+    defaultRequestOptions?: RequestOptions;
+}
+/**
+ * Server configuration for STDIO connectors
+ */
+export interface StdioServerConfig extends BaseServerConfig {
+    command: string;
+    args: string[];
+    env?: Record<string, string>;
+    cwd?: string;
+    /**
+     * Protocol version negotiation mode. Defaults to `"legacy"` for stdio (the
+     * SDK advises against probing for spawn-per-invocation tools). See
+     * {@link StdioConnector}.
+     */
+    protocolNegotiation?: VersionNegotiationMode;
+}
+/**
+ * Options forwarded to the platform `createOAuthProvider` when the client
+ * auto-provisions OAuth for an HTTP server. Platform-specific fields
+ * (e.g. Node `openBrowser`, browser `oauthProxyUrl`) are accepted and ignored
+ * by the other runtime.
+ */
+export interface AutoOAuthOptions {
+    storageKeyPrefix?: string;
+    clientName?: string;
+    clientUri?: string;
+    logoUri?: string;
+    callbackUrl?: string;
+    clientMetadataUrl?: string;
+    scope?: string;
+    /** Pre-registered public client id (skips DCR). */
+    staticClientInfo?: OAuthClientInformation;
+    /** Node: preferred loopback port. */
+    preferredPort?: number;
+    /** Node: ports to walk on EADDRINUSE. */
+    portRange?: number;
+    /** Node: loopback wait timeout in ms. */
+    authTimeoutMs?: number;
+    /** Node: override browser launch (CLI prints the URL instead). */
+    openBrowser?: (url: string) => void | Promise<void>;
+    /** Browser: wait for explicit authenticate() instead of auto popup. */
+    preventAutoAuth?: boolean;
+    /** Browser: full-page redirect instead of popup. */
+    useRedirectFlow?: boolean;
+    /** Browser: same-origin OAuth BFF base URL. */
+    oauthProxyUrl?: string;
+    /** Browser: route OAuth HTTP through `oauthProxyUrl` (default true when set). */
+    proxyOAuthRequests?: boolean;
+}
+/**
+ * Server configuration for HTTP connectors
+ */
+export interface HttpServerConfig extends BaseServerConfig {
+    url: string;
+    headers?: Record<string, string>;
+    fetch?: typeof fetch;
+    authToken?: string;
+    /** Connection timeout in milliseconds. */
+    timeout?: number;
+    authProvider?: AuthProvider | OAuthClientProvider;
+    /**
+     * Auto-OAuth options for HTTP servers.
+     * - omit / `{}`: client creates the platform provider on connect
+     * - `false`: disable auto-OAuth (e.g. CLI `--no-oauth`)
+     * - object: forwarded to `createOAuthProvider`
+     *
+     * Ignored when `authProvider` or `authToken` is set, or when `headers`
+     * already includes `Authorization`.
+     */
+    oauth?: AutoOAuthOptions | false;
+    /**
+     * Protocol version negotiation mode. Defaults to `"auto"` to negotiate both
+     * v1 and v2 MCP servers. See {@link HttpConnector}.
+     */
+    protocolNegotiation?: VersionNegotiationMode;
+}
+/** True when the client should auto-create an OAuth provider for this server. */
+export declare function shouldAutoProvisionOAuth(serverConfig: ServerConfig): serverConfig is HttpServerConfig;
+/**
+ * Discriminated union of all supported server configuration types
+ */
+export type ServerConfig = StdioServerConfig | HttpServerConfig;
+/**
+ * Top-level MCP client configuration shape.
+ * May include global callback defaults and clientInfo applied when per-server config omits them.
+ */
+export interface MCPClientConfigShape extends CallbackConfig {
+    /** Default clientInfo for all servers; overridable per server. */
+    clientInfo?: ClientInfo;
+    mcpServers?: Record<string, ServerConfig>;
+}
+/**
+ * Normalizes and validates clientInfo from config.
+ * Ensures required fields (name, version) are present and merges with defaults.
+ */
+export declare function normalizeClientInfo(input: unknown): ClientInfo;
+/** Resolve SDK client options, expanding the MCP Apps `views` capability shorthand. */
+export declare function resolveClientOptions(clientOptions: ClientOptions | undefined): ClientOptions | undefined;
+export declare function createConnectorFromConfig(serverConfig: ServerConfig, connectorOptions?: Partial<ConnectorInitOptions>): BaseConnector;
+export {};
+//# sourceMappingURL=config.d.ts.map

package/dist/core/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/core/config.ts"],"names":[],"mappings":"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"}