@mcp-ts/sdk 1.3.1 → 1.3.3

package/dist/client/react.d.ts

@@ -1,9 +1,9 @@
 import { SSEClient, AppHost } from './index.js';
 export { SSEClientOptions } from './index.js';
-import { c as McpConnectionState, M as McpConnectionEvent } from '../events-BgeztGYZ.js';
-export { D as Disposable, a as DisposableStore, E as Emitter, b as Event, d as McpObservabilityEvent } from '../events-BgeztGYZ.js';
-import { T as ToolInfo, k as FinishAuthResult, n as ListToolsRpcResult, L as ListPromptsResult, l as ListResourcesResult } from '../types-CLccx9wW.js';
-export { p as McpRpcRequest, q as McpRpcResponse } from '../types-CLccx9wW.js';
+import { c as McpConnectionState, M as McpConnectionEvent } from '../events-CK3N--3g.js';
+export { D as Disposable, a as DisposableStore, E as Emitter, b as Event, d as McpObservabilityEvent } from '../events-CK3N--3g.js';
+import { T as ToolInfo, k as FinishAuthResult, n as ListToolsRpcResult, L as ListPromptsResult, l as ListResourcesResult } from '../types-CW6lghof.js';
+export { p as McpRpcRequest, q as McpRpcResponse } from '../types-CW6lghof.js';
 import React$1 from 'react';
 import '@modelcontextprotocol/sdk/types.js';
 
@@ -54,6 +54,11 @@ interface UseMcpOptions {
      * @default 60000
      */
     requestTimeout?: number;
+    /**
+     * Enable client debug logs.
+     * @default false
+     */
+    debug?: boolean;
 }
 interface McpConnection {
     sessionId: string;
@@ -63,8 +68,9 @@ interface McpConnection {
     transport?: string;
     state: McpConnectionState;
     tools: ToolInfo[];
+    authUrl?: string;
     error?: string;
-    connectedAt?: Date;
+    createdAt?: Date;
 }
 interface McpClient$1 {
     /**
@@ -125,6 +131,10 @@ interface McpClient$1 {
      * Complete OAuth authorization
      */
     finishAuth: (sessionId: string, code: string) => Promise<FinishAuthResult>;
+    /**
+     * Explicitly resume OAuth flow for an existing session
+     */
+    resumeAuth: (sessionId: string) => Promise<void>;
     /**
      * Call a tool from a session
      */

package/dist/client/react.js

@@ -8,62 +8,27 @@ var jsxRuntime = require('react/jsx-runtime');
 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");
   }
@@ -99,22 +64,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);
@@ -123,43 +76,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,
@@ -173,103 +107,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);
+  }
+  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;
   }
-  /**
-   * Parse RPC response and handle different response formats
-   */
-  parseRpcResponse(data, requestId) {
+  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);
@@ -280,20 +204,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;
@@ -344,6 +262,7 @@ function useMcp(options) {
   } = options;
   const clientRef = react.useRef(null);
   const isMountedRef = react.useRef(true);
+  const suppressAuthRedirectSessionsRef = react.useRef(/* @__PURE__ */ new Set());
   const [connections, setConnections] = react.useState([]);
   const [status, setStatus] = react.useState(
     "disconnected"
@@ -367,7 +286,7 @@ function useMcp(options) {
           setStatus(newStatus);
         }
       },
-      requestTimeout: options.requestTimeout
+      debug: options.debug
     };
     const client = new SSEClient(clientOptions);
     clientRef.current = client;
@@ -384,22 +303,34 @@ function useMcp(options) {
   }, [url, identity, authToken, autoConnect, autoInitialize]);
   const updateConnectionsFromEvent = react.useCallback((event) => {
     if (!isMountedRef.current) return;
+    const isTransientReconnectState = (state) => state === "INITIALIZING" || state === "VALIDATING" || state === "RECONNECTING" || state === "CONNECTING" || state === "CONNECTED" || state === "DISCOVERING";
     setConnections((prev) => {
       switch (event.type) {
         case "state_changed": {
           const existing = prev.find((c) => c.sessionId === event.sessionId);
           if (existing) {
+            const nextState = existing.state === "READY" && isTransientReconnectState(event.state) ? existing.state : event.state;
             return prev.map(
-              (c) => c.sessionId === event.sessionId ? { ...c, state: event.state } : c
+              (c) => c.sessionId === event.sessionId ? {
+                ...c,
+                state: nextState,
+                // update createdAt if present in event, otherwise keep existing
+                createdAt: event.createdAt ? new Date(event.createdAt) : c.createdAt
+              } : c
             );
           } else {
+            if (event.state === "DISCONNECTED") {
+              return prev;
+            }
             return [
               ...prev,
               {
                 sessionId: event.sessionId,
                 serverId: event.serverId,
                 serverName: event.serverName,
+                serverUrl: event.serverUrl,
                 state: event.state,
+                createdAt: event.createdAt ? new Date(event.createdAt) : void 0,
                 tools: []
               }
             ];
@@ -416,14 +347,16 @@ function useMcp(options) {
         case "auth_required": {
           if (event.authUrl) {
             onLog?.("info", `OAuth required - redirecting to ${event.authUrl}`, { authUrl: event.authUrl });
-            if (onRedirect) {
-              onRedirect(event.authUrl);
-            } else if (typeof window !== "undefined") {
-              window.location.href = event.authUrl;
+            if (!suppressAuthRedirectSessionsRef.current.has(event.sessionId)) {
+              if (onRedirect) {
+                onRedirect(event.authUrl);
+              } else if (typeof window !== "undefined") {
+                window.location.href = event.authUrl;
+              }
             }
           }
           return prev.map(
-            (c) => c.sessionId === event.sessionId ? { ...c, state: "AUTHENTICATING" } : c
+            (c) => c.sessionId === event.sessionId ? { ...c, state: "AUTHENTICATING", authUrl: event.authUrl } : c
           );
         }
         case "error": {
@@ -438,7 +371,7 @@ function useMcp(options) {
           return prev;
       }
     });
-  }, [onLog]);
+  }, [onLog, onRedirect]);
   const loadSessions = react.useCallback(async () => {
     if (!clientRef.current) return;
     try {
@@ -453,7 +386,8 @@ function useMcp(options) {
             serverName: s.serverName ?? "Unknown Server",
             serverUrl: s.serverUrl,
             transport: s.transport,
-            state: "VALIDATING",
+            state: s.active === false ? "AUTHENTICATING" : "VALIDATING",
+            createdAt: new Date(s.createdAt),
             tools: []
           }))
         );
@@ -462,9 +396,15 @@ function useMcp(options) {
         sessions.map(async (session) => {
           if (clientRef.current) {
             try {
+              if (session.active === false) {
+                return;
+              }
+              suppressAuthRedirectSessionsRef.current.add(session.sessionId);
               await clientRef.current.restoreSession(session.sessionId);
             } catch (error) {
               console.error(`[useMcp] Failed to validate session ${session.sessionId}:`, error);
+            } finally {
+              suppressAuthRedirectSessionsRef.current.delete(session.sessionId);
             }
           }
         })
@@ -512,6 +452,13 @@ function useMcp(options) {
     }
     return await clientRef.current.finishAuth(sessionId, code);
   }, []);
+  const resumeAuth = react.useCallback(async (sessionId) => {
+    if (!clientRef.current) {
+      throw new Error("SSE client not initialized");
+    }
+    suppressAuthRedirectSessionsRef.current.delete(sessionId);
+    await clientRef.current.restoreSession(sessionId);
+  }, []);
   const callTool = react.useCallback(
     async (sessionId, toolName, toolArgs) => {
       if (!clientRef.current) {
@@ -590,6 +537,7 @@ function useMcp(options) {
     connectSSE,
     disconnectSSE,
     finishAuth,
+    resumeAuth,
     callTool,
     listTools,
     listPrompts,