@pancake-apps/web 0.0.1

package/dist/react/index.cjs

@@ -0,0 +1,1067 @@
+'use strict';
+
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/react/provider.tsx
+
+// src/types.ts
+var DEFAULT_HOST_CONTEXT = {
+  theme: "light",
+  displayMode: "inline",
+  availableDisplayModes: ["inline"],
+  viewport: { width: 0, height: 0 },
+  locale: "en-US",
+  timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+  platform: "web"
+};
+
+// src/adapters/mcp.ts
+var McpAdapter = class {
+  constructor(options) {
+    this.options = options;
+  }
+  protocol = "mcp";
+  app = null;
+  connected = false;
+  context = { ...DEFAULT_HOST_CONTEXT };
+  currentToolInput;
+  currentToolOutput;
+  state = null;
+  hostContextHandlers = /* @__PURE__ */ new Set();
+  toolInputHandlers = /* @__PURE__ */ new Set();
+  toolOutputHandlers = /* @__PURE__ */ new Set();
+  toolCancelledHandlers = /* @__PURE__ */ new Set();
+  teardownHandlers = /* @__PURE__ */ new Set();
+  isConnected() {
+    return this.connected;
+  }
+  async connect() {
+    if (this.connected) return;
+    if (typeof window === "undefined") {
+      this.connected = true;
+      return;
+    }
+    try {
+      const { App } = await import('@modelcontextprotocol/ext-apps');
+      this.app = new App(
+        { name: "pancake-client", version: "0.1.0" },
+        { tools: {} },
+        { autoResize: this.options?.autoResize ?? true }
+      );
+      const app = this.app;
+      app.onerror = (err) => this.log("error", err);
+      app.onhostcontextchanged = (params) => {
+        const hostContext = params?.hostContext ?? params;
+        this.context = this.mapHostContext(hostContext);
+        for (const handler of this.hostContextHandlers) {
+          handler(this.context);
+        }
+      };
+      app.ontoolinput = (params) => {
+        const args = params?.arguments;
+        if (args) {
+          this.currentToolInput = args;
+          for (const handler of this.toolInputHandlers) {
+            handler(args);
+          }
+        }
+      };
+      app.ontoolresult = (result) => {
+        const output = result?.structuredContent ?? {};
+        this.currentToolOutput = output;
+        for (const handler of this.toolOutputHandlers) {
+          handler(output);
+        }
+      };
+      app.ontoolcancelled = (params) => {
+        const reason = params?.reason;
+        for (const handler of this.toolCancelledHandlers) {
+          handler(reason);
+        }
+      };
+      app.onteardown = async (params) => {
+        const reason = params?.reason;
+        for (const handler of this.teardownHandlers) {
+          handler(reason);
+        }
+        return {};
+      };
+      await app.connect();
+      const initialContext = app.getHostContext();
+      if (initialContext) {
+        this.context = this.mapHostContext(initialContext);
+      }
+      this.connected = true;
+    } catch (error) {
+      console.warn("[Pancake] Failed to connect MCP adapter:", error);
+      this.connected = true;
+    }
+  }
+  async disconnect() {
+    this.connected = false;
+    this.app = null;
+  }
+  mapHostContext(raw) {
+    const ctx = raw;
+    const result = {
+      theme: ctx["theme"] ?? "light",
+      displayMode: ctx["displayMode"] ?? "inline",
+      availableDisplayModes: ctx["availableDisplayModes"] ?? ["inline"],
+      viewport: ctx["viewport"] ?? { width: 0, height: 0 },
+      locale: ctx["locale"] ?? "en-US",
+      timeZone: ctx["timeZone"] ?? Intl.DateTimeFormat().resolvedOptions().timeZone,
+      platform: ctx["platform"] ?? "web"
+    };
+    if (ctx["view"] !== void 0) {
+      result.view = ctx["view"];
+    }
+    if (ctx["safeAreaInsets"] !== void 0) {
+      result.safeAreaInsets = ctx["safeAreaInsets"];
+    }
+    return result;
+  }
+  getHostContext() {
+    return this.context;
+  }
+  onHostContextChange(handler) {
+    this.hostContextHandlers.add(handler);
+    return () => this.hostContextHandlers.delete(handler);
+  }
+  getViewParams() {
+    return {
+      inputs: this.currentToolInput ?? {},
+      data: this.currentToolOutput ?? {}
+    };
+  }
+  getToolInput() {
+    return this.currentToolInput;
+  }
+  getToolOutput() {
+    return this.currentToolOutput;
+  }
+  onToolInput(handler) {
+    this.toolInputHandlers.add(handler);
+    return () => this.toolInputHandlers.delete(handler);
+  }
+  onToolOutput(handler) {
+    this.toolOutputHandlers.add(handler);
+    return () => this.toolOutputHandlers.delete(handler);
+  }
+  async callTool(name, args) {
+    if (!this.app) {
+      throw new Error("Not connected");
+    }
+    const app = this.app;
+    const result = await app.callServerTool({ name, arguments: args });
+    return result.structuredContent ?? {};
+  }
+  async sendMessage(content) {
+    if (!this.app) return;
+    const app = this.app;
+    await app.sendMessage({
+      role: "user",
+      content: [{ type: "text", text: content.text }]
+    });
+  }
+  async openLink(url) {
+    if (!this.app) {
+      window.open(url, "_blank");
+      return;
+    }
+    const app = this.app;
+    await app.openLink({ url });
+  }
+  async requestDisplayMode(mode) {
+    if (!this.app) {
+      return { mode };
+    }
+    const app = this.app;
+    return app.requestDisplayMode({ mode });
+  }
+  requestClose() {
+  }
+  // State is not supported in MCP
+  getState() {
+    return this.state;
+  }
+  setState(state) {
+    this.state = state;
+  }
+  onToolCancelled(handler) {
+    this.toolCancelledHandlers.add(handler);
+    return () => this.toolCancelledHandlers.delete(handler);
+  }
+  onTeardown(handler) {
+    this.teardownHandlers.add(handler);
+    return () => this.teardownHandlers.delete(handler);
+  }
+  log(level, data) {
+    if (this.app) {
+      const app = this.app;
+      try {
+        app.sendLog({ level, data, logger: "pancake" });
+        return;
+      } catch {
+      }
+    }
+    console[level === "debug" ? "log" : level]("[Pancake]", data);
+  }
+  async sendSizeChanged(params) {
+    if (!this.app) return;
+    const app = this.app;
+    await app.sendSizeChanged(params);
+  }
+};
+
+// src/adapters/openai.ts
+var OpenAIAdapter = class {
+  protocol = "openai";
+  connected = false;
+  context = { ...DEFAULT_HOST_CONTEXT };
+  currentToolInput;
+  currentToolOutput;
+  state = null;
+  hostContextHandlers = /* @__PURE__ */ new Set();
+  toolInputHandlers = /* @__PURE__ */ new Set();
+  toolOutputHandlers = /* @__PURE__ */ new Set();
+  toolCancelledHandlers = /* @__PURE__ */ new Set();
+  teardownHandlers = /* @__PURE__ */ new Set();
+  globalsHandler = null;
+  setGlobalsHandler = null;
+  isConnected() {
+    return this.connected;
+  }
+  getOpenAI() {
+    if (typeof window !== "undefined" && "openai" in window) {
+      return window.openai;
+    }
+    return null;
+  }
+  async connect() {
+    if (this.connected) return;
+    await this.waitForOpenAI();
+    const openai = this.getOpenAI();
+    if (openai) {
+      this.readContextFromSDK();
+      this.readToolDataFromSDK();
+      if (typeof openai["init"] === "function") {
+        await openai["init"]();
+      }
+    }
+    this.setupGlobalsListener();
+    this.connected = true;
+  }
+  async disconnect() {
+    if (this.globalsHandler) {
+      window.removeEventListener("message", this.globalsHandler);
+    }
+    if (this.setGlobalsHandler) {
+      window.removeEventListener("openai:set_globals", this.setGlobalsHandler);
+    }
+    this.connected = false;
+  }
+  async waitForOpenAI(timeout = 5e3) {
+    if (this.getOpenAI()) return;
+    return new Promise((resolve) => {
+      const startTime = Date.now();
+      const check = () => {
+        if (this.getOpenAI()) {
+          resolve();
+          return;
+        }
+        if (Date.now() - startTime > timeout) {
+          resolve();
+          return;
+        }
+        setTimeout(check, 50);
+      };
+      const messageHandler = (event) => {
+        if (this.isSetGlobalsMessage(event.data)) {
+          setTimeout(() => {
+            if (this.getOpenAI()) {
+              window.removeEventListener("message", messageHandler);
+              resolve();
+            }
+          }, 50);
+        }
+      };
+      window.addEventListener("message", messageHandler);
+      check();
+    });
+  }
+  isSetGlobalsMessage(data) {
+    return data === "openai:set_globals" || typeof data === "object" && data !== null && "type" in data && data.type === "openai:set_globals" || typeof data === "object" && data !== null && "message" in data && data.message === "openai:set_globals";
+  }
+  setupGlobalsListener() {
+    this.setGlobalsHandler = (event) => {
+      const detail = event.detail;
+      const globals = detail?.globals ?? detail;
+      this.updateContextFromGlobals(globals);
+    };
+    window.addEventListener("openai:set_globals", this.setGlobalsHandler);
+    this.globalsHandler = (event) => {
+      if (this.isSetGlobalsMessage(event.data)) {
+        setTimeout(() => this.readContextFromSDK(), 50);
+      }
+    };
+    window.addEventListener("message", this.globalsHandler);
+  }
+  updateContextFromGlobals(globals) {
+    if (globals?.["theme"]) this.context.theme = globals["theme"];
+    if (globals?.["locale"]) this.context.locale = globals["locale"];
+    if (globals?.["displayMode"]) this.context.displayMode = globals["displayMode"];
+    for (const handler of this.hostContextHandlers) {
+      handler({ ...this.context });
+    }
+    if (globals?.["toolOutput"]) {
+      this.currentToolOutput = globals["toolOutput"];
+      for (const handler of this.toolOutputHandlers) {
+        handler(this.currentToolOutput);
+      }
+    }
+  }
+  readContextFromSDK() {
+    const openai = this.getOpenAI();
+    if (!openai) return;
+    if (typeof openai["theme"] === "string") {
+      this.context.theme = openai["theme"];
+    }
+    if (typeof openai["displayMode"] === "string") {
+      this.context.displayMode = openai["displayMode"];
+    }
+    if (typeof openai["locale"] === "string") {
+      this.context.locale = openai["locale"];
+    }
+    if (openai["safeArea"] && typeof openai["safeArea"] === "object") {
+      this.context.safeAreaInsets = openai["safeArea"];
+    }
+    if (typeof openai["maxHeight"] === "number") {
+      this.context.viewport = {
+        width: window.innerWidth,
+        height: openai["maxHeight"]
+      };
+    }
+  }
+  readToolDataFromSDK() {
+    const openai = this.getOpenAI();
+    if (!openai) return;
+    if (typeof openai["getToolInput"] === "function") {
+      this.currentToolInput = openai["getToolInput"]();
+    } else if (openai["toolInput"]) {
+      this.currentToolInput = openai["toolInput"];
+    } else if (openai["input"]) {
+      this.currentToolInput = openai["input"];
+    }
+    if (typeof openai["getToolOutput"] === "function") {
+      this.currentToolOutput = openai["getToolOutput"]();
+    } else if (openai["toolOutput"]) {
+      this.currentToolOutput = openai["toolOutput"];
+    } else if (openai["result"]) {
+      this.currentToolOutput = openai["result"];
+    }
+  }
+  getHostContext() {
+    return this.context;
+  }
+  onHostContextChange(handler) {
+    this.hostContextHandlers.add(handler);
+    return () => this.hostContextHandlers.delete(handler);
+  }
+  getViewParams() {
+    return {
+      inputs: this.currentToolInput ?? {},
+      data: this.currentToolOutput ?? {}
+    };
+  }
+  getToolInput() {
+    return this.currentToolInput;
+  }
+  getToolOutput() {
+    return this.currentToolOutput;
+  }
+  onToolInput(handler) {
+    this.toolInputHandlers.add(handler);
+    return () => this.toolInputHandlers.delete(handler);
+  }
+  onToolOutput(handler) {
+    this.toolOutputHandlers.add(handler);
+    return () => this.toolOutputHandlers.delete(handler);
+  }
+  async callTool(name, args) {
+    const openai = this.getOpenAI();
+    if (openai && typeof openai["callTool"] === "function") {
+      return openai["callTool"](name, args);
+    }
+    throw new Error("OpenAI SDK not available");
+  }
+  async sendMessage(content) {
+    const openai = this.getOpenAI();
+    if (openai && typeof openai["sendFollowUpMessage"] === "function") {
+      await openai["sendFollowUpMessage"]({ prompt: content.text });
+    }
+  }
+  async openLink(url) {
+    const openai = this.getOpenAI();
+    if (openai && typeof openai["openExternal"] === "function") {
+      await openai["openExternal"]({ href: url });
+    } else {
+      window.open(url, "_blank");
+    }
+  }
+  async requestDisplayMode(mode) {
+    const openai = this.getOpenAI();
+    if (openai && typeof openai["requestDisplayMode"] === "function") {
+      return openai["requestDisplayMode"]({ mode });
+    }
+    return { mode };
+  }
+  requestClose() {
+    const openai = this.getOpenAI();
+    if (openai && typeof openai["close"] === "function") {
+      openai["close"]();
+    }
+  }
+  // State IS supported in ChatGPT
+  getState() {
+    const openai = this.getOpenAI();
+    if (openai && typeof openai["getWidgetState"] === "function") {
+      return openai["getWidgetState"]();
+    }
+    return this.state;
+  }
+  setState(state) {
+    this.state = state;
+    const openai = this.getOpenAI();
+    if (openai && typeof openai["setWidgetState"] === "function") {
+      openai["setWidgetState"](state);
+    }
+  }
+  onToolCancelled(handler) {
+    this.toolCancelledHandlers.add(handler);
+    return () => this.toolCancelledHandlers.delete(handler);
+  }
+  onTeardown(handler) {
+    this.teardownHandlers.add(handler);
+    return () => this.teardownHandlers.delete(handler);
+  }
+  log(level, data) {
+    console[level === "debug" ? "log" : level]("[Pancake]", data);
+  }
+  async sendSizeChanged(params) {
+    const openai = this.getOpenAI();
+    if (openai && typeof openai["notifyIntrinsicHeight"] === "function") {
+      openai["notifyIntrinsicHeight"](params.height);
+    }
+  }
+};
+
+// src/adapters/mock.ts
+var MockAdapter = class {
+  protocol = "mock";
+  connected = false;
+  context;
+  toolInput;
+  toolOutput;
+  state = null;
+  hostContextHandlers = /* @__PURE__ */ new Set();
+  toolInputHandlers = /* @__PURE__ */ new Set();
+  toolOutputHandlers = /* @__PURE__ */ new Set();
+  toolCancelledHandlers = /* @__PURE__ */ new Set();
+  teardownHandlers = /* @__PURE__ */ new Set();
+  toolHandlers = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.context = { ...DEFAULT_HOST_CONTEXT, ...options?.hostContext };
+    this.toolInput = options?.toolInput;
+    this.toolOutput = options?.toolOutput;
+  }
+  isConnected() {
+    return this.connected;
+  }
+  async connect() {
+    this.connected = true;
+  }
+  async disconnect() {
+    this.connected = false;
+  }
+  // ─────────────────────────────────────────────────────────────
+  // Mock-specific methods for testing
+  // ─────────────────────────────────────────────────────────────
+  /**
+   * Set the host context (for testing)
+   */
+  setHostContext(ctx) {
+    this.context = { ...this.context, ...ctx };
+    for (const handler of this.hostContextHandlers) {
+      handler(this.context);
+    }
+  }
+  /**
+   * Set the tool input (for testing)
+   */
+  setToolInput(input) {
+    this.toolInput = input;
+    for (const handler of this.toolInputHandlers) {
+      handler(input);
+    }
+  }
+  /**
+   * Set the tool output (for testing)
+   */
+  setToolOutput(output) {
+    this.toolOutput = output;
+    for (const handler of this.toolOutputHandlers) {
+      handler(output);
+    }
+  }
+  /**
+   * Register a tool handler (for testing)
+   */
+  registerToolHandler(name, handler) {
+    this.toolHandlers.set(name, handler);
+  }
+  /**
+   * Trigger tool cancellation (for testing)
+   */
+  triggerToolCancelled(reason) {
+    for (const handler of this.toolCancelledHandlers) {
+      handler(reason);
+    }
+  }
+  /**
+   * Trigger teardown (for testing)
+   */
+  triggerTeardown(reason) {
+    for (const handler of this.teardownHandlers) {
+      handler(reason);
+    }
+  }
+  // ─────────────────────────────────────────────────────────────
+  // ProtocolAdapter implementation
+  // ─────────────────────────────────────────────────────────────
+  getHostContext() {
+    return this.context;
+  }
+  onHostContextChange(handler) {
+    this.hostContextHandlers.add(handler);
+    return () => this.hostContextHandlers.delete(handler);
+  }
+  getViewParams() {
+    return {
+      inputs: this.toolInput ?? {},
+      data: this.toolOutput ?? {}
+    };
+  }
+  getToolInput() {
+    return this.toolInput;
+  }
+  getToolOutput() {
+    return this.toolOutput;
+  }
+  onToolInput(handler) {
+    this.toolInputHandlers.add(handler);
+    return () => this.toolInputHandlers.delete(handler);
+  }
+  onToolOutput(handler) {
+    this.toolOutputHandlers.add(handler);
+    return () => this.toolOutputHandlers.delete(handler);
+  }
+  async callTool(name, args) {
+    const handler = this.toolHandlers.get(name);
+    if (handler) {
+      return handler(args);
+    }
+    console.log(`[MockAdapter] callTool: ${name}`, args);
+    return {};
+  }
+  async sendMessage(content) {
+    console.log(`[MockAdapter] sendMessage:`, content);
+  }
+  async openLink(url) {
+    console.log(`[MockAdapter] openLink: ${url}`);
+    if (typeof window !== "undefined") {
+      window.open(url, "_blank");
+    }
+  }
+  async requestDisplayMode(mode) {
+    console.log(`[MockAdapter] requestDisplayMode: ${mode}`);
+    this.context.displayMode = mode;
+    return { mode };
+  }
+  requestClose() {
+    console.log(`[MockAdapter] requestClose`);
+  }
+  getState() {
+    return this.state;
+  }
+  setState(state) {
+    this.state = state;
+  }
+  onToolCancelled(handler) {
+    this.toolCancelledHandlers.add(handler);
+    return () => this.toolCancelledHandlers.delete(handler);
+  }
+  onTeardown(handler) {
+    this.teardownHandlers.add(handler);
+    return () => this.teardownHandlers.delete(handler);
+  }
+  log(level, data) {
+    console[level === "debug" ? "log" : level]("[MockAdapter]", data);
+  }
+  async sendSizeChanged(params) {
+    console.log(`[MockAdapter] sendSizeChanged:`, params);
+  }
+};
+
+// src/detection.ts
+function detectProtocol() {
+  if (typeof window === "undefined") {
+    return "mock";
+  }
+  if ("openai" in window) {
+    return "openai";
+  }
+  const url = window.location.href;
+  const referrer = document.referrer;
+  const isChatGPTSandbox = url.includes("chatgpt") || url.includes("sandbox-proxy") || url.includes("widget-content") || referrer.includes("chatgpt") || referrer.includes("openai.com");
+  if (isChatGPTSandbox) {
+    return "openai";
+  }
+  if (window.parent !== window) {
+    return "mcp";
+  }
+  return "mock";
+}
+
+// src/client.ts
+var PancakeClient = class _PancakeClient {
+  adapter;
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  /**
+   * Create and connect a Pancake client.
+   */
+  static async create(options) {
+    const protocol = options?.forceAdapter ?? detectProtocol();
+    let adapter;
+    switch (protocol) {
+      case "mcp":
+        adapter = new McpAdapter({ autoResize: options?.autoResize ?? true });
+        break;
+      case "openai":
+        adapter = new OpenAIAdapter();
+        break;
+      case "mock":
+      default: {
+        const mockOptions = {};
+        if (options?.toolInput !== void 0) mockOptions.toolInput = options.toolInput;
+        if (options?.toolOutput !== void 0) mockOptions.toolOutput = options.toolOutput;
+        if (options?.hostContext !== void 0) mockOptions.hostContext = options.hostContext;
+        adapter = new MockAdapter(mockOptions);
+        break;
+      }
+    }
+    await adapter.connect();
+    return new _PancakeClient(adapter);
+  }
+  /**
+   * Create a Pancake client with a pre-configured adapter.
+   */
+  static fromAdapter(adapter) {
+    return new _PancakeClient(adapter);
+  }
+  /**
+   * Get the underlying protocol adapter.
+   */
+  getAdapter() {
+    return this.adapter;
+  }
+  /**
+   * Get the current protocol.
+   */
+  get protocol() {
+    return this.adapter.protocol;
+  }
+  /**
+   * Check if the client is connected.
+   */
+  isConnected() {
+    return this.adapter.isConnected();
+  }
+  // ─────────────────────────────────────────────────────────────
+  // Host Context
+  // ─────────────────────────────────────────────────────────────
+  /**
+   * Get the current host context.
+   */
+  getHostContext() {
+    return this.adapter.getHostContext();
+  }
+  /**
+   * Subscribe to host context changes.
+   */
+  onHostContextChange(handler) {
+    return this.adapter.onHostContextChange(handler);
+  }
+  // ─────────────────────────────────────────────────────────────
+  // View Parameters
+  // ─────────────────────────────────────────────────────────────
+  /**
+   * Get the current view parameters.
+   */
+  getViewParams() {
+    return this.adapter.getViewParams();
+  }
+  /**
+   * Get the current tool input.
+   */
+  getToolInput() {
+    return this.adapter.getToolInput();
+  }
+  /**
+   * Get the current tool output.
+   */
+  getToolOutput() {
+    return this.adapter.getToolOutput();
+  }
+  /**
+   * Subscribe to tool input changes.
+   */
+  onToolInput(handler) {
+    return this.adapter.onToolInput(handler);
+  }
+  /**
+   * Subscribe to tool output changes.
+   */
+  onToolOutput(handler) {
+    return this.adapter.onToolOutput(handler);
+  }
+  // ─────────────────────────────────────────────────────────────
+  // Tool Calls
+  // ─────────────────────────────────────────────────────────────
+  /**
+   * Call a tool on the server.
+   */
+  async callTool(name, args = {}) {
+    return this.adapter.callTool(name, args);
+  }
+  /**
+   * Navigate to a view (calls view:name tool).
+   */
+  async navigateToView(viewName, params = {}) {
+    await this.adapter.callTool(`view:${viewName}`, params);
+  }
+  /**
+   * Dispatch an action (calls action:name tool).
+   */
+  async dispatch(actionName, params = {}) {
+    return this.adapter.callTool(`action:${actionName}`, params);
+  }
+  /**
+   * Get data from a data fetcher (calls data:name tool).
+   */
+  async getData(dataName, params = {}) {
+    return this.adapter.callTool(`data:${dataName}`, params);
+  }
+  // ─────────────────────────────────────────────────────────────
+  // Communication
+  // ─────────────────────────────────────────────────────────────
+  /**
+   * Send a message to the model.
+   */
+  async say(message) {
+    await this.adapter.sendMessage({ type: "text", text: message });
+  }
+  /**
+   * Open a link in the host.
+   */
+  async openLink(url) {
+    await this.adapter.openLink(url);
+  }
+  /**
+   * Request a display mode change.
+   */
+  async requestDisplayMode(mode) {
+    return this.adapter.requestDisplayMode(mode);
+  }
+  /**
+   * Request to close the UI.
+   */
+  requestClose() {
+    this.adapter.requestClose();
+  }
+  // ─────────────────────────────────────────────────────────────
+  // State
+  // ─────────────────────────────────────────────────────────────
+  /**
+   * Get the current view state.
+   */
+  getState() {
+    return this.adapter.getState();
+  }
+  /**
+   * Set the view state.
+   */
+  setState(state) {
+    this.adapter.setState(state);
+  }
+  // ─────────────────────────────────────────────────────────────
+  // Events
+  // ─────────────────────────────────────────────────────────────
+  /**
+   * Subscribe to tool cancellation.
+   */
+  onToolCancelled(handler) {
+    return this.adapter.onToolCancelled(handler);
+  }
+  /**
+   * Subscribe to teardown.
+   */
+  onTeardown(handler) {
+    return this.adapter.onTeardown(handler);
+  }
+  // ─────────────────────────────────────────────────────────────
+  // Logging
+  // ─────────────────────────────────────────────────────────────
+  /**
+   * Log a message.
+   */
+  log(level, data) {
+    this.adapter.log(level, data);
+  }
+  // ─────────────────────────────────────────────────────────────
+  // Size Notifications
+  // ─────────────────────────────────────────────────────────────
+  /**
+   * Notify the host of a size change.
+   */
+  async sendSizeChanged(params) {
+    await this.adapter.sendSizeChanged(params);
+  }
+};
+var PancakeContext = react.createContext(null);
+function usePancakeContext() {
+  const ctx = react.useContext(PancakeContext);
+  if (!ctx) {
+    throw new Error("usePancakeContext must be used within a PancakeProvider");
+  }
+  return ctx;
+}
+function usePancakeClient() {
+  const { client, isConnecting, error } = usePancakeContext();
+  if (error) {
+    throw error;
+  }
+  if (isConnecting || !client) {
+    throw new Error("Pancake client not ready. Make sure PancakeProvider has finished connecting.");
+  }
+  return client;
+}
+function PancakeProvider({
+  children,
+  client: providedClient,
+  forceAdapter,
+  autoResize = true,
+  hostContext,
+  fallback,
+  errorFallback: ErrorFallback
+}) {
+  const [client, setClient] = react.useState(providedClient ?? null);
+  const [isConnecting, setIsConnecting] = react.useState(!providedClient);
+  const [error, setError] = react.useState(null);
+  react.useEffect(() => {
+    if (providedClient) {
+      setClient(providedClient);
+      setIsConnecting(false);
+      return;
+    }
+    setIsConnecting(true);
+    setError(null);
+    const options = { autoResize };
+    if (forceAdapter !== void 0) options.forceAdapter = forceAdapter;
+    if (hostContext !== void 0) options.hostContext = hostContext;
+    PancakeClient.create(options).then((newClient) => {
+      setClient(newClient);
+      setIsConnecting(false);
+    }).catch((err) => {
+      setError(err instanceof Error ? err : new Error(String(err)));
+      setIsConnecting(false);
+    });
+  }, [providedClient, forceAdapter, autoResize]);
+  if (error) {
+    if (ErrorFallback) {
+      return /* @__PURE__ */ jsxRuntime.jsx(ErrorFallback, { error, reset: () => setError(null) });
+    }
+    throw error;
+  }
+  if (isConnecting || !client) {
+    if (fallback) {
+      return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: fallback });
+    }
+    return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, {});
+  }
+  const value = {
+    client,
+    isConnecting,
+    error
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(PancakeContext.Provider, { value, children });
+}
+function useViewState(defaultValue) {
+  const client = usePancakeClient();
+  const [state, setStateInternal] = react.useState(() => {
+    const stored = client.getState();
+    return stored ?? defaultValue;
+  });
+  const setState = react.useCallback(
+    (newState) => {
+      setStateInternal((prev) => {
+        const next = typeof newState === "function" ? newState(prev) : newState;
+        client.setState(next);
+        return next;
+      });
+    },
+    [client]
+  );
+  return [state, setState];
+}
+function useHost() {
+  const { client } = usePancakeContext();
+  const [context, setContext] = react.useState(
+    () => client?.getHostContext() ?? DEFAULT_HOST_CONTEXT
+  );
+  react.useEffect(() => {
+    if (!client) return;
+    setContext(client.getHostContext());
+    return client.onHostContextChange(setContext);
+  }, [client]);
+  return context;
+}
+
+// src/react/hooks/useTheme.ts
+function useTheme() {
+  const host = useHost();
+  return host.theme;
+}
+function useDisplayMode() {
+  const client = usePancakeClient();
+  const host = useHost();
+  const requestMode = react.useCallback(
+    async (mode) => {
+      await client.requestDisplayMode(mode);
+    },
+    [client]
+  );
+  return {
+    mode: host.displayMode,
+    availableModes: host.availableDisplayModes,
+    requestMode
+  };
+}
+function useNavigation() {
+  const client = usePancakeClient();
+  const navigate = react.useCallback(
+    async (viewName, params) => {
+      await client.navigateToView(viewName, params ?? {});
+    },
+    [client]
+  );
+  const say = react.useCallback(
+    async (message) => {
+      await client.say(message);
+    },
+    [client]
+  );
+  return { navigate, say };
+}
+function useActionInput() {
+  const { client } = usePancakeContext();
+  const [input, setInput] = react.useState(() => {
+    return client?.getToolInput();
+  });
+  react.useEffect(() => {
+    if (!client) return;
+    setInput(client.getToolInput());
+    return client.onToolInput((newInput) => {
+      setInput(newInput);
+    });
+  }, [client]);
+  return input;
+}
+function useViewParams() {
+  const { client } = usePancakeContext();
+  const [params, setParams] = react.useState(() => {
+    if (!client) {
+      return { inputs: {}, data: {} };
+    }
+    const viewParams = client.getViewParams();
+    return {
+      inputs: viewParams.inputs,
+      data: viewParams.data
+    };
+  });
+  react.useEffect(() => {
+    if (!client) return;
+    const viewParams = client.getViewParams();
+    setParams({
+      inputs: viewParams.inputs,
+      data: viewParams.data
+    });
+    const unsubInput = client.onToolInput(() => {
+      const updated = client.getViewParams();
+      setParams({
+        inputs: updated.inputs,
+        data: updated.data
+      });
+    });
+    const unsubOutput = client.onToolOutput(() => {
+      const updated = client.getViewParams();
+      setParams({
+        inputs: updated.inputs,
+        data: updated.data
+      });
+    });
+    return () => {
+      unsubInput();
+      unsubOutput();
+    };
+  }, [client]);
+  return params;
+}
+function useAction() {
+  const client = usePancakeClient();
+  const dispatch = react.useCallback(
+    async (actionName, params) => {
+      return client.dispatch(actionName, params ?? {});
+    },
+    [client]
+  );
+  return { dispatch };
+}
+function useData() {
+  const client = usePancakeClient();
+  const getData = react.useCallback(
+    async (dataName, params) => {
+      return client.getData(dataName, params ?? {});
+    },
+    [client]
+  );
+  return { getData };
+}
+
+exports.PancakeContext = PancakeContext;
+exports.PancakeProvider = PancakeProvider;
+exports.useAction = useAction;
+exports.useActionInput = useActionInput;
+exports.useData = useData;
+exports.useDisplayMode = useDisplayMode;
+exports.useHost = useHost;
+exports.useNavigation = useNavigation;
+exports.usePancakeClient = usePancakeClient;
+exports.usePancakeContext = usePancakeContext;
+exports.useTheme = useTheme;
+exports.useViewParams = useViewParams;
+exports.useViewState = useViewState;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map