@mcp-b/transports 0.0.0-beta-20260109203913

package/dist/index.d.ts

@@ -0,0 +1,937 @@
+import { JSONRPCMessage } from "@modelcontextprotocol/sdk/types.js";
+import { Transport, TransportSendOptions } from "@modelcontextprotocol/sdk/shared/transport.js";
+
+//#region src/browser-types.d.ts
+/**
+ * Unique identifier for an event in the event store
+ */
+type EventId = string;
+/**
+ * Unique identifier for a stream of events
+ */
+type StreamId = string;
+/**
+ * Options for connecting to an MCP server
+ */
+interface MCPConnectOptions {
+  /**
+   * The event ID to resume from if reconnecting
+   */
+  resumeFrom?: EventId;
+}
+/**
+ * Information about the MCP server
+ */
+interface MCPServerInfo {
+  /**
+   * Unique identifier for this server instance
+   */
+  instanceId: string;
+  /**
+   * Whether the server maintains session state
+   */
+  stateful: boolean;
+  /**
+   * Whether the server has event storage enabled
+   */
+  hasEventStore: boolean;
+}
+/**
+ * Event storage interface for accessing stored events
+ */
+interface MCPEventStore {
+  /**
+   * Get stored events, optionally filtered by client and/or after a specific event
+   * @param clientId - Optional client ID to filter events
+   * @param afterEventId - Optional event ID to get events after
+   * @param limit - Maximum number of events to return (default: 100)
+   */
+  getEvents(clientId?: string, afterEventId?: EventId, limit?: number): StoredEvent[];
+  /**
+   * Get the ID of the last event, optionally for a specific client
+   * @param clientId - Optional client ID to filter by
+   */
+  getLastEventId(clientId?: string): EventId | null;
+  /**
+   * Clear stored events, optionally for a specific client
+   * @param clientId - Optional client ID to clear events for
+   */
+  clearEvents(clientId?: string): void;
+}
+/**
+ * The MCP interface exposed on window for browser environments
+ */
+interface MCPBrowserInterface {
+  /**
+   * Connect a client to the MCP server
+   * @param clientId - Unique identifier for the client
+   * @param options - Optional connection options
+   * @returns MessagePort for communication or null if connection fails
+   */
+  connect(clientId: string, options?: MCPConnectOptions): MessagePort | null;
+  /**
+   * Disconnect a client from the MCP server
+   * @param clientId - The client ID to disconnect
+   */
+  disconnect(clientId: string): void;
+  /**
+   * Terminate a client's session and clean up all associated resources
+   * @param clientId - The client ID to terminate
+   */
+  terminateSession?(clientId: string): void;
+  /**
+   * Check if the MCP server is available and running
+   */
+  isServerAvailable(): boolean;
+  /**
+   * Get information about the MCP server
+   */
+  getServerInfo(): MCPServerInfo;
+  /**
+   * Event storage access (only available in stateful mode with event store)
+   */
+  events?: MCPEventStore;
+}
+/**
+ * Extended Window interface with MCP support
+ */
+interface MCPWindow extends Window {
+  mcp?: MCPBrowserInterface;
+}
+/**
+ * Message types for internal MCP communication
+ */
+interface MCPServerInfoMessage {
+  type: 'mcp-server-info';
+  serverInstanceId: string;
+  serverSessionId?: string;
+  hasEventStore: boolean;
+  streamId: StreamId;
+}
+interface MCPEventMessage {
+  type: 'mcp-event';
+  eventId: EventId;
+  message: JSONRPCMessage;
+}
+interface MCPReplayEventMessage {
+  type: 'mcp-replay-event';
+  eventId: EventId;
+  message: JSONRPCMessage;
+}
+/**
+ * Stored event with metadata for event sourcing
+ */
+interface StoredEvent {
+  eventId: EventId;
+  streamId: StreamId;
+  message: JSONRPCMessage;
+  timestamp: number;
+  clientId: string;
+}
+declare enum NativeMessageType {
+  START = "start",
+  STARTED = "started",
+  STOP = "stop",
+  STOPPED = "stopped",
+  PING = "ping",
+  PONG = "pong",
+  ERROR = "error",
+  LIST_TOOLS = "list_tools",
+  CALL_TOOL = "call_tool",
+  TOOL_LIST_UPDATED = "tool_list_updated",
+  TOOL_LIST_UPDATED_ACK = "tool_list_updated_ack",
+  PROCESS_DATA = "process_data",
+  SERVER_STARTED = "server_started",
+  SERVER_STOPPED = "server_stopped",
+  ERROR_FROM_NATIVE_HOST = "error_from_native_host",
+  CONNECT_NATIVE = "connectNative",
+  PING_NATIVE = "ping_native",
+  DISCONNECT_NATIVE = "disconnect_native",
+}
+/**
+ * Chrome Extension Constants
+ * Centralized configuration values and magic constants
+ */
+declare const NATIVE_HOST: {
+  readonly NAME: "com.chromemcp.nativehost";
+  readonly DEFAULT_PORT: 12306;
+};
+declare const ERROR_MESSAGES: {
+  readonly NATIVE_CONNECTION_FAILED: "Failed to connect to native host";
+  readonly NATIVE_DISCONNECTED: "Native connection disconnected";
+  readonly SERVER_STATUS_LOAD_FAILED: "Failed to load server status";
+  readonly TOOL_EXECUTION_FAILED: "Tool execution failed";
+  readonly SERVER_STATUS_SAVE_FAILED: "Failed to save server status";
+};
+declare const SUCCESS_MESSAGES: {
+  readonly TOOL_EXECUTED: "Tool executed successfully";
+  readonly CONNECTION_ESTABLISHED: "Connection established";
+  readonly SERVER_STARTED: "Server started successfully";
+  readonly SERVER_STOPPED: "Server stopped successfully";
+};
+declare const STORAGE_KEYS: {
+  readonly SERVER_STATUS: "serverStatus";
+};
+declare const BACKGROUND_MESSAGE_TYPES: {
+  readonly GET_SERVER_STATUS: "get_server_status";
+  readonly REFRESH_SERVER_STATUS: "refresh_server_status";
+  readonly SERVER_STATUS_CHANGED: "server_status_changed";
+};
+declare const HOST_NAME: "com.chromemcp.nativehost";
+/**
+ * Server status management interface
+ */
+interface ServerStatus {
+  isRunning: boolean;
+  port?: number;
+  lastUpdated: number;
+}
+//#endregion
+//#region src/ExtensionClientTransport.d.ts
+/**
+ * Configuration options for ExtensionClientTransport
+ */
+interface ExtensionClientTransportOptions {
+  /**
+   * The extension ID to connect to (optional for same-extension connections)
+   */
+  extensionId?: string;
+  /**
+   * Port name for the connection
+   * Default: 'mcp'
+   */
+  portName?: string;
+  /**
+   * Enable automatic reconnection on disconnect
+   * Default: true
+   */
+  autoReconnect?: boolean;
+  /**
+   * Maximum number of reconnection attempts
+   * Default: 10
+   */
+  maxReconnectAttempts?: number;
+  /**
+   * Initial reconnection delay in milliseconds
+   * Default: 1000
+   */
+  reconnectDelay?: number;
+  /**
+   * Maximum reconnection delay in milliseconds
+   * Default: 30000
+   */
+  maxReconnectDelay?: number;
+  /**
+   * Reconnection backoff multiplier
+   * Default: 1.5
+   */
+  reconnectBackoffMultiplier?: number;
+}
+/**
+ * Client transport for Chrome extensions using Port-based messaging.
+ * This transport can be used in content scripts, popup scripts, or sidepanel scripts
+ * to connect to a server running in the background service worker.
+ *
+ * Features automatic reconnection to handle background service worker lifecycle.
+ */
+declare class ExtensionClientTransport implements Transport {
+  private _port;
+  private _extensionId;
+  private _portName;
+  private _messageHandler;
+  private _disconnectHandler;
+  private _isReconnecting;
+  private _reconnectAttempts;
+  private _reconnectTimer;
+  private _currentReconnectDelay;
+  private _isStarted;
+  private _isClosed;
+  private _autoReconnect;
+  private _maxReconnectAttempts;
+  private _reconnectDelay;
+  private _maxReconnectDelay;
+  private _reconnectBackoffMultiplier;
+  onclose?: () => void;
+  onerror?: (error: Error) => void;
+  onmessage?: (message: JSONRPCMessage) => void;
+  constructor(options?: ExtensionClientTransportOptions);
+  /**
+   * Starts the transport by connecting to the extension port
+   */
+  start(): Promise<void>;
+  /**
+   * Connects to the extension port
+   */
+  private _connect;
+  /**
+   * Sends a message to the server
+   */
+  send(message: JSONRPCMessage, _options?: TransportSendOptions): Promise<void>;
+  /**
+   * Closes the transport
+   */
+  close(): Promise<void>;
+  /**
+   * Cleans up event listeners and references
+   */
+  private _cleanup;
+  /**
+   * Schedules a reconnection attempt
+   */
+  private _scheduleReconnect;
+  /**
+   * Attempts to reconnect to the extension
+   */
+  private _attemptReconnect;
+}
+//#endregion
+//#region src/ExtensionServerTransport.d.ts
+/**
+ * Configuration options for ExtensionServerTransport
+ */
+type ExtensionServerTransportOptions = {
+  /**
+   * Enable keep-alive mechanism to prevent service worker shutdown
+   * Default: true
+   */
+  keepAlive?: boolean;
+  /**
+   * Keep-alive interval in milliseconds
+   * Default: 25000 (25 seconds, less than Chrome's 30-second timeout)
+   */
+  keepAliveInterval?: number;
+};
+/**
+ * Server transport for Chrome extensions using Port-based messaging.
+ * This transport handles a single client connection through Chrome's port messaging API.
+ * It should be used in the extension's background service worker.
+ *
+ * Features:
+ * - Keep-alive mechanism to prevent service worker shutdown
+ * - Graceful connection state management
+ */
+declare class ExtensionServerTransport implements Transport {
+  private _port;
+  private _started;
+  private _messageHandler;
+  private _disconnectHandler;
+  private _keepAliveTimer;
+  private _options;
+  private _connectionInfo;
+  onclose?: () => void;
+  onerror?: (error: Error) => void;
+  onmessage?: (message: JSONRPCMessage) => void;
+  constructor(port: chrome.runtime.Port, options?: ExtensionServerTransportOptions);
+  /**
+   * Starts the transport and begins handling messages
+   */
+  start(): Promise<void>;
+  /**
+   * Sends a message to the client
+   */
+  send(message: JSONRPCMessage, _options?: TransportSendOptions): Promise<void>;
+  /**
+   * Closes the transport
+   */
+  close(): Promise<void>;
+  /**
+   * Cleans up event listeners and references
+   */
+  private _cleanup;
+  /**
+   * Starts the keep-alive mechanism
+   */
+  private _startKeepAlive;
+  /**
+   * Stops the keep-alive mechanism
+   */
+  private _stopKeepAlive;
+  /**
+   * Gets connection information
+   */
+  getConnectionInfo(): {
+    uptime: number;
+    isConnected: boolean;
+    connectedAt: number;
+    lastMessageAt: number;
+    messageCount: number;
+  };
+}
+//#endregion
+//#region src/IframeChildTransport.d.ts
+interface IframeChildTransportOptions {
+  /** Whitelist of parent origins allowed to connect (for security) */
+  allowedOrigins: string[];
+  /** Optional channel name (default: 'mcp-iframe') */
+  channelId?: string;
+  /** Retry interval for broadcasting ready signal in milliseconds (default: 250) */
+  serverReadyRetryMs?: number;
+}
+/**
+ * IframeChildTransport - Server transport for iframe
+ *
+ * Use this transport when an iframe wants to expose an MCP server to its parent page.
+ * Supports cross-origin communication.
+ *
+ * @example
+ * ```typescript
+ * const transport = new IframeChildTransport({
+ *   allowedOrigins: ['https://parent-app.com'],
+ * });
+ *
+ * const server = new Server({ name: 'IframeApp', version: '1.0.0' });
+ * await server.connect(transport);
+ * ```
+ */
+declare class IframeChildTransport implements Transport {
+  private _started;
+  private _allowedOrigins;
+  private _channelId;
+  private _messageHandler?;
+  private _clientOrigin?;
+  private _serverReadyTimeout;
+  private readonly _serverReadyRetryMs;
+  onclose?: () => void;
+  onerror?: (error: Error) => void;
+  onmessage?: (message: JSONRPCMessage) => void;
+  constructor(options: IframeChildTransportOptions);
+  start(): Promise<void>;
+  private broadcastServerReady;
+  private scheduleServerReadyRetry;
+  private clearServerReadyRetry;
+  send(message: JSONRPCMessage): Promise<void>;
+  close(): Promise<void>;
+}
+//#endregion
+//#region src/IframeParentTransport.d.ts
+interface IframeParentTransportOptions {
+  /** Reference to the iframe element */
+  iframe: HTMLIFrameElement;
+  /** Expected origin of the iframe (for security) */
+  targetOrigin: string;
+  /** Optional channel name (default: 'mcp-iframe') */
+  channelId?: string;
+  /** Retry interval for ready handshake in milliseconds (default: 250) */
+  checkReadyRetryMs?: number;
+}
+/**
+ * IframeParentTransport - Client transport for parent page
+ *
+ * Use this transport when the parent page wants to connect to an MCP server
+ * running inside an iframe. Supports cross-origin communication.
+ *
+ * @example
+ * ```typescript
+ * const iframe = document.querySelector('iframe');
+ * const transport = new IframeParentTransport({
+ *   iframe,
+ *   targetOrigin: 'https://iframe-app.com',
+ * });
+ *
+ * const client = new Client({ name: 'Parent', version: '1.0.0' });
+ * await client.connect(transport);
+ * ```
+ */
+declare class IframeParentTransport implements Transport {
+  private _started;
+  private _iframe;
+  private _targetOrigin;
+  private _channelId;
+  private _messageHandler?;
+  private _checkReadyTimeout;
+  private readonly _checkReadyRetryMs;
+  readonly serverReadyPromise: Promise<void>;
+  private _serverReadyResolve;
+  private _serverReadyReject;
+  onclose?: () => void;
+  onerror?: (error: Error) => void;
+  onmessage?: (message: JSONRPCMessage) => void;
+  constructor(options: IframeParentTransportOptions);
+  start(): Promise<void>;
+  private sendCheckReady;
+  private scheduleCheckReadyRetry;
+  private clearCheckReadyRetry;
+  send(message: JSONRPCMessage): Promise<void>;
+  close(): Promise<void>;
+}
+//#endregion
+//#region src/TabClientTransport.d.ts
+/**
+ * Configuration options for TabClientTransport.
+ *
+ * @see {@link TabClientTransport}
+ */
+interface TabClientTransportOptions {
+  /**
+   * Expected origin of the server window for security validation.
+   *
+   * **Security**: This origin is checked against `event.origin` for all incoming
+   * messages to prevent cross-origin attacks. Only messages from this origin will
+   * be processed.
+   *
+   * @example 'https://example.com'
+   * @example 'http://localhost:3000'
+   */
+  targetOrigin: string;
+  /**
+   * Channel identifier for message routing.
+   *
+   * Multiple transports can coexist on the same page by using different channel IDs.
+   * This allows for isolated communication channels between different MCP clients
+   * and servers.
+   *
+   * @default 'mcp-default'
+   */
+  channelId?: string;
+  /**
+   * Request timeout in milliseconds.
+   *
+   * If a request doesn't receive a response within this time, a timeout error
+   * is synthesized and delivered to the client. This prevents infinite hangs
+   * when the server becomes unresponsive due to:
+   * - Page navigation
+   * - JavaScript errors
+   * - Network issues
+   * - Server crashes
+   *
+   * **Design rationale**: 10 seconds is appropriate for most tool operations.
+   * For operations that may take longer (e.g., complex computations, slow network
+   * requests), increase this value via the configuration option.
+   *
+   * @default 10000 (10 seconds)
+   * @see {@link _handleRequestTimeout} for timeout implementation
+   */
+  requestTimeout?: number;
+}
+/**
+ * Client-side transport for same-window MCP communication via postMessage.
+ *
+ * This transport connects an MCP client to a TabServerTransport running in the same
+ * window. Communication occurs via the browser's `window.postMessage()` API, which
+ * provides:
+ * - Same-window message passing (no network overhead)
+ * - Origin validation for security
+ * - Asynchronous message delivery
+ *
+ * **Architecture**:
+ * ```
+ * ┌─────────────────┐                    ┌──────────────────┐
+ * │  MCP Client     │  postMessage()     │  MCP Server      │
+ * │  (This side)    │ ←─────────────────→│  (TabServerTransport)
+ * └─────────────────┘                    └──────────────────┘
+ * ```
+ *
+ * **Key features**:
+ * - Request timeout to prevent infinite hangs (default 10s)
+ * - Server ready detection via handshake
+ * - Origin validation for security
+ * - Channel-based message routing
+ *
+ * **Use cases**:
+ * - MCP client running in content script connecting to page context
+ * - MCP client in extension popup connecting to background page
+ * - Testing and development scenarios
+ *
+ * @example Basic usage
+ * ```typescript
+ * const transport = new TabClientTransport({
+ *   targetOrigin: 'https://example.com',
+ *   channelId: 'my-mcp-channel',
+ *   requestTimeout: 10000, // Optional (default)
+ * });
+ *
+ * // Wait for server to be ready
+ * await transport.start();
+ * await transport.serverReadyPromise;
+ *
+ * // Now safe to send messages
+ * await transport.send({
+ *   jsonrpc: '2.0',
+ *   id: 1,
+ *   method: 'tools/call',
+ *   params: { name: 'my_tool', arguments: {} }
+ * });
+ * ```
+ *
+ * @example With custom timeout
+ * ```typescript
+ * const transport = new TabClientTransport({
+ *   targetOrigin: '*',
+ *   requestTimeout: 60000, // 60 seconds for slow operations
+ * });
+ * ```
+ *
+ * @see {@link TabServerTransport} for the server-side implementation
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage} for postMessage API
+ */
+declare class TabClientTransport implements Transport {
+  /** Transport state flag */
+  private _started;
+  /** Expected origin for message validation */
+  private readonly _targetOrigin;
+  /** Channel ID for message routing */
+  private readonly _channelId;
+  /** Request timeout in milliseconds */
+  private readonly _requestTimeout;
+  /** Message event listener */
+  private _messageHandler?;
+  /**
+   * Promise that resolves when the server is ready to receive messages.
+   *
+   * **Usage**: Always `await` this promise after calling `start()` and before
+   * sending messages. Sending messages before the server is ready may result
+   * in lost messages.
+   *
+   * @example
+   * ```typescript
+   * await transport.start();
+   * await transport.serverReadyPromise;
+   * // Now safe to send messages
+   * ```
+   */
+  readonly serverReadyPromise: Promise<void>;
+  /** Internal resolver for serverReadyPromise */
+  private readonly _serverReadyResolve;
+  /** Internal rejector for serverReadyPromise */
+  private readonly _serverReadyReject;
+  /**
+   * Active request tracking for timeout management.
+   *
+   * **Key**: Request ID (from JSON-RPC message)
+   * **Value**: Timeout ID and original request
+   *
+   * When a response is received, the entry is removed and timeout cleared.
+   * If timeout expires first, an error response is synthesized.
+   */
+  private readonly _activeRequests;
+  /** Callback invoked when transport closes */
+  onclose?: () => void;
+  /** Callback invoked on errors */
+  onerror?: (error: Error) => void;
+  /** Callback invoked when message received */
+  onmessage?: (message: JSONRPCMessage) => void;
+  /**
+   * Creates a new TabClientTransport instance.
+   *
+   * **Note**: The transport is not started automatically. Call `start()` to begin
+   * listening for messages.
+   *
+   * @param options - Configuration options
+   * @throws {Error} If targetOrigin is not specified
+   */
+  constructor(options: TabClientTransportOptions);
+  /**
+   * Starts the transport by registering message listeners.
+   *
+   * **Lifecycle**:
+   * 1. Register `window.addEventListener('message', ...)` handler
+   * 2. Send server ready check (in case server started first)
+   * 3. Wait for server ready signal via `serverReadyPromise`
+   *
+   * **Note**: Always `await transport.serverReadyPromise` after calling this method
+   * and before sending messages.
+   *
+   * @throws {Error} If transport is already started
+   */
+  start(): Promise<void>;
+  /**
+   * Sends a JSON-RPC message to the server.
+   *
+   * **Request timeout**: If this is a request (has `method` and `id`), a timeout
+   * is started. If the server doesn't respond within `requestTimeout` milliseconds,
+   * an error response is synthesized.
+   *
+   * **Await server ready**: This method automatically awaits `serverReadyPromise`
+   * before sending, ensuring messages aren't lost.
+   *
+   * @param message - JSON-RPC message to send
+   * @throws {Error} If transport is not started
+   */
+  send(message: JSONRPCMessage): Promise<void>;
+  /**
+   * Closes the transport and cleans up resources.
+   *
+   * **Cleanup performed**:
+   * - Removes message event listener
+   * - Clears all active request timeouts
+   * - Rejects server ready promise if still pending
+   * - Invokes `onclose` callback
+   *
+   * **Note**: After calling this method, the transport cannot be reused.
+   * Create a new instance if needed.
+   */
+  close(): Promise<void>;
+  /**
+   * Sends a server ready check message.
+   *
+   * This prompts the server to respond with 'mcp-server-ready' signal,
+   * resolving the `serverReadyPromise`. Useful when the server may have
+   * started before the client.
+   *
+   * @private
+   */
+  private _sendCheckReady;
+  /**
+   * Starts timeout tracking for a request.
+   *
+   * **Behavior**: After `requestTimeout` milliseconds, if no response is received,
+   * `_handleRequestTimeout` is called to synthesize an error response.
+   *
+   * **Note**: Only requests (messages with `method` and `id`) are tracked.
+   * Notifications (no `id`) and responses are not tracked.
+   *
+   * @param message - JSON-RPC request message
+   * @private
+   */
+  private _startRequestTimeout;
+  /**
+   * Clears timeout tracking for a response.
+   *
+   * Called when a response (with `result` or `error`) is received.
+   * Clears the timeout and removes the tracking entry.
+   *
+   * @param message - JSON-RPC response message
+   * @private
+   */
+  private _clearRequestTimeout;
+  /**
+   * Handles request timeout by synthesizing an error response.
+   *
+   * **Error response format** (JSON-RPC 2.0):
+   * ```json
+   * {
+   *   "jsonrpc": "2.0",
+   *   "id": "<request-id>",
+   *   "error": {
+   *     "code": -32000,
+   *     "message": "Request timeout - server may have navigated or become unresponsive",
+   *     "data": {
+   *       "timeoutMs": 10000,
+   *       "originalMethod": "tools/call"
+   *     }
+   *   }
+   * }
+   * ```
+   *
+   * **Error code**: `-32000` (Server error) per JSON-RPC 2.0 specification.
+   *
+   * @param requestId - ID of the timed-out request
+   * @private
+   */
+  private _handleRequestTimeout;
+}
+//#endregion
+//#region src/TabServerTransport.d.ts
+interface TabServerTransportOptions {
+  /** Whitelist of origins allowed to connect (for security) */
+  allowedOrigins: string[];
+  /** Optional channel name (default: 'mcp-default') */
+  channelId?: string;
+}
+declare class TabServerTransport implements Transport {
+  private _started;
+  private _allowedOrigins;
+  private _channelId;
+  private _messageHandler?;
+  private _clientOrigin?;
+  private _beforeUnloadHandler?;
+  private _cleanupInterval?;
+  private _pendingRequests;
+  private readonly REQUEST_TIMEOUT_MS;
+  onclose?: () => void;
+  onerror?: (error: Error) => void;
+  onmessage?: (message: JSONRPCMessage) => void;
+  constructor(options: TabServerTransportOptions);
+  start(): Promise<void>;
+  send(message: JSONRPCMessage): Promise<void>;
+  /**
+   * Handle page navigation by sending interrupted responses for all pending requests.
+   * Called during beforeunload event.
+   * @private
+   */
+  private _handleBeforeUnload;
+  /**
+   * Clean up stale requests that have been pending for too long.
+   * Called periodically to prevent memory leaks.
+   * @private
+   */
+  private _cleanupStaleRequests;
+  close(): Promise<void>;
+}
+//#endregion
+//#region src/UserScriptClientTransport.d.ts
+/**
+ * Configuration options for UserScriptClientTransport
+ */
+interface UserScriptClientTransportOptions {
+  /**
+   * The extension ID to connect to (optional for same-extension connections)
+   */
+  extensionId?: string;
+  /**
+   * Port name for the connection
+   * Default: 'mcp'
+   */
+  portName?: string;
+  /**
+   * Enable automatic reconnection on disconnect
+   * Default: true
+   */
+  autoReconnect?: boolean;
+  /**
+   * Maximum number of reconnection attempts
+   * Default: 10
+   */
+  maxReconnectAttempts?: number;
+  /**
+   * Initial reconnection delay in milliseconds
+   * Default: 1000
+   */
+  reconnectDelay?: number;
+  /**
+   * Maximum reconnection delay in milliseconds
+   * Default: 30000
+   */
+  maxReconnectDelay?: number;
+  /**
+   * Reconnection backoff multiplier
+   * Default: 1.5
+   */
+  reconnectBackoffMultiplier?: number;
+}
+/**
+ * Client transport for Chrome MV3 User Scripts using Port-based messaging.
+ * This transport can be used inside a User Script context to connect to the
+ * extension's background service worker. On the extension side, connections
+ * are received via chrome.runtime.onUserScriptConnect.
+ *
+ * Features automatic reconnection to handle background service worker lifecycle.
+ */
+declare class UserScriptClientTransport implements Transport {
+  private _port;
+  private _extensionId;
+  private _portName;
+  private _messageHandler;
+  private _disconnectHandler;
+  private _isReconnecting;
+  private _reconnectAttempts;
+  private _reconnectTimer;
+  private _currentReconnectDelay;
+  private _isStarted;
+  private _isClosed;
+  private _autoReconnect;
+  private _maxReconnectAttempts;
+  private _reconnectDelay;
+  private _maxReconnectDelay;
+  private _reconnectBackoffMultiplier;
+  onclose?: () => void;
+  onerror?: (error: Error) => void;
+  onmessage?: (message: JSONRPCMessage) => void;
+  constructor(options?: UserScriptClientTransportOptions);
+  /**
+   * Starts the transport by connecting to the extension port
+   */
+  start(): Promise<void>;
+  /**
+   * Connects to the extension port
+   */
+  private _connect;
+  /**
+   * Sends a message to the server
+   */
+  send(message: JSONRPCMessage, _options?: TransportSendOptions): Promise<void>;
+  /**
+   * Closes the transport
+   */
+  close(): Promise<void>;
+  /**
+   * Cleans up event listeners and references
+   */
+  private _cleanup;
+  /**
+   * Schedules a reconnection attempt
+   */
+  private _scheduleReconnect;
+  /**
+   * Attempts to reconnect to the extension
+   */
+  private _attemptReconnect;
+}
+//#endregion
+//#region src/UserScriptServerTransport.d.ts
+/**
+ * Configuration options for UserScriptServerTransport
+ */
+type UserScriptServerTransportOptions = {
+  /**
+   * Enable keep-alive mechanism to prevent service worker shutdown
+   * Default: true
+   */
+  keepAlive?: boolean;
+  /**
+   * Keep-alive interval in milliseconds
+   * Default: 25000 (25 seconds, less than Chrome's 30-second timeout)
+   */
+  keepAliveInterval?: number;
+};
+/**
+ * Server transport for Chrome MV3 User Scripts using Port-based messaging.
+ * This transport handles a single client connection through Chrome's port
+ * messaging API. It should be used in the extension's background service
+ * worker. Connections are initiated from User Scripts via chrome.runtime.connect
+ * and received here via chrome.runtime.onUserScriptConnect.
+ *
+ * Features:
+ * - Keep-alive mechanism to prevent service worker shutdown
+ * - Graceful connection state management
+ */
+declare class UserScriptServerTransport implements Transport {
+  private _port;
+  private _started;
+  private _messageHandler;
+  private _disconnectHandler;
+  private _keepAliveTimer;
+  private _options;
+  private _connectionInfo;
+  onclose?: () => void;
+  onerror?: (error: Error) => void;
+  onmessage?: (message: JSONRPCMessage) => void;
+  constructor(port: chrome.runtime.Port, options?: UserScriptServerTransportOptions);
+  /**
+   * Starts the transport and begins handling messages
+   */
+  start(): Promise<void>;
+  /**
+   * Sends a message to the client
+   */
+  send(message: JSONRPCMessage, _options?: TransportSendOptions): Promise<void>;
+  /**
+   * Closes the transport
+   */
+  close(): Promise<void>;
+  /**
+   * Cleans up event listeners and references
+   */
+  private _cleanup;
+  /**
+   * Starts the keep-alive mechanism
+   */
+  private _startKeepAlive;
+  /**
+   * Stops the keep-alive mechanism
+   */
+  private _stopKeepAlive;
+  /**
+   * Gets connection information
+   */
+  getConnectionInfo(): {
+    uptime: number;
+    isConnected: boolean;
+    connectedAt: number;
+    lastMessageAt: number;
+    messageCount: number;
+  };
+}
+//#endregion
+export { BACKGROUND_MESSAGE_TYPES, ERROR_MESSAGES, EventId, ExtensionClientTransport, ExtensionClientTransportOptions, ExtensionServerTransport, ExtensionServerTransportOptions, HOST_NAME, IframeChildTransport, IframeChildTransportOptions, IframeParentTransport, IframeParentTransportOptions, MCPBrowserInterface, MCPConnectOptions, MCPEventMessage, MCPEventStore, MCPReplayEventMessage, MCPServerInfo, MCPServerInfoMessage, MCPWindow, NATIVE_HOST, NativeMessageType, STORAGE_KEYS, SUCCESS_MESSAGES, ServerStatus, StoredEvent, StreamId, TabClientTransport, TabClientTransportOptions, TabServerTransport, TabServerTransportOptions, UserScriptClientTransport, UserScriptClientTransportOptions, UserScriptServerTransport, UserScriptServerTransportOptions };
+//# sourceMappingURL=index.d.ts.map