@assistant-ui/react-mcp 0.1.14 → 0.1.16

package/src/resources/storage/types.ts

@@ -3,6 +3,18 @@ import type { MCPCustomServerRecord } from "../../mcp-scope";
 import type { MCPPersistedAuthState } from "../../auth/types";
 
 export 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/src/utils/createMcpId.test.ts

@@ -0,0 +1,25 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { createMcpId } from "./createMcpId";
+import { assertValidServerId } from "./serverId";
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
+
+describe("createMcpId", () => {
+  it("uses the platform UUID when one is available", () => {
+    vi.stubGlobal("crypto", {
+      randomUUID: () => "11111111-2222-3333-4444-555555555555",
+    });
+    expect(createMcpId()).toBe("11111111-2222-3333-4444-555555555555");
+  });
+
+  it("falls back to a prefixed generated id without randomUUID", () => {
+    vi.stubGlobal("crypto", {});
+    const first = createMcpId();
+    const second = createMcpId();
+    expect(first).toMatch(/^mcp-[0-9A-Za-z]+$/);
+    expect(second).not.toBe(first);
+    expect(() => assertValidServerId(first)).not.toThrow();
+  });
+});

package/src/utils/createMcpId.ts

@@ -0,0 +1,10 @@
+import { generateId } from "@assistant-ui/core";
+
+/**
+ * Both forms are alphanumeric or hyphenated, so neither can contain the
+ * separators `assertValidServerId` reserves.
+ */
+export const createMcpId = (): string =>
+  typeof crypto !== "undefined" && "randomUUID" in crypto
+    ? crypto.randomUUID()
+    : `mcp-${generateId()}`;

package/src/utils/invokeMcpCallback.ts

@@ -1,27 +1,9 @@
-const reportCallbackError = (name: string, error: unknown) => {
-  console.error(`[react-mcp] ${name} callback threw an error`, error);
-};
+import { invokeUserCallback } from "@assistant-ui/core/internal";
 
 export const invokeMcpCallback = <TArgs extends unknown[]>(
   name: string,
   callback: ((...args: TArgs) => void) | undefined,
   ...args: TArgs
-) => {
-  if (!callback) return;
-
-  try {
-    const result = callback(...args) as unknown;
-    if (
-      result !== null &&
-      (typeof result === "object" || typeof result === "function") &&
-      "then" in result &&
-      typeof result.then === "function"
-    ) {
-      void Promise.resolve(result).catch((error) => {
-        reportCallbackError(name, error);
-      });
-    }
-  } catch (error) {
-    reportCallbackError(name, error);
-  }
+): void => {
+  void invokeUserCallback("react-mcp", name, callback, ...args);
 };