@frontmcp/ui 0.5.1 → 0.6.1

package/react/index.js

@@ -0,0 +1,3160 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// libs/ui/src/react/index.ts
+var react_exports = {};
+__export(react_exports, {
+  Alert: () => Alert,
+  Badge: () => Badge,
+  Button: () => Button,
+  Card: () => Card,
+  McpBridgeProvider: () => McpBridgeProvider,
+  isBrowser: () => isBrowser,
+  isServer: () => isServer,
+  renderAlert: () => renderAlert,
+  renderAlertSync: () => renderAlertSync,
+  renderBadge: () => renderBadge,
+  renderBadgeSync: () => renderBadgeSync,
+  renderButton: () => renderButton,
+  renderButtonSync: () => renderButtonSync,
+  renderCard: () => renderCard,
+  renderCardSync: () => renderCardSync,
+  renderChildrenToString: () => renderChildrenToString,
+  useCallTool: () => useCallTool,
+  useCapability: () => useCapability,
+  useDisplayMode: () => useDisplayMode,
+  useHostContext: () => useHostContext,
+  useMcpBridge: () => useMcpBridge,
+  useMcpBridgeContext: () => useMcpBridgeContext,
+  useOpenLink: () => useOpenLink,
+  useSendMessage: () => useSendMessage,
+  useStructuredContent: () => useStructuredContent,
+  useTheme: () => useTheme,
+  useToolCalls: () => useToolCalls,
+  useToolInput: () => useToolInput,
+  useToolOutput: () => useToolOutput
+});
+module.exports = __toCommonJS(react_exports);
+
+// libs/ui/src/react/Card.tsx
+var import_styles = require("@frontmcp/uipack/styles");
+
+// libs/ui/src/render/prerender.ts
+async function renderToString(element) {
+  const { prerender } = await import("react-dom/static");
+  const { prelude } = await prerender(element);
+  const reader = prelude.getReader();
+  const chunks = [];
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    if (value) chunks.push(value);
+  }
+  const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+  const combined = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    combined.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return new TextDecoder().decode(combined);
+}
+function renderToStringSync(element) {
+  const ReactDOMServer = require("react-dom/server");
+  return ReactDOMServer.renderToStaticMarkup(element);
+}
+
+// libs/ui/src/react/Card.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+function Card({
+  title,
+  subtitle,
+  headerActions,
+  footer,
+  variant = "default",
+  size = "md",
+  className,
+  id,
+  clickable,
+  href,
+  children
+}) {
+  const variantClasses = (0, import_styles.getCardVariantClasses)(variant);
+  const sizeClasses = (0, import_styles.getCardSizeClasses)(size);
+  const clickableClasses = clickable ? "cursor-pointer hover:shadow-md transition-shadow" : "";
+  const allClasses = (0, import_styles.cn)(variantClasses, sizeClasses, clickableClasses, className);
+  const hasHeader = title || subtitle || headerActions;
+  const content = /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
+    hasHeader && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "flex items-start justify-between mb-4", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { children: [
+        title && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("h3", { className: "text-lg font-semibold text-text-primary", children: title }),
+        subtitle && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { className: "text-sm text-text-secondary mt-1", children: subtitle })
+      ] }),
+      headerActions && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "flex items-center gap-2", children: headerActions })
+    ] }),
+    children,
+    footer && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "mt-4 pt-4 border-t border-divider", children: footer })
+  ] });
+  if (href) {
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("a", { href, className: allClasses, id, children: content });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: allClasses, id, children: content });
+}
+async function renderCard(props) {
+  const { children, headerActions, footer, ...rest } = props;
+  const element = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    Card,
+    {
+      ...rest,
+      headerActions: headerActions ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { dangerouslySetInnerHTML: { __html: headerActions } }) : void 0,
+      footer: footer ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { dangerouslySetInnerHTML: { __html: footer } }) : void 0,
+      children: children ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { dangerouslySetInnerHTML: { __html: children } }) : void 0
+    }
+  );
+  return renderToString(element);
+}
+function renderCardSync(props) {
+  const { children, headerActions, footer, ...rest } = props;
+  const element = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    Card,
+    {
+      ...rest,
+      headerActions: headerActions ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { dangerouslySetInnerHTML: { __html: headerActions } }) : void 0,
+      footer: footer ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { dangerouslySetInnerHTML: { __html: footer } }) : void 0,
+      children: children ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { dangerouslySetInnerHTML: { __html: children } }) : void 0
+    }
+  );
+  return renderToStringSync(element);
+}
+
+// libs/ui/src/react/Badge.tsx
+var import_styles2 = require("@frontmcp/uipack/styles");
+var import_jsx_runtime2 = require("react/jsx-runtime");
+function Badge({
+  variant = "default",
+  size = "md",
+  pill = false,
+  icon,
+  dot = false,
+  className,
+  removable = false,
+  onRemove,
+  children
+}) {
+  if (dot) {
+    const dotClasses = (0, import_styles2.cn)(
+      "inline-block rounded-full",
+      (0, import_styles2.getBadgeDotSizeClasses)(size),
+      (0, import_styles2.getBadgeDotVariantClasses)(variant),
+      className
+    );
+    const label = typeof children === "string" ? children : void 0;
+    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: dotClasses, "aria-label": label, title: label });
+  }
+  const variantClasses = (0, import_styles2.getBadgeVariantClasses)(variant);
+  const sizeClasses = (0, import_styles2.getBadgeSizeClasses)(size);
+  const baseClasses = (0, import_styles2.cn)(
+    "inline-flex items-center font-medium",
+    pill ? "rounded-full" : "rounded-md",
+    variantClasses,
+    sizeClasses,
+    className
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { className: baseClasses, children: [
+    icon && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "mr-1", children: icon }),
+    children,
+    removable && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+      "button",
+      {
+        type: "button",
+        className: "ml-1.5 -mr-1 hover:opacity-70 transition-opacity",
+        "aria-label": "Remove",
+        onClick: onRemove,
+        children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("svg", { className: "w-3 h-3", fill: "none", stroke: "currentColor", viewBox: "0 0 24 24", children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("path", { strokeLinecap: "round", strokeLinejoin: "round", strokeWidth: "2", d: "M6 18L18 6M6 6l12 12" }) })
+      }
+    )
+  ] });
+}
+async function renderBadge(props) {
+  const { children, icon, ...rest } = props;
+  const element = /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Badge, { ...rest, icon: icon ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { dangerouslySetInnerHTML: { __html: icon } }) : void 0, children });
+  return renderToString(element);
+}
+function renderBadgeSync(props) {
+  const { children, icon, ...rest } = props;
+  const element = /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(Badge, { ...rest, icon: icon ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { dangerouslySetInnerHTML: { __html: icon } }) : void 0, children });
+  return renderToStringSync(element);
+}
+
+// libs/ui/src/react/Button.tsx
+var import_styles3 = require("@frontmcp/uipack/styles");
+var import_jsx_runtime3 = require("react/jsx-runtime");
+function Button({
+  variant = "primary",
+  size = "md",
+  disabled = false,
+  loading = false,
+  fullWidth = false,
+  iconPosition = "left",
+  icon,
+  iconOnly = false,
+  type = "button",
+  className,
+  onClick,
+  children
+}) {
+  const variantClasses = (0, import_styles3.getButtonVariantClasses)(variant);
+  const sizeClasses = (0, import_styles3.getButtonSizeClasses)(size, iconOnly);
+  const disabledClasses = disabled || loading ? "opacity-50 cursor-not-allowed" : "";
+  const widthClasses = fullWidth ? "w-full" : "";
+  const allClasses = (0, import_styles3.cn)(import_styles3.BUTTON_BASE_CLASSES, variantClasses, sizeClasses, disabledClasses, widthClasses, className);
+  const iconElement = icon && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { className: iconPosition === "left" ? "mr-2" : "ml-2", children: icon });
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("button", { type, className: allClasses, disabled: disabled || loading, onClick, children: [
+    loading && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { className: "mr-2", dangerouslySetInnerHTML: { __html: import_styles3.LOADING_SPINNER } }),
+    !loading && icon && iconPosition === "left" && iconElement,
+    !iconOnly && children,
+    !loading && icon && iconPosition === "right" && iconElement
+  ] });
+}
+async function renderButton(props) {
+  const { children, icon, ...rest } = props;
+  const element = /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(Button, { ...rest, icon: icon ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { dangerouslySetInnerHTML: { __html: icon } }) : void 0, children });
+  return renderToString(element);
+}
+function renderButtonSync(props) {
+  const { children, icon, ...rest } = props;
+  const element = /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(Button, { ...rest, icon: icon ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { dangerouslySetInnerHTML: { __html: icon } }) : void 0, children });
+  return renderToStringSync(element);
+}
+
+// libs/ui/src/react/Alert.tsx
+var import_styles4 = require("@frontmcp/uipack/styles");
+var import_jsx_runtime4 = require("react/jsx-runtime");
+function Alert({
+  variant = "info",
+  title,
+  icon,
+  showIcon = true,
+  dismissible = false,
+  onDismiss,
+  className,
+  children
+}) {
+  const variantStyles = (0, import_styles4.getAlertVariantClasses)(variant);
+  const allClasses = (0, import_styles4.cn)(import_styles4.ALERT_BASE_CLASSES, variantStyles.container, className);
+  const iconContent = icon || (showIcon ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+    "span",
+    {
+      className: (0, import_styles4.cn)("flex-shrink-0", variantStyles.icon),
+      dangerouslySetInnerHTML: { __html: import_styles4.ALERT_ICONS[variant] }
+    }
+  ) : null);
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("div", { className: allClasses, role: "alert", children: /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("div", { className: "flex", children: [
+    iconContent && /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("div", { className: "flex-shrink-0 mr-3", children: iconContent }),
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("div", { className: "flex-1", children: [
+      title && /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("h4", { className: "font-semibold mb-1", children: title }),
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("div", { className: "text-sm", children })
+    ] }),
+    dismissible && /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+      "button",
+      {
+        type: "button",
+        className: "flex-shrink-0 ml-3 hover:opacity-70 transition-opacity",
+        "aria-label": "Dismiss",
+        onClick: onDismiss,
+        children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("span", { dangerouslySetInnerHTML: { __html: import_styles4.CLOSE_ICON } })
+      }
+    )
+  ] }) });
+}
+async function renderAlert(props) {
+  const { children, icon, ...rest } = props;
+  const element = /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(Alert, { ...rest, icon: icon ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("span", { dangerouslySetInnerHTML: { __html: icon } }) : void 0, children });
+  return renderToString(element);
+}
+function renderAlertSync(props) {
+  const { children, icon, ...rest } = props;
+  const element = /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(Alert, { ...rest, icon: icon ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("span", { dangerouslySetInnerHTML: { __html: icon } }) : void 0, children });
+  return renderToStringSync(element);
+}
+
+// libs/ui/src/react/hooks/context.tsx
+var import_react = require("react");
+
+// libs/ui/src/bridge/core/adapter-registry.ts
+var AdapterRegistry = class {
+  _adapters = /* @__PURE__ */ new Map();
+  _disabledAdapters = /* @__PURE__ */ new Set();
+  _adapterConfigs = /* @__PURE__ */ new Map();
+  _debug = false;
+  /**
+   * Enable or disable debug logging.
+   */
+  setDebug(enabled) {
+    this._debug = enabled;
+  }
+  /**
+   * Register an adapter factory with the registry.
+   * @param id - Unique adapter identifier
+   * @param factory - Factory function that creates the adapter
+   * @param defaultConfig - Optional default configuration
+   */
+  register(id, factory, defaultConfig) {
+    if (this._adapters.has(id)) {
+      this._log(`Overwriting existing adapter: ${id}`);
+    }
+    this._adapters.set(id, {
+      id,
+      factory,
+      defaultConfig
+    });
+    this._log(`Registered adapter: ${id}`);
+  }
+  /**
+   * Unregister an adapter from the registry.
+   * @param id - Adapter identifier to remove
+   */
+  unregister(id) {
+    const removed = this._adapters.delete(id);
+    if (removed) {
+      this._log(`Unregistered adapter: ${id}`);
+    }
+    return removed;
+  }
+  /**
+   * Check if an adapter is registered.
+   * @param id - Adapter identifier
+   */
+  has(id) {
+    return this._adapters.has(id);
+  }
+  /**
+   * Get all registered adapter IDs.
+   */
+  getRegisteredIds() {
+    return Array.from(this._adapters.keys());
+  }
+  /**
+   * Disable specific adapters (they won't be selected during auto-detection).
+   * @param ids - Adapter IDs to disable
+   */
+  disable(...ids) {
+    for (const id of ids) {
+      this._disabledAdapters.add(id);
+      this._log(`Disabled adapter: ${id}`);
+    }
+  }
+  /**
+   * Enable previously disabled adapters.
+   * @param ids - Adapter IDs to enable
+   */
+  enable(...ids) {
+    for (const id of ids) {
+      this._disabledAdapters.delete(id);
+      this._log(`Enabled adapter: ${id}`);
+    }
+  }
+  /**
+   * Check if an adapter is disabled.
+   * @param id - Adapter identifier
+   */
+  isDisabled(id) {
+    return this._disabledAdapters.has(id);
+  }
+  /**
+   * Set adapter-specific configuration.
+   * @param id - Adapter identifier
+   * @param config - Configuration to apply
+   */
+  configure(id, config) {
+    this._adapterConfigs.set(id, config);
+    this._log(`Configured adapter: ${id}`);
+  }
+  /**
+   * Get an adapter instance by ID.
+   * @param id - Adapter identifier
+   * @returns Adapter instance or undefined if not found/disabled
+   */
+  get(id) {
+    if (this._disabledAdapters.has(id)) {
+      this._log(`Adapter ${id} is disabled`);
+      return void 0;
+    }
+    const registration = this._adapters.get(id);
+    if (!registration) {
+      this._log(`Adapter ${id} not found`);
+      return void 0;
+    }
+    const config = this._mergeConfig(registration.defaultConfig, this._adapterConfigs.get(id));
+    if (config?.enabled === false) {
+      this._log(`Adapter ${id} is disabled via config`);
+      return void 0;
+    }
+    return registration.factory(config);
+  }
+  /**
+   * Auto-detect and return the best adapter for the current environment.
+   * Adapters are checked in priority order (highest first).
+   * @returns The first adapter that can handle the current environment, or undefined
+   */
+  detect() {
+    const candidates = this._getSortedCandidates();
+    for (const registration of candidates) {
+      if (this._disabledAdapters.has(registration.id)) {
+        this._log(`Skipping disabled adapter: ${registration.id}`);
+        continue;
+      }
+      const config = this._mergeConfig(registration.defaultConfig, this._adapterConfigs.get(registration.id));
+      if (config?.enabled === false) {
+        this._log(`Skipping adapter disabled via config: ${registration.id}`);
+        continue;
+      }
+      try {
+        const adapter = registration.factory(config);
+        if (adapter.canHandle()) {
+          this._log(`Detected adapter: ${registration.id} (priority: ${adapter.priority})`);
+          return adapter;
+        }
+        this._log(`Adapter ${registration.id} cannot handle current environment`);
+      } catch (error) {
+        this._log(`Error creating adapter ${registration.id}: ${error}`);
+      }
+    }
+    this._log("No suitable adapter detected");
+    return void 0;
+  }
+  /**
+   * Get all adapters that can handle the current environment.
+   * Useful for debugging or showing available options.
+   * @returns Array of compatible adapters sorted by priority (highest first)
+   */
+  detectAll() {
+    const candidates = this._getSortedCandidates();
+    const compatible = [];
+    for (const registration of candidates) {
+      if (this._disabledAdapters.has(registration.id)) {
+        continue;
+      }
+      const config = this._mergeConfig(registration.defaultConfig, this._adapterConfigs.get(registration.id));
+      if (config?.enabled === false) {
+        continue;
+      }
+      try {
+        const adapter = registration.factory(config);
+        if (adapter.canHandle()) {
+          compatible.push(adapter);
+        }
+      } catch {
+      }
+    }
+    return compatible;
+  }
+  /**
+   * Clear all registered adapters.
+   */
+  clear() {
+    this._adapters.clear();
+    this._disabledAdapters.clear();
+    this._adapterConfigs.clear();
+    this._log("Cleared all adapters");
+  }
+  /**
+   * Get sorted candidate adapters by priority (highest first).
+   */
+  _getSortedCandidates() {
+    const registrations = Array.from(this._adapters.values());
+    const withPriority = registrations.map((reg) => {
+      try {
+        const adapter = reg.factory(reg.defaultConfig);
+        return { registration: reg, priority: adapter.priority };
+      } catch {
+        return { registration: reg, priority: -1 };
+      }
+    });
+    withPriority.sort((a, b) => b.priority - a.priority);
+    return withPriority.map((item) => item.registration);
+  }
+  /**
+   * Merge default config with user config.
+   */
+  _mergeConfig(defaultConfig, userConfig) {
+    if (!defaultConfig && !userConfig) {
+      return void 0;
+    }
+    return {
+      ...defaultConfig,
+      ...userConfig,
+      options: {
+        ...defaultConfig?.options,
+        ...userConfig?.options
+      }
+    };
+  }
+  /**
+   * Log debug message if debugging is enabled.
+   */
+  _log(message) {
+    if (this._debug) {
+      console.log(`[AdapterRegistry] ${message}`);
+    }
+  }
+};
+var defaultRegistry = new AdapterRegistry();
+
+// libs/ui/src/bridge/core/bridge-factory.ts
+var DEFAULT_CONFIG = {
+  debug: false,
+  initTimeout: 5e3
+};
+var FrontMcpBridge = class {
+  _config;
+  _registry;
+  _adapter;
+  _initialized = false;
+  _initPromise;
+  /**
+   * Create a new FrontMcpBridge instance.
+   * @param config - Bridge configuration
+   * @param registry - Optional custom adapter registry (uses default if not provided)
+   */
+  constructor(config = {}, registry) {
+    this._config = { ...DEFAULT_CONFIG, ...config };
+    this._registry = registry || defaultRegistry;
+    if (this._config.debug) {
+      this._registry.setDebug(true);
+    }
+    if (this._config.disabledAdapters) {
+      this._registry.disable(...this._config.disabledAdapters);
+    }
+    if (this._config.adapterConfigs) {
+      for (const [id, adapterConfig] of Object.entries(this._config.adapterConfigs)) {
+        this._registry.configure(id, adapterConfig);
+      }
+    }
+  }
+  // ============================================
+  // Public Properties
+  // ============================================
+  /**
+   * Whether the bridge has been initialized.
+   */
+  get initialized() {
+    return this._initialized;
+  }
+  /**
+   * Current adapter ID, or undefined if not initialized.
+   */
+  get adapterId() {
+    return this._adapter?.id;
+  }
+  /**
+   * Current adapter capabilities, or undefined if not initialized.
+   */
+  get capabilities() {
+    return this._adapter?.capabilities;
+  }
+  // ============================================
+  // Lifecycle
+  // ============================================
+  /**
+   * Initialize the bridge.
+   * Auto-detects the best adapter for the current platform unless
+   * `forceAdapter` is specified in the config.
+   *
+   * @throws Error if no suitable adapter is found
+   */
+  async initialize() {
+    if (this._initPromise) {
+      return this._initPromise;
+    }
+    if (this._initialized) {
+      return;
+    }
+    this._initPromise = this._doInitialize();
+    try {
+      await this._initPromise;
+    } finally {
+      this._initPromise = void 0;
+    }
+  }
+  /**
+   * Internal initialization logic.
+   */
+  async _doInitialize() {
+    this._log("Initializing FrontMcpBridge...");
+    if (this._config.forceAdapter) {
+      this._adapter = this._registry.get(this._config.forceAdapter);
+      if (!this._adapter) {
+        throw new Error(`Forced adapter "${this._config.forceAdapter}" not found or disabled`);
+      }
+      this._log(`Using forced adapter: ${this._config.forceAdapter}`);
+    } else {
+      this._adapter = this._registry.detect();
+      if (!this._adapter) {
+        throw new Error("No suitable adapter detected for current environment");
+      }
+      this._log(`Auto-detected adapter: ${this._adapter.id}`);
+    }
+    try {
+      await this._withTimeout(this._adapter.initialize(), this._config.initTimeout || 5e3);
+      this._initialized = true;
+      this._log(`Bridge initialized with adapter: ${this._adapter.id}`);
+      this._emitEvent("bridge:ready", { adapter: this._adapter.id });
+    } catch (error) {
+      this._emitEvent("bridge:error", {
+        error: error instanceof Error ? error : new Error(String(error)),
+        adapter: this._adapter?.id
+      });
+      throw error;
+    }
+  }
+  /**
+   * Dispose the bridge and release resources.
+   */
+  dispose() {
+    if (this._adapter) {
+      this._adapter.dispose();
+      this._log(`Disposed adapter: ${this._adapter.id}`);
+    }
+    this._adapter = void 0;
+    this._initialized = false;
+  }
+  // ============================================
+  // Adapter Access
+  // ============================================
+  /**
+   * Get the active adapter instance.
+   */
+  getAdapter() {
+    return this._adapter;
+  }
+  /**
+   * Check if a specific capability is available.
+   * @param cap - Capability key to check
+   */
+  hasCapability(cap) {
+    return this._adapter?.capabilities[cap] === true;
+  }
+  // ============================================
+  // Data Access (delegate to adapter)
+  // ============================================
+  /**
+   * Get current theme.
+   */
+  getTheme() {
+    this._ensureInitialized();
+    return this._adapter.getTheme();
+  }
+  /**
+   * Get current display mode.
+   */
+  getDisplayMode() {
+    this._ensureInitialized();
+    return this._adapter.getDisplayMode();
+  }
+  /**
+   * Get tool input arguments.
+   */
+  getToolInput() {
+    this._ensureInitialized();
+    return this._adapter.getToolInput();
+  }
+  /**
+   * Get tool output/result.
+   */
+  getToolOutput() {
+    this._ensureInitialized();
+    return this._adapter.getToolOutput();
+  }
+  /**
+   * Get structured content (parsed output).
+   */
+  getStructuredContent() {
+    this._ensureInitialized();
+    return this._adapter.getStructuredContent();
+  }
+  /**
+   * Get persisted widget state.
+   */
+  getWidgetState() {
+    this._ensureInitialized();
+    return this._adapter.getWidgetState();
+  }
+  /**
+   * Get full host context.
+   */
+  getHostContext() {
+    this._ensureInitialized();
+    return this._adapter.getHostContext();
+  }
+  // ============================================
+  // Actions (delegate to adapter)
+  // ============================================
+  /**
+   * Call a tool on the MCP server.
+   * @param name - Tool name
+   * @param args - Tool arguments
+   */
+  async callTool(name, args) {
+    this._ensureInitialized();
+    if (!this.hasCapability("canCallTools")) {
+      throw new Error("Tool calls are not supported by the current adapter");
+    }
+    return this._adapter.callTool(name, args);
+  }
+  /**
+   * Send a follow-up message to the conversation.
+   * @param content - Message content
+   */
+  async sendMessage(content) {
+    this._ensureInitialized();
+    if (!this.hasCapability("canSendMessages")) {
+      throw new Error("Sending messages is not supported by the current adapter");
+    }
+    return this._adapter.sendMessage(content);
+  }
+  /**
+   * Open an external link.
+   * @param url - URL to open
+   */
+  async openLink(url) {
+    this._ensureInitialized();
+    return this._adapter.openLink(url);
+  }
+  /**
+   * Request a display mode change.
+   * @param mode - Desired display mode
+   */
+  async requestDisplayMode(mode) {
+    this._ensureInitialized();
+    return this._adapter.requestDisplayMode(mode);
+  }
+  /**
+   * Request widget close.
+   */
+  async requestClose() {
+    this._ensureInitialized();
+    return this._adapter.requestClose();
+  }
+  /**
+   * Set widget state (persisted across sessions).
+   * @param state - State object to persist
+   */
+  setWidgetState(state) {
+    this._ensureInitialized();
+    this._adapter.setWidgetState(state);
+  }
+  // ============================================
+  // Events (delegate to adapter)
+  // ============================================
+  /**
+   * Subscribe to host context changes.
+   * @param callback - Called when context changes
+   * @returns Unsubscribe function
+   */
+  onContextChange(callback) {
+    this._ensureInitialized();
+    return this._adapter.onContextChange(callback);
+  }
+  /**
+   * Subscribe to tool result updates.
+   * @param callback - Called when tool result is received
+   * @returns Unsubscribe function
+   */
+  onToolResult(callback) {
+    this._ensureInitialized();
+    return this._adapter.onToolResult(callback);
+  }
+  // ============================================
+  // Private Helpers
+  // ============================================
+  /**
+   * Ensure the bridge is initialized before operations.
+   */
+  _ensureInitialized() {
+    if (!this._initialized || !this._adapter) {
+      throw new Error("FrontMcpBridge is not initialized. Call initialize() first.");
+    }
+  }
+  /**
+   * Wrap a promise with a timeout.
+   */
+  _withTimeout(promise, ms) {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        reject(new Error(`Operation timed out after ${ms}ms`));
+      }, ms);
+      promise.then((result) => {
+        clearTimeout(timer);
+        resolve(result);
+      }).catch((error) => {
+        clearTimeout(timer);
+        reject(error);
+      });
+    });
+  }
+  /**
+   * Emit a bridge event via CustomEvent.
+   */
+  _emitEvent(type, payload) {
+    if (typeof window !== "undefined" && typeof CustomEvent !== "undefined") {
+      try {
+        const event = new CustomEvent(type, { detail: payload });
+        window.dispatchEvent(event);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Log debug message if debugging is enabled.
+   */
+  _log(message) {
+    if (this._config.debug) {
+      console.log(`[FrontMcpBridge] ${message}`);
+    }
+  }
+};
+
+// libs/ui/src/bridge/adapters/base-adapter.ts
+var DEFAULT_CAPABILITIES = {
+  canCallTools: false,
+  canSendMessages: false,
+  canOpenLinks: false,
+  canPersistState: true,
+  // localStorage fallback
+  hasNetworkAccess: true,
+  supportsDisplayModes: false,
+  supportsTheme: true
+};
+var DEFAULT_SAFE_AREA = {
+  top: 0,
+  bottom: 0,
+  left: 0,
+  right: 0
+};
+var BaseAdapter = class {
+  _capabilities = { ...DEFAULT_CAPABILITIES };
+  _hostContext;
+  _widgetState = {};
+  _toolInput = {};
+  _toolOutput = void 0;
+  _structuredContent = void 0;
+  _initialized = false;
+  _contextListeners = /* @__PURE__ */ new Set();
+  _toolResultListeners = /* @__PURE__ */ new Set();
+  constructor() {
+    this._hostContext = this._createDefaultHostContext();
+  }
+  get capabilities() {
+    return this._capabilities;
+  }
+  async initialize() {
+    if (this._initialized) return;
+    this._loadWidgetState();
+    this._readInjectedData();
+    this._initialized = true;
+  }
+  dispose() {
+    this._contextListeners.clear();
+    this._toolResultListeners.clear();
+    this._initialized = false;
+  }
+  // ============================================
+  // Data Access
+  // ============================================
+  getTheme() {
+    return this._hostContext.theme;
+  }
+  getDisplayMode() {
+    return this._hostContext.displayMode;
+  }
+  getUserAgent() {
+    return this._hostContext.userAgent;
+  }
+  getLocale() {
+    return this._hostContext.locale;
+  }
+  getToolInput() {
+    return this._toolInput;
+  }
+  getToolOutput() {
+    return this._toolOutput;
+  }
+  getStructuredContent() {
+    return this._structuredContent;
+  }
+  getWidgetState() {
+    return this._widgetState;
+  }
+  getSafeArea() {
+    return this._hostContext.safeArea;
+  }
+  getViewport() {
+    return this._hostContext.viewport;
+  }
+  getHostContext() {
+    return { ...this._hostContext };
+  }
+  // ============================================
+  // Actions (override in subclasses for real functionality)
+  // ============================================
+  async callTool(_name, _args) {
+    if (!this._capabilities.canCallTools) {
+      throw new Error(`Tool calls are not supported by ${this.name} adapter`);
+    }
+    throw new Error("callTool not implemented");
+  }
+  async sendMessage(_content) {
+    if (!this._capabilities.canSendMessages) {
+      throw new Error(`Sending messages is not supported by ${this.name} adapter`);
+    }
+    throw new Error("sendMessage not implemented");
+  }
+  async openLink(url) {
+    if (!this._capabilities.canOpenLinks) {
+      if (typeof window !== "undefined") {
+        window.open(url, "_blank", "noopener,noreferrer");
+        return;
+      }
+      throw new Error(`Opening links is not supported by ${this.name} adapter`);
+    }
+    throw new Error("openLink not implemented");
+  }
+  async requestDisplayMode(_mode) {
+    if (!this._capabilities.supportsDisplayModes) {
+      return;
+    }
+    throw new Error("requestDisplayMode not implemented");
+  }
+  async requestClose() {
+  }
+  setWidgetState(state) {
+    this._widgetState = { ...this._widgetState, ...state };
+    this._persistWidgetState();
+  }
+  // ============================================
+  // Events
+  // ============================================
+  onContextChange(callback) {
+    this._contextListeners.add(callback);
+    return () => {
+      this._contextListeners.delete(callback);
+    };
+  }
+  onToolResult(callback) {
+    this._toolResultListeners.add(callback);
+    return () => {
+      this._toolResultListeners.delete(callback);
+    };
+  }
+  // ============================================
+  // Protected Helpers
+  // ============================================
+  /**
+   * Create default host context from environment detection.
+   */
+  _createDefaultHostContext() {
+    return {
+      theme: this._detectTheme(),
+      displayMode: "inline",
+      locale: this._detectLocale(),
+      userAgent: this._detectUserAgent(),
+      safeArea: DEFAULT_SAFE_AREA,
+      viewport: this._detectViewport()
+    };
+  }
+  /**
+   * Detect theme from CSS media query.
+   */
+  _detectTheme() {
+    if (typeof window !== "undefined" && window.matchMedia) {
+      return window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+    }
+    return "light";
+  }
+  /**
+   * Detect locale from navigator.
+   */
+  _detectLocale() {
+    if (typeof navigator !== "undefined") {
+      return navigator.language || "en-US";
+    }
+    return "en-US";
+  }
+  /**
+   * Detect user agent capabilities.
+   */
+  _detectUserAgent() {
+    if (typeof navigator === "undefined") {
+      return { type: "web", hover: true, touch: false };
+    }
+    const ua = navigator.userAgent || "";
+    const isMobile = /iPhone|iPad|iPod|Android/i.test(ua);
+    const hasTouch = "ontouchstart" in window || navigator.maxTouchPoints > 0;
+    const hasHover = typeof window !== "undefined" && window.matchMedia && window.matchMedia("(hover: hover)").matches;
+    return {
+      type: isMobile ? "mobile" : "web",
+      hover: hasHover !== false,
+      touch: hasTouch
+    };
+  }
+  /**
+   * Detect viewport dimensions.
+   */
+  _detectViewport() {
+    if (typeof window !== "undefined") {
+      return {
+        width: window.innerWidth,
+        height: window.innerHeight
+      };
+    }
+    return void 0;
+  }
+  /**
+   * Read injected tool data from window globals.
+   */
+  _readInjectedData() {
+    if (typeof window === "undefined") return;
+    const win = window;
+    if (win.__mcpToolInput) {
+      this._toolInput = win.__mcpToolInput;
+    }
+    if (win.__mcpToolOutput) {
+      this._toolOutput = win.__mcpToolOutput;
+    }
+    if (win.__mcpStructuredContent) {
+      this._structuredContent = win.__mcpStructuredContent;
+    }
+    if (win.__mcpHostContext) {
+      this._hostContext = { ...this._hostContext, ...win.__mcpHostContext };
+    }
+  }
+  /**
+   * Load widget state from localStorage.
+   */
+  _loadWidgetState() {
+    if (typeof localStorage === "undefined") return;
+    try {
+      const key = this._getStateKey();
+      const stored = localStorage.getItem(key);
+      if (stored) {
+        this._widgetState = JSON.parse(stored);
+      }
+    } catch {
+    }
+  }
+  /**
+   * Persist widget state to localStorage.
+   */
+  _persistWidgetState() {
+    if (typeof localStorage === "undefined") return;
+    try {
+      const key = this._getStateKey();
+      localStorage.setItem(key, JSON.stringify(this._widgetState));
+    } catch {
+    }
+  }
+  /**
+   * Get localStorage key for widget state.
+   */
+  _getStateKey() {
+    if (typeof window !== "undefined") {
+      const toolName = window.__mcpToolName || "unknown";
+      return `frontmcp:widget:${toolName}`;
+    }
+    return "frontmcp:widget:unknown";
+  }
+  /**
+   * Notify context change listeners.
+   */
+  _notifyContextChange(changes) {
+    this._hostContext = { ...this._hostContext, ...changes };
+    this._contextListeners.forEach((cb) => {
+      try {
+        cb(changes);
+      } catch (e) {
+        console.error("[FrontMcpBridge] Context change listener error:", e);
+      }
+    });
+  }
+  /**
+   * Notify tool result listeners.
+   */
+  _notifyToolResult(result) {
+    this._toolOutput = result;
+    this._toolResultListeners.forEach((cb) => {
+      try {
+        cb(result);
+      } catch (e) {
+        console.error("[FrontMcpBridge] Tool result listener error:", e);
+      }
+    });
+  }
+};
+
+// libs/ui/src/bridge/adapters/openai.adapter.ts
+var OpenAIAdapter = class extends BaseAdapter {
+  id = "openai";
+  name = "OpenAI ChatGPT";
+  priority = 100;
+  // Highest priority
+  _openai;
+  _unsubscribeContext;
+  _unsubscribeToolResult;
+  constructor() {
+    super();
+    this._capabilities = {
+      ...DEFAULT_CAPABILITIES,
+      canCallTools: true,
+      canSendMessages: true,
+      canOpenLinks: true,
+      canPersistState: true,
+      hasNetworkAccess: true,
+      supportsDisplayModes: true,
+      supportsTheme: true
+    };
+  }
+  /**
+   * Check if OpenAI Apps SDK is available.
+   */
+  canHandle() {
+    if (typeof window === "undefined") return false;
+    const win = window;
+    return Boolean(win.openai?.canvas);
+  }
+  /**
+   * Initialize the OpenAI adapter.
+   */
+  async initialize() {
+    if (this._initialized) return;
+    this._openai = window.openai;
+    await super.initialize();
+    this._syncContextFromSDK();
+    if (this._openai?.canvas?.onContextChange) {
+      this._unsubscribeContext = this._openai.canvas.onContextChange((changes) => {
+        this._notifyContextChange(changes);
+      });
+    }
+    if (this._openai?.canvas?.onToolResult) {
+      this._unsubscribeToolResult = this._openai.canvas.onToolResult((result) => {
+        this._notifyToolResult(result);
+      });
+    }
+  }
+  /**
+   * Dispose adapter resources.
+   */
+  dispose() {
+    if (this._unsubscribeContext) {
+      this._unsubscribeContext();
+      this._unsubscribeContext = void 0;
+    }
+    if (this._unsubscribeToolResult) {
+      this._unsubscribeToolResult();
+      this._unsubscribeToolResult = void 0;
+    }
+    this._openai = void 0;
+    super.dispose();
+  }
+  // ============================================
+  // Data Access (override with SDK calls)
+  // ============================================
+  getTheme() {
+    if (this._openai?.canvas?.getTheme) {
+      const theme = this._openai.canvas.getTheme();
+      return theme === "dark" ? "dark" : "light";
+    }
+    return super.getTheme();
+  }
+  getDisplayMode() {
+    if (this._openai?.canvas?.getDisplayMode) {
+      const mode = this._openai.canvas.getDisplayMode();
+      if (mode === "fullscreen" || mode === "pip" || mode === "carousel") {
+        return mode;
+      }
+      return "inline";
+    }
+    return super.getDisplayMode();
+  }
+  // ============================================
+  // Actions (proxy to SDK)
+  // ============================================
+  async callTool(name, args) {
+    if (!this._openai?.canvas?.callServerTool) {
+      throw new Error("callServerTool not available in OpenAI SDK");
+    }
+    return this._openai.canvas.callServerTool(name, args);
+  }
+  async sendMessage(content) {
+    if (!this._openai?.canvas?.sendMessage) {
+      throw new Error("sendMessage not available in OpenAI SDK");
+    }
+    await this._openai.canvas.sendMessage(content);
+  }
+  async openLink(url) {
+    if (!this._openai?.canvas?.openLink) {
+      return super.openLink(url);
+    }
+    await this._openai.canvas.openLink(url);
+  }
+  async requestDisplayMode(mode) {
+    if (!this._openai?.canvas?.setDisplayMode) {
+      return super.requestDisplayMode(mode);
+    }
+    await this._openai.canvas.setDisplayMode(mode);
+    this._hostContext = { ...this._hostContext, displayMode: mode };
+  }
+  async requestClose() {
+    if (this._openai?.canvas?.close) {
+      await this._openai.canvas.close();
+    }
+  }
+  // ============================================
+  // Private Helpers
+  // ============================================
+  /**
+   * Sync context from OpenAI SDK.
+   */
+  _syncContextFromSDK() {
+    if (!this._openai?.canvas) return;
+    if (this._openai.canvas.getTheme) {
+      const theme = this._openai.canvas.getTheme();
+      this._hostContext.theme = theme === "dark" ? "dark" : "light";
+    }
+    if (this._openai.canvas.getDisplayMode) {
+      const mode = this._openai.canvas.getDisplayMode();
+      if (mode === "fullscreen" || mode === "pip" || mode === "carousel" || mode === "inline") {
+        this._hostContext.displayMode = mode;
+      }
+    }
+    if (this._openai.canvas.getContext) {
+      const ctx = this._openai.canvas.getContext();
+      if (ctx) {
+        this._hostContext = { ...this._hostContext, ...ctx };
+      }
+    }
+  }
+};
+function createOpenAIAdapter() {
+  return new OpenAIAdapter();
+}
+
+// libs/ui/src/bridge/adapters/ext-apps.adapter.ts
+var ExtAppsAdapter = class extends BaseAdapter {
+  id = "ext-apps";
+  name = "ext-apps (SEP-1865)";
+  priority = 80;
+  // High priority, but below OpenAI native
+  _config;
+  _messageListener;
+  _pendingRequests = /* @__PURE__ */ new Map();
+  _requestId = 0;
+  _trustedOrigin;
+  _hostCapabilities = {};
+  constructor(config) {
+    super();
+    this._config = config || {};
+    this._capabilities = {
+      ...DEFAULT_CAPABILITIES,
+      canPersistState: true,
+      hasNetworkAccess: true,
+      // ext-apps usually allows network
+      supportsTheme: true
+    };
+  }
+  /**
+   * Check if we're in an iframe (potential ext-apps context).
+   */
+  canHandle() {
+    if (typeof window === "undefined") return false;
+    const inIframe = window.parent !== window;
+    if (!inIframe) return false;
+    const win = window;
+    if (win.openai?.canvas) return false;
+    if (win.__mcpPlatform === "ext-apps") return true;
+    return true;
+  }
+  /**
+   * Initialize the ext-apps adapter with protocol handshake.
+   */
+  async initialize() {
+    if (this._initialized) return;
+    this._setupMessageListener();
+    await super.initialize();
+    await this._performHandshake();
+    this._initialized = true;
+  }
+  /**
+   * Dispose adapter resources.
+   */
+  dispose() {
+    if (this._messageListener && typeof window !== "undefined") {
+      window.removeEventListener("message", this._messageListener);
+      this._messageListener = void 0;
+    }
+    for (const [id, pending] of this._pendingRequests) {
+      clearTimeout(pending.timeout);
+      pending.reject(new Error("Adapter disposed"));
+    }
+    this._pendingRequests.clear();
+    super.dispose();
+  }
+  // ============================================
+  // Actions (via JSON-RPC)
+  // ============================================
+  async callTool(name, args) {
+    if (!this._hostCapabilities.serverToolProxy) {
+      throw new Error("Server tool proxy not supported by host");
+    }
+    return this._sendRequest("ui/callServerTool", {
+      name,
+      arguments: args
+    });
+  }
+  async sendMessage(content) {
+    await this._sendRequest("ui/message", { content });
+  }
+  async openLink(url) {
+    if (!this._hostCapabilities.openLink) {
+      return super.openLink(url);
+    }
+    await this._sendRequest("ui/openLink", { url });
+  }
+  async requestDisplayMode(mode) {
+    await this._sendRequest("ui/setDisplayMode", { mode });
+    this._hostContext = { ...this._hostContext, displayMode: mode };
+  }
+  async requestClose() {
+    await this._sendRequest("ui/close", {});
+  }
+  // ============================================
+  // Private: Message Handling
+  // ============================================
+  /**
+   * Setup postMessage listener for incoming messages.
+   */
+  _setupMessageListener() {
+    if (typeof window === "undefined") return;
+    this._messageListener = (event) => {
+      this._handleMessage(event);
+    };
+    window.addEventListener("message", this._messageListener);
+  }
+  /**
+   * Handle incoming postMessage events.
+   */
+  _handleMessage(event) {
+    if (!this._isOriginTrusted(event.origin)) {
+      return;
+    }
+    const data = event.data;
+    if (!data || typeof data !== "object") return;
+    if (data.jsonrpc !== "2.0") return;
+    if ("id" in data && (data.result !== void 0 || data.error !== void 0)) {
+      this._handleResponse(data);
+      return;
+    }
+    if ("method" in data && !("id" in data)) {
+      this._handleNotification(data);
+      return;
+    }
+  }
+  /**
+   * Handle JSON-RPC response.
+   */
+  _handleResponse(response) {
+    const pending = this._pendingRequests.get(response.id);
+    if (!pending) return;
+    clearTimeout(pending.timeout);
+    this._pendingRequests.delete(response.id);
+    if (response.error) {
+      pending.reject(new Error(`${response.error.message} (code: ${response.error.code})`));
+    } else {
+      pending.resolve(response.result);
+    }
+  }
+  /**
+   * Handle JSON-RPC notification from host.
+   */
+  _handleNotification(notification) {
+    switch (notification.method) {
+      case "ui/notifications/tool-input":
+        this._handleToolInput(notification.params);
+        break;
+      case "ui/notifications/tool-input-partial":
+        this._handleToolInputPartial(notification.params);
+        break;
+      case "ui/notifications/tool-result":
+        this._handleToolResult(notification.params);
+        break;
+      case "ui/notifications/host-context-changed":
+        this._handleHostContextChange(notification.params);
+        break;
+      case "ui/notifications/initialized":
+        break;
+      case "ui/notifications/cancelled":
+        this._handleCancelled(notification.params);
+        break;
+    }
+  }
+  /**
+   * Handle tool input notification.
+   */
+  _handleToolInput(params) {
+    this._toolInput = params.arguments || {};
+    this._emitBridgeEvent("tool:input", { arguments: this._toolInput });
+  }
+  /**
+   * Handle partial tool input (streaming).
+   */
+  _handleToolInputPartial(params) {
+    this._toolInput = { ...this._toolInput, ...params.arguments };
+    this._emitBridgeEvent("tool:input-partial", { arguments: this._toolInput });
+  }
+  /**
+   * Handle tool result notification.
+   */
+  _handleToolResult(params) {
+    this._toolOutput = params.content;
+    this._structuredContent = params.structuredContent;
+    this._notifyToolResult(params.content);
+    this._emitBridgeEvent("tool:result", {
+      content: params.content,
+      structuredContent: params.structuredContent
+    });
+  }
+  /**
+   * Handle host context change notification.
+   */
+  _handleHostContextChange(params) {
+    const changes = {};
+    if (params.theme !== void 0) {
+      changes.theme = params.theme;
+    }
+    if (params.displayMode !== void 0) {
+      changes.displayMode = params.displayMode;
+    }
+    if (params.viewport !== void 0) {
+      changes.viewport = params.viewport;
+    }
+    if (params.locale !== void 0) {
+      changes.locale = params.locale;
+    }
+    if (params.timezone !== void 0) {
+      changes.timezone = params.timezone;
+    }
+    this._notifyContextChange(changes);
+  }
+  /**
+   * Handle cancellation notification.
+   */
+  _handleCancelled(params) {
+    const reason = params?.reason;
+    this._emitBridgeEvent("tool:cancelled", { reason });
+  }
+  // ============================================
+  // Private: JSON-RPC Transport
+  // ============================================
+  /**
+   * Send a JSON-RPC request to the host.
+   */
+  _sendRequest(method, params) {
+    return new Promise((resolve, reject) => {
+      const id = ++this._requestId;
+      const timeout = this._config.options?.initTimeout || 1e4;
+      const request = {
+        jsonrpc: "2.0",
+        id,
+        method,
+        params
+      };
+      const timeoutHandle = setTimeout(() => {
+        this._pendingRequests.delete(id);
+        reject(new Error(`Request ${method} timed out after ${timeout}ms`));
+      }, timeout);
+      this._pendingRequests.set(id, {
+        resolve,
+        reject,
+        timeout: timeoutHandle
+      });
+      this._postMessage(request);
+    });
+  }
+  /**
+   * Send a JSON-RPC notification (no response expected).
+   */
+  _sendNotification(method, params) {
+    const notification = {
+      jsonrpc: "2.0",
+      method,
+      params
+    };
+    this._postMessage(notification);
+  }
+  /**
+   * Post a message to the parent window.
+   */
+  _postMessage(message) {
+    if (typeof window === "undefined") return;
+    const targetOrigin = this._trustedOrigin || "*";
+    window.parent.postMessage(message, targetOrigin);
+  }
+  // ============================================
+  // Private: Handshake
+  // ============================================
+  /**
+   * Perform the ui/initialize handshake with the host.
+   */
+  async _performHandshake() {
+    const params = {
+      appInfo: {
+        name: this._config.options?.appName || "FrontMCP Widget",
+        version: this._config.options?.appVersion || "1.0.0"
+      },
+      appCapabilities: {
+        tools: {
+          listChanged: false
+        }
+      },
+      protocolVersion: this._config.options?.protocolVersion || "2024-11-05"
+    };
+    try {
+      const result = await this._sendRequest("ui/initialize", params);
+      this._hostCapabilities = result.hostCapabilities || {};
+      this._capabilities = {
+        ...this._capabilities,
+        canCallTools: Boolean(this._hostCapabilities.serverToolProxy),
+        canSendMessages: true,
+        canOpenLinks: Boolean(this._hostCapabilities.openLink),
+        supportsDisplayModes: true
+      };
+      if (result.hostContext) {
+        this._hostContext = {
+          ...this._hostContext,
+          ...result.hostContext
+        };
+      }
+      if (!this._config.options?.trustedOrigins?.length) {
+      }
+    } catch (error) {
+      throw new Error(`ext-apps handshake failed: ${error}`);
+    }
+  }
+  // ============================================
+  // Private: Origin Security
+  // ============================================
+  /**
+   * Check if an origin is trusted.
+   * Uses trust-on-first-use if no explicit origins configured.
+   */
+  _isOriginTrusted(origin) {
+    const trustedOrigins = this._config.options?.trustedOrigins;
+    if (trustedOrigins && trustedOrigins.length > 0) {
+      return trustedOrigins.includes(origin);
+    }
+    if (!this._trustedOrigin) {
+      this._trustedOrigin = origin;
+      return true;
+    }
+    return this._trustedOrigin === origin;
+  }
+  // ============================================
+  // Private: Events
+  // ============================================
+  /**
+   * Emit a bridge event via CustomEvent.
+   */
+  _emitBridgeEvent(type, detail) {
+    if (typeof window !== "undefined" && typeof CustomEvent !== "undefined") {
+      try {
+        const event = new CustomEvent(type, { detail });
+        window.dispatchEvent(event);
+      } catch {
+      }
+    }
+  }
+};
+function createExtAppsAdapter(config) {
+  return new ExtAppsAdapter(config);
+}
+
+// libs/ui/src/bridge/adapters/claude.adapter.ts
+var ClaudeAdapter = class extends BaseAdapter {
+  id = "claude";
+  name = "Claude (Anthropic)";
+  priority = 60;
+  constructor() {
+    super();
+    this._capabilities = {
+      ...DEFAULT_CAPABILITIES,
+      canCallTools: false,
+      // Claude artifacts can't call tools
+      canSendMessages: false,
+      // Can't send messages back to conversation
+      canOpenLinks: true,
+      // Can open links via window.open
+      canPersistState: true,
+      // localStorage works
+      hasNetworkAccess: false,
+      // Network is blocked
+      supportsDisplayModes: false,
+      // No display mode control
+      supportsTheme: true
+      // Can detect system theme
+    };
+  }
+  /**
+   * Check if we're running in a Claude artifact/widget context.
+   */
+  canHandle() {
+    if (typeof window === "undefined") return false;
+    const win = window;
+    if (win.__mcpPlatform === "claude") return true;
+    if (win.claude) return true;
+    if (win.__claudeArtifact) return true;
+    if (typeof location !== "undefined") {
+      const href = location.href;
+      if (href.includes("claude.ai") || href.includes("anthropic.com")) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Initialize the Claude adapter.
+   */
+  async initialize() {
+    if (this._initialized) return;
+    await super.initialize();
+    this._setupThemeListener();
+  }
+  /**
+   * Open a link in a new tab.
+   * This is one of the few actions available in Claude artifacts.
+   */
+  async openLink(url) {
+    if (typeof window !== "undefined") {
+      window.open(url, "_blank", "noopener,noreferrer");
+    }
+  }
+  /**
+   * Request display mode change (no-op for Claude).
+   */
+  async requestDisplayMode(_mode) {
+  }
+  /**
+   * Request close (no-op for Claude).
+   */
+  async requestClose() {
+  }
+  // ============================================
+  // Private Helpers
+  // ============================================
+  /**
+   * Setup listener for system theme changes.
+   */
+  _setupThemeListener() {
+    if (typeof window === "undefined" || !window.matchMedia) return;
+    const mediaQuery = window.matchMedia("(prefers-color-scheme: dark)");
+    const handleChange = (e) => {
+      const newTheme = e.matches ? "dark" : "light";
+      if (newTheme !== this._hostContext.theme) {
+        this._notifyContextChange({ theme: newTheme });
+      }
+    };
+    if (mediaQuery.addEventListener) {
+      mediaQuery.addEventListener("change", handleChange);
+    } else if (mediaQuery.addListener) {
+      mediaQuery.addListener(handleChange);
+    }
+  }
+};
+function createClaudeAdapter() {
+  return new ClaudeAdapter();
+}
+
+// libs/ui/src/bridge/adapters/gemini.adapter.ts
+var GeminiAdapter = class extends BaseAdapter {
+  id = "gemini";
+  name = "Google Gemini";
+  priority = 40;
+  _gemini;
+  constructor() {
+    super();
+    this._capabilities = {
+      ...DEFAULT_CAPABILITIES,
+      canCallTools: false,
+      // May be enabled if SDK supports it
+      canSendMessages: false,
+      // May be enabled if SDK supports it
+      canOpenLinks: true,
+      canPersistState: true,
+      hasNetworkAccess: true,
+      supportsDisplayModes: false,
+      supportsTheme: true
+    };
+  }
+  /**
+   * Check if we're running in a Gemini context.
+   */
+  canHandle() {
+    if (typeof window === "undefined") return false;
+    const win = window;
+    if (win.__mcpPlatform === "gemini") return true;
+    if (win.gemini) return true;
+    if (typeof location !== "undefined") {
+      const href = location.href;
+      if (href.includes("gemini.google.com") || href.includes("bard.google.com")) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Initialize the Gemini adapter.
+   */
+  async initialize() {
+    if (this._initialized) return;
+    const win = window;
+    this._gemini = win.gemini;
+    if (this._gemini?.ui) {
+      if (this._gemini.ui.sendMessage) {
+        this._capabilities = { ...this._capabilities, canSendMessages: true };
+      }
+    }
+    await super.initialize();
+    this._setupThemeListener();
+  }
+  /**
+   * Get current theme.
+   */
+  getTheme() {
+    if (this._gemini?.ui?.getTheme) {
+      const theme = this._gemini.ui.getTheme();
+      return theme === "dark" ? "dark" : "light";
+    }
+    return super.getTheme();
+  }
+  /**
+   * Send a message (if supported by SDK).
+   */
+  async sendMessage(content) {
+    if (this._gemini?.ui?.sendMessage) {
+      await this._gemini.ui.sendMessage(content);
+      return;
+    }
+    throw new Error("Sending messages is not supported by Gemini adapter");
+  }
+  /**
+   * Open a link.
+   */
+  async openLink(url) {
+    if (this._gemini?.ui?.openLink) {
+      await this._gemini.ui.openLink(url);
+      return;
+    }
+    return super.openLink(url);
+  }
+  // ============================================
+  // Private Helpers
+  // ============================================
+  /**
+   * Setup listener for system theme changes.
+   */
+  _setupThemeListener() {
+    if (typeof window === "undefined" || !window.matchMedia) return;
+    const mediaQuery = window.matchMedia("(prefers-color-scheme: dark)");
+    const handleChange = (e) => {
+      if (!this._gemini?.ui?.getTheme) {
+        const newTheme = e.matches ? "dark" : "light";
+        if (newTheme !== this._hostContext.theme) {
+          this._notifyContextChange({ theme: newTheme });
+        }
+      }
+    };
+    if (mediaQuery.addEventListener) {
+      mediaQuery.addEventListener("change", handleChange);
+    } else if (mediaQuery.addListener) {
+      mediaQuery.addListener(handleChange);
+    }
+  }
+};
+function createGeminiAdapter() {
+  return new GeminiAdapter();
+}
+
+// libs/ui/src/bridge/adapters/generic.adapter.ts
+var GenericAdapter = class extends BaseAdapter {
+  id = "generic";
+  name = "Generic Web";
+  priority = 0;
+  // Lowest priority - fallback only
+  constructor() {
+    super();
+    this._capabilities = {
+      ...DEFAULT_CAPABILITIES,
+      canCallTools: false,
+      canSendMessages: false,
+      canOpenLinks: true,
+      // window.open works
+      canPersistState: true,
+      // localStorage works
+      hasNetworkAccess: true,
+      // Assume network available
+      supportsDisplayModes: false,
+      supportsTheme: true
+      // System theme detection
+    };
+  }
+  /**
+   * Generic adapter can always handle the environment.
+   * It serves as the fallback when no other adapter matches.
+   */
+  canHandle() {
+    return typeof window !== "undefined";
+  }
+  /**
+   * Initialize the generic adapter.
+   */
+  async initialize() {
+    if (this._initialized) return;
+    await super.initialize();
+    this._setupThemeListener();
+  }
+  /**
+   * Open a link using window.open.
+   */
+  async openLink(url) {
+    if (typeof window !== "undefined") {
+      window.open(url, "_blank", "noopener,noreferrer");
+    }
+  }
+  // ============================================
+  // Private Helpers
+  // ============================================
+  /**
+   * Setup listener for system theme changes.
+   */
+  _setupThemeListener() {
+    if (typeof window === "undefined" || !window.matchMedia) return;
+    const mediaQuery = window.matchMedia("(prefers-color-scheme: dark)");
+    const handleChange = (e) => {
+      const newTheme = e.matches ? "dark" : "light";
+      if (newTheme !== this._hostContext.theme) {
+        this._notifyContextChange({ theme: newTheme });
+      }
+    };
+    if (mediaQuery.addEventListener) {
+      mediaQuery.addEventListener("change", handleChange);
+    } else if (mediaQuery.addListener) {
+      mediaQuery.addListener(handleChange);
+    }
+  }
+};
+function createGenericAdapter() {
+  return new GenericAdapter();
+}
+
+// libs/ui/src/bridge/adapters/index.ts
+function registerBuiltInAdapters() {
+  defaultRegistry.register("openai", createOpenAIAdapter);
+  defaultRegistry.register("ext-apps", createExtAppsAdapter);
+  defaultRegistry.register("claude", createClaudeAdapter);
+  defaultRegistry.register("gemini", createGeminiAdapter);
+  defaultRegistry.register("generic", createGenericAdapter);
+}
+registerBuiltInAdapters();
+
+// libs/ui/src/bridge/runtime/iife-generator.ts
+function generateBridgeIIFE(options = {}) {
+  const { debug = false, trustedOrigins = [], minify = false } = options;
+  const adapters = options.adapters || ["openai", "ext-apps", "claude", "gemini", "generic"];
+  const parts = [];
+  parts.push("(function() {");
+  parts.push('"use strict";');
+  parts.push("");
+  if (debug) {
+    parts.push('function log(msg) { console.log("[FrontMcpBridge] " + msg); }');
+  } else {
+    parts.push("function log() {}");
+  }
+  parts.push("");
+  parts.push("var DEFAULT_SAFE_AREA = { top: 0, bottom: 0, left: 0, right: 0 };");
+  parts.push("");
+  parts.push(generateContextDetection());
+  parts.push("");
+  parts.push(generateBaseCapabilities());
+  parts.push("");
+  if (adapters.includes("openai")) {
+    parts.push(generateOpenAIAdapter());
+    parts.push("");
+  }
+  if (adapters.includes("ext-apps")) {
+    parts.push(generateExtAppsAdapter(trustedOrigins));
+    parts.push("");
+  }
+  if (adapters.includes("claude")) {
+    parts.push(generateClaudeAdapter());
+    parts.push("");
+  }
+  if (adapters.includes("gemini")) {
+    parts.push(generateGeminiAdapter());
+    parts.push("");
+  }
+  if (adapters.includes("generic")) {
+    parts.push(generateGenericAdapter());
+    parts.push("");
+  }
+  parts.push(generatePlatformDetection(adapters));
+  parts.push("");
+  parts.push(generateBridgeClass());
+  parts.push("");
+  parts.push("var bridge = new FrontMcpBridge();");
+  parts.push("bridge.initialize().then(function() {");
+  parts.push('  log("Bridge initialized with adapter: " + bridge.adapterId);');
+  parts.push('  window.dispatchEvent(new CustomEvent("bridge:ready", { detail: { adapter: bridge.adapterId } }));');
+  parts.push("}).catch(function(err) {");
+  parts.push('  console.error("[FrontMcpBridge] Init failed:", err);');
+  parts.push('  window.dispatchEvent(new CustomEvent("bridge:error", { detail: { error: err } }));');
+  parts.push("});");
+  parts.push("");
+  parts.push("window.FrontMcpBridge = bridge;");
+  parts.push("})();");
+  const code = parts.join("\n");
+  if (minify) {
+    return minifyJS(code);
+  }
+  return code;
+}
+function generateContextDetection() {
+  return `
+function detectTheme() {
+  if (typeof window !== 'undefined' && window.matchMedia) {
+    return window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light';
+  }
+  return 'light';
+}
+
+function detectLocale() {
+  if (typeof navigator !== 'undefined') {
+    return navigator.language || 'en-US';
+  }
+  return 'en-US';
+}
+
+function detectUserAgent() {
+  if (typeof navigator === 'undefined') {
+    return { type: 'web', hover: true, touch: false };
+  }
+  var ua = navigator.userAgent || '';
+  var isMobile = /iPhone|iPad|iPod|Android/i.test(ua);
+  var hasTouch = 'ontouchstart' in window || navigator.maxTouchPoints > 0;
+  var hasHover = window.matchMedia && window.matchMedia('(hover: hover)').matches;
+  return { type: isMobile ? 'mobile' : 'web', hover: hasHover !== false, touch: hasTouch };
+}
+
+function detectViewport() {
+  if (typeof window !== 'undefined') {
+    return { width: window.innerWidth, height: window.innerHeight };
+  }
+  return undefined;
+}
+
+function readInjectedData() {
+  var data = { toolInput: {}, toolOutput: undefined, structuredContent: undefined };
+  if (typeof window !== 'undefined') {
+    if (window.__mcpToolInput) data.toolInput = window.__mcpToolInput;
+    if (window.__mcpToolOutput) data.toolOutput = window.__mcpToolOutput;
+    if (window.__mcpStructuredContent) data.structuredContent = window.__mcpStructuredContent;
+  }
+  return data;
+}
+`.trim();
+}
+function generateBaseCapabilities() {
+  return `
+var DEFAULT_CAPABILITIES = {
+  canCallTools: false,
+  canSendMessages: false,
+  canOpenLinks: false,
+  canPersistState: true,
+  hasNetworkAccess: true,
+  supportsDisplayModes: false,
+  supportsTheme: true
+};
+`.trim();
+}
+function generateOpenAIAdapter() {
+  return `
+var OpenAIAdapter = {
+  id: 'openai',
+  name: 'OpenAI ChatGPT',
+  priority: 100,
+  capabilities: Object.assign({}, DEFAULT_CAPABILITIES, {
+    canCallTools: true,
+    canSendMessages: true,
+    canOpenLinks: true,
+    supportsDisplayModes: true
+  }),
+  canHandle: function() {
+    if (typeof window === 'undefined') return false;
+    // Check for window.openai.callTool (the actual OpenAI SDK API)
+    if (window.openai && typeof window.openai.callTool === 'function') return true;
+    // Also check if we're being injected with tool metadata (OpenAI injects toolOutput)
+    if (window.openai && (window.openai.toolOutput !== undefined || window.openai.toolInput !== undefined)) return true;
+    return false;
+  },
+  initialize: function(context) {
+    var sdk = window.openai;
+    context.sdk = sdk;
+    // OpenAI SDK exposes theme and displayMode directly as properties
+    if (sdk.theme) {
+      context.hostContext.theme = sdk.theme;
+    }
+    if (sdk.displayMode) {
+      context.hostContext.displayMode = sdk.displayMode;
+    }
+    // Note: OpenAI SDK does not have an onContextChange equivalent
+    return Promise.resolve();
+  },
+  callTool: function(context, name, args) {
+    return context.sdk.callTool(name, args);
+  },
+  sendMessage: function(context, content) {
+    if (typeof context.sdk.sendFollowUpMessage === 'function') {
+      return context.sdk.sendFollowUpMessage(content);
+    }
+    return Promise.reject(new Error('Messages not supported'));
+  },
+  openLink: function(context, url) {
+    window.open(url, '_blank', 'noopener,noreferrer');
+    return Promise.resolve();
+  },
+  requestDisplayMode: function(context, mode) {
+    return Promise.resolve();
+  },
+  requestClose: function(context) {
+    return Promise.resolve();
+  }
+};
+`.trim();
+}
+function generateExtAppsAdapter(trustedOrigins) {
+  const originsArray = trustedOrigins.length > 0 ? JSON.stringify(trustedOrigins) : "[]";
+  return `
+var ExtAppsAdapter = {
+  id: 'ext-apps',
+  name: 'ext-apps (SEP-1865)',
+  priority: 80,
+  capabilities: Object.assign({}, DEFAULT_CAPABILITIES, { canPersistState: true, hasNetworkAccess: true }),
+  trustedOrigins: ${originsArray},
+  trustedOrigin: null,
+  pendingRequests: {},
+  requestId: 0,
+  hostCapabilities: {},
+  canHandle: function() {
+    if (typeof window === 'undefined') return false;
+    if (window.parent === window) return false;
+    // Check for OpenAI SDK (window.openai.callTool) - defer to OpenAIAdapter
+    if (window.openai && typeof window.openai.callTool === 'function') return false;
+    if (window.__mcpPlatform === 'ext-apps') return true;
+    return true;
+  },
+  initialize: function(context) {
+    var self = this;
+    context.extApps = this;
+
+    window.addEventListener('message', function(event) {
+      self.handleMessage(context, event);
+    });
+
+    return self.performHandshake(context);
+  },
+  handleMessage: function(context, event) {
+    if (!this.isOriginTrusted(event.origin)) return;
+    var data = event.data;
+    if (!data || typeof data !== 'object' || data.jsonrpc !== '2.0') return;
+
+    if ('id' in data && (data.result !== undefined || data.error !== undefined)) {
+      var pending = this.pendingRequests[data.id];
+      if (pending) {
+        clearTimeout(pending.timeout);
+        delete this.pendingRequests[data.id];
+        if (data.error) {
+          pending.reject(new Error(data.error.message + ' (code: ' + data.error.code + ')'));
+        } else {
+          pending.resolve(data.result);
+        }
+      }
+      return;
+    }
+
+    if ('method' in data && !('id' in data)) {
+      this.handleNotification(context, data);
+    }
+  },
+  handleNotification: function(context, notification) {
+    var params = notification.params || {};
+    switch (notification.method) {
+      case 'ui/notifications/tool-input':
+        context.toolInput = params.arguments || {};
+        window.dispatchEvent(new CustomEvent('tool:input', { detail: { arguments: context.toolInput } }));
+        break;
+      case 'ui/notifications/tool-result':
+        context.toolOutput = params.content;
+        context.structuredContent = params.structuredContent;
+        context.notifyToolResult(params.content);
+        window.dispatchEvent(new CustomEvent('tool:result', { detail: params }));
+        break;
+      case 'ui/notifications/host-context-changed':
+        Object.assign(context.hostContext, params);
+        context.notifyContextChange(params);
+        break;
+    }
+  },
+  isOriginTrusted: function(origin) {
+    if (this.trustedOrigins.length > 0) {
+      return this.trustedOrigins.indexOf(origin) !== -1;
+    }
+    // When no trusted origins configured, only trust first message in iframe context
+    // This helps mitigate race conditions where a malicious iframe could establish trust
+    if (!this.trustedOrigin) {
+      if (window.parent !== window && origin) {
+        this.trustedOrigin = origin;
+        return true;
+      }
+      return false;
+    }
+    return this.trustedOrigin === origin;
+  },
+  sendRequest: function(method, params) {
+    var self = this;
+    return new Promise(function(resolve, reject) {
+      // Security: Require trusted origin before sending requests to prevent message leaks
+      if (!self.trustedOrigin && self.trustedOrigins.length === 0) {
+        reject(new Error('Cannot send request: no trusted origin established'));
+        return;
+      }
+
+      var id = ++self.requestId;
+      var timeout = setTimeout(function() {
+        delete self.pendingRequests[id];
+        reject(new Error('Request ' + method + ' timed out'));
+      }, 10000);
+
+      self.pendingRequests[id] = { resolve: resolve, reject: reject, timeout: timeout };
+
+      var targetOrigin = self.trustedOrigin || self.trustedOrigins[0];
+      window.parent.postMessage({ jsonrpc: '2.0', id: id, method: method, params: params }, targetOrigin);
+    });
+  },
+  performHandshake: function(context) {
+    var self = this;
+    var params = {
+      appInfo: { name: 'FrontMCP Widget', version: '1.0.0' },
+      appCapabilities: { tools: { listChanged: false } },
+      protocolVersion: '2024-11-05'
+    };
+
+    return this.sendRequest('ui/initialize', params).then(function(result) {
+      self.hostCapabilities = result.hostCapabilities || {};
+      self.capabilities = Object.assign({}, self.capabilities, {
+        canCallTools: Boolean(self.hostCapabilities.serverToolProxy),
+        canSendMessages: true,
+        canOpenLinks: Boolean(self.hostCapabilities.openLink),
+        supportsDisplayModes: true
+      });
+      if (result.hostContext) {
+        Object.assign(context.hostContext, result.hostContext);
+      }
+    });
+  },
+  callTool: function(context, name, args) {
+    if (!this.hostCapabilities.serverToolProxy) {
+      return Promise.reject(new Error('Server tool proxy not supported'));
+    }
+    return this.sendRequest('ui/callServerTool', { name: name, arguments: args });
+  },
+  sendMessage: function(context, content) {
+    return this.sendRequest('ui/message', { content: content });
+  },
+  openLink: function(context, url) {
+    if (!this.hostCapabilities.openLink) {
+      window.open(url, '_blank', 'noopener,noreferrer');
+      return Promise.resolve();
+    }
+    return this.sendRequest('ui/openLink', { url: url });
+  },
+  requestDisplayMode: function(context, mode) {
+    return this.sendRequest('ui/setDisplayMode', { mode: mode });
+  },
+  requestClose: function(context) {
+    return this.sendRequest('ui/close', {});
+  }
+};
+`.trim();
+}
+function generateClaudeAdapter() {
+  return `
+var ClaudeAdapter = {
+  id: 'claude',
+  name: 'Claude (Anthropic)',
+  priority: 60,
+  capabilities: Object.assign({}, DEFAULT_CAPABILITIES, {
+    canCallTools: false,
+    canSendMessages: false,
+    canOpenLinks: true,
+    hasNetworkAccess: false,
+    supportsDisplayModes: false
+  }),
+  canHandle: function() {
+    if (typeof window === 'undefined') return false;
+    if (window.__mcpPlatform === 'claude') return true;
+    if (window.claude) return true;
+    if (window.__claudeArtifact) return true;
+    if (typeof location !== 'undefined') {
+      var href = location.href;
+      if (href.indexOf('claude.ai') !== -1 || href.indexOf('anthropic.com') !== -1) return true;
+    }
+    return false;
+  },
+  initialize: function(context) {
+    return Promise.resolve();
+  },
+  callTool: function() {
+    return Promise.reject(new Error('Tool calls not supported in Claude'));
+  },
+  sendMessage: function() {
+    return Promise.reject(new Error('Messages not supported in Claude'));
+  },
+  openLink: function(context, url) {
+    window.open(url, '_blank', 'noopener,noreferrer');
+    return Promise.resolve();
+  },
+  requestDisplayMode: function() {
+    return Promise.resolve();
+  },
+  requestClose: function() {
+    return Promise.resolve();
+  }
+};
+`.trim();
+}
+function generateGeminiAdapter() {
+  return `
+var GeminiAdapter = {
+  id: 'gemini',
+  name: 'Google Gemini',
+  priority: 40,
+  capabilities: Object.assign({}, DEFAULT_CAPABILITIES, {
+    canOpenLinks: true,
+    hasNetworkAccess: true
+  }),
+  canHandle: function() {
+    if (typeof window === 'undefined') return false;
+    if (window.__mcpPlatform === 'gemini') return true;
+    if (window.gemini) return true;
+    if (typeof location !== 'undefined') {
+      var href = location.href;
+      if (href.indexOf('gemini.google.com') !== -1 || href.indexOf('bard.google.com') !== -1) return true;
+    }
+    return false;
+  },
+  initialize: function(context) {
+    if (window.gemini && window.gemini.ui && window.gemini.ui.getTheme) {
+      context.hostContext.theme = window.gemini.ui.getTheme() === 'dark' ? 'dark' : 'light';
+    }
+    return Promise.resolve();
+  },
+  callTool: function() {
+    return Promise.reject(new Error('Tool calls not supported in Gemini'));
+  },
+  sendMessage: function(context, content) {
+    if (window.gemini && window.gemini.ui && window.gemini.ui.sendMessage) {
+      return window.gemini.ui.sendMessage(content);
+    }
+    return Promise.reject(new Error('Messages not supported in Gemini'));
+  },
+  openLink: function(context, url) {
+    if (window.gemini && window.gemini.ui && window.gemini.ui.openLink) {
+      return window.gemini.ui.openLink(url);
+    }
+    window.open(url, '_blank', 'noopener,noreferrer');
+    return Promise.resolve();
+  },
+  requestDisplayMode: function() {
+    return Promise.resolve();
+  },
+  requestClose: function() {
+    return Promise.resolve();
+  }
+};
+`.trim();
+}
+function generateGenericAdapter() {
+  return `
+var GenericAdapter = {
+  id: 'generic',
+  name: 'Generic Web',
+  priority: 0,
+  capabilities: Object.assign({}, DEFAULT_CAPABILITIES, {
+    canOpenLinks: true,
+    hasNetworkAccess: true
+  }),
+  canHandle: function() {
+    return typeof window !== 'undefined';
+  },
+  initialize: function(context) {
+    return Promise.resolve();
+  },
+  callTool: function() {
+    return Promise.reject(new Error('Tool calls not supported'));
+  },
+  sendMessage: function() {
+    return Promise.reject(new Error('Messages not supported'));
+  },
+  openLink: function(context, url) {
+    window.open(url, '_blank', 'noopener,noreferrer');
+    return Promise.resolve();
+  },
+  requestDisplayMode: function() {
+    return Promise.resolve();
+  },
+  requestClose: function() {
+    return Promise.resolve();
+  }
+};
+`.trim();
+}
+function generatePlatformDetection(adapters) {
+  const adapterVars = adapters.map((a) => {
+    switch (a) {
+      case "openai":
+        return "OpenAIAdapter";
+      case "ext-apps":
+        return "ExtAppsAdapter";
+      case "claude":
+        return "ClaudeAdapter";
+      case "gemini":
+        return "GeminiAdapter";
+      case "generic":
+        return "GenericAdapter";
+      default:
+        return "";
+    }
+  }).filter(Boolean);
+  return `
+var ADAPTERS = [${adapterVars.join(", ")}].sort(function(a, b) { return b.priority - a.priority; });
+
+function detectPlatform() {
+  for (var i = 0; i < ADAPTERS.length; i++) {
+    if (ADAPTERS[i].canHandle()) {
+      log('Detected platform: ' + ADAPTERS[i].id);
+      return ADAPTERS[i];
+    }
+  }
+  log('No platform detected, using generic');
+  return GenericAdapter;
+}
+`.trim();
+}
+function generateBridgeClass() {
+  return `
+function FrontMcpBridge() {
+  this._adapter = null;
+  this._initialized = false;
+  this._context = {
+    hostContext: {
+      theme: detectTheme(),
+      displayMode: 'inline',
+      locale: detectLocale(),
+      userAgent: detectUserAgent(),
+      safeArea: DEFAULT_SAFE_AREA,
+      viewport: detectViewport()
+    },
+    toolInput: {},
+    toolOutput: undefined,
+    structuredContent: undefined,
+    widgetState: {},
+    contextListeners: [],
+    toolResultListeners: [],
+    notifyContextChange: function(changes) {
+      Object.assign(this.hostContext, changes);
+      for (var i = 0; i < this.contextListeners.length; i++) {
+        try { this.contextListeners[i](changes); } catch(e) {}
+      }
+    },
+    notifyToolResult: function(result) {
+      this.toolOutput = result;
+      for (var i = 0; i < this.toolResultListeners.length; i++) {
+        try { this.toolResultListeners[i](result); } catch(e) {}
+      }
+    }
+  };
+
+  var injected = readInjectedData();
+  this._context.toolInput = injected.toolInput;
+  this._context.toolOutput = injected.toolOutput;
+  this._context.structuredContent = injected.structuredContent;
+
+  this._loadWidgetState();
+}
+
+FrontMcpBridge.prototype._loadWidgetState = function() {
+  try {
+    var key = 'frontmcp:widget:' + (window.__mcpToolName || 'unknown');
+    var stored = localStorage.getItem(key);
+    if (stored) this._context.widgetState = JSON.parse(stored);
+  } catch(e) {}
+};
+
+FrontMcpBridge.prototype._saveWidgetState = function() {
+  try {
+    var key = 'frontmcp:widget:' + (window.__mcpToolName || 'unknown');
+    localStorage.setItem(key, JSON.stringify(this._context.widgetState));
+  } catch(e) {}
+};
+
+FrontMcpBridge.prototype.initialize = function() {
+  if (this._initialized) return Promise.resolve();
+  var self = this;
+  this._adapter = detectPlatform();
+  return this._adapter.initialize(this._context).then(function() {
+    self._initialized = true;
+    // Set up the data-tool-call click handler after initialization
+    self._setupDataToolCallHandler();
+  });
+};
+
+Object.defineProperty(FrontMcpBridge.prototype, 'initialized', { get: function() { return this._initialized; } });
+Object.defineProperty(FrontMcpBridge.prototype, 'adapterId', { get: function() { return this._adapter ? this._adapter.id : undefined; } });
+Object.defineProperty(FrontMcpBridge.prototype, 'capabilities', { get: function() { return this._adapter ? this._adapter.capabilities : DEFAULT_CAPABILITIES; } });
+
+FrontMcpBridge.prototype.getTheme = function() { return this._context.hostContext.theme; };
+FrontMcpBridge.prototype.getDisplayMode = function() { return this._context.hostContext.displayMode; };
+FrontMcpBridge.prototype.getToolInput = function() { return this._context.toolInput; };
+FrontMcpBridge.prototype.getToolOutput = function() { return this._context.toolOutput; };
+FrontMcpBridge.prototype.getStructuredContent = function() { return this._context.structuredContent; };
+FrontMcpBridge.prototype.getWidgetState = function() { return this._context.widgetState; };
+FrontMcpBridge.prototype.getHostContext = function() { return Object.assign({}, this._context.hostContext); };
+FrontMcpBridge.prototype.hasCapability = function(cap) { return this._adapter && this._adapter.capabilities[cap] === true; };
+
+// Get tool response metadata (platform-agnostic)
+// Used by inline mode widgets to detect when ui/html arrives
+FrontMcpBridge.prototype.getToolResponseMetadata = function() {
+  // OpenAI injects toolResponseMetadata for widget-producing tools
+  if (typeof window !== 'undefined' && window.openai && window.openai.toolResponseMetadata) {
+    return window.openai.toolResponseMetadata;
+  }
+  // Claude (future support)
+  if (typeof window !== 'undefined' && window.claude && window.claude.toolResponseMetadata) {
+    return window.claude.toolResponseMetadata;
+  }
+  // FrontMCP direct injection (for testing/ext-apps)
+  if (typeof window !== 'undefined' && window.__mcpToolResponseMetadata) {
+    return window.__mcpToolResponseMetadata;
+  }
+  return null;
+};
+
+// Subscribe to tool response metadata changes (for inline mode injection)
+FrontMcpBridge.prototype.onToolResponseMetadata = function(callback) {
+  var self = this;
+  var called = false;
+
+  // Check if already available
+  var existing = self.getToolResponseMetadata();
+  if (existing) {
+    called = true;
+    callback(existing);
+  }
+
+  // Set up property interceptors for OpenAI
+  if (typeof window !== 'undefined') {
+    // OpenAI: Intercept toolResponseMetadata assignment
+    if (!window.__frontmcpMetadataIntercepted) {
+      window.__frontmcpMetadataIntercepted = true;
+      window.__frontmcpMetadataCallbacks = [];
+
+      // Create openai object if it doesn't exist
+      if (!window.openai) window.openai = {};
+
+      var originalMetadata = window.openai.toolResponseMetadata;
+      Object.defineProperty(window.openai, 'toolResponseMetadata', {
+        get: function() { return originalMetadata; },
+        set: function(val) {
+          originalMetadata = val;
+          log('toolResponseMetadata set, notifying ' + window.__frontmcpMetadataCallbacks.length + ' listeners');
+          for (var i = 0; i < window.__frontmcpMetadataCallbacks.length; i++) {
+            try { window.__frontmcpMetadataCallbacks[i](val); } catch(e) {}
+          }
+        },
+        configurable: true
+      });
+    }
+
+    // Register callback wrapper (store reference for unsubscribe)
+    var wrapper = function(metadata) {
+      if (!called) {
+        called = true;
+        callback(metadata);
+      }
+    };
+    window.__frontmcpMetadataCallbacks.push(wrapper);
+
+    // Return unsubscribe function that removes the wrapper (not the original callback)
+    return function() {
+      if (window.__frontmcpMetadataCallbacks) {
+        var idx = window.__frontmcpMetadataCallbacks.indexOf(wrapper);
+        if (idx !== -1) window.__frontmcpMetadataCallbacks.splice(idx, 1);
+      }
+    };
+  }
+
+  // Return no-op unsubscribe for non-window environments
+  return function() {};
+};
+
+FrontMcpBridge.prototype.callTool = function(name, args) {
+  // Priority 1: Direct OpenAI SDK call (most reliable in OpenAI iframe)
+  // This bypasses adapter abstraction for maximum compatibility
+  if (typeof window !== 'undefined' && window.openai && typeof window.openai.callTool === 'function') {
+    log('callTool: Using OpenAI SDK directly');
+    return window.openai.callTool(name, args);
+  }
+
+  // Priority 2: Use adapter (if initialized and supports tool calls)
+  if (this._adapter && this._adapter.capabilities && this._adapter.capabilities.canCallTools) {
+    log('callTool: Using adapter ' + this._adapter.id);
+    return this._adapter.callTool(this._context, name, args);
+  }
+
+  // Not initialized or no tool support
+  if (!this._adapter) {
+    return Promise.reject(new Error('Bridge not initialized. Wait for bridge:ready event.'));
+  }
+  return Promise.reject(new Error('Tool calls not supported on this platform (' + this._adapter.id + ')'));
+};
+
+FrontMcpBridge.prototype.sendMessage = function(content) {
+  if (!this._adapter) return Promise.reject(new Error('Not initialized'));
+  return this._adapter.sendMessage(this._context, content);
+};
+
+FrontMcpBridge.prototype.openLink = function(url) {
+  if (!this._adapter) return Promise.reject(new Error('Not initialized'));
+  return this._adapter.openLink(this._context, url);
+};
+
+FrontMcpBridge.prototype.requestDisplayMode = function(mode) {
+  if (!this._adapter) return Promise.reject(new Error('Not initialized'));
+  var self = this;
+  return this._adapter.requestDisplayMode(this._context, mode).then(function() {
+    self._context.hostContext.displayMode = mode;
+  });
+};
+
+FrontMcpBridge.prototype.requestClose = function() {
+  if (!this._adapter) return Promise.reject(new Error('Not initialized'));
+  return this._adapter.requestClose(this._context);
+};
+
+FrontMcpBridge.prototype.setWidgetState = function(state) {
+  Object.assign(this._context.widgetState, state);
+  this._saveWidgetState();
+};
+
+FrontMcpBridge.prototype.onContextChange = function(callback) {
+  var listeners = this._context.contextListeners;
+  listeners.push(callback);
+  return function() {
+    var idx = listeners.indexOf(callback);
+    if (idx !== -1) listeners.splice(idx, 1);
+  };
+};
+
+FrontMcpBridge.prototype.onToolResult = function(callback) {
+  var listeners = this._context.toolResultListeners;
+  listeners.push(callback);
+  return function() {
+    var idx = listeners.indexOf(callback);
+    if (idx !== -1) listeners.splice(idx, 1);
+  };
+};
+
+// ==================== data-tool-call Click Handler ====================
+
+FrontMcpBridge.prototype._setupDataToolCallHandler = function() {
+  var self = this;
+
+  document.addEventListener('click', function(e) {
+    // Find the closest element with data-tool-call attribute
+    var target = e.target;
+    while (target && target !== document) {
+      if (target.hasAttribute && target.hasAttribute('data-tool-call')) {
+        var toolName = target.getAttribute('data-tool-call');
+        var argsAttr = target.getAttribute('data-tool-args');
+        var args = {};
+
+        try {
+          if (argsAttr) {
+            args = JSON.parse(argsAttr);
+          }
+        } catch (parseErr) {
+          console.error('[frontmcp] Failed to parse data-tool-args:', parseErr);
+        }
+
+        log('data-tool-call clicked: ' + toolName);
+
+        // Show loading state - save original content first
+        var originalContent = target.innerHTML;
+        var originalDisabled = target.disabled;
+        target.disabled = true;
+        target.classList.add('opacity-50', 'cursor-not-allowed');
+
+        // Add spinner for buttons
+        var spinner = '<svg class="animate-spin -ml-1 mr-2 h-4 w-4 inline" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24"><circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle><path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path></svg>';
+        if (target.tagName === 'BUTTON') {
+          target.innerHTML = spinner + 'Loading...';
+        }
+
+        // Helper to reset button state
+        function resetButton() {
+          target.innerHTML = originalContent;
+          target.disabled = originalDisabled;
+          target.classList.remove('opacity-50', 'cursor-not-allowed');
+        }
+
+        // Determine how to call the tool
+        var toolCallPromise;
+
+        // Priority 1: Direct OpenAI SDK call (bypasses adapter abstraction)
+        if (typeof window !== 'undefined' && window.openai && typeof window.openai.callTool === 'function') {
+          log('Using OpenAI SDK directly for tool call');
+          toolCallPromise = window.openai.callTool(toolName, args);
+        }
+        // Priority 2: Use adapter (if it supports tool calls)
+        else if (self.hasCapability('canCallTools')) {
+          log('Using adapter for tool call');
+          toolCallPromise = self.callTool(toolName, args);
+        }
+        // No tool call capability
+        else {
+          console.error('[frontmcp] Tool calls not supported on this platform (' + self.adapterId + ')');
+          resetButton();
+          target.dispatchEvent(new CustomEvent('tool:error', {
+            detail: { name: toolName, args: args, error: 'Tool calls not supported on this platform' },
+            bubbles: true
+          }));
+          e.preventDefault();
+          return;
+        }
+
+        // Handle the tool call result
+        toolCallPromise.then(function(result) {
+          log('Tool call succeeded: ' + toolName);
+          resetButton();
+
+          // Update bridge state to trigger widget re-render
+          // React isn't hydrated in OpenAI iframe, so useState doesn't work
+          // Instead, we use the bridge's reactive state system
+          if (result && window.__frontmcp && window.__frontmcp.bridge && typeof window.__frontmcp.bridge.setWidgetState === 'function') {
+            var newData = result.structuredContent || result;
+            log('Updating bridge state with new data');
+            window.__frontmcp.bridge.setWidgetState(newData);
+          }
+
+          // Dispatch success event
+          target.dispatchEvent(new CustomEvent('tool:success', {
+            detail: { name: toolName, args: args, result: result },
+            bubbles: true
+          }));
+        }).catch(function(err) {
+          console.error('[frontmcp] Tool call failed: ' + toolName, err);
+          resetButton();
+          // Dispatch error event
+          target.dispatchEvent(new CustomEvent('tool:error', {
+            detail: { name: toolName, args: args, error: err.message || err },
+            bubbles: true
+          }));
+        });
+
+        // Prevent default behavior (e.g., form submission)
+        e.preventDefault();
+        return;
+      }
+      target = target.parentElement;
+    }
+  }, true); // Use capture phase to handle before React handlers
+};
+`.trim();
+}
+function minifyJS(code) {
+  return code.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*$/gm, "").replace(/\s+/g, " ").replace(/\s*([{};,:()[\]])\s*/g, "$1").replace(/;\}/g, "}").trim();
+}
+function generatePlatformBundle(platform, options = {}) {
+  const platformAdapters = {
+    chatgpt: ["openai", "generic"],
+    claude: ["claude", "generic"],
+    gemini: ["gemini", "generic"],
+    universal: ["openai", "ext-apps", "claude", "gemini", "generic"]
+  };
+  return generateBridgeIIFE({
+    ...options,
+    adapters: platformAdapters[platform]
+  });
+}
+var UNIVERSAL_BRIDGE_SCRIPT = generateBridgeIIFE();
+var BRIDGE_SCRIPT_TAGS = {
+  universal: `<script>${UNIVERSAL_BRIDGE_SCRIPT}</script>`,
+  chatgpt: `<script>${generatePlatformBundle("chatgpt")}</script>`,
+  claude: `<script>${generatePlatformBundle("claude")}</script>`,
+  gemini: `<script>${generatePlatformBundle("gemini")}</script>`
+};
+
+// libs/ui/src/react/hooks/context.tsx
+var import_jsx_runtime5 = require("react/jsx-runtime");
+var McpBridgeContext = (0, import_react.createContext)(null);
+function McpBridgeProvider({ children, config, onReady, onError }) {
+  const [bridge, setBridge] = (0, import_react.useState)(null);
+  const [loading, setLoading] = (0, import_react.useState)(true);
+  const [error, setError] = (0, import_react.useState)(null);
+  (0, import_react.useEffect)(() => {
+    let mounted = true;
+    let bridgeInstance = null;
+    const initBridge = async () => {
+      try {
+        bridgeInstance = new FrontMcpBridge(config);
+        await bridgeInstance.initialize();
+        if (mounted) {
+          setBridge(bridgeInstance);
+          setLoading(false);
+          onReady?.(bridgeInstance);
+        }
+      } catch (err) {
+        if (mounted) {
+          const error2 = err instanceof Error ? err : new Error(String(err));
+          setError(error2);
+          setLoading(false);
+          onError?.(error2);
+        }
+      }
+    };
+    initBridge();
+    return () => {
+      mounted = false;
+      if (bridgeInstance) {
+        bridgeInstance.dispose();
+      }
+    };
+  }, [config, onReady, onError]);
+  const contextValue = (0, import_react.useMemo)(
+    () => ({
+      bridge,
+      loading,
+      error,
+      ready: !loading && !error && bridge !== null,
+      adapterId: bridge?.adapterId,
+      capabilities: bridge?.capabilities
+    }),
+    [bridge, loading, error]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(McpBridgeContext.Provider, { value: contextValue, children });
+}
+var SSR_DEFAULT_CONTEXT = {
+  bridge: null,
+  loading: false,
+  error: null,
+  ready: false,
+  adapterId: void 0,
+  capabilities: void 0
+};
+function useMcpBridgeContext() {
+  const context = (0, import_react.useContext)(McpBridgeContext);
+  if (!context) {
+    return SSR_DEFAULT_CONTEXT;
+  }
+  return context;
+}
+function useMcpBridge() {
+  const { bridge } = useMcpBridgeContext();
+  return bridge;
+}
+function useTheme() {
+  const { bridge, ready } = useMcpBridgeContext();
+  const [theme, setTheme] = (0, import_react.useState)("light");
+  (0, import_react.useEffect)(() => {
+    if (!ready || !bridge) return;
+    setTheme(bridge.getTheme());
+    const unsubscribe = bridge.onContextChange((changes) => {
+      if (changes.theme) {
+        setTheme(changes.theme);
+      }
+    });
+    return unsubscribe;
+  }, [bridge, ready]);
+  return theme;
+}
+function useDisplayMode() {
+  const { bridge, ready } = useMcpBridgeContext();
+  const [displayMode, setDisplayMode] = (0, import_react.useState)("inline");
+  (0, import_react.useEffect)(() => {
+    if (!ready || !bridge) return;
+    setDisplayMode(bridge.getDisplayMode());
+    const unsubscribe = bridge.onContextChange((changes) => {
+      if (changes.displayMode) {
+        setDisplayMode(changes.displayMode);
+      }
+    });
+    return unsubscribe;
+  }, [bridge, ready]);
+  return displayMode;
+}
+function useHostContext() {
+  const { bridge, ready } = useMcpBridgeContext();
+  const [context, setContext] = (0, import_react.useState)(null);
+  (0, import_react.useEffect)(() => {
+    if (!ready || !bridge) return;
+    const adapter = bridge.getAdapter?.();
+    if (adapter) {
+      setContext(adapter.getHostContext());
+    }
+    const unsubscribe = bridge.onContextChange((changes) => {
+      setContext((prev) => prev ? { ...prev, ...changes } : null);
+    });
+    return unsubscribe;
+  }, [bridge, ready]);
+  return context;
+}
+function useCapability(cap) {
+  const { capabilities } = useMcpBridgeContext();
+  return capabilities?.[cap] === true;
+}
+
+// libs/ui/src/react/hooks/tools.tsx
+var import_react2 = require("react");
+function useToolInput() {
+  const { bridge, ready } = useMcpBridgeContext();
+  if (!ready || !bridge) {
+    return null;
+  }
+  try {
+    return bridge.getToolInput();
+  } catch {
+    return null;
+  }
+}
+function useToolOutput() {
+  const { bridge, ready } = useMcpBridgeContext();
+  const [output, setOutput] = (0, import_react2.useState)(null);
+  (0, import_react2.useEffect)(() => {
+    if (!ready || !bridge) return;
+    try {
+      const initialOutput = bridge.getToolOutput();
+      if (initialOutput !== void 0) {
+        setOutput(initialOutput);
+      }
+    } catch {
+    }
+    const unsubscribe = bridge.onToolResult((result) => {
+      setOutput(result);
+    });
+    return unsubscribe;
+  }, [bridge, ready]);
+  return output;
+}
+function useStructuredContent() {
+  const { bridge, ready } = useMcpBridgeContext();
+  if (!ready || !bridge) {
+    return null;
+  }
+  try {
+    const adapter = bridge.getAdapter?.();
+    if (adapter) {
+      return adapter.getStructuredContent();
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function useCallTool(toolName, options = {}) {
+  const { bridge, ready } = useMcpBridgeContext();
+  const { onSuccess, onError, resetOnToolChange = true } = options;
+  console.log("useCallTool", toolName, bridge);
+  const [state, setState] = (0, import_react2.useState)({
+    data: null,
+    loading: false,
+    error: null,
+    called: false
+  });
+  (0, import_react2.useEffect)(() => {
+    if (resetOnToolChange) {
+      setState({
+        data: null,
+        loading: false,
+        error: null,
+        called: false
+      });
+    }
+  }, [toolName, resetOnToolChange]);
+  const reset = (0, import_react2.useCallback)(() => {
+    setState({
+      data: null,
+      loading: false,
+      error: null,
+      called: false
+    });
+  }, []);
+  const callTool = (0, import_react2.useCallback)(
+    async (args) => {
+      if (!ready || !bridge) {
+        const error = new Error("Bridge not initialized");
+        setState((prev) => ({ ...prev, error, called: true }));
+        onError?.(error);
+        return null;
+      }
+      setState((prev) => ({
+        ...prev,
+        loading: true,
+        error: null,
+        called: true
+      }));
+      try {
+        const result = await bridge.callTool(toolName, args);
+        const data = result;
+        setState({
+          data,
+          loading: false,
+          error: null,
+          called: true
+        });
+        onSuccess?.(data);
+        return data;
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        setState({
+          data: null,
+          loading: false,
+          error,
+          called: true
+        });
+        onError?.(error);
+        return null;
+      }
+    },
+    [bridge, ready, toolName, onSuccess, onError]
+  );
+  return [callTool, state, reset];
+}
+function useToolCalls(toolMap) {
+  const bridge = useMcpBridge();
+  const [states, setStates] = (0, import_react2.useState)(() => {
+    const initial = {};
+    for (const key of Object.keys(toolMap)) {
+      initial[key] = { data: null, loading: false, error: null, called: false };
+    }
+    return initial;
+  });
+  const createCallFn = (0, import_react2.useCallback)(
+    (key, toolName) => async (args) => {
+      if (!bridge) {
+        setStates((prev) => ({
+          ...prev,
+          [key]: {
+            ...prev[key],
+            error: new Error("Bridge not initialized"),
+            called: true
+          }
+        }));
+        return null;
+      }
+      setStates((prev) => ({
+        ...prev,
+        [key]: { ...prev[key], loading: true, error: null, called: true }
+      }));
+      try {
+        const result2 = await bridge.callTool(toolName, args);
+        setStates((prev) => ({
+          ...prev,
+          [key]: { data: result2, loading: false, error: null, called: true }
+        }));
+        return result2;
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        setStates((prev) => ({
+          ...prev,
+          [key]: { data: null, loading: false, error, called: true }
+        }));
+        return null;
+      }
+    },
+    [bridge]
+  );
+  const createResetFn = (0, import_react2.useCallback)(
+    (key) => () => {
+      setStates((prev) => ({
+        ...prev,
+        [key]: { data: null, loading: false, error: null, called: false }
+      }));
+    },
+    []
+  );
+  const result = {};
+  for (const [key, toolName] of Object.entries(toolMap)) {
+    const state = states[key] || {
+      data: null,
+      loading: false,
+      error: null,
+      called: false
+    };
+    result[key] = {
+      call: createCallFn(key, toolName),
+      data: state.data,
+      loading: state.loading,
+      error: state.error,
+      reset: createResetFn(key)
+    };
+  }
+  return result;
+}
+function useSendMessage() {
+  const bridge = useMcpBridge();
+  const [state, setState] = (0, import_react2.useState)({
+    loading: false,
+    error: null,
+    sent: false
+  });
+  const sendMessage = (0, import_react2.useCallback)(
+    async (content) => {
+      if (!bridge) {
+        setState({ loading: false, error: new Error("Bridge not initialized"), sent: false });
+        return;
+      }
+      setState({ loading: true, error: null, sent: false });
+      try {
+        await bridge.sendMessage(content);
+        setState({ loading: false, error: null, sent: true });
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        setState({ loading: false, error, sent: false });
+      }
+    },
+    [bridge]
+  );
+  return [sendMessage, state];
+}
+function useOpenLink() {
+  const bridge = useMcpBridge();
+  return (0, import_react2.useCallback)(
+    async (url) => {
+      if (!bridge) {
+        console.warn("Bridge not initialized, cannot open link");
+        return;
+      }
+      await bridge.openLink(url);
+    },
+    [bridge]
+  );
+}
+
+// libs/ui/src/react/utils.ts
+var import_utils = require("@frontmcp/uipack/utils");
+var cachedReactDOMServer = null;
+function getReactDOMServer() {
+  if (!cachedReactDOMServer) {
+    try {
+      cachedReactDOMServer = require("react-dom/server");
+    } catch {
+      return null;
+    }
+  }
+  return cachedReactDOMServer;
+}
+function renderChildrenToString(children) {
+  if (children == null) {
+    return "";
+  }
+  if (typeof children === "string") {
+    return (0, import_utils.escapeHtml)(children);
+  }
+  if (typeof children === "number") {
+    return String(children);
+  }
+  if (typeof children === "boolean") {
+    return "";
+  }
+  try {
+    const server = getReactDOMServer();
+    if (server) {
+      return server.renderToStaticMarkup(children);
+    }
+    return String(children);
+  } catch {
+    return String(children);
+  }
+}
+function isBrowser() {
+  return typeof window !== "undefined";
+}
+function isServer() {
+  return typeof window === "undefined";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Alert,
+  Badge,
+  Button,
+  Card,
+  McpBridgeProvider,
+  isBrowser,
+  isServer,
+  renderAlert,
+  renderAlertSync,
+  renderBadge,
+  renderBadgeSync,
+  renderButton,
+  renderButtonSync,
+  renderCard,
+  renderCardSync,
+  renderChildrenToString,
+  useCallTool,
+  useCapability,
+  useDisplayMode,
+  useHostContext,
+  useMcpBridge,
+  useMcpBridgeContext,
+  useOpenLink,
+  useSendMessage,
+  useStructuredContent,
+  useTheme,
+  useToolCalls,
+  useToolInput,
+  useToolOutput
+});