@assistant-ui/react-mcp 0.1.15 → 0.1.16

package/dist/resources/storage/McpMemoryStorage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"McpMemoryStorage.d.ts","names":[],"sources":["../../../src/resources/storage/McpMemoryStorage.ts"],"mappings":";;cAuBa,8CAAgB,SAAA"}
+{"version":3,"file":"McpMemoryStorage.d.ts","names":[],"sources":["../../../src/resources/storage/McpMemoryStorage.ts"],"mappings":";;cA6Ba,8CAAgB,SAAA"}

package/dist/resources/storage/McpMemoryStorage.js

@@ -1,22 +1,25 @@
+import { useMemo } from "@assistant-ui/tap/react-shim";
 import { resource } from "@assistant-ui/tap";
+import { generateId } from "@assistant-ui/core";
 //#region src/resources/storage/McpMemoryStorage.ts
-const useMcpMemoryStorage = () => {
+const useMcpMemoryStorage = () => useMemo(() => {
 	let servers = [];
 	const auth = /* @__PURE__ */ new Map();
 	return {
+		scopeId: `memory:${generateId()}`,
 		loadCustomServers: async () => [...servers],
 		saveCustomServers: async (records) => {
 			servers = [...records];
 		},
 		loadAuthState: async (id) => auth.get(id) ?? null,
-		saveAuthState: async (id, state) => {
-			auth.set(id, state);
+		saveAuthState: async (id_0, state) => {
+			auth.set(id_0, state);
 		},
-		clearAuthState: async (id) => {
-			auth.delete(id);
+		clearAuthState: async (id_1) => {
+			auth.delete(id_1);
 		}
 	};
-};
+}, []);
 const McpMemoryStorage = resource(useMcpMemoryStorage);
 //#endregion
 export { McpMemoryStorage };

package/dist/resources/storage/McpMemoryStorage.js.map

@@ -1 +1 @@
-{"version":3,"file":"McpMemoryStorage.js","names":["resource","MCPCustomServerRecord","MCPPersistedAuthState","MCPStorage","useMcpMemoryStorage","servers","auth","Map","loadCustomServers","saveCustomServers","records","loadAuthState","id","get","saveAuthState","state","set","clearAuthState","delete","McpMemoryStorage"],"sources":["../../../src/resources/storage/McpMemoryStorage.ts"],"sourcesContent":["import { resource } from \"@assistant-ui/tap\";\nimport type { MCPCustomServerRecord } from \"../../mcp-scope\";\nimport type { MCPPersistedAuthState } from \"../../auth/types\";\nimport type { MCPStorage } from \"./types\";\n\nconst useMcpMemoryStorage = (): MCPStorage => {\n  let servers: MCPCustomServerRecord[] = [];\n  const auth = new Map<string, MCPPersistedAuthState>();\n  return {\n    loadCustomServers: async () => [...servers],\n    saveCustomServers: async (records) => {\n      servers = [...records];\n    },\n    loadAuthState: async (id) => auth.get(id) ?? null,\n    saveAuthState: async (id, state) => {\n      auth.set(id, state);\n    },\n    clearAuthState: async (id) => {\n      auth.delete(id);\n    },\n  };\n};\n\nexport const McpMemoryStorage = resource(useMcpMemoryStorage);\n"],"mappings":";;AAKA,MAAMI,4BAAwC;CAC5C,IAAIC,UAAmC,CAAA;CACvC,MAAMC,uBAAO,IAAIC,IAAmC;CACpD,OAAO;EACLC,mBAAmB,YAAY,CAAC,GAAGH,OAAO;EAC1CI,mBAAmB,OAAOC,YAAY;GACpCL,UAAU,CAAC,GAAGK,OAAO;EACvB;EACAC,eAAe,OAAOC,OAAON,KAAKO,IAAID,EAAE,KAAK;EAC7CE,eAAe,OAAOF,IAAIG,UAAU;GAClCT,KAAKU,IAAIJ,IAAIG,KAAK;EACpB;EACAE,gBAAgB,OAAOL,OAAO;GAC5BN,KAAKY,OAAON,EAAE;EAChB;CACF;AACF;AAEA,MAAaO,mBAAmBnB,SAASI,mBAAmB"}
+{"version":3,"file":"McpMemoryStorage.js","names":["resource","useMemo","generateId","MCPCustomServerRecord","MCPPersistedAuthState","MCPStorage","useMcpMemoryStorage","servers","auth","Map","scopeId","loadCustomServers","saveCustomServers","records","loadAuthState","id","get","saveAuthState","state","set","clearAuthState","delete","McpMemoryStorage"],"sources":["../../../src/resources/storage/McpMemoryStorage.ts"],"sourcesContent":["import { resource } from \"@assistant-ui/tap\";\nimport { useMemo } from \"react\";\nimport { generateId } from \"@assistant-ui/core\";\nimport type { MCPCustomServerRecord } from \"../../mcp-scope\";\nimport type { MCPPersistedAuthState } from \"../../auth/types\";\nimport type { MCPStorage } from \"./types\";\n\nconst useMcpMemoryStorage = (): MCPStorage =>\n  useMemo(() => {\n    let servers: MCPCustomServerRecord[] = [];\n    const auth = new Map<string, MCPPersistedAuthState>();\n    return {\n      // Each memory store is its own private data: a distinct instance is a\n      // distinct scope, so replacing one keys a reconnect.\n      scopeId: `memory:${generateId()}`,\n      loadCustomServers: async () => [...servers],\n      saveCustomServers: async (records) => {\n        servers = [...records];\n      },\n      loadAuthState: async (id) => auth.get(id) ?? null,\n      saveAuthState: async (id, state) => {\n        auth.set(id, state);\n      },\n      clearAuthState: async (id) => {\n        auth.delete(id);\n      },\n    };\n  }, []);\n\nexport const McpMemoryStorage = resource(useMcpMemoryStorage);\n"],"mappings":";;;;AAOA,MAAMM,4BACJL,cAAc;CACZ,IAAIM,UAAmC,CAAA;CACvC,MAAMC,uBAAO,IAAIC,IAAmC;CACpD,OAAO;EAGLC,SAAS,UAAUR,WAAW;EAC9BS,mBAAmB,YAAY,CAAC,GAAGJ,OAAO;EAC1CK,mBAAmB,OAAOC,YAAY;GACpCN,UAAU,CAAC,GAAGM,OAAO;EACvB;EACAC,eAAe,OAAOC,OAAOP,KAAKQ,IAAID,EAAE,KAAK;EAC7CE,eAAe,OAAOF,MAAIG,UAAU;GAClCV,KAAKW,IAAIJ,MAAIG,KAAK;EACpB;EACAE,gBAAgB,OAAOL,SAAO;GAC5BP,KAAKa,OAAON,IAAE;EAChB;CACF;AACF,GAAG,CAAA,CAAE;AAEP,MAAaO,mBAAmBtB,SAASM,mBAAmB"}

package/dist/resources/storage/types.d.ts

@@ -3,6 +3,18 @@ import { MCPPersistedAuthState } from "../../auth/types.js";
 import { ResourceElement } from "@assistant-ui/tap";
 //#region src/resources/storage/types.d.ts
 type MCPStorage = {
+  /**
+   * Stable identity of the backing store. Two storages with the same scopeId
+   * must read and write the same persisted data. When present, server
+   * connections and the OAuth write fence key on it, so swapping to a
+   * differently-scoped storage reconnects instead of leaving a live OAuth flow
+   * on the replaced store, and clearing through a same-scoped replacement still
+   * waits for writes queued against the storage it replaced. When absent, the
+   * fence falls back to object identity while connections never re-key at all,
+   * so a storage rebuilt on every render has to declare a scopeId; without one
+   * a clear runs unfenced against the writes queued by the object it replaced.
+   */
+  scopeId?: string;
   loadCustomServers: () => Promise<MCPCustomServerRecord[]>;
   saveCustomServers: (records: MCPCustomServerRecord[]) => Promise<void>;
   loadAuthState: (serverId: string) => Promise<MCPPersistedAuthState | null>;

package/dist/resources/storage/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/resources/storage/types.ts"],"mappings":";;;;KAIY;EACV,yBAAyB,QAAQ;EACjC,oBAAoB,SAAS,4BAA4B;EACzD,gBAAgB,qBAAqB,QAAQ;EAC7C,gBACE,kBACA,OAAO,0BACJ;EACL,iBAAiB,qBAAqB;;KAG5B,oBAAoB,gBAAgB"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/resources/storage/types.ts"],"mappings":";;;;KAIY;;;;;;;;;;;;EAYV;EACA,yBAAyB,QAAQ;EACjC,oBAAoB,SAAS,4BAA4B;EACzD,gBAAgB,qBAAqB,QAAQ;EAC7C,gBACE,kBACA,OAAO,0BACJ;EACL,iBAAiB,qBAAqB;;KAG5B,oBAAoB,gBAAgB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@assistant-ui/react-mcp",
-  "version": "0.1.15",
+  "version": "0.1.16",
   "description": "MCP server configuration and connection primitives for @assistant-ui",
   "keywords": [
     "mcp",
@@ -27,13 +27,13 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@assistant-ui/core": "0.3.16",
-    "@assistant-ui/store": "0.3.11",
-    "@assistant-ui/tap": "0.9.15",
+    "@assistant-ui/core": "^0.3.17",
+    "@assistant-ui/store": "^0.3.12",
+    "@assistant-ui/tap": "^0.9.16",
     "@modelcontextprotocol/client": "^2.0.0",
     "@modelcontextprotocol/core": "^2.0.0",
     "@radix-ui/react-primitive": "^2.1.10",
-    "assistant-stream": "0.3.40"
+    "assistant-stream": "^0.3.41"
   },
   "peerDependencies": {
     "@types/react": "*",
@@ -45,9 +45,9 @@
     }
   },
   "devDependencies": {
-    "@assistant-ui/x-buildutils": "0.0.24",
+    "@assistant-ui/x-buildutils": "0.0.25",
     "@testing-library/dom": "^10.4.1",
-    "@testing-library/react": "^16.3.2",
+    "@testing-library/react": "^16.3.3",
     "@types/react": "^19.2.18",
     "jsdom": "^30.0.1",
     "react": "^19.2.8",

package/src/auth/createOAuthProvider.test.ts

@@ -1,8 +1,11 @@
 import type { OAuthDiscoveryState } from "@modelcontextprotocol/client";
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, vi } from "vitest";
 import type { MCPStorage } from "../resources/storage/types";
 import type { MCPPersistedAuthState } from "./types";
-import { createOAuthProvider } from "./createOAuthProvider";
+import {
+  clearOAuthProviderAuthState,
+  createOAuthProvider,
+} from "./createOAuthProvider";
 
 const discoveryState: OAuthDiscoveryState = {
   authorizationServerUrl: "https://auth.example.com",
@@ -36,6 +39,23 @@ const createStorage = (initial: MCPPersistedAuthState | null = null) => {
   return { storage, getState: () => state };
 };
 
+const createSharedStorages = (scopeId: string) => {
+  let state: MCPPersistedAuthState | null = null;
+  const create = (): MCPStorage => ({
+    scopeId,
+    loadCustomServers: async () => [],
+    saveCustomServers: async () => {},
+    loadAuthState: async () => state,
+    saveAuthState: async (_serverId, next) => {
+      state = next;
+    },
+    clearAuthState: async () => {
+      state = null;
+    },
+  });
+  return { create, getState: () => state };
+};
+
 const createProvider = (storage: MCPStorage) =>
   createOAuthProvider({
     serverId: "docs",
@@ -45,6 +65,55 @@ const createProvider = (storage: MCPStorage) =>
     onAuthorizationUrl: () => {},
   });
 
+describe("createOAuthProvider callback state", () => {
+  it("persists the generated state with the PKCE verifier", async () => {
+    const { storage, getState } = createStorage();
+    const provider = createProvider(storage);
+
+    const state = await provider.state?.();
+    await provider.saveCodeVerifier("pkce-verifier");
+
+    expect(state).toMatch(/^aui-mcp:ZG9jcw\./);
+    expect(getState()).toEqual({
+      codeVerifier: "pkce-verifier",
+      state,
+    });
+  });
+
+  it("consumes callback state when tokens are saved", async () => {
+    const { storage, getState } = createStorage({
+      codeVerifier: "pkce-verifier",
+      state: "aui-mcp:ZG9jcw.nonce",
+    });
+    const provider = createProvider(storage);
+
+    await provider.saveTokens({
+      access_token: "access-token",
+      token_type: "bearer",
+    });
+
+    expect(getState()).toEqual({
+      tokens: { access_token: "access-token", token_type: "bearer" },
+      codeVerifier: "pkce-verifier",
+    });
+  });
+
+  it.each(["verifier", "all"] as const)(
+    "clears callback state through the %s invalidation scope",
+    async (scope) => {
+      const { storage, getState } = createStorage({
+        codeVerifier: "pkce-verifier",
+        state: "aui-mcp:ZG9jcw.nonce",
+      });
+      const provider = createProvider(storage);
+
+      await provider.invalidateCredentials?.(scope);
+
+      expect(getState()).toEqual({});
+    },
+  );
+});
+
 describe("createOAuthProvider discovery state", () => {
   it("persists discovery state alongside the PKCE verifier", async () => {
     const { storage, getState } = createStorage({
@@ -84,3 +153,339 @@ describe("createOAuthProvider discovery state", () => {
     },
   );
 });
+
+describe("createOAuthProvider persistence", () => {
+  it("loads persisted auth state once for concurrent reads", async () => {
+    let resolveLoad!: (value: MCPPersistedAuthState | null) => void;
+    const loadAuthState = vi.fn(
+      () =>
+        new Promise<MCPPersistedAuthState | null>((resolve) => {
+          resolveLoad = resolve;
+        }),
+    );
+    const { storage } = createStorage();
+    storage.loadAuthState = loadAuthState;
+    const provider = createProvider(storage);
+
+    const tokens = provider.tokens();
+    const clientInformation = provider.clientInformation();
+
+    expect(loadAuthState).toHaveBeenCalledTimes(1);
+    resolveLoad(null);
+    await Promise.all([tokens, clientInformation]);
+  });
+
+  it("retries loading persisted auth state after a failure", async () => {
+    const failure = new Error("storage unavailable");
+    const loadAuthState = vi
+      .fn<() => Promise<MCPPersistedAuthState | null>>()
+      .mockRejectedValueOnce(failure)
+      .mockResolvedValueOnce({ codeVerifier: "pkce-verifier" });
+    const { storage } = createStorage();
+    storage.loadAuthState = loadAuthState;
+    const provider = createProvider(storage);
+
+    const tokens = provider.tokens();
+    const clientInformation = provider.clientInformation();
+
+    await expect(tokens).rejects.toBe(failure);
+    await expect(clientInformation).rejects.toBe(failure);
+    expect(loadAuthState).toHaveBeenCalledTimes(1);
+
+    await expect(provider.codeVerifier()).resolves.toBe("pkce-verifier");
+    expect(loadAuthState).toHaveBeenCalledTimes(2);
+  });
+
+  it("serializes writes so newer auth state is not overwritten", async () => {
+    const { storage } = createStorage();
+    const pendingWrites: Array<() => void> = [];
+    let persisted: MCPPersistedAuthState | null = null;
+    storage.saveAuthState = async (_serverId, next) => {
+      await new Promise<void>((resolve) => pendingWrites.push(resolve));
+      persisted = next;
+    };
+    const provider = createProvider(storage);
+    await provider.tokens();
+
+    const tokenSave = provider.saveTokens({
+      access_token: "access-token",
+      token_type: "bearer",
+    });
+    await vi.waitFor(() => expect(pendingWrites).toHaveLength(1));
+
+    const verifierSave = provider.saveCodeVerifier("pkce-verifier");
+    for (let i = 0; i < 10; i++) await Promise.resolve();
+    expect(pendingWrites).toHaveLength(1);
+
+    pendingWrites.shift()!();
+    await vi.waitFor(() => expect(pendingWrites).toHaveLength(1));
+    pendingWrites.shift()!();
+    await Promise.all([tokenSave, verifierSave]);
+
+    expect(persisted).toEqual({
+      tokens: { access_token: "access-token", token_type: "bearer" },
+      codeVerifier: "pkce-verifier",
+    });
+  });
+
+  it("continues persisting after a failed auth state write", async () => {
+    const { storage } = createStorage();
+    const failure = new Error("storage unavailable");
+    let saveCount = 0;
+    let persisted: MCPPersistedAuthState | null = null;
+    let rejectFirstSave!: (reason: unknown) => void;
+    storage.saveAuthState = async (_serverId, next) => {
+      saveCount += 1;
+      if (saveCount === 1) {
+        await new Promise<void>((_resolve, reject) => {
+          rejectFirstSave = reject;
+        });
+      }
+      persisted = next;
+    };
+    const provider = createProvider(storage);
+    await provider.tokens();
+
+    const tokenSave = provider.saveTokens({
+      access_token: "access-token",
+      token_type: "bearer",
+    });
+    const verifierSave = provider.saveCodeVerifier("pkce-verifier");
+
+    await vi.waitFor(() => expect(saveCount).toBe(1));
+    for (let i = 0; i < 10; i++) await Promise.resolve();
+    expect(saveCount).toBe(1);
+
+    const tokenSaveResult = expect(tokenSave).rejects.toBe(failure);
+    rejectFirstSave(failure);
+    await tokenSaveResult;
+    await expect(verifierSave).resolves.toBeUndefined();
+    expect(saveCount).toBe(2);
+    expect(persisted).toEqual({
+      tokens: { access_token: "access-token", token_type: "bearer" },
+      codeVerifier: "pkce-verifier",
+    });
+  });
+});
+
+describe("createOAuthProvider persistence across provider instances", () => {
+  it("shares one auth state load across provider instances", async () => {
+    let resolveLoad!: (value: MCPPersistedAuthState | null) => void;
+    const loadAuthState = vi.fn(
+      () =>
+        new Promise<MCPPersistedAuthState | null>((resolve) => {
+          resolveLoad = resolve;
+        }),
+    );
+    const { storage } = createStorage();
+    storage.loadAuthState = loadAuthState;
+    const provider = createProvider(storage);
+    const replacementProvider = createProvider(storage);
+
+    const tokens = provider.tokens();
+    const clientInformation = replacementProvider.clientInformation();
+
+    expect(loadAuthState).toHaveBeenCalledTimes(1);
+    resolveLoad(null);
+    await Promise.all([tokens, clientInformation]);
+  });
+
+  it("serializes writes across provider instances", async () => {
+    const { storage } = createStorage();
+    const pendingWrites: Array<() => void> = [];
+    let persisted: MCPPersistedAuthState | null = null;
+    storage.saveAuthState = async (_serverId, next) => {
+      await new Promise<void>((resolve) => pendingWrites.push(resolve));
+      persisted = next;
+    };
+    const provider = createProvider(storage);
+    const replacementProvider = createProvider(storage);
+    await Promise.all([provider.tokens(), replacementProvider.tokens()]);
+
+    const tokenSave = provider.saveTokens({
+      access_token: "access-token",
+      token_type: "bearer",
+    });
+    await vi.waitFor(() => expect(pendingWrites).toHaveLength(1));
+
+    const verifierSave = replacementProvider.saveCodeVerifier("pkce-verifier");
+    for (let i = 0; i < 10; i++) await Promise.resolve();
+    expect(pendingWrites).toHaveLength(1);
+
+    pendingWrites.shift()!();
+    await vi.waitFor(() => expect(pendingWrites).toHaveLength(1));
+    pendingWrites.shift()!();
+    await Promise.all([tokenSave, verifierSave]);
+
+    expect(persisted).toEqual({
+      tokens: { access_token: "access-token", token_type: "bearer" },
+      codeVerifier: "pkce-verifier",
+    });
+  });
+
+  it("clears after a pending write and fences the discarded provider", async () => {
+    const { storage, getState } = createStorage();
+    const pendingWrites: Array<() => void> = [];
+    const saveAuthState = storage.saveAuthState;
+    storage.saveAuthState = async (serverId, next) => {
+      await new Promise<void>((resolve) => pendingWrites.push(resolve));
+      await saveAuthState(serverId, next);
+    };
+    const clearAuthState = vi.spyOn(storage, "clearAuthState");
+    const provider = createProvider(storage);
+    await provider.tokens();
+
+    const save = provider.saveTokens({
+      access_token: "access-token",
+      token_type: "bearer",
+    });
+    await vi.waitFor(() => expect(pendingWrites).toHaveLength(1));
+
+    const clear = clearOAuthProviderAuthState(storage, "docs");
+    for (let i = 0; i < 10; i++) await Promise.resolve();
+    expect(clearAuthState).not.toHaveBeenCalled();
+
+    pendingWrites.shift()!();
+    await expect(save).resolves.toBeUndefined();
+    await clear;
+    expect(clearAuthState).toHaveBeenCalledTimes(1);
+    expect(getState()).toBeNull();
+
+    storage.saveAuthState = saveAuthState;
+    await provider.saveCodeVerifier("late-verifier");
+    expect(getState()).toBeNull();
+  });
+
+  it("fences a queued write when clearing through a same-scope storage", async () => {
+    const { create, getState } = createSharedStorages("same-scope-clear");
+    const storage = create();
+    const replacement = create();
+    const pendingWrites: Array<() => void> = [];
+    const saveAuthState = storage.saveAuthState;
+    storage.saveAuthState = async (serverId, next) => {
+      await new Promise<void>((resolve) => pendingWrites.push(resolve));
+      await saveAuthState(serverId, next);
+    };
+    const clearAuthState = vi.spyOn(replacement, "clearAuthState");
+    const provider = createProvider(storage);
+    await provider.tokens();
+
+    const save = provider.saveTokens({
+      access_token: "access-token",
+      token_type: "bearer",
+    });
+    await vi.waitFor(() => expect(pendingWrites).toHaveLength(1));
+
+    const clear = clearOAuthProviderAuthState(replacement, "docs");
+    for (let i = 0; i < 10; i++) await Promise.resolve();
+    expect(clearAuthState).not.toHaveBeenCalled();
+
+    pendingWrites.shift()!();
+    await expect(save).resolves.toBeUndefined();
+    await clear;
+    expect(clearAuthState).toHaveBeenCalledTimes(1);
+    expect(getState()).toBeNull();
+
+    storage.saveAuthState = saveAuthState;
+    await provider.saveCodeVerifier("late-verifier");
+    expect(getState()).toBeNull();
+  });
+
+  it("keeps differently-scoped storages on separate persistence", async () => {
+    const first = createSharedStorages("scope-a");
+    const second = createSharedStorages("scope-b");
+    const firstProvider = createProvider(first.create());
+    const secondProvider = createProvider(second.create());
+
+    await firstProvider.saveTokens({
+      access_token: "first-token",
+      token_type: "bearer",
+    });
+    await secondProvider.saveTokens({
+      access_token: "second-token",
+      token_type: "bearer",
+    });
+    await clearOAuthProviderAuthState(second.create(), "docs");
+    await firstProvider.saveCodeVerifier("first-verifier");
+
+    expect(first.getState()).toEqual({
+      tokens: { access_token: "first-token", token_type: "bearer" },
+      codeVerifier: "first-verifier",
+    });
+    expect(second.getState()).toBeNull();
+  });
+
+  it("re-derives static client information for a replacement provider", async () => {
+    const { storage } = createStorage();
+    const provider = createOAuthProvider({
+      serverId: "docs",
+      config: { type: "oauth", clientId: "client-a" },
+      storage,
+      redirectUri: "http://localhost/callback",
+      onAuthorizationUrl: () => {},
+    });
+    await expect(provider.clientInformation()).resolves.toEqual({
+      client_id: "client-a",
+      redirect_uris: ["http://localhost/callback"],
+    });
+
+    const replacementProvider = createOAuthProvider({
+      serverId: "docs",
+      config: { type: "oauth", clientId: "client-b", clientSecret: "secret-b" },
+      storage,
+      redirectUri: "http://localhost/callback-2",
+      onAuthorizationUrl: () => {},
+    });
+    await expect(replacementProvider.clientInformation()).resolves.toEqual({
+      client_id: "client-b",
+      client_secret: "secret-b",
+      redirect_uris: ["http://localhost/callback-2"],
+    });
+  });
+
+  it("does not leak static client information to a dynamic provider", async () => {
+    const { storage } = createStorage();
+    const staticProvider = createOAuthProvider({
+      serverId: "docs",
+      config: { type: "oauth", clientId: "client-a" },
+      storage,
+      redirectUri: "http://localhost/callback",
+      onAuthorizationUrl: () => {},
+    });
+    await expect(staticProvider.clientInformation()).resolves.toEqual({
+      client_id: "client-a",
+      redirect_uris: ["http://localhost/callback"],
+    });
+
+    const dynamicProvider = createProvider(storage);
+    await expect(dynamicProvider.clientInformation()).resolves.toBeUndefined();
+  });
+
+  it("keeps a provider built while the clear is in flight usable", async () => {
+    const { storage, getState } = createStorage();
+    let releaseClear: (() => void) | undefined;
+    const clearAuthState = storage.clearAuthState;
+    storage.clearAuthState = async (serverId) => {
+      await new Promise<void>((resolve) => {
+        releaseClear = resolve;
+      });
+      await clearAuthState(serverId);
+    };
+    const provider = createProvider(storage);
+    await provider.saveTokens({
+      access_token: "access-token",
+      token_type: "bearer",
+    });
+
+    const clear = clearOAuthProviderAuthState(storage, "docs");
+    await vi.waitFor(() => expect(releaseClear).toBeTypeOf("function"));
+
+    const replacementProvider = createProvider(storage);
+    releaseClear!();
+    await clear;
+    expect(getState()).toBeNull();
+
+    await replacementProvider.saveCodeVerifier("new-verifier");
+    expect(getState()).toEqual({ codeVerifier: "new-verifier" });
+  });
+});