@pancake-apps/web 0.0.0-snapshot-20260125200133

package/README.md

@@ -0,0 +1,333 @@
+# @pancake-apps/web
+
+Unified SDK for building views that work across AI host environments (ChatGPT Apps SDK and MCP Apps).
+
+## Features
+
+- **Multi-platform support**: Write once, run everywhere (ChatGPT Apps SDK or MCP Apps)
+- **React 18 optimized**: Built with `useSyncExternalStore` for efficient state management
+- **Type-safe**: Full TypeScript support with comprehensive type definitions
+- **Modular**: Use the unified SDK or platform-specific SDKs based on your needs
+- **Tree-shakeable**: ESM-only with proper exports for optimal bundle size
+
+## Installation
+
+```bash
+npm install @pancake-apps/web
+```
+
+## Package Structure
+
+This package provides three subpath exports:
+
+| Import Path | Description |
+|-------------|-------------|
+| `@pancake-apps/web` | Unified SDK - auto-detects platform |
+| `@pancake-apps/web/apps-sdk` | ChatGPT Apps SDK (wraps `window.openai`) |
+| `@pancake-apps/web/mcp-apps` | MCP Apps SDK (JSON-RPC over postMessage) |
+
+## Quick Start
+
+### Unified SDK (Recommended)
+
+The unified SDK automatically detects the platform and provides a consistent API:
+
+```tsx
+import {
+  useTheme,
+  useLocale,
+  useDisplayMode,
+  useHostEnvironment,
+  callTool,
+  sendFollowUpMessage,
+} from '@pancake-apps/web';
+
+function MyApp() {
+  const theme = useTheme(); // 'light' | 'dark'
+  const locale = useLocale(); // e.g., 'en-US'
+  const displayMode = useDisplayMode(); // 'inline' | 'pip' | 'fullscreen'
+
+  // Get all environment info at once
+  const env = useHostEnvironment();
+
+  const handleClick = async () => {
+    // Call a tool
+    const result = await callTool('my-tool', { param: 'value' });
+
+    // Send a message back to the conversation
+    await sendFollowUpMessage('Here is the result...');
+  };
+
+  return (
+    <div data-theme={theme}>
+      {/* Your app */}
+    </div>
+  );
+}
+```
+
+### Platform-Specific SDKs
+
+If you know your target platform, you can import directly:
+
+```tsx
+// For ChatGPT Apps
+import { useTheme, callTool } from '@pancake-apps/web/apps-sdk';
+
+// For MCP Apps
+import { useTheme, callTool } from '@pancake-apps/web/mcp-apps';
+```
+
+## Semantic API (Recommended)
+
+The Semantic API provides the simplest, most intuitive way to build Pancake apps:
+
+### useViewData Hook
+
+Get all view data in one hook with loading states:
+
+```tsx
+import { useViewData, say } from '@pancake-apps/web';
+
+interface MyInput {
+  query: string;
+}
+
+interface MyOutput {
+  results: string[];
+}
+
+function MyApp() {
+  const {
+    status,        // 'idle' | 'streaming' | 'pending' | 'ready' | 'error'
+    isReady,       // true when both input and output are available
+    isStreaming,   // true when receiving streaming input (MCP only)
+    input,         // Tool input parameters
+    inputPartial,  // Partial input during streaming
+    output,        // Tool output data
+    error,         // Error if isError is true
+  } = useViewData<MyInput, MyOutput>();
+
+  if (!isReady) {
+    return <div>Loading...</div>;
+  }
+
+  return (
+    <div>
+      <h1>Results for: {input?.query}</h1>
+      <ul>
+        {output?.results.map((r, i) => <li key={i}>{r}</li>)}
+      </ul>
+      <button onClick={() => say('Thanks for the results!')}>
+        Send Feedback
+      </button>
+    </div>
+  );
+}
+```
+
+### Semantic Actions
+
+```tsx
+import { say, navigateToView } from '@pancake-apps/web';
+
+// Send a message to the conversation
+say('Task completed successfully!');
+
+// Navigate to another view/tool
+await navigateToView('settings');
+await navigateToView('user-profile', { userId: '123' });
+```
+
+### PancakeProvider
+
+Wrap your app with `PancakeProvider` for proper MCP initialization:
+
+```tsx
+import { PancakeProvider, usePancakeContext } from '@pancake-apps/web';
+
+function App() {
+  return (
+    <PancakeProvider
+      onError={(e) => console.error('Init failed:', e)}
+      fallback={<LoadingSpinner />}
+    >
+      <MyPancakeApp />
+    </PancakeProvider>
+  );
+}
+
+function MyPancakeApp() {
+  const { isReady, platform, error } = usePancakeContext();
+
+  if (error) return <ErrorDisplay error={error} />;
+  if (!isReady) return <Loading />;
+
+  return <Content platform={platform} />;
+}
+```
+
+**Provider Props:**
+
+| Prop | Type | Description |
+|------|------|-------------|
+| `children` | `ReactNode` | App content |
+| `onError` | `(error: Error) => void` | Error callback |
+| `fallback` | `ReactNode` | Loading component (MCP only) |
+| `immediate` | `boolean` | Render before init completes |
+| `debug` | `boolean` | Enable debug logging |
+
+## API Reference
+
+### Hooks
+
+#### Simple Hooks (State)
+
+| Hook | Return Type | Description |
+|------|-------------|-------------|
+| `useTheme()` | `'light' \| 'dark'` | Current color theme |
+| `useLocale()` | `string` | Locale string (e.g., `'en-US'`) |
+| `useDisplayMode()` | `DisplayMode` | Current display mode |
+| `usePlatform()` | `Platform` | Current platform identifier |
+| `useDeviceType()` | `DeviceType` | Device type (mobile/tablet/desktop) |
+| `useSafeArea()` | `SafeAreaInsets` | Safe area insets for notched devices |
+| `useMaxHeight()` | `number` | Maximum height constraint |
+| `useContainerSize()` | `ContainerSize` | Container dimensions |
+| `useInputCapabilities()` | `InputCapabilities` | Input device capabilities |
+| `useToolInput<T>()` | `T \| undefined` | Tool input parameters |
+| `useToolOutput<T>()` | `T \| undefined` | Tool output data |
+| `useToolResponseMetadata()` | `ToolResponseMetadata \| undefined` | Tool response metadata |
+
+#### Rich Hooks (State + Actions)
+
+| Hook | Description |
+|------|-------------|
+| `useCallTool(toolName, options?)` | Call tools with loading/error state management |
+| `useViewParams<T>()` | Parse URL search parameters |
+| `useViewState<T>(initial)` | Manage view state with reset and dirty tracking |
+
+#### Convenience Hooks
+
+| Hook | Description |
+|------|-------------|
+| `useHostEnvironment()` | Get all environment info in one object |
+| `useDisplayModeControl()` | Control display mode with helper methods |
+
+### Actions
+
+| Function | Description |
+|----------|-------------|
+| `callTool(name, args)` | Call a tool |
+| `sendFollowUpMessage(message)` | Send a message to the conversation |
+| `openExternal(url)` | Open an external URL |
+| `requestDisplayMode(mode)` | Request a display mode change |
+| `isSupported(feature)` | Check if a feature is supported |
+
+### Types
+
+```typescript
+type Theme = 'light' | 'dark';
+type DisplayMode = 'inline' | 'pip' | 'fullscreen';
+type Platform = 'ios' | 'android' | 'macos' | 'windows' | 'web';
+type DeviceType = 'mobile' | 'tablet' | 'desktop';
+
+interface SafeAreaInsets {
+  top: number;
+  right: number;
+  bottom: number;
+  left: number;
+}
+
+interface ContainerSize {
+  width: number;
+  height: number;
+}
+
+interface InputCapabilities {
+  canHover: boolean;
+  hasCoarsePointer: boolean;
+}
+
+interface CallToolResult<T = unknown> {
+  content: ContentBlock[];
+  structuredContent?: T;
+  isError?: boolean;
+  _meta?: Record<string, unknown>;
+}
+```
+
+## Feature Detection
+
+Check if specific features are supported on the current platform:
+
+```tsx
+import { isSupported } from '@pancake-apps/web';
+
+if (isSupported('uploadFile')) {
+  // Apps SDK only feature
+}
+
+if (isSupported('readResource')) {
+  // MCP Apps only feature
+}
+```
+
+## Global Object
+
+For imperative access outside React, use the actions directly:
+
+```typescript
+import { callTool, sendFollowUpMessage, openExternal } from '@pancake-apps/web';
+
+// Call a tool
+const result = await callTool('my-tool', { param: 'value' });
+
+// Send a message
+sendFollowUpMessage('Here is the result...');
+
+// Open external URL
+openExternal('https://example.com');
+```
+
+## Platform Differences
+
+| Feature | Apps SDK | MCP Apps |
+|---------|----------|----------|
+| `uploadFile` | ✅ | ❌ |
+| `getFileDownloadUrl` | ✅ | ❌ |
+| `requestModal` | ✅ | ❌ |
+| `readResource` | ❌ | ✅ |
+| `updateModelContext` | ❌ | ✅ |
+| `logging` | ❌ | ✅ |
+| `callTool` | ✅ | ✅ |
+| `sendMessage` | ✅ | ✅ |
+| `openLink` | ✅ | ✅ |
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Run development build with watch
+npm run dev
+
+# Run tests
+npm test
+
+# Run tests once
+npm run test:run
+
+# Type check
+npm run typecheck
+
+# Lint
+npm run lint
+
+# Build for production
+npm run build
+```
+
+## License
+
+MIT

package/dist/adaptor-interface-BYbH9PpT.d.ts

@@ -0,0 +1,370 @@
+/**
+ * Unified Pancake SDK Type Definitions
+ *
+ * These types normalize across both ChatGPT Apps SDK and MCP Apps platforms.
+ */
+type Theme = 'light' | 'dark';
+type DisplayMode = 'inline' | 'pip' | 'fullscreen';
+/**
+ * Normalized platform types
+ * - Apps SDK: No platform info, defaults to 'web'
+ * - MCP Apps: 'web' | 'desktop' | 'mobile' mapped to our types
+ */
+type Platform = 'ios' | 'android' | 'macos' | 'windows' | 'web';
+type DeviceType = 'mobile' | 'tablet' | 'desktop';
+interface SafeAreaInsets {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+interface ContainerSize {
+    width: number;
+    height: number;
+}
+interface InputCapabilities {
+    canHover: boolean;
+    hasCoarsePointer: boolean;
+}
+interface ContentBlock {
+    type: string;
+    text?: string;
+    [key: string]: unknown;
+}
+interface CallToolResult<TOutput = unknown> {
+    content: ContentBlock[];
+    structuredContent?: TOutput;
+    isError?: boolean;
+    _meta?: Record<string, unknown>;
+}
+/**
+ * Status for view parameter loading
+ */
+type ViewParamsStatus = 'idle' | 'pending' | 'success';
+interface UseViewParamsResult<TInput, TOutput, TMeta> {
+    status: ViewParamsStatus;
+    isIdle: boolean;
+    isPending: boolean;
+    isSuccess: boolean;
+    input: TInput | undefined;
+    output: TOutput | undefined;
+    metadata: TMeta | undefined;
+}
+type CallToolStatus = 'idle' | 'pending' | 'success' | 'error';
+interface UseCallToolCallbacks<TOutput> {
+    onSuccess?: (data: CallToolResult<TOutput>) => void;
+    onError?: (error: Error) => void;
+    onSettled?: () => void;
+}
+interface UseCallToolResult<TInput, TOutput> {
+    status: CallToolStatus;
+    isIdle: boolean;
+    isPending: boolean;
+    isSuccess: boolean;
+    isError: boolean;
+    data: CallToolResult<TOutput> | undefined;
+    error: Error | undefined;
+    callTool: (args?: TInput, callbacks?: UseCallToolCallbacks<TOutput>) => void;
+    callToolAsync: (args?: TInput) => Promise<CallToolResult<TOutput>>;
+    reset: () => void;
+}
+/**
+ * Features that may or may not be supported depending on platform
+ */
+type Feature = 'uploadFile' | 'getFileDownloadUrl' | 'requestModal' | 'requestClose' | 'setOpenInAppUrl' | 'notifyIntrinsicHeight' | 'readResource' | 'updateModelContext' | 'timezone' | 'cssVariables' | 'toolInfo' | 'logging' | 'ping' | 'onTeardown' | 'callTool' | 'sendMessage' | 'openLink' | 'requestDisplayMode' | 'sizeReporting';
+type LogLevel = 'debug' | 'info' | 'warning' | 'error';
+interface ResourceContent {
+    uri: string;
+    mimeType: string;
+    text?: string;
+    blob?: string;
+    _meta?: Record<string, unknown>;
+}
+interface ResourceReadResult {
+    contents: ResourceContent[];
+}
+interface UpdateModelContextParams {
+    content?: ContentBlock[];
+    structuredContent?: Record<string, unknown>;
+}
+interface ResourceTeardownParams {
+    reason: string;
+}
+type TeardownHandler = (params: ResourceTeardownParams) => Promise<void> | void;
+interface AdaptorStoreState {
+    theme: Theme;
+    locale: string;
+    displayMode: DisplayMode;
+    maxHeight: number;
+    safeArea: SafeAreaInsets;
+    containerSize: ContainerSize;
+    containerWidth: number;
+    containerHeight: number;
+    platform: Platform;
+    deviceType: DeviceType;
+    canHover: boolean;
+    hasCoarsePointer: boolean;
+    inputCapabilities: InputCapabilities;
+    toolInput: unknown;
+    toolInputPartial: unknown;
+    toolOutput: unknown;
+    toolResponseMetadata: unknown;
+    viewState: unknown;
+}
+interface ExternalStore<T> {
+    subscribe: (callback: () => void) => () => void;
+    getSnapshot: () => T;
+    getServerSnapshot: () => T | undefined;
+}
+interface ToolResponseMetadata {
+    toolName?: string;
+    timestamp?: number;
+    [key: string]: unknown;
+}
+type AdaptorStoreKey = keyof AdaptorStoreState;
+/**
+ * Status for view data loading in the semantic API
+ */
+type ViewDataStatus = 'idle' | 'streaming' | 'pending' | 'ready' | 'error';
+/**
+ * Result type for the useViewData semantic hook
+ */
+interface UseViewDataResult<TInput, TOutput, TMeta> {
+    /** Current status of the view data */
+    status: ViewDataStatus;
+    /** True when no input has been received yet */
+    isIdle: boolean;
+    /** True when input received but no output yet */
+    isPending: boolean;
+    /** True when receiving streaming input (MCP Apps only) */
+    isStreaming: boolean;
+    /** True when both input and output are available */
+    isReady: boolean;
+    /** True when an error occurred */
+    isError: boolean;
+    /** The complete tool input */
+    input: TInput | undefined;
+    /** Partial input during streaming (MCP Apps only) */
+    inputPartial: Partial<TInput> | undefined;
+    /** The tool output */
+    output: TOutput | undefined;
+    /** Tool response metadata */
+    metadata: TMeta | undefined;
+    /** Error if isError is true */
+    error: Error | undefined;
+}
+/**
+ * Status for action execution
+ */
+type ActionStatus = 'idle' | 'pending' | 'success' | 'error';
+/**
+ * Status for data queries (extends ActionStatus with stale state)
+ */
+type DataStatus = 'idle' | 'pending' | 'success' | 'error' | 'stale';
+/**
+ * Marker type for action tools (side-effect, fire-and-forget)
+ * Use for: save, delete, update, navigate, send, submit
+ */
+type ActionTool<TInput = void> = {
+    readonly _brand: 'ActionTool';
+    readonly _input: TInput;
+};
+/**
+ * Marker type for data tools (read-only queries)
+ * Use for: search, get, list, fetch
+ */
+type DataTool<TInput = void, TOutput = unknown> = {
+    readonly _brand: 'DataTool';
+    readonly _input: TInput;
+    readonly _output: TOutput;
+};
+/**
+ * Callbacks for useAction hook
+ */
+interface UseActionCallbacks {
+    onSuccess?: () => void;
+    onError?: (error: Error) => void;
+    onSettled?: () => void;
+}
+/**
+ * Result type for useAction hook
+ */
+interface UseActionResult<TInput> {
+    /** Current status of the action */
+    status: ActionStatus;
+    /** True when action has not been executed yet */
+    isIdle: boolean;
+    /** True when action is executing */
+    isPending: boolean;
+    /** True when action completed successfully */
+    isSuccess: boolean;
+    /** True when action failed */
+    isError: boolean;
+    /** Error if isError is true */
+    error: Error | undefined;
+    /** Execute the action (fire-and-forget with callbacks) */
+    execute: (input?: TInput, callbacks?: UseActionCallbacks) => void;
+    /** Execute the action (promise-based) */
+    executeAsync: (input?: TInput) => Promise<void>;
+    /** Reset state back to idle */
+    reset: () => void;
+}
+/**
+ * Options for useData hook
+ */
+interface UseDataOptions<TOutput> {
+    /** Initial data to use before first fetch */
+    initialData?: TOutput;
+    /** Time in ms before data is considered stale (default: 0 = immediately stale) */
+    staleTime?: number;
+    /** Time in ms to keep data in cache (default: 5 minutes) */
+    cacheTime?: number;
+    /** Refetch when window regains focus */
+    refetchOnWindowFocus?: boolean;
+    /** Refetch on interval (ms) */
+    refetchInterval?: number;
+    /** Callback on successful fetch */
+    onSuccess?: (data: TOutput) => void;
+    /** Callback on fetch error */
+    onError?: (error: Error) => void;
+}
+/**
+ * Result type for useData hook
+ */
+interface UseDataResult<TInput, TOutput> {
+    /** Current status of the data */
+    status: DataStatus;
+    /** True when no data has been fetched yet */
+    isIdle: boolean;
+    /** True when data is being fetched for the first time */
+    isPending: boolean;
+    /** True when data is available */
+    isSuccess: boolean;
+    /** True when fetch failed */
+    isError: boolean;
+    /** True when data exists but is stale */
+    isStale: boolean;
+    /** True when a fetch is in progress (including background refetch) */
+    isFetching: boolean;
+    /** The fetched data */
+    data: TOutput | undefined;
+    /** Error if isError is true */
+    error: Error | undefined;
+    /** Fetch data (fire-and-forget) */
+    fetch: (input?: TInput) => void;
+    /** Fetch data (promise-based) */
+    fetchAsync: (input?: TInput) => Promise<TOutput>;
+    /** Refetch using the last input */
+    refetch: () => void;
+    /** Invalidate the cache (marks data as stale) */
+    invalidate: () => void;
+}
+
+/**
+ * Platform Detection
+ *
+ * Detects which host environment is available.
+ */
+type HostPlatform = 'apps-sdk' | 'mcp-apps';
+declare global {
+    interface Window {
+        __PANCAKE_FORCE_MCP__?: boolean;
+    }
+}
+/**
+ * Check if ChatGPT Apps SDK (window.openai) is available
+ */
+declare function isAppsSdkAvailable(): boolean;
+/**
+ * Check if MCP Apps environment is likely available
+ *
+ * MCP Apps uses postMessage, so we check for iframe context
+ */
+declare function isMcpAppsAvailable(): boolean;
+declare function getPlatform(): HostPlatform;
+
+/**
+ * Unified Adaptor Interface
+ *
+ * Defines the contract that both platform adaptors must implement.
+ */
+
+interface UnifiedAdaptor {
+    /**
+     * Platform identifier
+     */
+    readonly platform: 'apps-sdk' | 'mcp-apps';
+    /**
+     * Get an external store for a specific state key
+     * Used with useSyncExternalStore
+     */
+    getExternalStore<K extends AdaptorStoreKey>(key: K): ExternalStore<AdaptorStoreState[K]>;
+    getTheme(): Theme;
+    getLocale(): string;
+    getDisplayMode(): DisplayMode;
+    getMaxHeight(): number;
+    getSafeArea(): SafeAreaInsets;
+    getPlatform(): Platform;
+    getDeviceType(): DeviceType;
+    getContainerSize(): {
+        width: number;
+        height: number;
+    };
+    getInputCapabilities(): {
+        canHover: boolean;
+        hasCoarsePointer: boolean;
+    };
+    getToolInput<T>(): T | undefined;
+    getToolOutput<T>(): T | undefined;
+    getToolResponseMetadata<T>(): T | undefined;
+    getViewState<T>(): T | undefined;
+    /**
+     * Get partial tool input during streaming (MCP-specific)
+     * Used by useViewData for streaming status detection
+     */
+    getToolInputPartial<T>(): Partial<T> | undefined;
+    callTool<TInput, TOutput>(name: string, args?: TInput): Promise<CallToolResult<TOutput>>;
+    sendFollowUpMessage(message: string): void;
+    openExternal(url: string): void;
+    requestDisplayMode(mode: DisplayMode): void;
+    setViewState<T>(state: T): void;
+    isSupported(feature: Feature): boolean;
+    /**
+     * Read a resource by URI (MCP-specific, throws on Apps SDK)
+     */
+    readResource(uri: string): Promise<ResourceReadResult>;
+    /**
+     * Update the model context (MCP-specific, no-op on Apps SDK)
+     */
+    updateModelContext(params: UpdateModelContextParams): Promise<void>;
+    /**
+     * Log a message (MCP sends to host, Apps SDK uses console)
+     */
+    log(level: LogLevel, data: unknown, logger?: string): void;
+    /**
+     * Ping the host (MCP-specific, no-op on Apps SDK)
+     */
+    ping(): Promise<void>;
+    /**
+     * Register a teardown handler (MCP-specific, no-op on Apps SDK)
+     */
+    onTeardown(handler: TeardownHandler): () => void;
+    /**
+     * Notify the host of size changes (MCP sends notification, Apps SDK uses notifyIntrinsicHeight)
+     */
+    notifySizeChanged(width: number, height: number): void;
+    /**
+     * Setup automatic size reporting via ResizeObserver
+     */
+    setupAutoSizeReporting(element: HTMLElement): () => void;
+    /**
+     * Initialize the adaptor (MCP Apps requires explicit init)
+     */
+    initialize?(): Promise<void>;
+    /**
+     * Ensure initialized before operations
+     */
+    ensureReady(): Promise<void>;
+}
+
+export { type ActionTool as A, type ContainerSize as C, type DisplayMode as D, type ExternalStore as E, type Feature as F, type HostPlatform as H, type InputCapabilities as I, type LogLevel as L, type Platform as P, type ResourceContent as R, type SafeAreaInsets as S, type Theme as T, type UpdateModelContextParams as U, type ViewDataStatus as V, type DeviceType as a, isMcpAppsAvailable as b, type CallToolResult as c, type ContentBlock as d, type ToolResponseMetadata as e, type ResourceReadResult as f, getPlatform as g, type ResourceTeardownParams as h, isAppsSdkAvailable as i, type TeardownHandler as j, type DataTool as k, type UnifiedAdaptor as l, type UseViewDataResult as m, type UseActionResult as n, type UseDataOptions as o, type UseDataResult as p, type UseCallToolResult as q, type UseCallToolCallbacks as r, type UseViewParamsResult as s, type ActionStatus as t, type AdaptorStoreKey as u, type AdaptorStoreState as v, type CallToolStatus as w, type DataStatus as x, type UseActionCallbacks as y, type ViewParamsStatus as z };

package/dist/apps-sdk/index.d.ts

@@ -0,0 +1 @@
+export { A as AppsSdkBridge, j as AppsSdkStore, b as CallToolResult, C as ContentBlock, D as DisplayMode, M as ModalOptions, O as OpenAiGlobals, c as OpenAiMethods, d as OpenAiRuntime, g as SET_GLOBALS_EVENT_TYPE, S as SafeAreaInsets, f as SetGlobalsEvent, e as SetGlobalsEventDetail, T as Theme, y as callTool, l as createOpenAiGlobalHook, h as getBridge, E as getFileDownloadUrl, k as getStore, i as isAppsSdkAvailable, H as notifyIntrinsicHeight, J as openExternal, I as requestClose, F as requestDisplayMode, G as requestModal, z as sendFollowUpMessage, K as setOpenInAppUrl, B as uploadFile, o as useDisplayMode, n as useLocale, p as useMaxHeight, u as useOpenAiGlobal, q as useSafeArea, m as useTheme, t as useToolInput, v as useToolOutput, w as useToolResponseMetadata, s as useUserAgent, r as useView, x as useWidgetState } from '../index-BBfZZJWn.js';

package/dist/apps-sdk/index.js

@@ -0,0 +1,4 @@
+export { AppsSdkBridge, AppsSdkStore, SET_GLOBALS_EVENT_TYPE, callTool, createOpenAiGlobalHook, getBridge, getFileDownloadUrl, getStore, isAppsSdkAvailable, notifyIntrinsicHeight, openExternal, requestClose, requestDisplayMode, requestModal, sendFollowUpMessage, setOpenInAppUrl, uploadFile, useDisplayMode, useLocale, useMaxHeight, useOpenAiGlobal, useSafeArea, useTheme, useToolInput, useToolOutput, useToolResponseMetadata, useUserAgent, useView, useWidgetState } from '../chunk-5NYJ2IVD.js';
+import '../chunk-PZ5AY32C.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map