@assistant-ui/react-mcp 0.1.20 → 0.1.22

package/src/resources/McpServerResource.ts

@@ -7,8 +7,6 @@ import {
   StreamableHTTPClientTransport,
   UnauthorizedError,
   type ClientOptions,
-  type ElicitRequest,
-  type ElicitResult,
   type StreamableHTTPClientTransportOptions,
 } from "@modelcontextprotocol/client";
 import {
@@ -21,20 +19,18 @@ import { assertValidServerId } from "../utils/serverId";
 import {
   hasPersistedCredentials,
   isAuthStateForServerUrl,
+  isSecureNetworkUrl,
 } from "../utils/serverUrl";
-import { validateElicitationContent } from "./validateElicitationContent";
 import type { MCPStorage } from "./storage/types";
 import type {
   MCPAuthConfig,
   MCPConnectionState,
-  MCPElicitation,
-  MCPElicitationResponse,
   MCPServerKind,
   MCPServerState,
   MCPToolInfo,
 } from "../mcp-scope";
-import { createMcpId } from "../utils/createMcpId";
 import { beginMcpServerRemovalFence } from "./McpServerRemovalFence";
+import { useMcpElicitationLifecycle } from "./McpElicitationLifecycle";
 
 export type McpServerResourceProps = {
   id: string;
@@ -96,10 +92,12 @@ const useMcpServerResourceInstance = (
   const [tools, setTools] = useState<MCPToolInfo[]>([]);
   const [lastError, setLastError] = useState<{ message: string } | null>(null);
   const [authorizationUrl, setAuthorizationUrl] = useState<string | null>(null);
-  const [pendingElicitations, setPendingElicitations] = useState<
-    MCPElicitation[]
-  >([]);
-
+  const {
+    pendingElicitations,
+    cancelPendingElicitations,
+    requestElicitation,
+    answerElicitation,
+  } = useMcpElicitationLifecycle();
   const clientRef = useRef<Client | null>(null);
   const transportRef = useRef<StreamableHTTPClientTransport | null>(null);
   const pendingTransportRef = useRef<StreamableHTTPClientTransport | null>(
@@ -114,17 +112,6 @@ const useMcpServerResourceInstance = (
     promise: Promise<void>;
     resolve: () => void;
   } | null>(null);
-  const elicitationResolversRef = useRef(
-    new Map<
-      string,
-      {
-        resolve: (result: ElicitResult) => void;
-        signal: AbortSignal;
-        onAbort: () => void;
-        requestedSchema: unknown;
-      }
-    >(),
-  );
   const pendingDisposalRef = useRef<{ cancelled: boolean } | null>(null);
   const mountedRef = useRef(true);
 
@@ -154,37 +141,6 @@ const useMcpServerResourceInstance = (
     await closeQueuedTransports(transport ? [transport] : []);
   };
 
-  const resolvePendingElicitation = (id: string, result: ElicitResult) => {
-    const entry = elicitationResolversRef.current.get(id);
-    if (!entry) return false;
-    elicitationResolversRef.current.delete(id);
-    entry.signal.removeEventListener("abort", entry.onAbort);
-    setPendingElicitations((current) =>
-      current.filter((elicitation) => elicitation.id !== id),
-    );
-    entry.resolve(result);
-    return true;
-  };
-
-  const setPendingElicitationError = (
-    id: string,
-    error: NonNullable<MCPElicitation["error"]>,
-  ) => {
-    if (!elicitationResolversRef.current.has(id)) return false;
-    setPendingElicitations((current) =>
-      current.map((elicitation) =>
-        elicitation.id === id ? { ...elicitation, error } : elicitation,
-      ),
-    );
-    return true;
-  };
-
-  const cancelPendingElicitations = () => {
-    for (const [id] of elicitationResolversRef.current) {
-      resolvePendingElicitation(id, { action: "cancel" });
-    }
-  };
-
   const detachTransports = () => {
     cancelPendingElicitations();
     const pendingTransport = pendingTransportRef.current;
@@ -258,6 +214,11 @@ const useMcpServerResourceInstance = (
 
   const buildTransport = useEffectEvent(
     async (generation: number): Promise<StreamableHTTPClientTransport> => {
+      if (props.auth.type !== "none" && !isSecureNetworkUrl(props.url)) {
+        throw new Error(
+          `Authenticated MCP server "${props.id}" must use HTTPS or loopback HTTP.`,
+        );
+      }
       if (props.auth.type === "oauth") {
         const generationOwner = { current: generation };
         const authProvider = createOAuthProvider({
@@ -267,9 +228,18 @@ const useMcpServerResourceInstance = (
           storage: props.storage,
           redirectUri: props.redirectUri,
           onAuthorizationUrl: (url) => {
-            if (isCurrentConnection(generationOwner.current)) {
-              setAuthorizationUrl(url.toString());
+            if (!isCurrentConnection(generationOwner.current)) return;
+            if (url.protocol !== "http:" && url.protocol !== "https:") {
+              throw new Error(
+                `Unsupported MCP OAuth authorization URL protocol: ${url.protocol}`,
+              );
             }
+            if (!isSecureNetworkUrl(url.toString())) {
+              throw new Error(
+                "MCP OAuth authorization URL must use HTTPS or loopback HTTP.",
+              );
+            }
+            setAuthorizationUrl(url.toString());
           },
         });
         const transport = new StreamableHTTPClientTransport(
@@ -375,49 +345,10 @@ const useMcpServerResourceInstance = (
         clientOptions,
       );
       if (props.elicitation !== false) {
-        client.setRequestHandler(
-          "elicitation/create",
-          (request: ElicitRequest, context): Promise<ElicitResult> => {
-            if (!isCurrentConnection(generation)) {
-              return Promise.resolve({ action: "cancel" });
-            }
-            if (!("requestedSchema" in request.params)) {
-              return Promise.resolve({ action: "cancel" });
-            }
-            const { message, requestedSchema } = request.params;
-
-            const id = createMcpId();
-            const promise = new Promise<ElicitResult>((resolve) => {
-              const onAbort = () => {
-                resolvePendingElicitation(id, { action: "cancel" });
-              };
-              elicitationResolversRef.current.set(id, {
-                resolve,
-                signal: context.mcpReq.signal,
-                onAbort,
-                requestedSchema,
-              });
-            });
-            setPendingElicitations((current) => [
-              ...current,
-              {
-                id,
-                message,
-                requestedSchema,
-              },
-            ]);
-            const entry = elicitationResolversRef.current.get(id);
-            if (entry) {
-              if (context.mcpReq.signal.aborted) {
-                entry.onAbort();
-              } else {
-                context.mcpReq.signal.addEventListener("abort", entry.onAbort, {
-                  once: true,
-                });
-              }
-            }
-            return promise;
-          },
+        client.setRequestHandler("elicitation/create", (request, context) =>
+          requestElicitation(request, context.mcpReq.signal, () =>
+            isCurrentConnection(generation),
+          ),
         );
       }
       const startedAt = Date.now();
@@ -721,58 +652,7 @@ const useMcpServerResourceInstance = (
       return await client.readResource({ uri });
     },
     completeAuth: doCompleteAuth,
-    answerElicitation: (
-      id: string,
-      response: MCPElicitationResponse,
-    ): readonly { property: string; message: string }[] | undefined => {
-      if (response.action === "accept") {
-        const entry = elicitationResolversRef.current.get(id);
-        if (!entry) return undefined;
-
-        if (
-          typeof response.content !== "object" ||
-          response.content === null ||
-          Array.isArray(response.content)
-        ) {
-          const errors = [
-            {
-              property: "content",
-              message: "Response content must be an object.",
-            },
-          ];
-          setPendingElicitationError(id, {
-            message: "Invalid elicitation content: content.",
-            properties: ["content"],
-          });
-          return errors;
-        }
-
-        const errors = validateElicitationContent(
-          entry.requestedSchema,
-          response.content,
-        );
-        if (errors.length > 0) {
-          const properties = [
-            ...new Set(errors.map((error) => error.property)),
-          ];
-          setPendingElicitationError(id, {
-            message: `Invalid elicitation content: ${properties.join(", ")}.`,
-            properties,
-          });
-          return errors;
-        }
-
-        const result: ElicitResult = {
-          action: "accept",
-          content: response.content as ElicitResult["content"],
-        };
-        resolvePendingElicitation(id, result);
-        return undefined;
-      }
-
-      resolvePendingElicitation(id, { action: response.action });
-      return undefined;
-    },
+    answerElicitation,
   };
 };
 

package/src/resources/storage/McpLocalStorage.ts

@@ -1,16 +1,15 @@
 import { resource } from "@assistant-ui/tap";
 import { useMemo } from "react";
-import {
-  OAuthMetadataSchema,
-  OAuthClientInformationFullSchema,
-  OAuthProtectedResourceMetadataSchema,
-  OAuthTokensSchema,
-} from "@modelcontextprotocol/core";
-import { normalizeMcpServerUrl } from "../../utils/serverUrl";
-import type { MCPAuthConfig, MCPCustomServerRecord } from "../../mcp-scope";
-import type { MCPPersistedAuthState } from "../../auth/types";
-import { assertValidServerId } from "../../utils/serverId";
 import type { MCPStorage } from "./types";
+import {
+  normalizeCustomServerRecords,
+  normalizePersistedAuthState,
+} from "./McpStoredDataNormalization";
+
+export {
+  normalizeCustomServerRecords,
+  normalizePersistedAuthState,
+} from "./McpStoredDataNormalization";
 
 export type McpLocalStorageOptions = {
   /** Namespace prefix for keys. Default "aui-mcp". */
@@ -38,205 +37,6 @@ function resolveStorage(opts: McpLocalStorageOptions): Storage | null {
   return null;
 }
 
-const isRecord = (value: unknown): value is Record<string, unknown> =>
-  typeof value === "object" && value !== null && !Array.isArray(value);
-
-const isOptionalString = (value: unknown): value is string | undefined =>
-  value === undefined || typeof value === "string";
-
-const isNonEmptyString = (value: unknown): value is string =>
-  typeof value === "string" && value.trim().length > 0;
-
-const isOptionalNonEmptyString = (
-  value: unknown,
-): value is string | undefined =>
-  value === undefined || isNonEmptyString(value);
-
-const isOptionalStringArray = (value: unknown): value is string[] | undefined =>
-  value === undefined ||
-  (Array.isArray(value) && value.every((item) => typeof item === "string"));
-
-const isOptionalConnectionTimeout = (
-  value: unknown,
-): value is number | undefined =>
-  value === undefined ||
-  (typeof value === "number" && Number.isFinite(value) && value >= 0);
-
-const isValidServerId = (id: string): boolean => {
-  try {
-    assertValidServerId(id);
-    return true;
-  } catch {
-    return false;
-  }
-};
-
-const isMCPAuthConfig = (auth: unknown): auth is MCPAuthConfig => {
-  if (!isRecord(auth)) return false;
-
-  switch (auth.type) {
-    case "none":
-      return true;
-    case "bearer":
-      return isOptionalNonEmptyString(auth.token);
-    case "oauth":
-      return (
-        isOptionalStringArray(auth.scopes) &&
-        isOptionalString(auth.authorizationEndpoint) &&
-        isOptionalString(auth.tokenEndpoint) &&
-        isOptionalString(auth.registrationEndpoint) &&
-        isOptionalString(auth.clientId) &&
-        isOptionalString(auth.clientSecret)
-      );
-    default:
-      return false;
-  }
-};
-
-const isCustomServerRecord = (
-  value: unknown,
-): value is MCPCustomServerRecord => {
-  if (!isRecord(value)) return false;
-  if (typeof value.id !== "string" || !isValidServerId(value.id)) {
-    return false;
-  }
-  return (
-    isNonEmptyString(value.name) &&
-    isNonEmptyString(value.url) &&
-    Number.isFinite(value.createdAt) &&
-    isMCPAuthConfig(value.auth) &&
-    isOptionalConnectionTimeout(value.connectionTimeout)
-  );
-};
-
-const normalizeCustomServerRecord = (
-  value: unknown,
-): MCPCustomServerRecord | null => {
-  if (isCustomServerRecord(value)) return value;
-  if (!isRecord(value)) return null;
-
-  const record = { ...value };
-  delete record.connectionTimeout;
-  return isCustomServerRecord(record) ? record : null;
-};
-
-export const normalizeCustomServerRecords = (
-  value: unknown,
-): MCPCustomServerRecord[] => {
-  if (!Array.isArray(value)) return [];
-  return value.flatMap((item) => {
-    const record = normalizeCustomServerRecord(item);
-    return record === null ? [] : [record];
-  });
-};
-
-const normalizeOAuthTokens = (
-  value: unknown,
-): MCPPersistedAuthState["tokens"] | undefined => {
-  const result = OAuthTokensSchema.safeParse(value);
-  return result.success ? result.data : undefined;
-};
-
-const normalizeClientInformation = (
-  value: unknown,
-): MCPPersistedAuthState["clientInformation"] | undefined => {
-  const result = OAuthClientInformationFullSchema.safeParse(value);
-  return result.success ? result.data : undefined;
-};
-
-const isSecureNetworkUrl = (value: unknown): value is string => {
-  if (!isNonEmptyString(value)) return false;
-  try {
-    const url = new URL(value);
-    const isIpv4Loopback = /^127(?:\.\d{1,3}){3}$/.test(url.hostname);
-    return (
-      url.protocol === "https:" ||
-      (url.protocol === "http:" &&
-        (url.hostname === "localhost" ||
-          url.hostname.endsWith(".localhost") ||
-          isIpv4Loopback ||
-          url.hostname === "[::1]"))
-    );
-  } catch {
-    return false;
-  }
-};
-
-const isMcpServerUrl = (value: unknown): value is string => {
-  if (typeof value !== "string") return false;
-  try {
-    const url = new URL(value);
-    return url.protocol === "https:" || url.protocol === "http:";
-  } catch {
-    return false;
-  }
-};
-
-const normalizeDiscoveryState = (
-  value: unknown,
-): MCPPersistedAuthState["discoveryState"] | undefined => {
-  if (!isRecord(value) || !isSecureNetworkUrl(value.authorizationServerUrl)) {
-    return undefined;
-  }
-
-  // A malformed optional field is dropped alone: keeping the validated
-  // authorization server URL preserves the redirect-time binding, and the SDK
-  // re-discovers whatever metadata is missing.
-  const state: NonNullable<MCPPersistedAuthState["discoveryState"]> = {
-    authorizationServerUrl: value.authorizationServerUrl,
-  };
-
-  if (isSecureNetworkUrl(value.resourceMetadataUrl)) {
-    state.resourceMetadataUrl = value.resourceMetadataUrl;
-  }
-
-  const metadata = OAuthMetadataSchema.safeParse(
-    value.authorizationServerMetadata,
-  );
-  if (metadata.success) state.authorizationServerMetadata = metadata.data;
-
-  const resourceMetadata = OAuthProtectedResourceMetadataSchema.safeParse(
-    value.resourceMetadata,
-  );
-  if (resourceMetadata.success) state.resourceMetadata = resourceMetadata.data;
-
-  return state;
-};
-
-export const normalizePersistedAuthState = (
-  value: unknown,
-): MCPPersistedAuthState | null => {
-  if (!isRecord(value)) return null;
-  if ("serverUrl" in value && !isMcpServerUrl(value.serverUrl)) return null;
-
-  const state: MCPPersistedAuthState = {};
-  if (isMcpServerUrl(value.serverUrl)) {
-    state.serverUrl = normalizeMcpServerUrl(value.serverUrl);
-  }
-  if (isNonEmptyString(value.token)) state.token = value.token;
-  if (isNonEmptyString(value.tokensClientId)) {
-    state.tokensClientId = value.tokensClientId;
-  }
-  if (isNonEmptyString(value.codeVerifier)) {
-    state.codeVerifier = value.codeVerifier;
-  }
-  if (isNonEmptyString(value.state)) state.state = value.state;
-
-  const tokens = normalizeOAuthTokens(value.tokens);
-  if (tokens) state.tokens = tokens;
-
-  const clientInformation = normalizeClientInformation(value.clientInformation);
-  if (clientInformation) state.clientInformation = clientInformation;
-  if (value.clientInformationSource === "registered") {
-    state.clientInformationSource = value.clientInformationSource;
-  }
-
-  const discoveryState = normalizeDiscoveryState(value.discoveryState);
-  if (discoveryState) state.discoveryState = discoveryState;
-
-  return Object.keys(state).length > 0 ? state : null;
-};
-
 const useMcpLocalStorage = (opts: McpLocalStorageOptions = {}): MCPStorage => {
   const prefix = opts.keyPrefix ?? "aui-mcp";
   const storage = resolveStorage(opts);

package/src/resources/storage/McpStoredDataNormalization.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from "vitest";
+import {
+  normalizeCustomServerRecords,
+  normalizePersistedAuthState,
+} from "./McpStoredDataNormalization";
+
+describe("stored data normalization", () => {
+  it("rejects unsafe persisted server ids and URLs", () => {
+    expect(
+      normalizeCustomServerRecords([
+        {
+          id: "docs__tool",
+          name: "Docs",
+          url: "https://example.com/mcp",
+          auth: { type: "none" },
+          createdAt: 1,
+        },
+      ]),
+    ).toEqual([]);
+    expect(
+      normalizePersistedAuthState({ serverUrl: "javascript:alert(1)" }),
+    ).toBeNull();
+  });
+});

package/src/resources/storage/McpStoredDataNormalization.ts

@@ -0,0 +1,201 @@
+import {
+  OAuthMetadataSchema,
+  OAuthClientInformationFullSchema,
+  OAuthProtectedResourceMetadataSchema,
+  OAuthTokensSchema,
+} from "@modelcontextprotocol/core";
+import {
+  isSecureNetworkUrl,
+  normalizeMcpServerUrl,
+} from "../../utils/serverUrl";
+import type { MCPAuthConfig, MCPCustomServerRecord } from "../../mcp-scope";
+import type { MCPPersistedAuthState } from "../../auth/types";
+import { assertValidServerId } from "../../utils/serverId";
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null && !Array.isArray(value);
+
+const isOptionalString = (value: unknown): value is string | undefined =>
+  value === undefined || typeof value === "string";
+
+const isNonEmptyString = (value: unknown): value is string =>
+  typeof value === "string" && value.trim().length > 0;
+
+const isOptionalNonEmptyString = (
+  value: unknown,
+): value is string | undefined =>
+  value === undefined || isNonEmptyString(value);
+
+const isOptionalStringArray = (value: unknown): value is string[] | undefined =>
+  value === undefined ||
+  (Array.isArray(value) && value.every((item) => typeof item === "string"));
+
+const isOptionalConnectionTimeout = (
+  value: unknown,
+): value is number | undefined =>
+  value === undefined ||
+  (typeof value === "number" && Number.isFinite(value) && value >= 0);
+
+const isValidServerId = (id: string): boolean => {
+  try {
+    assertValidServerId(id);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+const isMCPAuthConfig = (auth: unknown): auth is MCPAuthConfig => {
+  if (!isRecord(auth)) return false;
+
+  switch (auth.type) {
+    case "none":
+      return true;
+    case "bearer":
+      return isOptionalNonEmptyString(auth.token);
+    case "oauth":
+      return (
+        isOptionalStringArray(auth.scopes) &&
+        isOptionalString(auth.authorizationEndpoint) &&
+        isOptionalString(auth.tokenEndpoint) &&
+        isOptionalString(auth.registrationEndpoint) &&
+        isOptionalString(auth.clientId) &&
+        isOptionalString(auth.clientSecret)
+      );
+    default:
+      return false;
+  }
+};
+
+const isCustomServerRecord = (
+  value: unknown,
+): value is MCPCustomServerRecord => {
+  if (!isRecord(value)) return false;
+  if (typeof value.id !== "string" || !isValidServerId(value.id)) {
+    return false;
+  }
+  return (
+    isNonEmptyString(value.name) &&
+    isNonEmptyString(value.url) &&
+    Number.isFinite(value.createdAt) &&
+    isMCPAuthConfig(value.auth) &&
+    isOptionalConnectionTimeout(value.connectionTimeout)
+  );
+};
+
+const normalizeCustomServerRecord = (
+  value: unknown,
+): MCPCustomServerRecord | null => {
+  if (isCustomServerRecord(value)) return value;
+  if (!isRecord(value)) return null;
+
+  const record = { ...value };
+  delete record.connectionTimeout;
+  return isCustomServerRecord(record) ? record : null;
+};
+
+export const normalizeCustomServerRecords = (
+  value: unknown,
+): MCPCustomServerRecord[] => {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((item) => {
+    const record = normalizeCustomServerRecord(item);
+    return record === null ? [] : [record];
+  });
+};
+
+const normalizeOAuthTokens = (
+  value: unknown,
+): MCPPersistedAuthState["tokens"] | undefined => {
+  const result = OAuthTokensSchema.safeParse(value);
+  return result.success ? result.data : undefined;
+};
+
+const normalizeClientInformation = (
+  value: unknown,
+): MCPPersistedAuthState["clientInformation"] | undefined => {
+  const result = OAuthClientInformationFullSchema.safeParse(value);
+  return result.success ? result.data : undefined;
+};
+
+const isMcpServerUrl = (value: unknown): value is string => {
+  if (typeof value !== "string") return false;
+  try {
+    const url = new URL(value);
+    return url.protocol === "https:" || url.protocol === "http:";
+  } catch {
+    return false;
+  }
+};
+
+const normalizeDiscoveryState = (
+  value: unknown,
+): MCPPersistedAuthState["discoveryState"] | undefined => {
+  if (
+    !isRecord(value) ||
+    typeof value.authorizationServerUrl !== "string" ||
+    !isSecureNetworkUrl(value.authorizationServerUrl)
+  ) {
+    return undefined;
+  }
+
+  // A malformed optional field is dropped alone: keeping the validated
+  // authorization server URL preserves the redirect-time binding, and the SDK
+  // re-discovers whatever metadata is missing.
+  const state: NonNullable<MCPPersistedAuthState["discoveryState"]> = {
+    authorizationServerUrl: value.authorizationServerUrl,
+  };
+
+  if (
+    typeof value.resourceMetadataUrl === "string" &&
+    isSecureNetworkUrl(value.resourceMetadataUrl)
+  ) {
+    state.resourceMetadataUrl = value.resourceMetadataUrl;
+  }
+
+  const metadata = OAuthMetadataSchema.safeParse(
+    value.authorizationServerMetadata,
+  );
+  if (metadata.success) state.authorizationServerMetadata = metadata.data;
+
+  const resourceMetadata = OAuthProtectedResourceMetadataSchema.safeParse(
+    value.resourceMetadata,
+  );
+  if (resourceMetadata.success) state.resourceMetadata = resourceMetadata.data;
+
+  return state;
+};
+
+export const normalizePersistedAuthState = (
+  value: unknown,
+): MCPPersistedAuthState | null => {
+  if (!isRecord(value)) return null;
+  if ("serverUrl" in value && !isMcpServerUrl(value.serverUrl)) return null;
+
+  const state: MCPPersistedAuthState = {};
+  if (isMcpServerUrl(value.serverUrl)) {
+    state.serverUrl = normalizeMcpServerUrl(value.serverUrl);
+  }
+  if (isNonEmptyString(value.token)) state.token = value.token;
+  if (isNonEmptyString(value.tokensClientId)) {
+    state.tokensClientId = value.tokensClientId;
+  }
+  if (isNonEmptyString(value.codeVerifier)) {
+    state.codeVerifier = value.codeVerifier;
+  }
+  if (isNonEmptyString(value.state)) state.state = value.state;
+
+  const tokens = normalizeOAuthTokens(value.tokens);
+  if (tokens) state.tokens = tokens;
+
+  const clientInformation = normalizeClientInformation(value.clientInformation);
+  if (clientInformation) state.clientInformation = clientInformation;
+  if (value.clientInformationSource === "registered") {
+    state.clientInformationSource = value.clientInformationSource;
+  }
+
+  const discoveryState = normalizeDiscoveryState(value.discoveryState);
+  if (discoveryState) state.discoveryState = discoveryState;
+
+  return Object.keys(state).length > 0 ? state : null;
+};