mcp-use 1.2.1 → 1.2.2-canary.1

package/dist/chunk-JV7HAYUT.js

@@ -1,860 +0,0 @@
-import {
-  BrowserOAuthClientProvider
-} from "./chunk-62GFHYCL.js";
-import {
-  __name
-} from "./chunk-SHUYVCID.js";
-
-// src/react/useMcp.ts
-import {
-  CallToolResultSchema,
-  GetPromptResultSchema,
-  ListPromptsResultSchema,
-  ListResourcesResultSchema,
-  ListToolsResultSchema,
-  ReadResourceResultSchema
-} from "@modelcontextprotocol/sdk/types.js";
-import { useCallback, useEffect, useRef, useState } from "react";
-import { auth, UnauthorizedError } from "@modelcontextprotocol/sdk/client/auth.js";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { sanitizeUrl } from "strict-url-sanitise";
-
-// src/utils/assert.ts
-function assert(condition, message) {
-  if (!condition) {
-    throw new Error(message);
-  }
-}
-__name(assert, "assert");
-
-// src/react/useMcp.ts
-var DEFAULT_RECONNECT_DELAY = 3e3;
-var DEFAULT_RETRY_DELAY = 5e3;
-var AUTH_TIMEOUT = 5 * 60 * 1e3;
-function useMcp(options) {
-  const {
-    url,
-    enabled = true,
-    clientName,
-    clientUri,
-    callbackUrl = typeof window !== "undefined" ? sanitizeUrl(new URL("/oauth/callback", window.location.origin).toString()) : "/oauth/callback",
-    storageKeyPrefix = "mcp:auth",
-    clientConfig = {},
-    customHeaders = {},
-    debug: _debug = false,
-    autoRetry = false,
-    autoReconnect = DEFAULT_RECONNECT_DELAY,
-    transportType = "auto",
-    preventAutoAuth = false,
-    onPopupWindow,
-    timeout = 3e4,
-    // 30 seconds default for connection timeout
-    sseReadTimeout = 3e5
-    // 5 minutes default for SSE read timeout
-  } = options;
-  const [state, setState] = useState("discovering");
-  const [tools, setTools] = useState([]);
-  const [resources, setResources] = useState([]);
-  const [resourceTemplates, setResourceTemplates] = useState([]);
-  const [prompts, setPrompts] = useState([]);
-  const [error, setError] = useState(void 0);
-  const [log, setLog] = useState([]);
-  const [authUrl, setAuthUrl] = useState(void 0);
-  const clientRef = useRef(null);
-  const transportRef = useRef(null);
-  const authProviderRef = useRef(null);
-  const connectingRef = useRef(false);
-  const isMountedRef = useRef(true);
-  const connectAttemptRef = useRef(0);
-  const authTimeoutRef = useRef(null);
-  const stateRef = useRef(state);
-  const autoReconnectRef = useRef(autoReconnect);
-  const successfulTransportRef = useRef(null);
-  useEffect(() => {
-    stateRef.current = state;
-    autoReconnectRef.current = autoReconnect;
-  }, [state, autoReconnect]);
-  const addLog = useCallback(
-    (level, message, ...args) => {
-      const fullMessage = args.length > 0 ? `${message} ${args.map((arg) => JSON.stringify(arg)).join(" ")}` : message;
-      console[level](`[useMcp] ${fullMessage}`);
-      if (isMountedRef.current) {
-        setLog((prevLog) => [...prevLog.slice(-100), { level, message: fullMessage, timestamp: Date.now() }]);
-      }
-    },
-    []
-  );
-  const disconnect = useCallback(
-    async (quiet = false) => {
-      if (!quiet) addLog("info", "Disconnecting...");
-      connectingRef.current = false;
-      if (authTimeoutRef.current) clearTimeout(authTimeoutRef.current);
-      authTimeoutRef.current = null;
-      const transport = transportRef.current;
-      clientRef.current = null;
-      transportRef.current = null;
-      if (isMountedRef.current && !quiet) {
-        setState("discovering");
-        setTools([]);
-        setResources([]);
-        setResourceTemplates([]);
-        setPrompts([]);
-        setError(void 0);
-        setAuthUrl(void 0);
-      }
-      if (transport) {
-        try {
-          await transport.close();
-          if (!quiet) addLog("debug", "Transport closed");
-        } catch (err) {
-          if (!quiet) addLog("warn", "Error closing transport:", err);
-        }
-      }
-    },
-    [addLog]
-  );
-  const failConnection = useCallback(
-    (errorMessage, connectionError) => {
-      addLog("error", errorMessage, connectionError ?? "");
-      if (isMountedRef.current) {
-        setState("failed");
-        setError(errorMessage);
-        const manualUrl = authProviderRef.current?.getLastAttemptedAuthUrl();
-        if (manualUrl) {
-          setAuthUrl(manualUrl);
-          addLog("info", "Manual authentication URL may be available.", manualUrl);
-        }
-      }
-      connectingRef.current = false;
-    },
-    [addLog]
-  );
-  const connect = useCallback(async () => {
-    if (!enabled || !url) {
-      addLog("debug", enabled ? "No server URL provided, skipping connection." : "Connection disabled via enabled flag.");
-      return;
-    }
-    if (connectingRef.current) {
-      addLog("debug", "Connection attempt already in progress.");
-      return;
-    }
-    if (!isMountedRef.current) {
-      addLog("debug", "Connect called after unmount, aborting.");
-      return;
-    }
-    connectingRef.current = true;
-    connectAttemptRef.current += 1;
-    setError(void 0);
-    setAuthUrl(void 0);
-    successfulTransportRef.current = null;
-    setState("discovering");
-    addLog("info", `Connecting attempt #${connectAttemptRef.current} to ${url}...`);
-    if (!authProviderRef.current) {
-      authProviderRef.current = new BrowserOAuthClientProvider(url, {
-        storageKeyPrefix,
-        clientName,
-        clientUri,
-        callbackUrl,
-        preventAutoAuth,
-        onPopupWindow
-      });
-      addLog("debug", "BrowserOAuthClientProvider initialized in connect.");
-    }
-    if (!clientRef.current) {
-      clientRef.current = new Client(
-        { name: clientConfig.name || "mcp-use", version: clientConfig.version || "0.1.0" },
-        { capabilities: {} }
-      );
-      addLog("debug", "MCP Client initialized in connect.");
-    }
-    const tryConnectWithTransport = /* @__PURE__ */ __name(async (transportTypeParam, isAuthRetry = false) => {
-      addLog("info", `Attempting connection with ${transportTypeParam.toUpperCase()} transport${isAuthRetry ? " (after auth)" : ""}...`);
-      if (stateRef.current !== "authenticating") {
-        setState("connecting");
-      }
-      let transportInstance;
-      try {
-        assert(authProviderRef.current, "Auth Provider must be initialized");
-        assert(clientRef.current, "Client must be initialized");
-        if (transportRef.current) {
-          await transportRef.current.close().catch((e) => addLog("warn", `Error closing previous transport: ${e.message}`));
-          transportRef.current = null;
-        }
-        const commonOptions = {
-          authProvider: authProviderRef.current,
-          requestInit: {
-            headers: {
-              Accept: "application/json, text/event-stream",
-              ...customHeaders
-            }
-          }
-          // Note: The MCP SDK's SSEClientTransport doesn't expose timeout configuration directly
-          // Timeout handling is managed by the underlying EventSource and browser/Node.js fetch implementations
-          // The timeout and sseReadTimeout options are preserved for future use or custom implementations
-        };
-        const sanitizedUrl = sanitizeUrl(url);
-        const targetUrl = new URL(sanitizedUrl);
-        addLog("debug", `Creating ${transportTypeParam.toUpperCase()} transport for URL: ${targetUrl.toString()}`);
-        if (transportTypeParam === "http") {
-          addLog("debug", "Creating StreamableHTTPClientTransport...");
-          transportInstance = new StreamableHTTPClientTransport(targetUrl, commonOptions);
-          addLog("debug", "StreamableHTTPClientTransport created successfully");
-        } else {
-          addLog("debug", "Creating SSEClientTransport...");
-          transportInstance = new SSEClientTransport(targetUrl, commonOptions);
-          addLog("debug", "SSEClientTransport created successfully");
-        }
-        transportRef.current = transportInstance;
-        addLog("debug", `${transportTypeParam.toUpperCase()} transport created and assigned to ref.`);
-      } catch (err) {
-        failConnection(
-          `Failed to create ${transportTypeParam.toUpperCase()} transport: ${err instanceof Error ? err.message : String(err)}`,
-          err instanceof Error ? err : void 0
-        );
-        return "failed";
-      }
-      transportInstance.onmessage = (message) => {
-        addLog("debug", `[Transport] Received: ${JSON.stringify(message)}`);
-        clientRef.current?.handleMessage?.(message);
-      };
-      transportInstance.onerror = (err) => {
-        addLog("warn", `Transport error event (${transportTypeParam.toUpperCase()}):`, err);
-        failConnection(`Transport error (${transportTypeParam.toUpperCase()}): ${err.message}`, err);
-      };
-      transportInstance.onclose = () => {
-        if (!isMountedRef.current || connectingRef.current) return;
-        addLog("info", `Transport connection closed (${successfulTransportRef.current || "unknown"} type).`);
-        const currentState = stateRef.current;
-        const currentAutoReconnect = autoReconnectRef.current;
-        if (currentState === "ready" && currentAutoReconnect) {
-          const delay = typeof currentAutoReconnect === "number" ? currentAutoReconnect : DEFAULT_RECONNECT_DELAY;
-          addLog("info", `Attempting to reconnect in ${delay}ms...`);
-          setState("connecting");
-          setTimeout(() => {
-            if (isMountedRef.current) {
-              connect();
-            }
-          }, delay);
-        } else if (currentState !== "failed" && currentState !== "authenticating") {
-          failConnection("Cannot connect to server");
-        }
-      };
-      try {
-        addLog("info", `Connecting client via ${transportTypeParam.toUpperCase()}...`);
-        await clientRef.current.connect(transportInstance);
-        addLog("info", `Client connected via ${transportTypeParam.toUpperCase()}. Loading tools, resources, and prompts...`);
-        successfulTransportRef.current = transportTypeParam;
-        setState("loading");
-        const toolsResponse = await clientRef.current.request({ method: "tools/list" }, ListToolsResultSchema);
-        let resourcesResponse = { resources: [], resourceTemplates: [] };
-        try {
-          resourcesResponse = await clientRef.current.request({ method: "resources/list" }, ListResourcesResultSchema);
-        } catch (err) {
-          addLog("debug", "Server does not support resources/list method", err);
-        }
-        let promptsResponse = { prompts: [] };
-        try {
-          promptsResponse = await clientRef.current.request({ method: "prompts/list" }, ListPromptsResultSchema);
-        } catch (err) {
-          addLog("debug", "Server does not support prompts/list method", err);
-        }
-        if (isMountedRef.current) {
-          setTools(toolsResponse.tools);
-          setResources(resourcesResponse.resources);
-          setResourceTemplates(Array.isArray(resourcesResponse.resourceTemplates) ? resourcesResponse.resourceTemplates : []);
-          setPrompts(promptsResponse.prompts);
-          const summary = [`Loaded ${toolsResponse.tools.length} tools`];
-          if (resourcesResponse.resources.length > 0 || resourcesResponse.resourceTemplates && resourcesResponse.resourceTemplates.length > 0) {
-            summary.push(`${resourcesResponse.resources.length} resources`);
-            if (Array.isArray(resourcesResponse.resourceTemplates) && resourcesResponse.resourceTemplates.length > 0) {
-              summary.push(`${resourcesResponse.resourceTemplates.length} resource templates`);
-            }
-          }
-          if (promptsResponse.prompts.length > 0) {
-            summary.push(`${promptsResponse.prompts.length} prompts`);
-          }
-          addLog("info", summary.join(", ") + ".");
-          setState("ready");
-          connectAttemptRef.current = 0;
-          return "success";
-        } else {
-          return "failed";
-        }
-      } catch (connectErr) {
-        addLog("debug", `Client connect error via ${transportTypeParam.toUpperCase()}:`, connectErr);
-        const errorInstance = connectErr instanceof Error ? connectErr : new Error(String(connectErr));
-        const errorMessage = errorInstance.message;
-        const is404 = errorMessage.includes("404") || errorMessage.includes("Not Found");
-        const is405 = errorMessage.includes("405") || errorMessage.includes("Method Not Allowed");
-        const isLikelyCors = errorMessage === "Failed to fetch" || errorMessage === "NetworkError when attempting to fetch resource." || errorMessage === "Load failed";
-        if (transportTypeParam === "http" && (is404 || is405 || isLikelyCors)) {
-          addLog("warn", `HTTP transport failed (${isLikelyCors ? "CORS" : is404 ? "404" : "405"}), will try fallback.`);
-          return "fallback";
-        }
-        if (errorInstance instanceof UnauthorizedError || errorMessage.includes("Unauthorized") || errorMessage.includes("401")) {
-          if (isAuthRetry) {
-            addLog("error", "Authentication failed even after successful token refresh. This may indicate a server issue.");
-            failConnection("Authentication loop detected - auth succeeded but connection still unauthorized.");
-            return "failed";
-          }
-          addLog("info", "Authentication required.");
-          assert(authProviderRef.current, "Auth Provider not available for auth flow");
-          const existingTokens = await authProviderRef.current.tokens();
-          if (preventAutoAuth && !existingTokens) {
-            addLog("info", "Authentication required but auto-auth prevented. User action needed.");
-            setState("pending_auth");
-            return "auth_redirect";
-          }
-          if (stateRef.current !== "authenticating" && stateRef.current !== "pending_auth") {
-            setState("authenticating");
-            if (authTimeoutRef.current) clearTimeout(authTimeoutRef.current);
-            authTimeoutRef.current = setTimeout(() => {
-              if (isMountedRef.current) {
-                const currentState = stateRef.current;
-                if (currentState === "authenticating") {
-                  failConnection("Authentication timed out. Please try again.");
-                }
-              }
-            }, AUTH_TIMEOUT);
-          }
-          try {
-            assert(url, "Server URL is required for authentication");
-            const baseUrl = new URL(url).origin;
-            const authResult = await auth(authProviderRef.current, { serverUrl: baseUrl });
-            if (!isMountedRef.current) return "failed";
-            if (authResult === "AUTHORIZED") {
-              addLog("info", "Authentication successful via existing token or refresh. Retrying transport connection...");
-              if (authTimeoutRef.current) clearTimeout(authTimeoutRef.current);
-              authTimeoutRef.current = null;
-              return await tryConnectWithTransport(transportTypeParam, true);
-            } else if (authResult === "REDIRECT") {
-              addLog("info", "Redirecting for authentication. Waiting for callback...");
-              return "auth_redirect";
-            }
-          } catch (sdkAuthError) {
-            if (!isMountedRef.current) return "failed";
-            if (authTimeoutRef.current) clearTimeout(authTimeoutRef.current);
-            failConnection(
-              `Failed to initiate authentication: ${sdkAuthError instanceof Error ? sdkAuthError.message : String(sdkAuthError)}`,
-              sdkAuthError instanceof Error ? sdkAuthError : void 0
-            );
-            return "failed";
-          }
-        }
-        failConnection(`Failed to connect via ${transportTypeParam.toUpperCase()}: ${errorMessage}`, errorInstance);
-        return "failed";
-      }
-    }, "tryConnectWithTransport");
-    let finalStatus = "failed";
-    if (transportType === "sse") {
-      addLog("debug", "Using SSE-only transport mode");
-      finalStatus = await tryConnectWithTransport("sse");
-    } else if (transportType === "http") {
-      addLog("debug", "Using HTTP-only transport mode");
-      finalStatus = await tryConnectWithTransport("http");
-    } else {
-      addLog("debug", "Using auto transport mode (HTTP with SSE fallback)");
-      const httpResult = await tryConnectWithTransport("http");
-      if (httpResult === "fallback" && isMountedRef.current && stateRef.current !== "authenticating") {
-        addLog("info", "HTTP failed, attempting SSE fallback...");
-        const sseResult = await tryConnectWithTransport("sse");
-        finalStatus = sseResult;
-      } else {
-        finalStatus = httpResult;
-      }
-    }
-    if (finalStatus === "success" || finalStatus === "failed" || finalStatus === "auth_redirect") {
-      connectingRef.current = false;
-    }
-    addLog("debug", `Connection sequence finished with status: ${finalStatus}`);
-  }, [
-    addLog,
-    failConnection,
-    disconnect,
-    url,
-    storageKeyPrefix,
-    clientName,
-    clientUri,
-    callbackUrl,
-    clientConfig.name,
-    clientConfig.version,
-    customHeaders,
-    transportType,
-    preventAutoAuth,
-    onPopupWindow,
-    enabled,
-    timeout,
-    sseReadTimeout
-  ]);
-  const callTool = useCallback(
-    async (name, args) => {
-      if (stateRef.current !== "ready" || !clientRef.current) {
-        throw new Error(`MCP client is not ready (current state: ${state}). Cannot call tool "${name}".`);
-      }
-      addLog("info", `Calling tool: ${name}`, args);
-      try {
-        const result = await clientRef.current.request({ method: "tools/call", params: { name, arguments: args } }, CallToolResultSchema);
-        addLog("info", `Tool "${name}" call successful:`, result);
-        return result;
-      } catch (err) {
-        addLog("error", `Error calling tool "${name}": ${err instanceof Error ? err.message : String(err)}`, err);
-        const errorInstance = err instanceof Error ? err : new Error(String(err));
-        if (errorInstance instanceof UnauthorizedError || errorInstance.message.includes("Unauthorized") || errorInstance.message.includes("401")) {
-          addLog("warn", "Tool call unauthorized, attempting re-authentication...");
-          setState("authenticating");
-          if (authTimeoutRef.current) clearTimeout(authTimeoutRef.current);
-          authTimeoutRef.current = setTimeout(() => {
-            if (isMountedRef.current) {
-              const currentState2 = stateRef.current;
-              if (currentState2 === "authenticating") {
-                failConnection("Authentication timed out. Please try again.");
-              }
-            }
-          }, AUTH_TIMEOUT);
-          try {
-            assert(authProviderRef.current, "Auth Provider not available for tool re-auth");
-            assert(url, "Server URL is required for authentication");
-            const baseUrl = new URL(url).origin;
-            const authResult = await auth(authProviderRef.current, { serverUrl: baseUrl });
-            if (!isMountedRef.current) return;
-            if (authResult === "AUTHORIZED") {
-              addLog("info", "Re-authentication successful. Retrying tool call is recommended, or reconnecting.");
-              if (authTimeoutRef.current) clearTimeout(authTimeoutRef.current);
-              connectingRef.current = false;
-              connect();
-            } else if (authResult === "REDIRECT") {
-              addLog("info", "Redirecting for re-authentication for tool call.");
-            }
-          } catch (sdkAuthError) {
-            if (!isMountedRef.current) return;
-            if (authTimeoutRef.current) clearTimeout(authTimeoutRef.current);
-            failConnection(
-              `Re-authentication failed: ${sdkAuthError instanceof Error ? sdkAuthError.message : String(sdkAuthError)}`,
-              sdkAuthError instanceof Error ? sdkAuthError : void 0
-            );
-          }
-        }
-        const currentState = stateRef.current;
-        if (currentState !== "authenticating") {
-          throw err;
-        }
-        return void 0;
-      }
-    },
-    [state, url, addLog, failConnection, connect]
-  );
-  const retry = useCallback(() => {
-    if (stateRef.current === "failed") {
-      addLog("info", "Retry requested...");
-      connect();
-    } else {
-      addLog("warn", `Retry called but state is not 'failed' (state: ${stateRef.current}). Ignoring.`);
-    }
-  }, [addLog, connect]);
-  const authenticate = useCallback(async () => {
-    addLog("info", "Manual authentication requested...");
-    const currentState = stateRef.current;
-    if (currentState === "failed") {
-      addLog("info", "Attempting to reconnect and authenticate via retry...");
-      retry();
-    } else if (currentState === "pending_auth") {
-      addLog("info", "Proceeding with authentication from pending state...");
-      setState("authenticating");
-      if (authTimeoutRef.current) clearTimeout(authTimeoutRef.current);
-      authTimeoutRef.current = setTimeout(() => {
-        if (isMountedRef.current) {
-          const currentStateValue = stateRef.current;
-          if (currentStateValue === "authenticating") {
-            failConnection("Authentication timed out. Please try again.");
-          }
-        }
-      }, AUTH_TIMEOUT);
-      try {
-        assert(authProviderRef.current, "Auth Provider not available for manual auth");
-        assert(url, "Server URL is required for authentication");
-        const baseUrl = new URL(url).origin;
-        const authResult = await auth(authProviderRef.current, { serverUrl: baseUrl });
-        if (!isMountedRef.current) return;
-        if (authResult === "AUTHORIZED") {
-          addLog("info", "Manual authentication successful. Re-attempting connection...");
-          if (authTimeoutRef.current) clearTimeout(authTimeoutRef.current);
-          connectingRef.current = false;
-          connect();
-        } else if (authResult === "REDIRECT") {
-          addLog("info", "Redirecting for manual authentication. Waiting for callback...");
-        }
-      } catch (authError) {
-        if (!isMountedRef.current) return;
-        if (authTimeoutRef.current) clearTimeout(authTimeoutRef.current);
-        failConnection(
-          `Manual authentication failed: ${authError instanceof Error ? authError.message : String(authError)}`,
-          authError instanceof Error ? authError : void 0
-        );
-      }
-    } else if (currentState === "authenticating") {
-      addLog("warn", "Already attempting authentication. Check for blocked popups or wait for timeout.");
-      const manualUrl = authProviderRef.current?.getLastAttemptedAuthUrl();
-      if (manualUrl && !authUrl) {
-        setAuthUrl(manualUrl);
-        addLog("info", "Manual authentication URL retrieved:", manualUrl);
-      }
-    } else {
-      addLog(
-        "info",
-        `Client not in a state requiring manual authentication trigger (state: ${currentState}). If needed, try disconnecting and reconnecting.`
-      );
-    }
-  }, [addLog, retry, authUrl, url, failConnection, connect]);
-  const clearStorage = useCallback(() => {
-    if (authProviderRef.current) {
-      const count = authProviderRef.current.clearStorage();
-      addLog("info", `Cleared ${count} item(s) from localStorage for ${url}.`);
-      setAuthUrl(void 0);
-      disconnect();
-    } else {
-      addLog("warn", "Auth provider not initialized, cannot clear storage.");
-    }
-  }, [url, addLog, disconnect]);
-  const listResources = useCallback(async () => {
-    if (stateRef.current !== "ready" || !clientRef.current) {
-      throw new Error(`MCP client is not ready (current state: ${state}). Cannot list resources.`);
-    }
-    addLog("info", "Listing resources...");
-    try {
-      const resourcesResponse = await clientRef.current.request({ method: "resources/list" }, ListResourcesResultSchema);
-      if (isMountedRef.current) {
-        setResources(resourcesResponse.resources);
-        setResourceTemplates(Array.isArray(resourcesResponse.resourceTemplates) ? resourcesResponse.resourceTemplates : []);
-        addLog(
-          "info",
-          `Listed ${resourcesResponse.resources.length} resources, ${Array.isArray(resourcesResponse.resourceTemplates) ? resourcesResponse.resourceTemplates.length : 0} resource templates.`
-        );
-      }
-    } catch (err) {
-      addLog("error", `Error listing resources: ${err instanceof Error ? err.message : String(err)}`, err);
-      throw err;
-    }
-  }, [state, addLog]);
-  const readResource = useCallback(
-    async (uri) => {
-      if (stateRef.current !== "ready" || !clientRef.current) {
-        throw new Error(`MCP client is not ready (current state: ${state}). Cannot read resource "${uri}".`);
-      }
-      addLog("info", `Reading resource: ${uri}`);
-      try {
-        const result = await clientRef.current.request({ method: "resources/read", params: { uri } }, ReadResourceResultSchema);
-        addLog("info", `Resource "${uri}" read successfully`);
-        return result;
-      } catch (err) {
-        addLog("error", `Error reading resource "${uri}": ${err instanceof Error ? err.message : String(err)}`, err);
-        throw err;
-      }
-    },
-    [state, addLog]
-  );
-  const listPrompts = useCallback(async () => {
-    if (stateRef.current !== "ready" || !clientRef.current) {
-      throw new Error(`MCP client is not ready (current state: ${state}). Cannot list prompts.`);
-    }
-    addLog("info", "Listing prompts...");
-    try {
-      const promptsResponse = await clientRef.current.request({ method: "prompts/list" }, ListPromptsResultSchema);
-      if (isMountedRef.current) {
-        setPrompts(promptsResponse.prompts);
-        addLog("info", `Listed ${promptsResponse.prompts.length} prompts.`);
-      }
-    } catch (err) {
-      addLog("error", `Error listing prompts: ${err instanceof Error ? err.message : String(err)}`, err);
-      throw err;
-    }
-  }, [state, addLog]);
-  const getPrompt = useCallback(
-    async (name, args) => {
-      if (stateRef.current !== "ready" || !clientRef.current) {
-        throw new Error(`MCP client is not ready (current state: ${state}). Cannot get prompt "${name}".`);
-      }
-      addLog("info", `Getting prompt: ${name}`, args);
-      try {
-        const result = await clientRef.current.request({ method: "prompts/get", params: { name, arguments: args } }, GetPromptResultSchema);
-        addLog("info", `Prompt "${name}" retrieved successfully`);
-        return result;
-      } catch (err) {
-        addLog("error", `Error getting prompt "${name}": ${err instanceof Error ? err.message : String(err)}`, err);
-        throw err;
-      }
-    },
-    [state, addLog]
-  );
-  const connectRef = useRef(connect);
-  const failConnectionRef = useRef(failConnection);
-  useEffect(() => {
-    connectRef.current = connect;
-    failConnectionRef.current = failConnection;
-  });
-  useEffect(() => {
-    const messageHandler = /* @__PURE__ */ __name((event) => {
-      if (event.origin !== window.location.origin) return;
-      if (event.data?.type === "mcp_auth_callback") {
-        addLog("info", "Received auth callback message.", event.data);
-        if (authTimeoutRef.current) clearTimeout(authTimeoutRef.current);
-        authTimeoutRef.current = null;
-        if (event.data.success) {
-          addLog("info", "Authentication successful via popup. Reconnecting client...");
-          if (connectingRef.current) {
-            addLog("debug", "Connection attempt already in progress, resetting flag to allow reconnection.");
-          }
-          connectingRef.current = false;
-          setTimeout(() => {
-            if (isMountedRef.current) {
-              addLog("debug", "Initiating reconnection after successful auth callback.");
-              connectRef.current();
-            }
-          }, 100);
-        } else {
-          failConnectionRef.current(`Authentication failed in callback: ${event.data.error || "Unknown reason."}`);
-        }
-      }
-    }, "messageHandler");
-    window.addEventListener("message", messageHandler);
-    addLog("debug", "Auth callback message listener added.");
-    return () => {
-      window.removeEventListener("message", messageHandler);
-      addLog("debug", "Auth callback message listener removed.");
-      if (authTimeoutRef.current) clearTimeout(authTimeoutRef.current);
-    };
-  }, [addLog]);
-  useEffect(() => {
-    isMountedRef.current = true;
-    if (!enabled || !url) {
-      addLog("debug", enabled ? "No server URL provided, skipping connection." : "Connection disabled via enabled flag.");
-      setState("discovering");
-      return () => {
-        isMountedRef.current = false;
-      };
-    }
-    addLog("debug", "useMcp mounted, initiating connection.");
-    connectAttemptRef.current = 0;
-    if (!authProviderRef.current || authProviderRef.current.serverUrl !== url) {
-      authProviderRef.current = new BrowserOAuthClientProvider(url, {
-        storageKeyPrefix,
-        clientName,
-        clientUri,
-        callbackUrl,
-        preventAutoAuth,
-        onPopupWindow
-      });
-      addLog("debug", "BrowserOAuthClientProvider initialized/updated on mount/option change.");
-    }
-    connect();
-    return () => {
-      isMountedRef.current = false;
-      addLog("debug", "useMcp unmounting, disconnecting.");
-      disconnect(true);
-    };
-  }, [url, enabled, storageKeyPrefix, callbackUrl, clientName, clientUri, clientConfig.name, clientConfig.version]);
-  useEffect(() => {
-    let retryTimeoutId = null;
-    if (state === "failed" && autoRetry && connectAttemptRef.current > 0) {
-      const delay = typeof autoRetry === "number" ? autoRetry : DEFAULT_RETRY_DELAY;
-      addLog("info", `Connection failed, auto-retrying in ${delay}ms...`);
-      retryTimeoutId = setTimeout(() => {
-        if (isMountedRef.current && stateRef.current === "failed") {
-          retry();
-        }
-      }, delay);
-    }
-    return () => {
-      if (retryTimeoutId) clearTimeout(retryTimeoutId);
-    };
-  }, [state, autoRetry, retry, addLog]);
-  return {
-    state,
-    tools,
-    resources,
-    resourceTemplates,
-    prompts,
-    error,
-    log,
-    authUrl,
-    callTool,
-    listResources,
-    readResource,
-    listPrompts,
-    getPrompt,
-    retry,
-    disconnect,
-    authenticate,
-    clearStorage
-  };
-}
-__name(useMcp, "useMcp");
-
-// src/react/useWidget.ts
-import { useCallback as useCallback2, useEffect as useEffect2, useMemo, useState as useState2, useSyncExternalStore } from "react";
-
-// src/react/widget-types.ts
-var SET_GLOBALS_EVENT_TYPE = "openai:set_globals";
-
-// src/react/useWidget.ts
-function useOpenAiGlobal(key) {
-  return useSyncExternalStore(
-    (onChange) => {
-      const handleSetGlobal = /* @__PURE__ */ __name((event) => {
-        const customEvent = event;
-        const value = customEvent.detail.globals[key];
-        if (value === void 0) {
-          return;
-        }
-        onChange();
-      }, "handleSetGlobal");
-      if (typeof window !== "undefined") {
-        window.addEventListener(
-          SET_GLOBALS_EVENT_TYPE,
-          handleSetGlobal
-        );
-      }
-      return () => {
-        if (typeof window !== "undefined") {
-          window.removeEventListener(
-            SET_GLOBALS_EVENT_TYPE,
-            handleSetGlobal
-          );
-        }
-      };
-    },
-    () => typeof window !== "undefined" && window.openai ? window.openai[key] : void 0
-  );
-}
-__name(useOpenAiGlobal, "useOpenAiGlobal");
-function useWidget(defaultProps) {
-  console.log(window?.location?.search, window.openai);
-  const isOpenAiAvailable = useMemo(() => typeof window !== "undefined" && !!window.openai, []);
-  const provider = useMemo(() => {
-    return isOpenAiAvailable ? "openai" : "mcp-ui";
-  }, [isOpenAiAvailable]);
-  const urlParams = useMemo(() => {
-    const urlParams2 = new URLSearchParams(window?.location?.search);
-    if (urlParams2.has("mcpUseParams")) {
-      return JSON.parse(urlParams2.get("mcpUseParams"));
-    }
-    return {
-      toolInput: {},
-      toolOutput: {},
-      toolId: ""
-    };
-  }, [window?.location?.search]);
-  console.log(urlParams);
-  const toolInput = provider === "openai" ? useOpenAiGlobal("toolInput") : urlParams.toolInput;
-  const toolOutput = provider === "openai" ? useOpenAiGlobal("toolOutput") : urlParams.toolOutput;
-  const toolResponseMetadata = useOpenAiGlobal("toolResponseMetadata");
-  const widgetState = useOpenAiGlobal("widgetState");
-  const theme = useOpenAiGlobal("theme");
-  const displayMode = useOpenAiGlobal("displayMode");
-  const safeArea = useOpenAiGlobal("safeArea");
-  const maxHeight = useOpenAiGlobal("maxHeight");
-  const userAgent = useOpenAiGlobal("userAgent");
-  const locale = useOpenAiGlobal("locale");
-  const [localWidgetState, setLocalWidgetState] = useState2(null);
-  useEffect2(() => {
-    if (widgetState !== void 0) {
-      setLocalWidgetState(widgetState);
-    }
-  }, [widgetState]);
-  const callTool = useCallback2(
-    async (name, args) => {
-      if (!window.openai?.callTool) {
-        throw new Error("window.openai.callTool is not available");
-      }
-      return window.openai.callTool(name, args);
-    },
-    []
-  );
-  const sendFollowUpMessage = useCallback2(async (prompt) => {
-    if (!window.openai?.sendFollowUpMessage) {
-      throw new Error("window.openai.sendFollowUpMessage is not available");
-    }
-    return window.openai.sendFollowUpMessage({ prompt });
-  }, []);
-  const openExternal = useCallback2((href) => {
-    if (!window.openai?.openExternal) {
-      throw new Error("window.openai.openExternal is not available");
-    }
-    window.openai.openExternal({ href });
-  }, []);
-  const requestDisplayMode = useCallback2(
-    async (mode) => {
-      if (!window.openai?.requestDisplayMode) {
-        throw new Error("window.openai.requestDisplayMode is not available");
-      }
-      return window.openai.requestDisplayMode({ mode });
-    },
-    []
-  );
-  const setState = useCallback2(
-    async (state) => {
-      const newState = typeof state === "function" ? state(localWidgetState) : state;
-      if (!window.openai?.setWidgetState) {
-        throw new Error("window.openai.setWidgetState is not available");
-      }
-      setLocalWidgetState(newState);
-      return window.openai.setWidgetState(newState);
-    },
-    [localWidgetState]
-  );
-  return {
-    // Props and state (with defaults)
-    props: toolInput || defaultProps || {},
-    output: toolOutput ?? null,
-    metadata: toolResponseMetadata ?? null,
-    state: localWidgetState,
-    setState,
-    // Layout and theme (with safe defaults)
-    theme: theme || "light",
-    displayMode: displayMode || "inline",
-    safeArea: safeArea || { insets: { top: 0, bottom: 0, left: 0, right: 0 } },
-    maxHeight: maxHeight || 600,
-    userAgent: userAgent || {
-      device: { type: "desktop" },
-      capabilities: { hover: true, touch: false }
-    },
-    locale: locale || "en",
-    // Actions
-    callTool,
-    sendFollowUpMessage,
-    openExternal,
-    requestDisplayMode,
-    // Availability
-    isAvailable: isOpenAiAvailable
-  };
-}
-__name(useWidget, "useWidget");
-function useWidgetProps(defaultProps) {
-  const { props } = useWidget(defaultProps);
-  return props;
-}
-__name(useWidgetProps, "useWidgetProps");
-function useWidgetTheme() {
-  const { theme } = useWidget();
-  return theme;
-}
-__name(useWidgetTheme, "useWidgetTheme");
-function useWidgetState(defaultState) {
-  const { state, setState } = useWidget();
-  useEffect2(() => {
-    if (state === null && defaultState !== void 0 && window.openai?.setWidgetState) {
-      setState(defaultState);
-    }
-  }, []);
-  return [state, setState];
-}
-__name(useWidgetState, "useWidgetState");
-
-export {
-  useMcp,
-  useWidget,
-  useWidgetProps,
-  useWidgetTheme,
-  useWidgetState
-};