@pancake-apps/web 0.0.0-snapshot-20260125200133

package/dist/chunk-YGGRUIUG.js

@@ -0,0 +1,977 @@
+import { __export } from './chunk-PZ5AY32C.js';
+import { useSyncExternalStore } from 'react';
+
+// src/mcp-apps/index.ts
+var mcp_apps_exports = {};
+__export(mcp_apps_exports, {
+  DEFAULT_CLIENT_INFO: () => DEFAULT_CLIENT_INFO,
+  ERROR_CODES: () => ERROR_CODES,
+  JsonRpcError: () => JsonRpcError,
+  MCP_METHODS: () => MCP_METHODS,
+  McpAppsBridge: () => McpAppsBridge,
+  McpAppsStore: () => McpAppsStore,
+  PROTOCOL_VERSION: () => PROTOCOL_VERSION,
+  callTool: () => callTool,
+  createErrorResponse: () => createErrorResponse,
+  createMcpStoreHook: () => createMcpStoreHook,
+  createMcpView: () => createMcpView,
+  createNotification: () => createNotification,
+  createRequest: () => createRequest,
+  createSuccessResponse: () => createSuccessResponse,
+  generateId: () => generateId,
+  getBridge: () => getBridge,
+  getStore: () => getStore,
+  initialize: () => initialize,
+  isErrorResponse: () => isErrorResponse,
+  isJsonRpcMessage: () => isJsonRpcMessage,
+  isNotification: () => isNotification,
+  isRequest: () => isRequest,
+  isResponse: () => isResponse,
+  log: () => log,
+  logDebug: () => logDebug,
+  logError: () => logError,
+  logInfo: () => logInfo,
+  logWarning: () => logWarning,
+  notifySizeChanged: () => notifySizeChanged,
+  onTeardown: () => onTeardown,
+  openLink: () => openLink,
+  readResource: () => readResource,
+  requestDisplayMode: () => requestDisplayMode,
+  sendMessage: () => sendMessage,
+  setupAutoSizeReporting: () => setupAutoSizeReporting,
+  updateModelContext: () => updateModelContext,
+  useAvailableDisplayModes: () => useAvailableDisplayModes,
+  useContainerDimensions: () => useContainerDimensions,
+  useDeviceCapabilities: () => useDeviceCapabilities,
+  useDisplayMode: () => useDisplayMode,
+  useHostCapabilities: () => useHostCapabilities,
+  useHostContext: () => useHostContext,
+  useIsInitialized: () => useIsInitialized,
+  useLocale: () => useLocale,
+  useMcpStore: () => useMcpStore,
+  usePlatform: () => usePlatform,
+  useSafeArea: () => useSafeArea,
+  useStyles: () => useStyles,
+  useTheme: () => useTheme,
+  useTimezone: () => useTimezone,
+  useToolInfo: () => useToolInfo,
+  useToolInput: () => useToolInput,
+  useToolResult: () => useToolResult
+});
+
+// src/mcp-apps/types.ts
+var PROTOCOL_VERSION = "2025-11-21";
+var DEFAULT_CLIENT_INFO = {
+  name: "pancake-mcp-apps",
+  version: "1.0.0"
+};
+var MCP_METHODS = {
+  // Guest -> Host Requests
+  INITIALIZE: "ui/initialize",
+  OPEN_LINK: "ui/open-link",
+  MESSAGE: "ui/message",
+  REQUEST_DISPLAY_MODE: "ui/request-display-mode",
+  UPDATE_MODEL_CONTEXT: "ui/update-model-context",
+  TOOLS_CALL: "tools/call",
+  RESOURCES_READ: "resources/read",
+  PING: "ping",
+  // Guest -> Host Notifications
+  INITIALIZED: "ui/notifications/initialized",
+  SIZE_CHANGED: "ui/notifications/size-changed",
+  LOG_MESSAGE: "notifications/message",
+  // Host -> Guest Notifications
+  TOOL_INPUT: "ui/notifications/tool-input",
+  TOOL_INPUT_PARTIAL: "ui/notifications/tool-input-partial",
+  TOOL_RESULT: "ui/notifications/tool-result",
+  TOOL_CANCELLED: "ui/notifications/tool-cancelled",
+  HOST_CONTEXT_CHANGED: "ui/notifications/host-context-changed",
+  RESOURCE_TEARDOWN: "ui/resource-teardown"
+};
+
+// src/mcp-apps/protocol.ts
+function generateId() {
+  return crypto.randomUUID();
+}
+function createRequest(method, params, id = generateId()) {
+  const request = {
+    jsonrpc: "2.0",
+    id,
+    method
+  };
+  if (params !== void 0) {
+    request.params = params;
+  }
+  return request;
+}
+function createNotification(method, params) {
+  const notification = {
+    jsonrpc: "2.0",
+    method
+  };
+  if (params !== void 0) {
+    notification.params = params;
+  }
+  return notification;
+}
+function createSuccessResponse(id, result) {
+  return {
+    jsonrpc: "2.0",
+    id,
+    result
+  };
+}
+function createErrorResponse(id, code, message, data) {
+  return {
+    jsonrpc: "2.0",
+    id,
+    error: {
+      code,
+      message,
+      ...data !== void 0 && { data }
+    }
+  };
+}
+function isJsonRpcMessage(data) {
+  if (typeof data !== "object" || data === null) return false;
+  return data.jsonrpc === "2.0";
+}
+function isRequest(message) {
+  return "id" in message && "method" in message && !("result" in message) && !("error" in message);
+}
+function isNotification(message) {
+  return "method" in message && !("id" in message);
+}
+function isResponse(message) {
+  return "id" in message && ("result" in message || "error" in message);
+}
+function isErrorResponse(response) {
+  return "error" in response;
+}
+var ERROR_CODES = {
+  PARSE_ERROR: -32700,
+  INVALID_REQUEST: -32600,
+  METHOD_NOT_FOUND: -32601,
+  INVALID_PARAMS: -32602,
+  INTERNAL_ERROR: -32603
+};
+var JsonRpcError = class _JsonRpcError extends Error {
+  code;
+  data;
+  constructor(code, message, data) {
+    super(message);
+    this.name = "JsonRpcError";
+    this.code = code;
+    this.data = data;
+  }
+  static fromResponse(response) {
+    return new _JsonRpcError(response.error.code, response.error.message, response.error.data);
+  }
+};
+
+// src/mcp-apps/bridge.ts
+var DEFAULT_TIMEOUT = 3e4;
+var McpAppsBridge = class _McpAppsBridge {
+  static instance = null;
+  pendingRequests = /* @__PURE__ */ new Map();
+  notificationHandlers = /* @__PURE__ */ new Map();
+  teardownHandlers = /* @__PURE__ */ new Set();
+  _isInitialized = false;
+  initializeResult = null;
+  resizeObserver = null;
+  /**
+   * Get the singleton bridge instance
+   */
+  static getInstance() {
+    if (!_McpAppsBridge.instance) {
+      _McpAppsBridge.instance = new _McpAppsBridge();
+    }
+    return _McpAppsBridge.instance;
+  }
+  /**
+   * Reset the singleton (for testing)
+   */
+  static reset() {
+    if (_McpAppsBridge.instance) {
+      _McpAppsBridge.instance.cleanup();
+    }
+    _McpAppsBridge.instance = null;
+  }
+  constructor() {
+    this.setupMessageListener();
+  }
+  /**
+   * Check if the bridge has been initialized
+   */
+  get isInitialized() {
+    return this._isInitialized;
+  }
+  /**
+   * Get the initialization result (host context, capabilities, etc.)
+   */
+  get initResult() {
+    return this.initializeResult;
+  }
+  // ============================================
+  // Message Handling
+  // ============================================
+  setupMessageListener() {
+    if (typeof window !== "undefined") {
+      window.addEventListener("message", this.handleMessage);
+    }
+  }
+  cleanup() {
+    if (typeof window !== "undefined") {
+      window.removeEventListener("message", this.handleMessage);
+    }
+    for (const [, pending] of this.pendingRequests) {
+      clearTimeout(pending.timeout);
+      pending.reject(new Error("Bridge was reset"));
+    }
+    this.pendingRequests.clear();
+    this.notificationHandlers.clear();
+    this.teardownHandlers.clear();
+    if (this.resizeObserver) {
+      this.resizeObserver.disconnect();
+      this.resizeObserver = null;
+    }
+  }
+  handleMessage = (event) => {
+    const data = event.data;
+    if (!isJsonRpcMessage(data)) {
+      return;
+    }
+    if (isResponse(data)) {
+      const id = String(data.id);
+      const pending = this.pendingRequests.get(id);
+      if (pending) {
+        clearTimeout(pending.timeout);
+        this.pendingRequests.delete(id);
+        if (isErrorResponse(data)) {
+          pending.reject(JsonRpcError.fromResponse(data));
+        } else {
+          pending.resolve(data.result);
+        }
+      }
+      return;
+    }
+    if (isRequest(data)) {
+      this.handleHostRequest(data);
+      return;
+    }
+    if (isNotification(data)) {
+      this.handleNotification(data.method, data.params);
+    }
+  };
+  handleHostRequest(request) {
+    if (request.method === MCP_METHODS.RESOURCE_TEARDOWN) {
+      this.handleTeardown(request);
+    }
+  }
+  async handleTeardown(request) {
+    const params = request.params;
+    try {
+      await Promise.all(Array.from(this.teardownHandlers).map((handler) => handler(params)));
+      this.sendResponse(request.id, {});
+    } catch (error) {
+      this.sendErrorResponse(
+        request.id,
+        -32603,
+        error instanceof Error ? error.message : "Teardown failed"
+      );
+    }
+  }
+  handleNotification(method, params) {
+    const handlers = this.notificationHandlers.get(method);
+    if (handlers) {
+      handlers.forEach((handler) => handler(params));
+    }
+  }
+  // ============================================
+  // Sending Messages
+  // ============================================
+  send(message) {
+    if (typeof window !== "undefined") {
+      window.parent.postMessage(message, "*");
+    }
+  }
+  sendResponse(id, result) {
+    this.send({
+      jsonrpc: "2.0",
+      id,
+      result
+    });
+  }
+  sendErrorResponse(id, code, message) {
+    this.send({
+      jsonrpc: "2.0",
+      id,
+      error: { code, message }
+    });
+  }
+  /**
+   * Send a request and wait for response
+   */
+  async sendRequest(method, params, timeout = DEFAULT_TIMEOUT) {
+    const request = createRequest(method, params);
+    const id = String(request.id);
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        this.pendingRequests.delete(id);
+        reject(new Error(`Request ${method} timed out after ${timeout}ms`));
+      }, timeout);
+      this.pendingRequests.set(id, {
+        resolve,
+        reject,
+        timeout: timeoutId
+      });
+      this.send(request);
+    });
+  }
+  /**
+   * Send a notification (no response expected)
+   */
+  sendNotification(method, params) {
+    this.send(createNotification(method, params));
+  }
+  // ============================================
+  // Subscription
+  // ============================================
+  /**
+   * Subscribe to notifications from the host
+   */
+  onNotification(method, handler) {
+    if (!this.notificationHandlers.has(method)) {
+      this.notificationHandlers.set(method, /* @__PURE__ */ new Set());
+    }
+    this.notificationHandlers.get(method).add(handler);
+    return () => {
+      this.notificationHandlers.get(method)?.delete(handler);
+    };
+  }
+  /**
+   * Register a teardown handler
+   */
+  onTeardown(handler) {
+    this.teardownHandlers.add(handler);
+    return () => {
+      this.teardownHandlers.delete(handler);
+    };
+  }
+  // ============================================
+  // Initialization
+  // ============================================
+  /**
+   * Initialize the connection with the host
+   */
+  async initialize(options = {}) {
+    if (this._isInitialized && this.initializeResult) {
+      return this.initializeResult;
+    }
+    const result = await this.sendRequest(MCP_METHODS.INITIALIZE, {
+      protocolVersion: PROTOCOL_VERSION,
+      capabilities: options.capabilities ?? {},
+      clientInfo: options.clientInfo ?? DEFAULT_CLIENT_INFO
+    });
+    this.initializeResult = result;
+    this._isInitialized = true;
+    this.sendNotification(MCP_METHODS.INITIALIZED);
+    return result;
+  }
+  /**
+   * Ensure the bridge is initialized before performing operations
+   */
+  async ensureInitialized() {
+    if (!this._isInitialized) {
+      await this.initialize();
+    }
+  }
+  // ============================================
+  // Tool Operations
+  // ============================================
+  /**
+   * Call a server tool
+   */
+  async callTool(name, args) {
+    await this.ensureInitialized();
+    return this.sendRequest(MCP_METHODS.TOOLS_CALL, {
+      name,
+      arguments: args
+    });
+  }
+  // ============================================
+  // Resource Operations
+  // ============================================
+  /**
+   * Read a resource by URI
+   */
+  async readResource(uri) {
+    await this.ensureInitialized();
+    return this.sendRequest(MCP_METHODS.RESOURCES_READ, {
+      uri
+    });
+  }
+  // ============================================
+  // Message Operations
+  // ============================================
+  /**
+   * Send a message to the host's chat interface
+   */
+  async sendMessage(text) {
+    await this.ensureInitialized();
+    await this.sendRequest(MCP_METHODS.MESSAGE, {
+      role: "user",
+      content: {
+        type: "text",
+        text
+      }
+    });
+  }
+  // ============================================
+  // Link Operations
+  // ============================================
+  /**
+   * Request the host to open a URL
+   */
+  async openLink(url) {
+    await this.ensureInitialized();
+    await this.sendRequest(MCP_METHODS.OPEN_LINK, { url });
+  }
+  // ============================================
+  // Display Operations
+  // ============================================
+  /**
+   * Request a change in display mode
+   */
+  async requestDisplayMode(mode) {
+    await this.ensureInitialized();
+    const result = await this.sendRequest(MCP_METHODS.REQUEST_DISPLAY_MODE, {
+      mode
+    });
+    return result.mode;
+  }
+  // ============================================
+  // Model Context Operations
+  // ============================================
+  /**
+   * Update the host's model context
+   */
+  async updateModelContext(params) {
+    await this.ensureInitialized();
+    await this.sendRequest(MCP_METHODS.UPDATE_MODEL_CONTEXT, params);
+  }
+  // ============================================
+  // Size Reporting
+  // ============================================
+  /**
+   * Notify the host of size changes
+   */
+  notifySizeChanged(width, height) {
+    this.sendNotification(MCP_METHODS.SIZE_CHANGED, { width, height });
+  }
+  /**
+   * Setup automatic size reporting via ResizeObserver
+   */
+  setupAutoSizeReporting(element = document.documentElement) {
+    if (this.resizeObserver) {
+      this.resizeObserver.disconnect();
+    }
+    this.resizeObserver = new ResizeObserver((entries) => {
+      const entry = entries[0];
+      if (!entry) return;
+      this.notifySizeChanged(entry.contentRect.width, entry.contentRect.height);
+    });
+    this.resizeObserver.observe(element);
+    return () => {
+      if (this.resizeObserver) {
+        this.resizeObserver.disconnect();
+        this.resizeObserver = null;
+      }
+    };
+  }
+  // ============================================
+  // Logging
+  // ============================================
+  /**
+   * Send a log message to the host
+   */
+  log(level, data, logger) {
+    this.sendNotification(MCP_METHODS.LOG_MESSAGE, {
+      level,
+      data,
+      ...logger && { logger }
+    });
+  }
+  // ============================================
+  // Health Check
+  // ============================================
+  /**
+   * Ping the host to check connection
+   */
+  async ping() {
+    await this.sendRequest(MCP_METHODS.PING);
+  }
+};
+function getBridge() {
+  return McpAppsBridge.getInstance();
+}
+
+// src/mcp-apps/store.ts
+var McpAppsStore = class _McpAppsStore {
+  static instance = null;
+  state = {
+    isInitialized: false,
+    hostContext: {},
+    hostCapabilities: void 0,
+    hostInfo: void 0,
+    toolInput: void 0,
+    toolResult: void 0,
+    toolInputPartial: void 0,
+    isCancelled: false,
+    cancelReason: void 0
+  };
+  subscribers = /* @__PURE__ */ new Map();
+  unsubscribers = [];
+  static getInstance() {
+    if (!_McpAppsStore.instance) {
+      _McpAppsStore.instance = new _McpAppsStore();
+    }
+    return _McpAppsStore.instance;
+  }
+  static reset() {
+    if (_McpAppsStore.instance) {
+      _McpAppsStore.instance.cleanup();
+    }
+    _McpAppsStore.instance = null;
+  }
+  constructor() {
+    this.setupNotificationHandlers();
+  }
+  cleanup() {
+    this.unsubscribers.forEach((unsub) => unsub());
+    this.unsubscribers = [];
+    this.subscribers.clear();
+    this.state = {
+      isInitialized: false,
+      hostContext: {},
+      hostCapabilities: void 0,
+      hostInfo: void 0,
+      toolInput: void 0,
+      toolResult: void 0,
+      toolInputPartial: void 0,
+      isCancelled: false,
+      cancelReason: void 0
+    };
+  }
+  setupNotificationHandlers() {
+    const bridge = getBridge();
+    this.unsubscribers.push(
+      bridge.onNotification(MCP_METHODS.TOOL_INPUT, (params) => {
+        const { arguments: args } = params;
+        this.updateState({ toolInput: args, toolInputPartial: void 0 });
+      })
+    );
+    this.unsubscribers.push(
+      bridge.onNotification(MCP_METHODS.TOOL_INPUT_PARTIAL, (params) => {
+        const { arguments: args } = params;
+        this.updateState({ toolInputPartial: args });
+      })
+    );
+    this.unsubscribers.push(
+      bridge.onNotification(MCP_METHODS.TOOL_RESULT, (params) => {
+        this.updateState({ toolResult: params });
+      })
+    );
+    this.unsubscribers.push(
+      bridge.onNotification(MCP_METHODS.TOOL_CANCELLED, (params) => {
+        const { reason } = params;
+        this.updateState({ isCancelled: true, cancelReason: reason });
+      })
+    );
+    this.unsubscribers.push(
+      bridge.onNotification(MCP_METHODS.HOST_CONTEXT_CHANGED, (params) => {
+        const changes = params;
+        this.updateState({
+          hostContext: { ...this.state.hostContext, ...changes }
+        });
+      })
+    );
+  }
+  /**
+   * Update store state and notify subscribers
+   */
+  updateState(updates) {
+    const changedKeys = Object.keys(updates);
+    this.state = { ...this.state, ...updates };
+    for (const key of changedKeys) {
+      const keySubscribers = this.subscribers.get(key);
+      if (keySubscribers) {
+        keySubscribers.forEach((cb) => cb());
+      }
+    }
+    const wildcardSubscribers = this.subscribers.get("*");
+    if (wildcardSubscribers) {
+      wildcardSubscribers.forEach((cb) => cb());
+    }
+  }
+  /**
+   * Set initialization result from bridge
+   */
+  setInitialized(hostContext, hostCapabilities, hostInfo) {
+    this.updateState({
+      isInitialized: true,
+      hostContext,
+      hostCapabilities,
+      hostInfo
+    });
+  }
+  /**
+   * Subscribe to changes for specific keys or all changes
+   */
+  subscribe(keys, callback) {
+    const keyArray = keys === "*" ? ["*"] : Array.isArray(keys) ? keys : [keys];
+    for (const key of keyArray) {
+      if (!this.subscribers.has(key)) {
+        this.subscribers.set(key, /* @__PURE__ */ new Set());
+      }
+      this.subscribers.get(key).add(callback);
+    }
+    return () => {
+      for (const key of keyArray) {
+        this.subscribers.get(key)?.delete(callback);
+      }
+    };
+  }
+  /**
+   * Get current value of a state property
+   */
+  getSnapshot(key) {
+    return this.state[key];
+  }
+  /**
+   * Get the full state snapshot
+   */
+  getFullSnapshot() {
+    return this.state;
+  }
+  /**
+   * Get server snapshot (for SSR)
+   */
+  getServerSnapshot(key) {
+    const defaults = {
+      isInitialized: false,
+      hostContext: {}
+    };
+    return defaults[key];
+  }
+};
+function getStore() {
+  return McpAppsStore.getInstance();
+}
+function createMcpStoreHook(key) {
+  return function useMcpStore2() {
+    const store = getStore();
+    return useSyncExternalStore(
+      (callback) => store.subscribe(key, callback),
+      () => store.getSnapshot(key),
+      () => store.getServerSnapshot(key)
+    );
+  };
+}
+function useMcpStore(key) {
+  const store = getStore();
+  return useSyncExternalStore(
+    (callback) => store.subscribe(key, callback),
+    () => store.getSnapshot(key),
+    () => store.getServerSnapshot(key)
+  );
+}
+
+// src/mcp-apps/hooks/use-theme.ts
+function useTheme() {
+  const hostContext = useMcpStore("hostContext");
+  return hostContext.theme ?? "light";
+}
+
+// src/mcp-apps/hooks/use-locale.ts
+function useLocale() {
+  const hostContext = useMcpStore("hostContext");
+  return hostContext.locale ?? "en-US";
+}
+
+// src/mcp-apps/hooks/use-timezone.ts
+function useTimezone() {
+  const hostContext = useMcpStore("hostContext");
+  return hostContext.timeZone;
+}
+
+// src/mcp-apps/hooks/use-display-mode.ts
+function useDisplayMode() {
+  const hostContext = useMcpStore("hostContext");
+  return hostContext.displayMode ?? "inline";
+}
+
+// src/mcp-apps/hooks/use-available-display-modes.ts
+function useAvailableDisplayModes() {
+  const hostContext = useMcpStore("hostContext");
+  return hostContext.availableDisplayModes ?? ["inline"];
+}
+
+// src/mcp-apps/hooks/use-container-dimensions.ts
+function useContainerDimensions() {
+  const hostContext = useMcpStore("hostContext");
+  return hostContext.containerDimensions;
+}
+
+// src/mcp-apps/hooks/use-safe-area.ts
+var DEFAULT_SAFE_AREA = {
+  top: 0,
+  right: 0,
+  bottom: 0,
+  left: 0
+};
+function useSafeArea() {
+  const hostContext = useMcpStore("hostContext");
+  return hostContext.safeAreaInsets ?? DEFAULT_SAFE_AREA;
+}
+
+// src/mcp-apps/hooks/use-platform.ts
+function usePlatform() {
+  const hostContext = useMcpStore("hostContext");
+  return hostContext.platform;
+}
+
+// src/mcp-apps/hooks/use-device-capabilities.ts
+var DEFAULT_CAPABILITIES = {
+  touch: false,
+  hover: true
+};
+function useDeviceCapabilities() {
+  const hostContext = useMcpStore("hostContext");
+  return hostContext.deviceCapabilities ?? DEFAULT_CAPABILITIES;
+}
+
+// src/mcp-apps/hooks/use-styles.ts
+function useStyles() {
+  const hostContext = useMcpStore("hostContext");
+  return hostContext.styles;
+}
+
+// src/mcp-apps/hooks/use-tool-info.ts
+function useToolInfo() {
+  const hostContext = useMcpStore("hostContext");
+  return hostContext.toolInfo;
+}
+
+// src/mcp-apps/hooks/use-tool-input.ts
+function useToolInput() {
+  return useMcpStore("toolInput");
+}
+
+// src/mcp-apps/hooks/use-tool-result.ts
+function useToolResult() {
+  return useMcpStore("toolResult");
+}
+
+// src/mcp-apps/hooks/use-host-context.ts
+function useHostContext() {
+  return useMcpStore("hostContext");
+}
+
+// src/mcp-apps/hooks/use-host-capabilities.ts
+function useHostCapabilities() {
+  return useMcpStore("hostCapabilities");
+}
+
+// src/mcp-apps/hooks/use-is-initialized.ts
+function useIsInitialized() {
+  return useMcpStore("isInitialized");
+}
+
+// src/mcp-apps/actions/initialize.ts
+async function initialize(options) {
+  const bridge = getBridge();
+  const result = await bridge.initialize(options);
+  const store = getStore();
+  store.setInitialized(result.hostContext, result.hostCapabilities, result.hostInfo);
+  return result;
+}
+
+// src/mcp-apps/actions/call-tool.ts
+async function callTool(name, args) {
+  const bridge = getBridge();
+  return bridge.callTool(name, args);
+}
+
+// src/mcp-apps/actions/read-resource.ts
+async function readResource(uri) {
+  const bridge = getBridge();
+  return bridge.readResource(uri);
+}
+
+// src/mcp-apps/actions/send-message.ts
+async function sendMessage(text) {
+  const bridge = getBridge();
+  return bridge.sendMessage(text);
+}
+
+// src/mcp-apps/actions/open-link.ts
+async function openLink(url) {
+  const bridge = getBridge();
+  return bridge.openLink(url);
+}
+
+// src/mcp-apps/actions/request-display-mode.ts
+async function requestDisplayMode(mode) {
+  const bridge = getBridge();
+  return bridge.requestDisplayMode(mode);
+}
+
+// src/mcp-apps/actions/update-model-context.ts
+async function updateModelContext(params) {
+  const bridge = getBridge();
+  return bridge.updateModelContext(params);
+}
+
+// src/mcp-apps/actions/notify-size-changed.ts
+function notifySizeChanged(width, height) {
+  const bridge = getBridge();
+  bridge.notifySizeChanged(width, height);
+}
+function setupAutoSizeReporting(element = document.documentElement) {
+  const bridge = getBridge();
+  return bridge.setupAutoSizeReporting(element);
+}
+
+// src/mcp-apps/actions/log.ts
+function log(level, data, logger) {
+  const bridge = getBridge();
+  bridge.log(level, data, logger);
+}
+var logDebug = (data, logger) => log("debug", data, logger);
+var logInfo = (data, logger) => log("info", data, logger);
+var logWarning = (data, logger) => log("warning", data, logger);
+var logError = (data, logger) => log("error", data, logger);
+
+// src/mcp-apps/actions/on-teardown.ts
+function onTeardown(handler) {
+  const bridge = getBridge();
+  return bridge.onTeardown(handler);
+}
+
+// src/mcp-apps/create-view.ts
+var MCP_FONTS_STYLE_ID = "mcp-app-fonts";
+function injectStyles(styles) {
+  if (!styles) return;
+  if (styles.variables) {
+    for (const [key, value] of Object.entries(styles.variables)) {
+      document.documentElement.style.setProperty(key, value);
+    }
+  }
+  if (styles.css?.fonts) {
+    let fontEl = document.getElementById(MCP_FONTS_STYLE_ID);
+    if (!fontEl) {
+      fontEl = document.createElement("style");
+      fontEl.id = MCP_FONTS_STYLE_ID;
+      document.head.appendChild(fontEl);
+    }
+    fontEl.textContent = styles.css.fonts;
+  }
+}
+function setupEnhancedSizeReporting(options = {}) {
+  const {
+    debounceMs = 100,
+    threshold = 2,
+    useMutationObserver = true,
+    element = document.body
+  } = options;
+  let lastSentHeight = 0;
+  let timeoutId = null;
+  const reportSize = () => {
+    const height = document.body.scrollHeight;
+    const width = document.documentElement.clientWidth;
+    if (Math.abs(height - lastSentHeight) > threshold) {
+      notifySizeChanged(width, height);
+      lastSentHeight = height;
+    }
+  };
+  const debouncedReport = () => {
+    if (timeoutId) clearTimeout(timeoutId);
+    timeoutId = setTimeout(reportSize, debounceMs);
+  };
+  const resizeObserver = new ResizeObserver(debouncedReport);
+  resizeObserver.observe(element);
+  let mutationObserver = null;
+  if (useMutationObserver) {
+    mutationObserver = new MutationObserver(debouncedReport);
+    mutationObserver.observe(document.body, {
+      childList: true,
+      subtree: true,
+      attributes: true
+    });
+  }
+  reportSize();
+  return () => {
+    if (timeoutId) clearTimeout(timeoutId);
+    resizeObserver.disconnect();
+    mutationObserver?.disconnect();
+  };
+}
+function computeChanges(prev, next) {
+  const changes = {};
+  for (const key of Object.keys(next)) {
+    if (prev[key] !== next[key]) {
+      changes[key] = next[key];
+    }
+  }
+  return changes;
+}
+async function createMcpView(options = {}) {
+  const {
+    clientInfo,
+    autoResize = true,
+    autoInjectStyles = false,
+    onReady,
+    onContextChange,
+    onTeardown: onTeardownCallback
+  } = options;
+  const cleanupFns = [];
+  const initResult = await initialize(clientInfo ? { clientInfo } : void 0);
+  const store = getStore();
+  if (autoInjectStyles) {
+    injectStyles(initResult.hostContext.styles);
+  }
+  if (autoResize) {
+    const resizeOptions = typeof autoResize === "object" ? autoResize : {};
+    const cleanup = setupEnhancedSizeReporting(resizeOptions);
+    cleanupFns.push(cleanup);
+  }
+  let previousContext = initResult.hostContext;
+  const unsubscribe = store.subscribe("hostContext", () => {
+    const newContext = store.getSnapshot("hostContext");
+    const changes = computeChanges(previousContext, newContext);
+    if (autoInjectStyles && changes.styles) {
+      injectStyles(newContext.styles);
+    }
+    onContextChange?.(newContext, changes);
+    previousContext = newContext;
+  });
+  cleanupFns.push(unsubscribe);
+  if (onTeardownCallback) {
+    const unregisterTeardown = onTeardown((params) => {
+      onTeardownCallback(params.reason);
+    });
+    cleanupFns.push(unregisterTeardown);
+  }
+  onReady?.(initResult.hostContext);
+  return {
+    getContext: () => store.getSnapshot("hostContext"),
+    notifySize: notifySizeChanged,
+    destroy: () => {
+      cleanupFns.forEach((fn) => fn());
+    }
+  };
+}
+
+export { DEFAULT_CLIENT_INFO, ERROR_CODES, JsonRpcError, MCP_METHODS, McpAppsBridge, McpAppsStore, PROTOCOL_VERSION, callTool, createErrorResponse, createMcpStoreHook, createMcpView, createNotification, createRequest, createSuccessResponse, generateId, getBridge, getStore, initialize, isErrorResponse, isJsonRpcMessage, isNotification, isRequest, isResponse, log, logDebug, logError, logInfo, logWarning, mcp_apps_exports, notifySizeChanged, onTeardown, openLink, readResource, requestDisplayMode, sendMessage, setupAutoSizeReporting, updateModelContext, useAvailableDisplayModes, useContainerDimensions, useDeviceCapabilities, useDisplayMode, useHostCapabilities, useHostContext, useIsInitialized, useLocale, useMcpStore, usePlatform, useSafeArea, useStyles, useTheme, useTimezone, useToolInfo, useToolInput, useToolResult };
+//# sourceMappingURL=chunk-YGGRUIUG.js.map
+//# sourceMappingURL=chunk-YGGRUIUG.js.map