@mcp-ts/sdk 1.3.2 → 1.3.4

package/dist/adapters/agui-adapter.d.mts

@@ -1,4 +1,4 @@
-import { M as MCPClient, a as MultiSessionClient } from '../multi-session-client-B1DBx5yR.mjs';
+import { M as MCPClient, a as MultiSessionClient } from '../multi-session-client-DzjmT7FX.mjs';
 import '../events-CK3N--3g.mjs';
 import '@modelcontextprotocol/sdk/types.js';
 import '@modelcontextprotocol/sdk/client/auth.js';

package/dist/adapters/agui-adapter.d.ts

@@ -1,4 +1,4 @@
-import { M as MCPClient, a as MultiSessionClient } from '../multi-session-client-DyFzyJUx.js';
+import { M as MCPClient, a as MultiSessionClient } from '../multi-session-client-FAFpUzZ4.js';
 import '../events-CK3N--3g.js';
 import '@modelcontextprotocol/sdk/types.js';
 import '@modelcontextprotocol/sdk/client/auth.js';

package/dist/adapters/agui-middleware.d.mts

@@ -2,7 +2,7 @@ import { Observable } from 'rxjs';
 import { Middleware, RunAgentInput, AbstractAgent, BaseEvent } from '@ag-ui/client';
 export { AbstractAgent, BaseEvent, EventType, Middleware, RunAgentInput, Tool, ToolCallEndEvent } from '@ag-ui/client';
 import { AguiTool } from './agui-adapter.mjs';
-import '../multi-session-client-B1DBx5yR.mjs';
+import '../multi-session-client-DzjmT7FX.mjs';
 import '../events-CK3N--3g.mjs';
 import '@modelcontextprotocol/sdk/types.js';
 import '@modelcontextprotocol/sdk/client/auth.js';

package/dist/adapters/agui-middleware.d.ts

@@ -2,7 +2,7 @@ import { Observable } from 'rxjs';
 import { Middleware, RunAgentInput, AbstractAgent, BaseEvent } from '@ag-ui/client';
 export { AbstractAgent, BaseEvent, EventType, Middleware, RunAgentInput, Tool, ToolCallEndEvent } from '@ag-ui/client';
 import { AguiTool } from './agui-adapter.js';
-import '../multi-session-client-DyFzyJUx.js';
+import '../multi-session-client-FAFpUzZ4.js';
 import '../events-CK3N--3g.js';
 import '@modelcontextprotocol/sdk/types.js';
 import '@modelcontextprotocol/sdk/client/auth.js';

package/dist/adapters/ai-adapter.d.mts

@@ -1,4 +1,4 @@
-import { M as MCPClient, a as MultiSessionClient } from '../multi-session-client-B1DBx5yR.mjs';
+import { M as MCPClient, a as MultiSessionClient } from '../multi-session-client-DzjmT7FX.mjs';
 import { ToolSet } from 'ai';
 import '../events-CK3N--3g.mjs';
 import '@modelcontextprotocol/sdk/types.js';

package/dist/adapters/ai-adapter.d.ts

@@ -1,4 +1,4 @@
-import { M as MCPClient, a as MultiSessionClient } from '../multi-session-client-DyFzyJUx.js';
+import { M as MCPClient, a as MultiSessionClient } from '../multi-session-client-FAFpUzZ4.js';
 import { ToolSet } from 'ai';
 import '../events-CK3N--3g.js';
 import '@modelcontextprotocol/sdk/types.js';

package/dist/adapters/langchain-adapter.d.mts

@@ -1,4 +1,4 @@
-import { M as MCPClient, a as MultiSessionClient } from '../multi-session-client-B1DBx5yR.mjs';
+import { M as MCPClient, a as MultiSessionClient } from '../multi-session-client-DzjmT7FX.mjs';
 import { StructuredTool } from '@langchain/core/tools';
 import '../events-CK3N--3g.mjs';
 import '@modelcontextprotocol/sdk/types.js';

package/dist/adapters/langchain-adapter.d.ts

@@ -1,4 +1,4 @@
-import { M as MCPClient, a as MultiSessionClient } from '../multi-session-client-DyFzyJUx.js';
+import { M as MCPClient, a as MultiSessionClient } from '../multi-session-client-FAFpUzZ4.js';
 import { StructuredTool } from '@langchain/core/tools';
 import '../events-CK3N--3g.js';
 import '@modelcontextprotocol/sdk/types.js';

package/dist/adapters/mastra-adapter.d.mts

@@ -1,4 +1,4 @@
-import { M as MCPClient, a as MultiSessionClient } from '../multi-session-client-B1DBx5yR.mjs';
+import { M as MCPClient, a as MultiSessionClient } from '../multi-session-client-DzjmT7FX.mjs';
 import { z } from 'zod';
 import '../events-CK3N--3g.mjs';
 import '@modelcontextprotocol/sdk/types.js';

package/dist/adapters/mastra-adapter.d.ts

@@ -1,4 +1,4 @@
-import { M as MCPClient, a as MultiSessionClient } from '../multi-session-client-DyFzyJUx.js';
+import { M as MCPClient, a as MultiSessionClient } from '../multi-session-client-FAFpUzZ4.js';
 import { z } from 'zod';
 import '../events-CK3N--3g.js';
 import '@modelcontextprotocol/sdk/types.js';

package/dist/client/index.d.mts

@@ -1,25 +1,18 @@
 import { M as McpConnectionEvent, d as McpObservabilityEvent, e as McpAppsUIEvent } from '../events-CK3N--3g.mjs';
 export { D as Disposable, a as DisposableStore, E as Emitter, b as Event, c as McpConnectionState } from '../events-CK3N--3g.mjs';
-import { s as SessionListResult, e as ConnectParams, h as ConnectResult, j as DisconnectResult, n as ListToolsRpcResult, r as RestoreSessionResult, k as FinishAuthResult, L as ListPromptsResult, l as ListResourcesResult } from '../types-PjM1W07s.mjs';
-export { p as McpRpcRequest, q as McpRpcResponse, T as ToolInfo } from '../types-PjM1W07s.mjs';
+import { s as SessionListResult, e as ConnectParams, h as ConnectResult, j as DisconnectResult, n as ListToolsRpcResult, r as RestoreSessionResult, k as FinishAuthResult, L as ListPromptsResult, l as ListResourcesResult } from '../types-CW6lghof.mjs';
+export { p as McpRpcRequest, q as McpRpcResponse, T as ToolInfo } from '../types-CW6lghof.mjs';
 import '@modelcontextprotocol/sdk/types.js';
 
 /**
- * SSE Client for MCP Connections
+ * Stateless RPC-over-stream client for MCP connections.
  *
- * Browser-side client that manages real-time communication with the MCP server
- * using Server-Sent Events (SSE) for server→client streaming and HTTP POST for
- * client→server RPC requests.
- *
- * Key features:
- * - Direct HTTP response for RPC calls (bypasses SSE latency)
- * - Resource preloading for instant MCP App UI loading
- * - Automatic reconnection with exponential backoff
- * - Type-safe RPC methods
+ * Uses single POST requests with `Accept: text/event-stream` for every RPC call.
+ * Progress events and the final rpc-response are delivered in the same response.
  */
 
 interface SSEClientOptions {
-    /** SSE endpoint URL */
+    /** MCP endpoint URL */
     url: string;
     /** User/Client identifier */
     identity: string;
@@ -33,36 +26,17 @@ interface SSEClientOptions {
     onStatusChange?: (status: ConnectionStatus) => void;
     /** Callback for MCP App UI events */
     onEvent?: (event: McpAppsUIEvent) => void;
-    /** Request timeout in milliseconds @default 60000 */
-    requestTimeout?: number;
     /** Enable debug logging @default false */
     debug?: boolean;
 }
 type ConnectionStatus = 'connecting' | 'connected' | 'disconnected' | 'error';
-/**
- * SSE Client for real-time MCP connection management
- */
 declare class SSEClient {
     private readonly options;
-    private eventSource;
-    private pendingRequests;
     private resourceCache;
-    private reconnectAttempts;
-    private isManuallyDisconnected;
-    private connectionPromise;
-    private connectionResolver;
+    private connected;
     constructor(options: SSEClientOptions);
-    /**
-     * Connect to the SSE endpoint
-     */
     connect(): void;
-    /**
-     * Disconnect from the SSE endpoint
-     */
     disconnect(): void;
-    /**
-     * Check if connected to the SSE endpoint
-     */
     isConnected(): boolean;
     getSessions(): Promise<SessionListResult>;
     connectToServer(params: ConnectParams): Promise<ConnectResult>;
@@ -75,48 +49,18 @@ declare class SSEClient {
     getPrompt(sessionId: string, name: string, args?: Record<string, string>): Promise<unknown>;
     listResources(sessionId: string): Promise<ListResourcesResult>;
     readResource(sessionId: string, uri: string): Promise<unknown>;
-    /**
-     * Preload UI resources for tools that have UI metadata.
-     * Call this when tools are discovered to enable instant MCP App UI loading.
-     */
     preloadToolUiResources(sessionId: string, tools: Array<{
         name: string;
         _meta?: unknown;
     }>): void;
-    /**
-     * Get a preloaded resource from cache, or fetch if not cached.
-     */
     getOrFetchResource(sessionId: string, uri: string): Promise<unknown>;
-    /**
-     * Check if a resource is already cached
-     */
     hasPreloadedResource(uri: string): boolean;
-    /**
-     * Clear the resource cache
-     */
     clearResourceCache(): void;
-    /**
-     * Send an RPC request and return the response directly from HTTP.
-     * This bypasses SSE latency by returning results in the HTTP response body.
-     */
     private sendRequest;
-    /**
-     * Parse RPC response and handle different response formats
-     */
+    private readRpcResponseFromStream;
     private parseRpcResponse;
-    /**
-     * Wait for RPC response via SSE (legacy fallback)
-     */
-    private waitForSseResponse;
-    /**
-     * Handle RPC response received via SSE (legacy)
-     */
-    private handleRpcResponse;
-    private setupEventListeners;
-    private attemptReconnect;
     private buildUrl;
     private buildHeaders;
-    private rejectAllPendingRequests;
     private extractUiResourceUri;
     private emitUiEventIfPresent;
     private log;

package/dist/client/index.d.ts

@@ -1,25 +1,18 @@
 import { M as McpConnectionEvent, d as McpObservabilityEvent, e as McpAppsUIEvent } from '../events-CK3N--3g.js';
 export { D as Disposable, a as DisposableStore, E as Emitter, b as Event, c as McpConnectionState } from '../events-CK3N--3g.js';
-import { s as SessionListResult, e as ConnectParams, h as ConnectResult, j as DisconnectResult, n as ListToolsRpcResult, r as RestoreSessionResult, k as FinishAuthResult, L as ListPromptsResult, l as ListResourcesResult } from '../types-PjM1W07s.js';
-export { p as McpRpcRequest, q as McpRpcResponse, T as ToolInfo } from '../types-PjM1W07s.js';
+import { s as SessionListResult, e as ConnectParams, h as ConnectResult, j as DisconnectResult, n as ListToolsRpcResult, r as RestoreSessionResult, k as FinishAuthResult, L as ListPromptsResult, l as ListResourcesResult } from '../types-CW6lghof.js';
+export { p as McpRpcRequest, q as McpRpcResponse, T as ToolInfo } from '../types-CW6lghof.js';
 import '@modelcontextprotocol/sdk/types.js';
 
 /**
- * SSE Client for MCP Connections
+ * Stateless RPC-over-stream client for MCP connections.
  *
- * Browser-side client that manages real-time communication with the MCP server
- * using Server-Sent Events (SSE) for server→client streaming and HTTP POST for
- * client→server RPC requests.
- *
- * Key features:
- * - Direct HTTP response for RPC calls (bypasses SSE latency)
- * - Resource preloading for instant MCP App UI loading
- * - Automatic reconnection with exponential backoff
- * - Type-safe RPC methods
+ * Uses single POST requests with `Accept: text/event-stream` for every RPC call.
+ * Progress events and the final rpc-response are delivered in the same response.
  */
 
 interface SSEClientOptions {
-    /** SSE endpoint URL */
+    /** MCP endpoint URL */
     url: string;
     /** User/Client identifier */
     identity: string;
@@ -33,36 +26,17 @@ interface SSEClientOptions {
     onStatusChange?: (status: ConnectionStatus) => void;
     /** Callback for MCP App UI events */
     onEvent?: (event: McpAppsUIEvent) => void;
-    /** Request timeout in milliseconds @default 60000 */
-    requestTimeout?: number;
     /** Enable debug logging @default false */
     debug?: boolean;
 }
 type ConnectionStatus = 'connecting' | 'connected' | 'disconnected' | 'error';
-/**
- * SSE Client for real-time MCP connection management
- */
 declare class SSEClient {
     private readonly options;
-    private eventSource;
-    private pendingRequests;
     private resourceCache;
-    private reconnectAttempts;
-    private isManuallyDisconnected;
-    private connectionPromise;
-    private connectionResolver;
+    private connected;
     constructor(options: SSEClientOptions);
-    /**
-     * Connect to the SSE endpoint
-     */
     connect(): void;
-    /**
-     * Disconnect from the SSE endpoint
-     */
     disconnect(): void;
-    /**
-     * Check if connected to the SSE endpoint
-     */
     isConnected(): boolean;
     getSessions(): Promise<SessionListResult>;
     connectToServer(params: ConnectParams): Promise<ConnectResult>;
@@ -75,48 +49,18 @@ declare class SSEClient {
     getPrompt(sessionId: string, name: string, args?: Record<string, string>): Promise<unknown>;
     listResources(sessionId: string): Promise<ListResourcesResult>;
     readResource(sessionId: string, uri: string): Promise<unknown>;
-    /**
-     * Preload UI resources for tools that have UI metadata.
-     * Call this when tools are discovered to enable instant MCP App UI loading.
-     */
     preloadToolUiResources(sessionId: string, tools: Array<{
         name: string;
         _meta?: unknown;
     }>): void;
-    /**
-     * Get a preloaded resource from cache, or fetch if not cached.
-     */
     getOrFetchResource(sessionId: string, uri: string): Promise<unknown>;
-    /**
-     * Check if a resource is already cached
-     */
     hasPreloadedResource(uri: string): boolean;
-    /**
-     * Clear the resource cache
-     */
     clearResourceCache(): void;
-    /**
-     * Send an RPC request and return the response directly from HTTP.
-     * This bypasses SSE latency by returning results in the HTTP response body.
-     */
     private sendRequest;
-    /**
-     * Parse RPC response and handle different response formats
-     */
+    private readRpcResponseFromStream;
     private parseRpcResponse;
-    /**
-     * Wait for RPC response via SSE (legacy fallback)
-     */
-    private waitForSseResponse;
-    /**
-     * Handle RPC response received via SSE (legacy)
-     */
-    private handleRpcResponse;
-    private setupEventListeners;
-    private attemptReconnect;
     private buildUrl;
     private buildHeaders;
-    private rejectAllPendingRequests;
     private extractUiResourceUri;
     private emitUiEventIfPresent;
     private log;

package/dist/client/index.js

@@ -6,62 +6,27 @@ var appBridge = require('@modelcontextprotocol/ext-apps/app-bridge');
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-var DEFAULT_REQUEST_TIMEOUT = 6e4;
-var MAX_RECONNECT_ATTEMPTS = 5;
-var BASE_RECONNECT_DELAY = 1e3;
 var SSEClient = class {
   constructor(options) {
     this.options = options;
-    __publicField(this, "eventSource", null);
-    __publicField(this, "pendingRequests", /* @__PURE__ */ new Map());
     __publicField(this, "resourceCache", /* @__PURE__ */ new Map());
-    __publicField(this, "reconnectAttempts", 0);
-    __publicField(this, "isManuallyDisconnected", false);
-    __publicField(this, "connectionPromise", null);
-    __publicField(this, "connectionResolver", null);
+    __publicField(this, "connected", false);
   }
-  // ============================================
-  // Connection Management
-  // ============================================
-  /**
-   * Connect to the SSE endpoint
-   */
   connect() {
-    if (this.eventSource) {
+    if (this.connected) {
       return;
     }
-    this.isManuallyDisconnected = false;
-    this.options.onStatusChange?.("connecting");
-    this.connectionPromise = new Promise((resolve) => {
-      this.connectionResolver = resolve;
-    });
-    const url = this.buildUrl();
-    this.eventSource = new EventSource(url);
-    this.setupEventListeners();
+    this.connected = true;
+    this.options.onStatusChange?.("connected");
+    this.log("RPC mode: post_stream");
   }
-  /**
-   * Disconnect from the SSE endpoint
-   */
   disconnect() {
-    this.isManuallyDisconnected = true;
-    if (this.eventSource) {
-      this.eventSource.close();
-      this.eventSource = null;
-    }
-    this.connectionPromise = null;
-    this.connectionResolver = null;
-    this.rejectAllPendingRequests(new Error("Connection closed"));
+    this.connected = false;
     this.options.onStatusChange?.("disconnected");
   }
-  /**
-   * Check if connected to the SSE endpoint
-   */
   isConnected() {
-    return this.eventSource?.readyState === EventSource.OPEN;
+    return this.connected;
   }
-  // ============================================
-  // RPC Methods
-  // ============================================
   async getSessions() {
     return this.sendRequest("getSessions");
   }
@@ -97,22 +62,10 @@ var SSEClient = class {
   async readResource(sessionId, uri) {
     return this.sendRequest("readResource", { sessionId, uri });
   }
-  // ============================================
-  // Resource Preloading (for instant UI loading)
-  // ============================================
-  /**
-   * Preload UI resources for tools that have UI metadata.
-   * Call this when tools are discovered to enable instant MCP App UI loading.
-   */
   preloadToolUiResources(sessionId, tools) {
     for (const tool of tools) {
       const uri = this.extractUiResourceUri(tool);
-      if (!uri) continue;
-      if (this.resourceCache.has(uri)) {
-        this.log(`Resource already cached: ${uri}`);
-        continue;
-      }
-      this.log(`Preloading UI resource for tool "${tool.name}": ${uri}`);
+      if (!uri || this.resourceCache.has(uri)) continue;
       const promise = this.sendRequest("readResource", { sessionId, uri }).catch((err) => {
         this.log(`Failed to preload resource ${uri}: ${err.message}`, "warn");
         this.resourceCache.delete(uri);
@@ -121,43 +74,24 @@ var SSEClient = class {
       this.resourceCache.set(uri, promise);
     }
   }
-  /**
-   * Get a preloaded resource from cache, or fetch if not cached.
-   */
   getOrFetchResource(sessionId, uri) {
     const cached = this.resourceCache.get(uri);
-    if (cached) {
-      this.log(`Cache hit for resource: ${uri}`);
-      return cached;
-    }
-    this.log(`Cache miss, fetching resource: ${uri}`);
+    if (cached) return cached;
     const promise = this.sendRequest("readResource", { sessionId, uri });
     this.resourceCache.set(uri, promise);
     return promise;
   }
-  /**
-   * Check if a resource is already cached
-   */
   hasPreloadedResource(uri) {
     return this.resourceCache.has(uri);
   }
-  /**
-   * Clear the resource cache
-   */
   clearResourceCache() {
     this.resourceCache.clear();
   }
-  // ============================================
-  // Private: Request Handling
-  // ============================================
-  /**
-   * Send an RPC request and return the response directly from HTTP.
-   * This bypasses SSE latency by returning results in the HTTP response body.
-   */
   async sendRequest(method, params) {
-    if (this.connectionPromise) {
-      await this.connectionPromise;
+    if (!this.connected) {
+      this.connect();
     }
+    this.log(`RPC request via post_stream: ${method}`);
     const request = {
       id: `rpc_${nanoid.nanoid(10)}`,
       method,
@@ -171,103 +105,93 @@ var SSEClient = class {
     if (!response.ok) {
       throw new Error(`HTTP ${response.status}: ${response.statusText}`);
     }
-    const data = await response.json();
-    return this.parseRpcResponse(data, request.id);
+    const contentType = (response.headers.get("content-type") || "").toLowerCase();
+    if (!contentType.includes("text/event-stream")) {
+      const data2 = await response.json();
+      return this.parseRpcResponse(data2);
+    }
+    const data = await this.readRpcResponseFromStream(response);
+    return this.parseRpcResponse(data);
   }
-  /**
-   * Parse RPC response and handle different response formats
-   */
-  parseRpcResponse(data, requestId) {
+  async readRpcResponseFromStream(response) {
+    if (!response.body) {
+      throw new Error("Streaming response body is missing");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let rpcResponse = null;
+    const dispatchBlock = (block) => {
+      const lines = block.split("\n");
+      let eventName = "message";
+      const dataLines = [];
+      for (const rawLine of lines) {
+        const line = rawLine.replace(/\r$/, "");
+        if (!line || line.startsWith(":")) continue;
+        if (line.startsWith("event:")) {
+          eventName = line.slice("event:".length).trim();
+          continue;
+        }
+        if (line.startsWith("data:")) {
+          dataLines.push(line.slice("data:".length).trimStart());
+        }
+      }
+      if (!dataLines.length) return;
+      const payloadText = dataLines.join("\n");
+      let payload = payloadText;
+      try {
+        payload = JSON.parse(payloadText);
+      } catch {
+      }
+      switch (eventName) {
+        case "connected":
+          this.options.onStatusChange?.("connected");
+          break;
+        case "connection":
+          this.options.onConnectionEvent?.(payload);
+          break;
+        case "observability":
+          this.options.onObservabilityEvent?.(payload);
+          break;
+        case "rpc-response":
+          rpcResponse = payload;
+          break;
+      }
+    };
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let separatorMatch = buffer.match(/\r?\n\r?\n/);
+      while (separatorMatch && separatorMatch.index !== void 0) {
+        const separatorIndex = separatorMatch.index;
+        const separatorLength = separatorMatch[0].length;
+        const block = buffer.slice(0, separatorIndex);
+        buffer = buffer.slice(separatorIndex + separatorLength);
+        dispatchBlock(block);
+        separatorMatch = buffer.match(/\r?\n\r?\n/);
+      }
+    }
+    if (buffer.trim()) {
+      dispatchBlock(buffer);
+    }
+    if (!rpcResponse) {
+      throw new Error("Missing rpc-response event in streamed RPC result");
+    }
+    return rpcResponse;
+  }
+  parseRpcResponse(data) {
     if ("result" in data) {
       return data.result;
     }
     if ("error" in data && data.error) {
       throw new Error(data.error.message || "Unknown RPC error");
     }
-    if ("acknowledged" in data) {
-      return this.waitForSseResponse(requestId);
+    if (data && typeof data === "object" && "id" in data) {
+      return void 0;
     }
     throw new Error("Invalid RPC response format");
   }
-  /**
-   * Wait for RPC response via SSE (legacy fallback)
-   */
-  waitForSseResponse(requestId) {
-    const timeoutMs = this.options.requestTimeout ?? DEFAULT_REQUEST_TIMEOUT;
-    return new Promise((resolve, reject) => {
-      const timeoutId = setTimeout(() => {
-        this.pendingRequests.delete(requestId);
-        reject(new Error(`Request timeout after ${timeoutMs}ms`));
-      }, timeoutMs);
-      this.pendingRequests.set(requestId, {
-        resolve,
-        reject,
-        timeoutId
-      });
-    });
-  }
-  /**
-   * Handle RPC response received via SSE (legacy)
-   */
-  handleRpcResponse(response) {
-    const pending = this.pendingRequests.get(response.id);
-    if (!pending) return;
-    clearTimeout(pending.timeoutId);
-    this.pendingRequests.delete(response.id);
-    if (response.error) {
-      pending.reject(new Error(response.error.message));
-    } else {
-      pending.resolve(response.result);
-    }
-  }
-  // ============================================
-  // Private: Event Handling
-  // ============================================
-  setupEventListeners() {
-    if (!this.eventSource) return;
-    this.eventSource.addEventListener("open", () => {
-      this.log("Connected");
-      this.reconnectAttempts = 0;
-      this.options.onStatusChange?.("connected");
-    });
-    this.eventSource.addEventListener("connected", () => {
-      this.log("Server ready");
-      this.connectionResolver?.();
-      this.connectionResolver = null;
-    });
-    this.eventSource.addEventListener("connection", (e) => {
-      const event = JSON.parse(e.data);
-      this.options.onConnectionEvent?.(event);
-    });
-    this.eventSource.addEventListener("observability", (e) => {
-      const event = JSON.parse(e.data);
-      this.options.onObservabilityEvent?.(event);
-    });
-    this.eventSource.addEventListener("rpc-response", (e) => {
-      const response = JSON.parse(e.data);
-      this.handleRpcResponse(response);
-    });
-    this.eventSource.addEventListener("error", () => {
-      this.log("Connection error", "error");
-      this.options.onStatusChange?.("error");
-      this.attemptReconnect();
-    });
-  }
-  attemptReconnect() {
-    if (this.isManuallyDisconnected || this.reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
-      return;
-    }
-    this.reconnectAttempts++;
-    const delay = BASE_RECONNECT_DELAY * this.reconnectAttempts;
-    this.log(`Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS})`);
-    setTimeout(() => {
-      this.disconnect();
-      this.connect();
-    }, delay);
-  }
-  // ============================================
-  // Private: Utilities
-  // ============================================
   buildUrl() {
     const url = new URL(this.options.url, globalThis.location?.origin);
     url.searchParams.set("identity", this.options.identity);
@@ -278,20 +202,14 @@ var SSEClient = class {
   }
   buildHeaders() {
     const headers = {
-      "Content-Type": "application/json"
+      "Content-Type": "application/json",
+      "Accept": "text/event-stream"
     };
     if (this.options.authToken) {
       headers["Authorization"] = `Bearer ${this.options.authToken}`;
     }
     return headers;
   }
-  rejectAllPendingRequests(error) {
-    for (const [, pending] of this.pendingRequests) {
-      clearTimeout(pending.timeoutId);
-      pending.reject(error);
-    }
-    this.pendingRequests.clear();
-  }
   extractUiResourceUri(tool) {
     const meta = tool._meta?.ui;
     if (!meta || typeof meta !== "object") return void 0;