@assistant-ui/react-mcp 0.1.19 → 0.1.20

package/dist/utils/invokeMcpCallback.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"invokeMcpCallback.d.ts","names":[],"sources":["../../src/utils/invokeMcpCallback.ts"],"mappings":";qBAEa,oBAAqB,yBAChC,cACA,eAAe,MAAM,gCAClB,MAAM"}
+{"version":3,"file":"invokeMcpCallback.d.ts","sourceRoot":"","sources":["../../src/utils/invokeMcpCallback.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,iBAAiB,GAAI,KAAK,SAAS,OAAO,EAAE,EACvD,MAAM,MAAM,EACZ,UAAU,CAAC,CAAC,GAAG,IAAI,EAAE,KAAK,KAAK,IAAI,CAAC,GAAG,SAAS,EAChD,GAAG,MAAM,KAAK,KACb,IAEF,CAAC"}

package/dist/utils/serverId.d.ts

@@ -1,5 +1,3 @@
-//#region src/utils/serverId.d.ts
 export declare function assertValidServerId(id: string): void;
 export declare function assertUniqueServerIds(ids: Iterable<string>): void;
-//#endregion
 //# sourceMappingURL=serverId.d.ts.map

package/dist/utils/serverId.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"serverId.d.ts","names":[],"sources":["../../src/utils/serverId.ts"],"mappings":";wBAIgB,oBAAoB;wBAgBpB,sBAAsB,KAAK"}
+{"version":3,"file":"serverId.d.ts","sourceRoot":"","sources":["../../src/utils/serverId.ts"],"names":[],"mappings":"AAIA,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAcpD;AAED,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,IAAI,CAUjE"}

package/dist/utils/serverUrl.d.ts

@@ -1,7 +1,5 @@
-import { MCPPersistedAuthState } from "../auth/types.js";
-//#region src/utils/serverUrl.d.ts
+import type { MCPPersistedAuthState } from "../auth/types.js";
 export declare const normalizeMcpServerUrl: (serverUrl: string) => string;
 export declare const isAuthStateForServerUrl: (state: MCPPersistedAuthState | null, serverUrl: string) => boolean;
 export declare const hasPersistedCredentials: (state: MCPPersistedAuthState | null) => boolean;
-//#endregion
 //# sourceMappingURL=serverUrl.d.ts.map

package/dist/utils/serverUrl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"serverUrl.d.ts","names":[],"sources":["../../src/utils/serverUrl.ts"],"mappings":";;qBAEa,wBAAyB;qBAGzB,0BACX,OAAO,8BACP;qBAaW,0BACX,OAAO"}
+{"version":3,"file":"serverUrl.d.ts","sourceRoot":"","sources":["../../src/utils/serverUrl.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,yBAAsB;AAE3D,eAAO,MAAM,qBAAqB,GAAI,WAAW,MAAM,KAAG,MAC3B,CAAC;AAEhC,eAAO,MAAM,uBAAuB,GAClC,OAAO,qBAAqB,GAAG,IAAI,EACnC,WAAW,MAAM,KAChB,OAUF,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAClC,OAAO,qBAAqB,GAAG,IAAI,KAClC,OAA0D,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@assistant-ui/react-mcp",
-  "version": "0.1.19",
+  "version": "0.1.20",
   "description": "MCP server configuration and connection primitives for @assistant-ui",
   "keywords": [
     "mcp",
@@ -27,13 +27,13 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@assistant-ui/core": "^0.3.20",
-    "@assistant-ui/store": "^0.3.14",
-    "@assistant-ui/tap": "^0.9.18",
+    "@assistant-ui/core": "^0.3.21",
+    "@assistant-ui/store": "^0.3.15",
+    "@assistant-ui/tap": "^0.9.19",
     "@modelcontextprotocol/client": "^2.0.0",
     "@modelcontextprotocol/core": "^2.0.0",
     "@radix-ui/react-primitive": "^2.1.10",
-    "assistant-stream": "^0.3.44"
+    "assistant-stream": "^0.3.45"
   },
   "peerDependencies": {
     "@types/react": "*",
@@ -45,7 +45,7 @@
     }
   },
   "devDependencies": {
-    "@assistant-ui/x-buildutils": "0.0.28",
+    "@assistant-ui/x-buildutils": "0.0.29",
     "@testing-library/dom": "^10.4.2",
     "@testing-library/react": "^16.3.3",
     "@types/react": "^19.3.0",

package/src/resources/McpServerResource.test.ts

@@ -1,5 +1,6 @@
 import { createTapRoot, resource, useResource } from "@assistant-ui/tap";
 import type { ClientOutput } from "@assistant-ui/store";
+import { UnauthorizedError } from "@modelcontextprotocol/client";
 import { useEffect, useState } from "react";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import type { MCPAuthConfig } from "../mcp-scope";
@@ -192,6 +193,15 @@ const mount = (
 const unboundAuthMessage =
   'MCP server "docs" has saved authentication for a different URL. Authenticate again to connect to https://example.com/mcp.';
 
+const getOAuthProvider = (index: number) => {
+  const provider =
+    mocks.StreamableHTTPClientTransport.mock.calls[index]?.[1]?.authProvider;
+  if (!provider) throw new Error("Expected OAuth provider");
+  return provider as {
+    redirectToAuthorization: (url: URL) => Promise<void>;
+  };
+};
+
 describe("McpServerResource automatic authentication", () => {
   beforeEach(resetMocks);
 
@@ -632,6 +642,70 @@ describe("McpServerResource connectionTimeout", () => {
 describe("McpServerResource connection lifecycle", () => {
   beforeEach(resetMocks);
 
+  it("publishes authorization URLs from the current connection", async () => {
+    const root = mount({ auth: { type: "oauth" } });
+
+    try {
+      await root.getValue().connect();
+      await getOAuthProvider(0).redirectToAuthorization(
+        new URL("https://auth.example.com/current"),
+      );
+      await waitForResourceUpdate(
+        () => root.getValue().getState().authorizationUrl !== null,
+      );
+
+      expect(root.getValue().getState().authorizationUrl).toBe(
+        "https://auth.example.com/current",
+      );
+    } finally {
+      root.unmount();
+    }
+  });
+
+  it("ignores authorization URLs after disconnect", async () => {
+    const root = mount({ auth: { type: "oauth" } });
+
+    try {
+      await root.getValue().connect();
+      const provider = getOAuthProvider(0);
+      await root.getValue().disconnect();
+
+      await provider.redirectToAuthorization(
+        new URL("https://auth.example.com/stale"),
+      );
+      await flushMacrotask();
+
+      expect(root.getValue().getState()).toMatchObject({
+        connectionState: "disconnected",
+        authorizationUrl: null,
+      });
+    } finally {
+      root.unmount();
+    }
+  });
+
+  it("ignores authorization URLs from a superseded connection", async () => {
+    const root = mount({ auth: { type: "oauth" } });
+
+    try {
+      await root.getValue().connect();
+      const staleProvider = getOAuthProvider(0);
+      await root.getValue().connect();
+
+      await staleProvider.redirectToAuthorization(
+        new URL("https://auth.example.com/stale"),
+      );
+      await flushMacrotask();
+
+      expect(root.getValue().getState()).toMatchObject({
+        connectionState: "connected",
+        authorizationUrl: null,
+      });
+    } finally {
+      root.unmount();
+    }
+  });
+
   it("replaces direct resource connections when the server id changes", async () => {
     const storage = createStorage();
     let updateId = (_id: string) => {};
@@ -747,6 +821,44 @@ describe("McpServerResource connection lifecycle", () => {
 describe("McpServerResource completeAuth", () => {
   beforeEach(resetMocks);
 
+  it("transfers authorization URL ownership when reusing the auth transport", async () => {
+    const storage = createStorage();
+    vi.mocked(storage.loadAuthState).mockResolvedValue({
+      serverUrl: "https://example.com/mcp",
+      state: "expected",
+    });
+    mocks.connectResults.push(() =>
+      Promise.reject(new UnauthorizedError("authorization required")),
+    );
+    const root = mount({ auth: { type: "oauth" }, storage });
+
+    try {
+      await root.getValue().connect();
+      await waitForResourceUpdate(
+        () => root.getValue().getState().connectionState === "authRequired",
+      );
+      const provider = getOAuthProvider(0);
+
+      await root
+        .getValue()
+        .completeAuth("https://example.com/callback?code=abc&state=expected");
+      await provider.redirectToAuthorization(
+        new URL("https://auth.example.com/reauthorize"),
+      );
+      await waitForResourceUpdate(
+        () => root.getValue().getState().authorizationUrl !== null,
+      );
+
+      expect(root.getValue().getState()).toMatchObject({
+        connectionState: "connected",
+        authorizationUrl: "https://auth.example.com/reauthorize",
+      });
+      expect(mocks.transports).toHaveLength(1);
+    } finally {
+      root.unmount();
+    }
+  });
+
   it("lets callback validation win over mount-time auto-connect", async () => {
     const pendingLoads: Array<(value: MCPPersistedAuthState | null) => void> =
       [];

package/src/resources/McpServerResource.ts

@@ -105,6 +105,9 @@ const useMcpServerResourceInstance = (
   const pendingTransportRef = useRef<StreamableHTTPClientTransport | null>(
     null,
   );
+  const transportGenerationRef = useRef(
+    new WeakMap<StreamableHTTPClientTransport, { current: number }>(),
+  );
   const connectionGenerationRef = useRef(0);
   const pendingAuthValidationRef = useRef<{
     count: number;
@@ -254,19 +257,29 @@ const useMcpServerResourceInstance = (
   });
 
   const buildTransport = useEffectEvent(
-    async (): Promise<StreamableHTTPClientTransport> => {
+    async (generation: number): Promise<StreamableHTTPClientTransport> => {
       if (props.auth.type === "oauth") {
+        const generationOwner = { current: generation };
         const authProvider = createOAuthProvider({
           serverId: props.id,
           serverUrl: props.url,
           config: props.auth,
           storage: props.storage,
           redirectUri: props.redirectUri,
-          onAuthorizationUrl: (url) => setAuthorizationUrl(url.toString()),
-        });
-        return new StreamableHTTPClientTransport(new URL(props.url), {
-          authProvider,
+          onAuthorizationUrl: (url) => {
+            if (isCurrentConnection(generationOwner.current)) {
+              setAuthorizationUrl(url.toString());
+            }
+          },
         });
+        const transport = new StreamableHTTPClientTransport(
+          new URL(props.url),
+          {
+            authProvider,
+          },
+        );
+        transportGenerationRef.current.set(transport, generationOwner);
+        return transport;
       }
       if (props.auth.type === "bearer") {
         const { state, unbound } = await loadAuthState();
@@ -443,7 +456,7 @@ const useMcpServerResourceInstance = (
     setTools([]);
     let transport: StreamableHTTPClientTransport | null = null;
     try {
-      transport = await buildTransport();
+      transport = await buildTransport(generation);
       if (!isCurrentConnection(generation)) {
         await closeQueuedTransports([transport]);
         return;
@@ -536,12 +549,14 @@ const useMcpServerResourceInstance = (
     try {
       let transport = transportRef.current;
       if (!transport) {
-        transport = await buildTransport();
+        transport = await buildTransport(generation);
         if (!isCurrentConnection(generation)) {
           await closeQueuedTransports([transport]);
           throw createInterruptedAuthError();
         }
       }
+      const generationOwner = transportGenerationRef.current.get(transport);
+      if (generationOwner) generationOwner.current = generation;
       transportRef.current = null;
       clientRef.current = null;
       pendingTransportRef.current = transport;