@mcp-ts/sdk 1.6.1 → 2.0.0

package/dist/client/react.mjs

@@ -28,8 +28,8 @@ var SSEClient = class {
   isConnected() {
     return this.connected;
   }
-  async getSessions() {
-    return this.sendRequest("getSessions");
+  async listSessions() {
+    return this.sendRequest("listSessions");
   }
   async connectToServer(params) {
     return this.sendRequest("connect", params);
@@ -45,8 +45,8 @@ var SSEClient = class {
     this.emitUiEventIfPresent(result, sessionId, toolName);
     return result;
   }
-  async restoreSession(sessionId) {
-    return this.sendRequest("restoreSession", { sessionId });
+  async getSession(sessionId) {
+    return this.sendRequest("getSession", { sessionId });
   }
   async finishAuth(sessionId, code) {
     return this.sendRequest("finishAuth", { sessionId, code });
@@ -112,7 +112,7 @@ var SSEClient = class {
       return this.parseRpcResponse(data2);
     }
     const data = await this.readRpcResponseFromStream(response, {
-      delayConnectionEvents: method === "connect" || method === "restoreSession" || method === "finishAuth"
+      delayConnectionEvents: method === "connect" || method === "getSession" || method === "finishAuth"
     });
     return this.parseRpcResponse(data);
   }
@@ -202,17 +202,13 @@ var SSEClient = class {
     throw new Error("Invalid RPC response format");
   }
   buildUrl() {
-    const url = new URL(this.options.url, globalThis.location?.origin);
-    url.searchParams.set("identity", this.options.identity);
-    if (this.options.authToken) {
-      url.searchParams.set("token", this.options.authToken);
-    }
-    return url.toString();
+    return new URL(this.options.url, globalThis.location?.origin).toString();
   }
   buildHeaders() {
     const headers = {
       "Content-Type": "application/json",
-      "Accept": "text/event-stream"
+      "Accept": "text/event-stream",
+      "x-mcp-user-id": this.options.userId
     };
     if (this.options.authToken) {
       headers["Authorization"] = `Bearer ${this.options.authToken}`;
@@ -259,7 +255,7 @@ var SSEClient = class {
 function useMcp(options) {
   const {
     url,
-    identity,
+    userId,
     authToken,
     autoConnect = true,
     autoInitialize = true,
@@ -280,7 +276,7 @@ function useMcp(options) {
     isMountedRef.current = true;
     const clientOptions = {
       url,
-      identity,
+      userId,
       authToken,
       onConnectionEvent: (event) => {
         updateConnectionsFromEvent(event);
@@ -309,7 +305,7 @@ function useMcp(options) {
       isMountedRef.current = false;
       client.disconnect();
     };
-  }, [url, identity, authToken, autoConnect, autoInitialize]);
+  }, [url, userId, authToken, autoConnect, autoInitialize]);
   const updateConnectionsFromEvent = useCallback((event) => {
     if (!isMountedRef.current) return;
     const isTransientReconnectState = (state) => state === "INITIALIZING" || state === "VALIDATING" || state === "RECONNECTING" || state === "CONNECTING" || state === "CONNECTED" || state === "DISCOVERING";
@@ -404,7 +400,7 @@ function useMcp(options) {
     if (!clientRef.current) return;
     try {
       setIsInitializing(true);
-      const result = await clientRef.current.getSessions();
+      const result = await clientRef.current.listSessions();
       const sessions = result.sessions || [];
       if (isMountedRef.current) {
         setConnections(
@@ -428,7 +424,7 @@ function useMcp(options) {
                 return;
               }
               suppressAuthRedirectSessionsRef.current.add(session.sessionId);
-              await clientRef.current.restoreSession(session.sessionId);
+              await clientRef.current.getSession(session.sessionId);
             } catch (error) {
               console.error(`[useMcp] Failed to validate session ${session.sessionId}:`, error);
             } finally {
@@ -506,7 +502,7 @@ function useMcp(options) {
       throw new Error("SSE client not initialized");
     }
     suppressAuthRedirectSessionsRef.current.delete(sessionId);
-    await clientRef.current.restoreSession(sessionId);
+    await clientRef.current.getSession(sessionId);
   }, []);
   const callTool = useCallback(
     async (sessionId, toolName, toolArgs) => {
@@ -625,14 +621,31 @@ function useMcp(options) {
 }
 var AUTH_CODE_MESSAGE = "MCP_AUTH_CODE";
 var AUTH_RESULT_MESSAGE = "MCP_AUTH_RESULT";
+var AUTH_CHANNEL_NAME = "mcp-auth-channel";
+function createAuthBroadcastChannel() {
+  if (typeof BroadcastChannel === "undefined") {
+    return null;
+  }
+  try {
+    return new BroadcastChannel(AUTH_CHANNEL_NAME);
+  } catch {
+    return null;
+  }
+}
 function postPopupResult(popupWindow, result) {
-  popupWindow?.postMessage(
-    {
-      type: AUTH_RESULT_MESSAGE,
-      ...result
-    },
-    window.location.origin
-  );
+  const payload = {
+    type: AUTH_RESULT_MESSAGE,
+    ...result
+  };
+  try {
+    popupWindow?.postMessage(payload, window.location.origin);
+  } catch {
+  }
+  const channel = createAuthBroadcastChannel();
+  if (channel) {
+    channel.postMessage(payload);
+    channel.close();
+  }
 }
 function openCenteredPopup(url, options = {}) {
   const {
@@ -673,60 +686,87 @@ function createOAuthPopupRedirectHandler(options = {}) {
 }
 function useMcpOAuthPopup(connections, finishAuth) {
   const pendingPopupsRef = useRef(/* @__PURE__ */ new Map());
+  const processingCodesRef = useRef(/* @__PURE__ */ new Set());
   useEffect(() => {
     const handleMessage = async (event) => {
-      if (event.origin !== window.location.origin) {
+      if (event.origin && event.origin !== window.location.origin) {
         return;
       }
-      if (event.data?.type !== AUTH_CODE_MESSAGE || !event.data.code) {
+      const code = typeof event.data?.code === "string" ? event.data.code : "";
+      if (event.data?.type !== AUTH_CODE_MESSAGE || !code) {
         return;
       }
       const popupWindow = event.source && "postMessage" in event.source ? event.source : null;
       const targetSessionId = typeof event.data.sessionId === "string" ? event.data.sessionId : "";
+      if (popupWindow && targetSessionId) {
+        pendingPopupsRef.current.set(targetSessionId, popupWindow);
+      }
       if (!targetSessionId) {
-        postPopupResult(popupWindow, {
-          success: false,
-          error: "Missing OAuth session identifier"
-        });
+        if (popupWindow) {
+          postPopupResult(popupWindow, {
+            success: false,
+            error: "Missing OAuth session identifier"
+          });
+        }
         return;
       }
       const targetSession = connections.find((connection) => connection.sessionId === targetSessionId);
       if (!targetSession) {
-        postPopupResult(popupWindow, {
-          sessionId: targetSessionId,
-          success: false,
-          error: "OAuth session not found in the current client state"
-        });
+        if (popupWindow) {
+          postPopupResult(popupWindow, {
+            sessionId: targetSessionId,
+            success: false,
+            error: "OAuth session not found in the current client state"
+          });
+        }
         return;
       }
-      if (popupWindow) {
-        pendingPopupsRef.current.set(targetSession.sessionId, popupWindow);
+      const codeKey = `${targetSession.sessionId}:${code}`;
+      if (processingCodesRef.current.has(codeKey)) {
+        return;
       }
+      processingCodesRef.current.add(codeKey);
       try {
-        await finishAuth(targetSession.sessionId, event.data.code);
+        await finishAuth(targetSession.sessionId, code);
       } catch (error) {
+        processingCodesRef.current.delete(codeKey);
         pendingPopupsRef.current.delete(targetSession.sessionId);
-        postPopupResult(popupWindow, {
-          sessionId: targetSession.sessionId,
-          success: false,
-          error: error instanceof Error ? error.message : "Failed to finish auth"
-        });
+        if (popupWindow) {
+          postPopupResult(popupWindow, {
+            sessionId: targetSession.sessionId,
+            success: false,
+            error: error instanceof Error ? error.message : "Failed to finish auth"
+          });
+        }
+      }
+    };
+    const channel = createAuthBroadcastChannel();
+    const handleChannelMessage = (event) => {
+      if (event.data?.type === AUTH_CODE_MESSAGE) {
+        void handleMessage(event);
       }
     };
     window.addEventListener("message", handleMessage);
-    return () => window.removeEventListener("message", handleMessage);
+    channel?.addEventListener("message", handleChannelMessage);
+    return () => {
+      window.removeEventListener("message", handleMessage);
+      channel?.removeEventListener("message", handleChannelMessage);
+      channel?.close();
+    };
   }, [connections, finishAuth]);
   useEffect(() => {
     for (const connection of connections) {
-      const popupWindow = pendingPopupsRef.current.get(connection.sessionId);
-      if (!popupWindow) {
-        continue;
-      }
-      if (connection.state === "AUTHENTICATED") {
+      const popupWindow = pendingPopupsRef.current.get(connection.sessionId) || null;
+      if (connection.state === "AUTHENTICATED" || connection.state === "READY" || connection.state === "CONNECTED") {
         postPopupResult(popupWindow, {
           sessionId: connection.sessionId,
           success: true
         });
+        for (const codeKey of processingCodesRef.current) {
+          if (codeKey.startsWith(`${connection.sessionId}:`)) {
+            processingCodesRef.current.delete(codeKey);
+          }
+        }
         pendingPopupsRef.current.delete(connection.sessionId);
         continue;
       }
@@ -736,6 +776,11 @@ function useMcpOAuthPopup(connections, finishAuth) {
           success: false,
           error: connection.error || "Failed to complete authorization"
         });
+        for (const codeKey of processingCodesRef.current) {
+          if (codeKey.startsWith(`${connection.sessionId}:`)) {
+            processingCodesRef.current.delete(codeKey);
+          }
+        }
         pendingPopupsRef.current.delete(connection.sessionId);
       }
     }
@@ -756,10 +801,9 @@ function McpOAuthCallbackContent({
 }) {
   const [phase, setPhase] = useState(debugPhase || "loading");
   const [errorMessage, setErrorMessage] = useState("");
-  const openerMissing = typeof window !== "undefined" ? !window.opener : false;
   const missingCode = !code;
   const missingSessionId = !sessionId;
-  const blockingError = openerMissing ? "Error: No opener window found. This window should be opened from the app." : missingCode ? "Error: No authorization code received." : missingSessionId ? "Error: No OAuth state received." : null;
+  const blockingError = missingCode ? "Error: No authorization code received." : missingSessionId ? "Error: No OAuth state received." : null;
   useEffect(() => {
     if (debugPhase) {
       setPhase(debugPhase);
@@ -772,8 +816,9 @@ function McpOAuthCallbackContent({
       return;
     }
     let closed = false;
+    const channel = createAuthBroadcastChannel();
     const handleResult = (event) => {
-      if (event.origin !== window.location.origin) {
+      if (event.origin && event.origin !== window.location.origin) {
         return;
       }
       if (event.data?.type !== AUTH_RESULT_MESSAGE) {
@@ -785,6 +830,7 @@ function McpOAuthCallbackContent({
       if (event.data.success) {
         setPhase("success");
         window.removeEventListener("message", handleResult);
+        channel?.close();
         closed = true;
         window.setTimeout(() => window.close(), 1200);
         return;
@@ -794,21 +840,23 @@ function McpOAuthCallbackContent({
       setErrorMessage(message);
     };
     window.addEventListener("message", handleResult);
-    try {
-      window.opener.postMessage(
-        { type: AUTH_CODE_MESSAGE, code, sessionId },
-        window.location.origin
-      );
-    } catch (error) {
-      console.error("Failed to communicate with opener:", error);
-      window.setTimeout(() => {
+    channel?.addEventListener("message", handleResult);
+    const payload = { type: AUTH_CODE_MESSAGE, code, sessionId };
+    if (window.opener) {
+      try {
+        window.opener.postMessage(payload, window.location.origin);
+      } catch {
         setPhase("error");
         setErrorMessage("Error: Could not communicate with main window.");
-      }, 0);
+      }
+    }
+    if (channel) {
+      channel.postMessage(payload);
     }
     return () => {
       if (!closed) {
         window.removeEventListener("message", handleResult);
+        channel?.close();
       }
     };
   }, [blockingError, code, sessionId, debugPhase]);
@@ -1342,7 +1390,7 @@ var AppHost = class {
   async getSessionId() {
     if (this.sessionId) return this.sessionId;
     if (!this.client) return void 0;
-    const result = await this.client.getSessions();
+    const result = await this.client.listSessions();
     return result.sessions?.[0]?.sessionId;
   }
   isMcpUri(url) {