@mcp-use/client 2.2.3 → 2.2.4

package/dist/code-mode/executor-vm.d.ts

@@ -1,39 +0,0 @@
-import type { MCPClient, VMExecutorOptions } from "../core/node.js";
-import { BaseCodeExecutor, type ExecutionResult } from "./executor.js";
-/**
- * Check if VM executor is available in the current environment
- * This is a synchronous check that returns true if vm was already loaded
- */
-export declare function isVMAvailable(): boolean;
-/**
- * VM-based code executor using Node.js vm module.
- * Executes code in an isolated V8 context with access to MCP tools.
- */
-export declare class VMCodeExecutor extends BaseCodeExecutor {
-    private defaultTimeout;
-    private memoryLimitMb?;
-    constructor(client: MCPClient, options?: VMExecutorOptions);
-    /**
-     * Ensure VM module is loaded before execution
-     */
-    private ensureVMLoaded;
-    /**
-     * Execute JavaScript/TypeScript code with access to MCP tools.
-     *
-     * @param code - Code to execute
-     * @param timeout - Execution timeout in milliseconds (default: configured timeout or 30000)
-     */
-    execute(code: string, timeout?: number): Promise<ExecutionResult>;
-    /**
-     * Build the VM execution context with MCP tools and standard globals.
-     *
-     * @param logs - Array to capture console output
-     */
-    private _buildContext;
-    /**
-     * Clean up resources.
-     * VM executor doesn't need cleanup, but method kept for interface consistency.
-     */
-    cleanup(): Promise<void>;
-}
-//# sourceMappingURL=executor-vm.d.ts.map

package/dist/code-mode/executor-vm.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"executor-vm.d.ts","sourceRoot":"","sources":["../../src/code-mode/executor-vm.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEpE,OAAO,EAAE,gBAAgB,EAAE,KAAK,eAAe,EAAE,MAAM,eAAe,CAAC;AAsEvE;;;GAGG;AACH,wBAAgB,aAAa,IAAI,OAAO,CAGvC;AAED;;;GAGG;AACH,qBAAa,cAAe,SAAQ,gBAAgB;IAClD,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,aAAa,CAAC,CAAS;gBAEnB,MAAM,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,iBAAiB;IAS1D;;OAEG;YACW,cAAc;IAc5B;;;;;OAKG;IACG,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IAsEvE;;;;OAIG;YACW,aAAa;IA6F3B;;;OAGG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAG/B"}

package/dist/code-mode/executor.d.ts

@@ -1,81 +0,0 @@
-import type { Tool } from "@modelcontextprotocol/client";
-import type { CodeExecutorFunction, MCPClient } from "../core/node.js";
-export interface ExecutionResult {
-    result: unknown;
-    logs: string[];
-    error: string | null;
-    execution_time: number;
-}
-interface ToolSearchResult {
-    name: string;
-    server: string;
-    description?: string;
-    input_schema?: Tool["inputSchema"];
-}
-interface ToolSearchMeta {
-    total_tools: number;
-    namespaces: string[];
-    result_count: number;
-}
-export interface ToolSearchResponse {
-    meta: ToolSearchMeta;
-    results: ToolSearchResult[];
-}
-type SearchToolsFunction = (query?: string, detailLevel?: "names" | "descriptions" | "full") => Promise<ToolSearchResponse>;
-interface ToolNamespaceInfo {
-    serverName: string;
-    tools: Tool[];
-    session: any;
-}
-/**
- * Abstract base class for code executors.
- * Provides shared functionality for connecting to MCP servers and building tool contexts.
- */
-export declare abstract class BaseCodeExecutor {
-    protected client: MCPClient;
-    protected _connecting: boolean;
-    constructor(client: MCPClient);
-    /**
-     * Execute code with access to MCP tools.
-     * @param code - The code to execute
-     * @param timeout - Execution timeout in milliseconds
-     */
-    abstract execute(code: string, timeout?: number): Promise<ExecutionResult>;
-    /**
-     * Clean up resources used by the executor.
-     * Should be called when the executor is no longer needed.
-     */
-    abstract cleanup(): Promise<void>;
-    /**
-     * Ensure all configured MCP servers are connected before execution.
-     * Prevents race conditions with a connection lock.
-     */
-    protected ensureServersConnected(): Promise<void>;
-    /**
-     * Get tool namespace information from all active MCP sessions.
-     * Filters out the internal code_mode server.
-     */
-    protected getToolNamespaces(): ToolNamespaceInfo[];
-    /**
-     * Create a search function for discovering available MCP tools.
-     * Used by code execution environments to find tools at runtime.
-     */
-    createSearchToolsFunction(): SearchToolsFunction;
-}
-/**
- * Adapts a plain `(code, timeout) => Promise<ExecutionResult>` function to the
- * {@link BaseCodeExecutor} interface so a custom executor participates in the
- * normal executor lifecycle (`searchTools`, `close()` cleanup).
- *
- * The function is invoked with the `MCPClient` as its `this`, matching how a
- * custom executor was called before this adapter existed. Cleanup is a no-op:
- * the caller owns whatever runtime the function wraps.
- */
-export declare class FunctionCodeExecutor extends BaseCodeExecutor {
-    private fn;
-    constructor(client: MCPClient, fn: CodeExecutorFunction);
-    execute(code: string, timeout?: number): Promise<ExecutionResult>;
-    cleanup(): Promise<void>;
-}
-export {};
-//# sourceMappingURL=executor.d.ts.map

package/dist/code-mode/executor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../src/code-mode/executor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,8BAA8B,CAAC;AACzD,OAAO,KAAK,EAAE,oBAAoB,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAGvE,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,OAAO,CAAC;IAChB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,UAAU,gBAAgB;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;CACpC;AAED,UAAU,cAAc;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,cAAc,CAAC;IACrB,OAAO,EAAE,gBAAgB,EAAE,CAAC;CAC7B;AAED,KAAK,mBAAmB,GAAG,CACzB,KAAK,CAAC,EAAE,MAAM,EACd,WAAW,CAAC,EAAE,OAAO,GAAG,cAAc,GAAG,MAAM,KAC5C,OAAO,CAAC,kBAAkB,CAAC,CAAC;AAEjC,UAAU,iBAAiB;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,OAAO,EAAE,GAAG,CAAC;CACd;AAED;;;GAGG;AACH,8BAAsB,gBAAgB;IACpC,SAAS,CAAC,MAAM,EAAE,SAAS,CAAC;IAC5B,SAAS,CAAC,WAAW,EAAE,OAAO,CAAS;gBAE3B,MAAM,EAAE,SAAS;IAI7B;;;;OAIG;IACH,QAAQ,CAAC,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IAE1E;;;OAGG;IACH,QAAQ,CAAC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAEjC;;;OAGG;cACa,sBAAsB,IAAI,OAAO,CAAC,IAAI,CAAC;IA+BvD;;;OAGG;IACH,SAAS,CAAC,iBAAiB,IAAI,iBAAiB,EAAE;IA6BlD;;;OAGG;IACI,yBAAyB,IAAI,mBAAmB;CAoExD;AAED;;;;;;;;GAQG;AACH,qBAAa,oBAAqB,SAAQ,gBAAgB;IACxD,OAAO,CAAC,EAAE,CAAuB;gBAErB,MAAM,EAAE,SAAS,EAAE,EAAE,EAAE,oBAAoB;IAKjD,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;IAIjE,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAG/B"}

package/dist/core/base.d.ts

@@ -1,423 +0,0 @@
-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 such as the Node.js `MCPClient` 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 MCPSession} for session management
- */
-export declare abstract class BaseMCPClient {
-    /**
-     * Internal configuration object containing MCP server definitions.
-     */
-    protected config: MCPClientConfigShape;
-    /**
-     * Map of server names to their active sessions.
-     */
-    protected sessions: Record<string, MCPSession>;
-    /**
-     * Tracks teardown by session identity so overlapping cleanup paths share the
-     * same disconnect. In particular, createSession() can replace a session while
-     * closeSession() is already disconnecting it.
-     */
-    private readonly sessionDisconnects;
-    /**
-     * 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);
-    private disconnectSession;
-    /**
-     * 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 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 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 and the previous session is disconnected; any previously returned
-     * reference to it becomes unusable.
-     *
-     * @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 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 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

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

package/dist/core/browser.d.ts

@@ -1,32 +0,0 @@
-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 {
-    /**
-     * Returns the installed `@mcp-use/client` package version.
-     *
-     * @returns The package version string.
-     */
-    static getPackageVersion(): string;
-    /**
-     * Creates a browser MCP client.
-     *
-     * @param config - Client configuration containing an optional `mcpServers` map.
-     */
-    constructor(config?: Record<string, any>);
-    /**
-     * Creates a browser client from an inline configuration object.
-     *
-     * @param cfg - Client configuration containing an optional `mcpServers` map.
-     * @returns A browser client initialized with `cfg`.
-     */
-    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

@@ -1 +0,0 @@
-{"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;AA0B1C,qBAAa,gBAAiB,SAAQ,aAAa;IACjD;;;;OAIG;WACW,iBAAiB,IAAI,MAAM;IAIzC;;;;OAIG;gBACS,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAKxC;;;;;OAKG;WACW,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;CA2DjB"}