@pancake-apps/web 0.0.0-snapshot-20260125200133

package/dist/index-DtukOUjY.d.ts

@@ -0,0 +1,738 @@
+import { J as JsonRpcId, a as JsonRpcRequest, b as JsonRpcNotification, c as JsonRpcSuccessResponse, d as JsonRpcErrorResponse, e as JsonRpcMessage, M as McpUiInitializeResult, R as ResourceTeardownParams, I as InitializeOptions, C as CallToolResult, f as ResourceReadResult, D as DisplayMode, U as UpdateModelContextParams, L as LogLevel, H as HostContext, g as HostCapabilities, h as HostInfo, i as McpStoreState, T as Theme, j as ContainerDimensions, k as SafeAreaInsets, P as Platform, l as DeviceCapabilities, m as Styles, n as ToolInfo, o as ClientInfo, p as ContentBlock, q as DEFAULT_CLIENT_INFO, r as InitializeParams, s as JsonRpcResponse, t as LogMessageParams, u as MCP_METHODS, v as McpUiResourceCsp, O as OpenLinkParams, w as PROTOCOL_VERSION, x as PermissionFields, y as RequestDisplayModeParams, z as RequestDisplayModeResult, A as ResourceContent, B as ResourceReadParams, E as SandboxCapabilities, F as SizeChangedParams, G as StyleCss, S as StyleVariables, K as ToolCancelledParams, N as ToolInputParams, Q as ToolInputPartialParams, V as ToolsCallParams, W as UiMessageParams } from './types-B_O3kZYh.js';
+
+/**
+ * JSON-RPC 2.0 Protocol Helpers
+ *
+ * Utilities for creating and parsing JSON-RPC messages.
+ */
+
+/**
+ * Generate a unique request ID
+ */
+declare function generateId(): string;
+/**
+ * Create a JSON-RPC request
+ */
+declare function createRequest(method: string, params?: unknown, id?: JsonRpcId): JsonRpcRequest;
+/**
+ * Create a JSON-RPC notification (no id, no response expected)
+ */
+declare function createNotification(method: string, params?: unknown): JsonRpcNotification;
+/**
+ * Create a JSON-RPC success response
+ */
+declare function createSuccessResponse(id: JsonRpcId, result: unknown): JsonRpcSuccessResponse;
+/**
+ * Create a JSON-RPC error response
+ */
+declare function createErrorResponse(id: JsonRpcId, code: number, message: string, data?: unknown): JsonRpcErrorResponse;
+/**
+ * Check if a message is a valid JSON-RPC message
+ */
+declare function isJsonRpcMessage(data: unknown): data is JsonRpcMessage;
+/**
+ * Check if a message is a JSON-RPC request
+ */
+declare function isRequest(message: JsonRpcMessage): message is JsonRpcRequest;
+/**
+ * Check if a message is a JSON-RPC notification
+ */
+declare function isNotification(message: JsonRpcMessage): message is JsonRpcNotification;
+/**
+ * Check if a message is a JSON-RPC response
+ */
+declare function isResponse(message: JsonRpcMessage): message is JsonRpcSuccessResponse | JsonRpcErrorResponse;
+/**
+ * Check if a response is an error
+ */
+declare function isErrorResponse(response: JsonRpcSuccessResponse | JsonRpcErrorResponse): response is JsonRpcErrorResponse;
+/**
+ * Standard JSON-RPC error codes
+ */
+declare const ERROR_CODES: {
+    readonly PARSE_ERROR: -32700;
+    readonly INVALID_REQUEST: -32600;
+    readonly METHOD_NOT_FOUND: -32601;
+    readonly INVALID_PARAMS: -32602;
+    readonly INTERNAL_ERROR: -32603;
+};
+/**
+ * Create an error from a JSON-RPC error response
+ */
+declare class JsonRpcError extends Error {
+    code: number;
+    data?: unknown;
+    constructor(code: number, message: string, data?: unknown);
+    static fromResponse(response: JsonRpcErrorResponse): JsonRpcError;
+}
+
+/**
+ * McpAppsBridge
+ *
+ * Singleton bridge that handles JSON-RPC communication with the MCP host
+ * via postMessage. Manages initialization, request/response tracking,
+ * and notification handling.
+ */
+
+type NotificationHandler = (params: unknown) => void;
+type TeardownHandler$1 = (params: ResourceTeardownParams) => Promise<void> | void;
+declare class McpAppsBridge {
+    private static instance;
+    private pendingRequests;
+    private notificationHandlers;
+    private teardownHandlers;
+    private _isInitialized;
+    private initializeResult;
+    private resizeObserver;
+    /**
+     * Get the singleton bridge instance
+     */
+    static getInstance(): McpAppsBridge;
+    /**
+     * Reset the singleton (for testing)
+     */
+    static reset(): void;
+    private constructor();
+    /**
+     * Check if the bridge has been initialized
+     */
+    get isInitialized(): boolean;
+    /**
+     * Get the initialization result (host context, capabilities, etc.)
+     */
+    get initResult(): McpUiInitializeResult | null;
+    private setupMessageListener;
+    private cleanup;
+    private handleMessage;
+    private handleHostRequest;
+    private handleTeardown;
+    private handleNotification;
+    private send;
+    private sendResponse;
+    private sendErrorResponse;
+    /**
+     * Send a request and wait for response
+     */
+    sendRequest<T>(method: string, params?: unknown, timeout?: number): Promise<T>;
+    /**
+     * Send a notification (no response expected)
+     */
+    sendNotification(method: string, params?: unknown): void;
+    /**
+     * Subscribe to notifications from the host
+     */
+    onNotification(method: string, handler: NotificationHandler): () => void;
+    /**
+     * Register a teardown handler
+     */
+    onTeardown(handler: TeardownHandler$1): () => void;
+    /**
+     * Initialize the connection with the host
+     */
+    initialize(options?: InitializeOptions): Promise<McpUiInitializeResult>;
+    /**
+     * Ensure the bridge is initialized before performing operations
+     */
+    ensureInitialized(): Promise<void>;
+    /**
+     * Call a server tool
+     */
+    callTool<TInput = Record<string, unknown>, TOutput = unknown>(name: string, args?: TInput): Promise<CallToolResult<TOutput>>;
+    /**
+     * Read a resource by URI
+     */
+    readResource(uri: string): Promise<ResourceReadResult>;
+    /**
+     * Send a message to the host's chat interface
+     */
+    sendMessage(text: string): Promise<void>;
+    /**
+     * Request the host to open a URL
+     */
+    openLink(url: string): Promise<void>;
+    /**
+     * Request a change in display mode
+     */
+    requestDisplayMode(mode: DisplayMode): Promise<DisplayMode>;
+    /**
+     * Update the host's model context
+     */
+    updateModelContext(params: UpdateModelContextParams): Promise<void>;
+    /**
+     * Notify the host of size changes
+     */
+    notifySizeChanged(width: number, height: number): void;
+    /**
+     * Setup automatic size reporting via ResizeObserver
+     */
+    setupAutoSizeReporting(element?: HTMLElement): () => void;
+    /**
+     * Send a log message to the host
+     */
+    log(level: LogLevel, data: unknown, logger?: string): void;
+    /**
+     * Ping the host to check connection
+     */
+    ping(): Promise<void>;
+}
+/**
+ * Get the bridge instance (convenience function)
+ */
+declare function getBridge(): McpAppsBridge;
+
+/**
+ * McpAppsStore
+ *
+ * External store implementation for React 18's useSyncExternalStore.
+ * Listens to MCP notifications for reactive updates.
+ */
+
+type Subscriber = () => void;
+type Unsubscribe = () => void;
+declare class McpAppsStore {
+    private static instance;
+    private state;
+    private subscribers;
+    private unsubscribers;
+    static getInstance(): McpAppsStore;
+    static reset(): void;
+    private constructor();
+    private cleanup;
+    private setupNotificationHandlers;
+    /**
+     * Update store state and notify subscribers
+     */
+    private updateState;
+    /**
+     * Set initialization result from bridge
+     */
+    setInitialized(hostContext: HostContext, hostCapabilities: HostCapabilities, hostInfo: HostInfo): void;
+    /**
+     * Subscribe to changes for specific keys or all changes
+     */
+    subscribe(keys: keyof McpStoreState | (keyof McpStoreState)[] | '*', callback: Subscriber): Unsubscribe;
+    /**
+     * Get current value of a state property
+     */
+    getSnapshot<K extends keyof McpStoreState>(key: K): McpStoreState[K];
+    /**
+     * Get the full state snapshot
+     */
+    getFullSnapshot(): McpStoreState;
+    /**
+     * Get server snapshot (for SSR)
+     */
+    getServerSnapshot<K extends keyof McpStoreState>(key: K): McpStoreState[K] | undefined;
+}
+
+/**
+ * Get the store instance (convenience function)
+ */
+declare function getStore(): McpAppsStore;
+
+/**
+ * Base hook factory for creating reactive hooks for MCP store properties
+ */
+
+/**
+ * Create a hook that subscribes to a specific store property
+ */
+declare function createMcpStoreHook<K extends keyof McpStoreState>(key: K): () => McpStoreState[K];
+/**
+ * Generic hook to access any MCP store property
+ */
+declare function useMcpStore<K extends keyof McpStoreState>(key: K): McpStoreState[K];
+
+/**
+ * Get the current theme (light or dark)
+ *
+ * @returns Current theme, defaults to 'light' if not set
+ */
+declare function useTheme(): Theme;
+
+/**
+ * Get the user's locale setting
+ *
+ * @returns BCP 47 language tag (e.g., 'en-US')
+ */
+declare function useLocale(): string;
+
+/**
+ * Get the user's timezone
+ *
+ * @returns IANA timezone string (e.g., 'America/New_York')
+ */
+declare function useTimezone(): string | undefined;
+
+/**
+ * Get the current display mode
+ *
+ * @returns Current display mode: 'inline', 'fullscreen', or 'pip'
+ */
+declare function useDisplayMode(): DisplayMode;
+
+/**
+ * Get the list of available display modes
+ *
+ * @returns Array of available display modes
+ */
+declare function useAvailableDisplayModes(): DisplayMode[];
+
+/**
+ * Get the container dimension constraints
+ *
+ * @returns Container dimensions or undefined
+ */
+declare function useContainerDimensions(): ContainerDimensions | undefined;
+
+/**
+ * Get safe area insets for devices with notches/rounded corners
+ *
+ * @returns Safe area insets object
+ */
+declare function useSafeArea(): SafeAreaInsets;
+
+/**
+ * Get the host platform
+ *
+ * @returns Platform: 'web', 'desktop', or 'mobile'
+ */
+declare function usePlatform(): Platform | undefined;
+
+/**
+ * Get device capabilities (touch, hover support)
+ *
+ * @returns Device capabilities object
+ */
+declare function useDeviceCapabilities(): DeviceCapabilities;
+
+/**
+ * Get CSS styling information from the host
+ *
+ * Includes CSS variables and font CSS to inject.
+ *
+ * @returns Styles object or undefined
+ */
+declare function useStyles(): Styles | undefined;
+
+/**
+ * Get information about the tool that triggered this UI
+ *
+ * @returns Tool info or undefined
+ */
+declare function useToolInfo(): ToolInfo | undefined;
+
+/**
+ * Get the complete tool input arguments
+ *
+ * Sent via ui/notifications/tool-input after initialization.
+ *
+ * @returns Tool input arguments or undefined
+ */
+declare function useToolInput<T = Record<string, unknown>>(): T | undefined;
+
+/**
+ * Get the tool execution result
+ *
+ * Sent via ui/notifications/tool-result.
+ *
+ * @returns Tool result or undefined
+ */
+declare function useToolResult<T = unknown>(): CallToolResult<T> | undefined;
+
+/**
+ * Get the full host context object
+ *
+ * Use this for accessing multiple context properties at once.
+ *
+ * @returns Host context object
+ */
+declare function useHostContext(): HostContext;
+
+/**
+ * Get the host's capabilities
+ *
+ * @returns Host capabilities or undefined if not initialized
+ */
+declare function useHostCapabilities(): HostCapabilities | undefined;
+
+/**
+ * Check if the MCP connection has been initialized
+ *
+ * @returns true if initialized, false otherwise
+ */
+declare function useIsInitialized(): boolean;
+
+/**
+ * Initialize the MCP connection with the host
+ *
+ * This must be called before using other actions. If called multiple times,
+ * subsequent calls return the cached result.
+ *
+ * @param options - Optional initialization options
+ * @returns Promise resolving to initialization result
+ *
+ * @example
+ * ```tsx
+ * useEffect(() => {
+ *   initialize({
+ *     clientInfo: { name: 'my-app', version: '1.0.0' }
+ *   }).then((result) => {
+ *     console.log('Initialized with:', result.hostContext);
+ *   });
+ * }, []);
+ * ```
+ */
+declare function initialize(options?: InitializeOptions): Promise<McpUiInitializeResult>;
+
+/**
+ * Call an MCP server tool
+ *
+ * @param name - Tool name to call
+ * @param args - Optional arguments for the tool
+ * @returns Promise resolving to tool result
+ *
+ * @example
+ * ```tsx
+ * const result = await callTool('search', { query: 'pancakes' });
+ * console.log(result.structuredContent);
+ * ```
+ */
+declare function callTool<TInput = Record<string, unknown>, TOutput = unknown>(name: string, args?: TInput): Promise<CallToolResult<TOutput>>;
+
+/**
+ * Read content from an MCP resource
+ *
+ * @param uri - Resource URI to read
+ * @returns Promise resolving to resource contents
+ *
+ * @example
+ * ```tsx
+ * const result = await readResource('ui://my-resource');
+ * console.log(result.contents[0]?.text);
+ * ```
+ */
+declare function readResource(uri: string): Promise<ResourceReadResult>;
+
+/**
+ * Send a message to the host's chat interface
+ *
+ * @param text - Message text to send
+ *
+ * @example
+ * ```tsx
+ * await sendMessage('Show me more options');
+ * ```
+ */
+declare function sendMessage(text: string): Promise<void>;
+
+/**
+ * Request the host to open a URL in the user's browser
+ *
+ * @param url - URL to open
+ *
+ * @example
+ * ```tsx
+ * await openLink('https://example.com');
+ * ```
+ */
+declare function openLink(url: string): Promise<void>;
+
+/**
+ * Request a change in display mode
+ *
+ * Note: The host may return a different mode than requested.
+ *
+ * @param mode - Desired display mode
+ * @returns Promise resolving to the actual mode set
+ *
+ * @example
+ * ```tsx
+ * const actualMode = await requestDisplayMode('fullscreen');
+ * if (actualMode !== 'fullscreen') {
+ *   console.log('Fullscreen not available');
+ * }
+ * ```
+ */
+declare function requestDisplayMode(mode: DisplayMode): Promise<DisplayMode>;
+
+/**
+ * Update the host's model context for future conversation turns
+ *
+ * Each update overwrites previous updates from the same UI instance.
+ *
+ * @param params - Context update parameters
+ *
+ * @example
+ * ```tsx
+ * await updateModelContext({
+ *   structuredContent: { selectedItems: ['a', 'b', 'c'] }
+ * });
+ * ```
+ */
+declare function updateModelContext(params: UpdateModelContextParams): Promise<void>;
+
+/**
+ * Notify the host of size changes
+ *
+ * Use this when in flexible sizing mode (maxHeight set, not height).
+ *
+ * @param width - Current width in pixels
+ * @param height - Current height in pixels
+ *
+ * @example
+ * ```tsx
+ * // In a ResizeObserver callback
+ * notifySizeChanged(entry.contentRect.width, entry.contentRect.height);
+ * ```
+ */
+declare function notifySizeChanged(width: number, height: number): void;
+/**
+ * Setup automatic size reporting via ResizeObserver
+ *
+ * @param element - Element to observe (defaults to document.documentElement)
+ * @returns Cleanup function to stop observing
+ *
+ * @example
+ * ```tsx
+ * useEffect(() => {
+ *   return setupAutoSizeReporting();
+ * }, []);
+ * ```
+ */
+declare function setupAutoSizeReporting(element?: HTMLElement): () => void;
+
+/**
+ * Send a log message to the host
+ *
+ * @param level - Log level: 'debug', 'info', 'warning', or 'error'
+ * @param data - Data to log
+ * @param logger - Optional logger name
+ *
+ * @example
+ * ```tsx
+ * log('info', { action: 'button_click', target: 'submit' });
+ * log('error', error.message, 'ErrorHandler');
+ * ```
+ */
+declare function log(level: LogLevel, data: unknown, logger?: string): void;
+declare const logDebug: (data: unknown, logger?: string) => void;
+declare const logInfo: (data: unknown, logger?: string) => void;
+declare const logWarning: (data: unknown, logger?: string) => void;
+declare const logError: (data: unknown, logger?: string) => void;
+
+type TeardownHandler = (params: ResourceTeardownParams) => Promise<void> | void;
+/**
+ * Register a handler for resource teardown
+ *
+ * Called when the host is about to unmount the UI. Use this to
+ * save state or perform cleanup before the iframe is destroyed.
+ *
+ * @param handler - Async or sync function called on teardown
+ * @returns Unsubscribe function
+ *
+ * @example
+ * ```tsx
+ * useEffect(() => {
+ *   return onTeardown(async ({ reason }) => {
+ *     await saveProgress();
+ *     console.log('Teardown reason:', reason);
+ *   });
+ * }, []);
+ * ```
+ */
+declare function onTeardown(handler: TeardownHandler): () => void;
+
+/**
+ * createMcpView
+ *
+ * High-level API for creating MCP views with minimal boilerplate.
+ * Handles initialization, style injection, size reporting, and teardown.
+ */
+
+interface AutoResizeOptions {
+    /** Debounce interval in milliseconds (default: 100) */
+    debounceMs?: number;
+    /** Pixel threshold to avoid noise (default: 2) */
+    threshold?: number;
+    /** Watch DOM changes with MutationObserver (default: true) */
+    useMutationObserver?: boolean;
+    /** Element to observe (default: document.body) */
+    element?: HTMLElement;
+}
+interface CreateMcpViewOptions {
+    /** Client identification */
+    clientInfo?: ClientInfo;
+    /** Enable automatic size reporting (default: true) */
+    autoResize?: boolean | AutoResizeOptions;
+    /** Inject host CSS variables and fonts into DOM (default: false) */
+    autoInjectStyles?: boolean;
+    /** Called after initialization, context is ready */
+    onReady?: (context: HostContext) => void;
+    /** Called when host context changes (after styles are re-applied if autoInjectStyles) */
+    onContextChange?: (context: HostContext, changes: Partial<HostContext>) => void;
+    /** Called when host requests teardown */
+    onTeardown?: (reason: string) => void;
+}
+interface McpView {
+    /** Get current host context */
+    getContext(): HostContext;
+    /** Manually notify size change */
+    notifySize(width: number, height: number): void;
+    /** Cleanup all subscriptions and observers */
+    destroy(): void;
+}
+/**
+ * Create an MCP view with automatic lifecycle management
+ *
+ * Handles:
+ * - Initialization handshake with host
+ * - Style injection (CSS variables + fonts)
+ * - Automatic size reporting with debouncing
+ * - Host context change subscriptions
+ * - Teardown handling
+ *
+ * @example
+ * ```ts
+ * const view = await createMcpView({
+ *   clientInfo: { name: 'my-view', version: '1.0.0' },
+ *   autoResize: true,
+ *   autoInjectStyles: true,
+ *
+ *   onReady: (context) => {
+ *     console.log('View ready with theme:', context.theme);
+ *     renderContent();
+ *   },
+ *
+ *   onContextChange: (context) => {
+ *     updateTheme(context.theme);
+ *   },
+ *
+ *   onTeardown: (reason) => {
+ *     saveState();
+ *   },
+ * });
+ *
+ * // Later: manual cleanup
+ * view.destroy();
+ * ```
+ */
+declare function createMcpView(options?: CreateMcpViewOptions): Promise<McpView>;
+
+/**
+ * @pancake-apps/web/mcp-apps
+ *
+ * Complete SDK for building Guest UIs that communicate with MCP hosts.
+ * Implements JSON-RPC 2.0 over postMessage as per MCP Apps specification.
+ */
+
+type mcpApps_AutoResizeOptions = AutoResizeOptions;
+declare const mcpApps_CallToolResult: typeof CallToolResult;
+declare const mcpApps_ClientInfo: typeof ClientInfo;
+declare const mcpApps_ContainerDimensions: typeof ContainerDimensions;
+declare const mcpApps_ContentBlock: typeof ContentBlock;
+type mcpApps_CreateMcpViewOptions = CreateMcpViewOptions;
+declare const mcpApps_DEFAULT_CLIENT_INFO: typeof DEFAULT_CLIENT_INFO;
+declare const mcpApps_DeviceCapabilities: typeof DeviceCapabilities;
+declare const mcpApps_DisplayMode: typeof DisplayMode;
+declare const mcpApps_ERROR_CODES: typeof ERROR_CODES;
+declare const mcpApps_HostCapabilities: typeof HostCapabilities;
+declare const mcpApps_HostContext: typeof HostContext;
+declare const mcpApps_HostInfo: typeof HostInfo;
+declare const mcpApps_InitializeOptions: typeof InitializeOptions;
+declare const mcpApps_InitializeParams: typeof InitializeParams;
+type mcpApps_JsonRpcError = JsonRpcError;
+declare const mcpApps_JsonRpcError: typeof JsonRpcError;
+declare const mcpApps_JsonRpcErrorResponse: typeof JsonRpcErrorResponse;
+declare const mcpApps_JsonRpcId: typeof JsonRpcId;
+declare const mcpApps_JsonRpcMessage: typeof JsonRpcMessage;
+declare const mcpApps_JsonRpcNotification: typeof JsonRpcNotification;
+declare const mcpApps_JsonRpcRequest: typeof JsonRpcRequest;
+declare const mcpApps_JsonRpcResponse: typeof JsonRpcResponse;
+declare const mcpApps_JsonRpcSuccessResponse: typeof JsonRpcSuccessResponse;
+declare const mcpApps_LogLevel: typeof LogLevel;
+declare const mcpApps_LogMessageParams: typeof LogMessageParams;
+declare const mcpApps_MCP_METHODS: typeof MCP_METHODS;
+type mcpApps_McpAppsBridge = McpAppsBridge;
+declare const mcpApps_McpAppsBridge: typeof McpAppsBridge;
+type mcpApps_McpAppsStore = McpAppsStore;
+declare const mcpApps_McpAppsStore: typeof McpAppsStore;
+declare const mcpApps_McpStoreState: typeof McpStoreState;
+declare const mcpApps_McpUiInitializeResult: typeof McpUiInitializeResult;
+declare const mcpApps_McpUiResourceCsp: typeof McpUiResourceCsp;
+type mcpApps_McpView = McpView;
+declare const mcpApps_OpenLinkParams: typeof OpenLinkParams;
+declare const mcpApps_PROTOCOL_VERSION: typeof PROTOCOL_VERSION;
+declare const mcpApps_PermissionFields: typeof PermissionFields;
+declare const mcpApps_Platform: typeof Platform;
+declare const mcpApps_RequestDisplayModeParams: typeof RequestDisplayModeParams;
+declare const mcpApps_RequestDisplayModeResult: typeof RequestDisplayModeResult;
+declare const mcpApps_ResourceContent: typeof ResourceContent;
+declare const mcpApps_ResourceReadParams: typeof ResourceReadParams;
+declare const mcpApps_ResourceReadResult: typeof ResourceReadResult;
+declare const mcpApps_ResourceTeardownParams: typeof ResourceTeardownParams;
+declare const mcpApps_SafeAreaInsets: typeof SafeAreaInsets;
+declare const mcpApps_SandboxCapabilities: typeof SandboxCapabilities;
+declare const mcpApps_SizeChangedParams: typeof SizeChangedParams;
+declare const mcpApps_StyleCss: typeof StyleCss;
+declare const mcpApps_StyleVariables: typeof StyleVariables;
+declare const mcpApps_Styles: typeof Styles;
+declare const mcpApps_Theme: typeof Theme;
+declare const mcpApps_ToolCancelledParams: typeof ToolCancelledParams;
+declare const mcpApps_ToolInfo: typeof ToolInfo;
+declare const mcpApps_ToolInputParams: typeof ToolInputParams;
+declare const mcpApps_ToolInputPartialParams: typeof ToolInputPartialParams;
+declare const mcpApps_ToolsCallParams: typeof ToolsCallParams;
+declare const mcpApps_UiMessageParams: typeof UiMessageParams;
+declare const mcpApps_UpdateModelContextParams: typeof UpdateModelContextParams;
+declare const mcpApps_callTool: typeof callTool;
+declare const mcpApps_createErrorResponse: typeof createErrorResponse;
+declare const mcpApps_createMcpStoreHook: typeof createMcpStoreHook;
+declare const mcpApps_createMcpView: typeof createMcpView;
+declare const mcpApps_createNotification: typeof createNotification;
+declare const mcpApps_createRequest: typeof createRequest;
+declare const mcpApps_createSuccessResponse: typeof createSuccessResponse;
+declare const mcpApps_generateId: typeof generateId;
+declare const mcpApps_getBridge: typeof getBridge;
+declare const mcpApps_getStore: typeof getStore;
+declare const mcpApps_initialize: typeof initialize;
+declare const mcpApps_isErrorResponse: typeof isErrorResponse;
+declare const mcpApps_isJsonRpcMessage: typeof isJsonRpcMessage;
+declare const mcpApps_isNotification: typeof isNotification;
+declare const mcpApps_isRequest: typeof isRequest;
+declare const mcpApps_isResponse: typeof isResponse;
+declare const mcpApps_log: typeof log;
+declare const mcpApps_logDebug: typeof logDebug;
+declare const mcpApps_logError: typeof logError;
+declare const mcpApps_logInfo: typeof logInfo;
+declare const mcpApps_logWarning: typeof logWarning;
+declare const mcpApps_notifySizeChanged: typeof notifySizeChanged;
+declare const mcpApps_onTeardown: typeof onTeardown;
+declare const mcpApps_openLink: typeof openLink;
+declare const mcpApps_readResource: typeof readResource;
+declare const mcpApps_requestDisplayMode: typeof requestDisplayMode;
+declare const mcpApps_sendMessage: typeof sendMessage;
+declare const mcpApps_setupAutoSizeReporting: typeof setupAutoSizeReporting;
+declare const mcpApps_updateModelContext: typeof updateModelContext;
+declare const mcpApps_useAvailableDisplayModes: typeof useAvailableDisplayModes;
+declare const mcpApps_useContainerDimensions: typeof useContainerDimensions;
+declare const mcpApps_useDeviceCapabilities: typeof useDeviceCapabilities;
+declare const mcpApps_useDisplayMode: typeof useDisplayMode;
+declare const mcpApps_useHostCapabilities: typeof useHostCapabilities;
+declare const mcpApps_useHostContext: typeof useHostContext;
+declare const mcpApps_useIsInitialized: typeof useIsInitialized;
+declare const mcpApps_useLocale: typeof useLocale;
+declare const mcpApps_useMcpStore: typeof useMcpStore;
+declare const mcpApps_usePlatform: typeof usePlatform;
+declare const mcpApps_useSafeArea: typeof useSafeArea;
+declare const mcpApps_useStyles: typeof useStyles;
+declare const mcpApps_useTheme: typeof useTheme;
+declare const mcpApps_useTimezone: typeof useTimezone;
+declare const mcpApps_useToolInfo: typeof useToolInfo;
+declare const mcpApps_useToolInput: typeof useToolInput;
+declare const mcpApps_useToolResult: typeof useToolResult;
+declare namespace mcpApps {
+  export { type mcpApps_AutoResizeOptions as AutoResizeOptions, mcpApps_CallToolResult as CallToolResult, mcpApps_ClientInfo as ClientInfo, mcpApps_ContainerDimensions as ContainerDimensions, mcpApps_ContentBlock as ContentBlock, type mcpApps_CreateMcpViewOptions as CreateMcpViewOptions, mcpApps_DEFAULT_CLIENT_INFO as DEFAULT_CLIENT_INFO, mcpApps_DeviceCapabilities as DeviceCapabilities, mcpApps_DisplayMode as DisplayMode, mcpApps_ERROR_CODES as ERROR_CODES, mcpApps_HostCapabilities as HostCapabilities, mcpApps_HostContext as HostContext, mcpApps_HostInfo as HostInfo, mcpApps_InitializeOptions as InitializeOptions, mcpApps_InitializeParams as InitializeParams, mcpApps_JsonRpcError as JsonRpcError, mcpApps_JsonRpcErrorResponse as JsonRpcErrorResponse, mcpApps_JsonRpcId as JsonRpcId, mcpApps_JsonRpcMessage as JsonRpcMessage, mcpApps_JsonRpcNotification as JsonRpcNotification, mcpApps_JsonRpcRequest as JsonRpcRequest, mcpApps_JsonRpcResponse as JsonRpcResponse, mcpApps_JsonRpcSuccessResponse as JsonRpcSuccessResponse, mcpApps_LogLevel as LogLevel, mcpApps_LogMessageParams as LogMessageParams, mcpApps_MCP_METHODS as MCP_METHODS, mcpApps_McpAppsBridge as McpAppsBridge, mcpApps_McpAppsStore as McpAppsStore, mcpApps_McpStoreState as McpStoreState, mcpApps_McpUiInitializeResult as McpUiInitializeResult, mcpApps_McpUiResourceCsp as McpUiResourceCsp, type mcpApps_McpView as McpView, mcpApps_OpenLinkParams as OpenLinkParams, mcpApps_PROTOCOL_VERSION as PROTOCOL_VERSION, mcpApps_PermissionFields as PermissionFields, mcpApps_Platform as Platform, mcpApps_RequestDisplayModeParams as RequestDisplayModeParams, mcpApps_RequestDisplayModeResult as RequestDisplayModeResult, mcpApps_ResourceContent as ResourceContent, mcpApps_ResourceReadParams as ResourceReadParams, mcpApps_ResourceReadResult as ResourceReadResult, mcpApps_ResourceTeardownParams as ResourceTeardownParams, mcpApps_SafeAreaInsets as SafeAreaInsets, mcpApps_SandboxCapabilities as SandboxCapabilities, mcpApps_SizeChangedParams as SizeChangedParams, mcpApps_StyleCss as StyleCss, mcpApps_StyleVariables as StyleVariables, mcpApps_Styles as Styles, mcpApps_Theme as Theme, mcpApps_ToolCancelledParams as ToolCancelledParams, mcpApps_ToolInfo as ToolInfo, mcpApps_ToolInputParams as ToolInputParams, mcpApps_ToolInputPartialParams as ToolInputPartialParams, mcpApps_ToolsCallParams as ToolsCallParams, mcpApps_UiMessageParams as UiMessageParams, mcpApps_UpdateModelContextParams as UpdateModelContextParams, mcpApps_callTool as callTool, mcpApps_createErrorResponse as createErrorResponse, mcpApps_createMcpStoreHook as createMcpStoreHook, mcpApps_createMcpView as createMcpView, mcpApps_createNotification as createNotification, mcpApps_createRequest as createRequest, mcpApps_createSuccessResponse as createSuccessResponse, mcpApps_generateId as generateId, mcpApps_getBridge as getBridge, mcpApps_getStore as getStore, mcpApps_initialize as initialize, mcpApps_isErrorResponse as isErrorResponse, mcpApps_isJsonRpcMessage as isJsonRpcMessage, mcpApps_isNotification as isNotification, mcpApps_isRequest as isRequest, mcpApps_isResponse as isResponse, mcpApps_log as log, mcpApps_logDebug as logDebug, mcpApps_logError as logError, mcpApps_logInfo as logInfo, mcpApps_logWarning as logWarning, mcpApps_notifySizeChanged as notifySizeChanged, mcpApps_onTeardown as onTeardown, mcpApps_openLink as openLink, mcpApps_readResource as readResource, mcpApps_requestDisplayMode as requestDisplayMode, mcpApps_sendMessage as sendMessage, mcpApps_setupAutoSizeReporting as setupAutoSizeReporting, mcpApps_updateModelContext as updateModelContext, mcpApps_useAvailableDisplayModes as useAvailableDisplayModes, mcpApps_useContainerDimensions as useContainerDimensions, mcpApps_useDeviceCapabilities as useDeviceCapabilities, mcpApps_useDisplayMode as useDisplayMode, mcpApps_useHostCapabilities as useHostCapabilities, mcpApps_useHostContext as useHostContext, mcpApps_useIsInitialized as useIsInitialized, mcpApps_useLocale as useLocale, mcpApps_useMcpStore as useMcpStore, mcpApps_usePlatform as usePlatform, mcpApps_useSafeArea as useSafeArea, mcpApps_useStyles as useStyles, mcpApps_useTheme as useTheme, mcpApps_useTimezone as useTimezone, mcpApps_useToolInfo as useToolInfo, mcpApps_useToolInput as useToolInput, mcpApps_useToolResult as useToolResult };
+}
+
+export { type AutoResizeOptions as $, useToolInfo as A, useToolInput as B, useToolResult as C, useHostContext as D, ERROR_CODES as E, useHostCapabilities as F, useIsInitialized as G, initialize as H, callTool as I, JsonRpcError as J, readResource as K, sendMessage as L, McpAppsBridge as M, openLink as N, requestDisplayMode as O, updateModelContext as P, notifySizeChanged as Q, setupAutoSizeReporting as R, log as S, logDebug as T, logInfo as U, logWarning as V, logError as W, onTeardown as X, createMcpView as Y, type McpView as Z, type CreateMcpViewOptions as _, createNotification as a, createSuccessResponse as b, createRequest as c, createErrorResponse as d, isRequest as e, isNotification as f, generateId as g, isResponse as h, isJsonRpcMessage as i, isErrorResponse as j, getBridge as k, McpAppsStore as l, mcpApps as m, getStore as n, createMcpStoreHook as o, useTheme as p, useLocale as q, useTimezone as r, useDisplayMode as s, useAvailableDisplayModes as t, useMcpStore as u, useContainerDimensions as v, useSafeArea as w, usePlatform as x, useDeviceCapabilities as y, useStyles as z };