mcp-use 1.2.1 → 1.2.2-canary.1

package/dist/chunk-KLIBVJ3Z.js

@@ -0,0 +1,759 @@
+import {
+  BrowserMCPClient,
+  BrowserOAuthClientProvider
+} from "./chunk-RSGKBEHH.js";
+import {
+  __name
+} from "./chunk-SHUYVCID.js";
+
+// src/react/useMcp.ts
+import { useCallback, useEffect, useRef, useState } from "react";
+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 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;
+      if (clientRef.current) {
+        try {
+          const serverName = "inspector-server";
+          await clientRef.current.closeSession(serverName);
+        } catch (err) {
+          if (!quiet) addLog("warn", "Error closing session:", err);
+        }
+      }
+      clientRef.current = null;
+      if (isMountedRef.current && !quiet) {
+        setState("discovering");
+        setTools([]);
+        setResources([]);
+        setResourceTemplates([]);
+        setPrompts([]);
+        setError(void 0);
+        setAuthUrl(void 0);
+      }
+    },
+    [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 BrowserMCPClient();
+      addLog("debug", "BrowserMCPClient initialized in connect.");
+    }
+    const tryConnectWithTransport = /* @__PURE__ */ __name(async (transportTypeParam, isAuthRetry = false) => {
+      addLog(
+        "info",
+        `Attempting connection with transport: ${transportTypeParam}`
+      );
+      try {
+        const serverName = "inspector-server";
+        const serverConfig = {
+          url,
+          transport: transportTypeParam === "sse" ? "http" : transportTypeParam
+        };
+        if (customHeaders && Object.keys(customHeaders).length > 0) {
+          serverConfig.headers = customHeaders;
+        }
+        if (authProviderRef.current) {
+          const tokens = await authProviderRef.current.tokens();
+          if (tokens?.access_token) {
+            serverConfig.headers = {
+              ...serverConfig.headers,
+              Authorization: `Bearer ${tokens.access_token}`
+            };
+          }
+        }
+        clientRef.current.addServer(serverName, {
+          ...serverConfig,
+          authProvider: authProviderRef.current
+          // ← SDK handles OAuth automatically!
+        });
+        const session = await clientRef.current.createSession(serverName);
+        await session.initialize();
+        addLog("info", "\u2705 Successfully connected to MCP server");
+        setState("ready");
+        successfulTransportRef.current = transportTypeParam;
+        setTools(session.connector.tools || []);
+        const resourcesResult = await session.connector.listAllResources();
+        setResources(resourcesResult.resources || []);
+        const promptsResult = await session.connector.listPrompts();
+        setPrompts(promptsResult.prompts || []);
+        return "success";
+      } catch (err) {
+        const errorMessage = err?.message || String(err);
+        if (err.code === 401 || errorMessage.includes("401") || errorMessage.includes("Unauthorized")) {
+          if (customHeaders && Object.keys(customHeaders).length > 0) {
+            failConnection(
+              "Authentication failed: Server returned 401 Unauthorized. Check your Authorization header value is correct."
+            );
+            return "failed";
+          }
+          failConnection(
+            "Authentication required: Server returned 401 Unauthorized. Add an Authorization header in the Custom Headers section (e.g., Authorization: Bearer YOUR_API_KEY)."
+          );
+          return "failed";
+        }
+        failConnection(errorMessage, err);
+        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 serverName = "inspector-server";
+        const session = clientRef.current.getSession(serverName);
+        if (!session) {
+          throw new Error("No active session found");
+        }
+        const result = await session.connector.callTool(name, args || {});
+        addLog("info", `Tool "${name}" call successful:`, result);
+        return result;
+      } catch (err) {
+        addLog("error", `Tool "${name}" call failed:`, err);
+        throw err;
+      }
+    },
+    [state]
+  );
+  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");
+        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 serverName = "inspector-server";
+      const session = clientRef.current.getSession(serverName);
+      if (!session) {
+        throw new Error("No active session found");
+      }
+      const resourcesResult = await session.connector.listAllResources();
+      setResources(resourcesResult.resources || []);
+      addLog("info", "Resources listed successfully");
+    } catch (err) {
+      addLog("error", "List resources failed:", err);
+      throw err;
+    }
+  }, [state]);
+  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.`
+        );
+      }
+      addLog("info", `Reading resource: ${uri}`);
+      try {
+        const serverName = "inspector-server";
+        const session = clientRef.current.getSession(serverName);
+        if (!session) {
+          throw new Error("No active session found");
+        }
+        const result = await session.connector.readResource(uri);
+        addLog("info", "Resource read successful:", result);
+        return result;
+      } catch (err) {
+        addLog("error", "Resource read failed:", err);
+        throw err;
+      }
+    },
+    [state]
+  );
+  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 serverName = "inspector-server";
+      const session = clientRef.current.getSession(serverName);
+      if (!session) {
+        throw new Error("No active session found");
+      }
+      const promptsResult = await session.connector.listPrompts();
+      setPrompts(promptsResult.prompts || []);
+      addLog("info", "Prompts listed successfully");
+    } catch (err) {
+      addLog("error", "List prompts failed:", err);
+      throw err;
+    }
+  }, [state]);
+  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.`
+        );
+      }
+      addLog("info", `Getting prompt: ${name}`, args);
+      try {
+        const serverName = "inspector-server";
+        const session = clientRef.current.getSession(serverName);
+        if (!session) {
+          throw new Error("No active session found");
+        }
+        const result = await session.connector.getPrompt(name, args || {});
+        addLog("info", `Prompt "${name}" retrieved successfully:`, result);
+        return result;
+      } catch (err) {
+        addLog("error", `Prompt "${name}" retrieval failed:`, err);
+        throw err;
+      }
+    },
+    [state]
+  );
+  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,
+    client: clientRef.current,
+    callTool,
+    readResource,
+    listResources,
+    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
+};