@unoverse-platform/studio 0.1.103 → 0.1.104

package/vendor/sdk/mcpAppBridge.ts

@@ -1,24 +1,15 @@
 /**
- * The MCP Apps host bridge (SEP-1865, spec 2026-01-26) — the STANDARD door.
+ * The MCP Apps host bridge, on the official MCP Apps SDK (`@modelcontextprotocol/ext-apps`).
  *
  * An MCP Apps host (ChatGPT, Claude Desktop, Goose, …) renders this bundle in a sandboxed
- * iframe and speaks JSON-RPC over postMessage: the app sends `ui/initialize`, the host
- * answers with `hostContext`, then pushes `ui/notifications/tool-input` and
- * `ui/notifications/tool-result`. The RESULT notification carries the tool call's full
- * `CallToolResult` — content, structuredContent and `_meta` — and `_meta` is where our
+ * iframe. The SDK's `App` speaks the protocol: `ui/initialize`, the tool notifications, the
+ * host context, display modes and size. The RESULT carries the tool call's `_meta`, where our
  * server puts the boot facts (`unoverse/serverUrl`, `unoverse/app`, `unoverse/token`).
- * This is the lane that still works everywhere: ChatGPT's legacy `window.openai` globals
- * now arrive with `toolResponseMetadata` EMPTY (observed live 2026-08-13), and non-OpenAI
- * hosts never had them.
  *
- * Deliberately MINIMAL: initialize + the two tool notifications. No display-mode calls, no
- * host-proxied tools/call — the SDK keeps its own /mcp + /stream connections (the CSP's
- * connectDomains exist exactly for this). Extend only against the spec:
- * https://github.com/modelcontextprotocol/ext-apps/blob/main/specification/2026-01-26/apps.mdx
+ * What stays ours: the boot callback, the answer handed back to the host's model, and the
+ * mapping from a task's own state to the host's display mode.
  */
-
-/** Spec revision we speak. Hosts negotiate; the field is required on ui/initialize. */
-const UI_PROTOCOL_VERSION = "2026-01-26";
+import { App } from "@modelcontextprotocol/ext-apps";
 
 type ToolResult = {
   content?: unknown;
@@ -27,109 +18,141 @@ type ToolResult = {
 };
 
 export type McpAppHost = {
-  /** True once the host answered ui/initialize — the signal that a STANDARD host owns this
-   *  iframe, used to silence the `unoverse:*` embed-host messages (a standard host validates
-   *  every inbound postMessage as JSON-RPC and logs ours as errors). */
+  /** True once the host answered ui/initialize: a standard host owns this iframe, so the
+   *  `unoverse:*` embed-host messages are not posted at it. */
   connected: boolean;
-  hostContext?: Record<string, unknown>;
+  /** The answer keys the tool result named (`structuredContent.asks`). */
+  asks?: string[];
 };
 
-/** Whether ANY MCP app host owns this iframe — standard bridge or legacy window.openai.
- *  The embed-host messages (`unoverse:status`/`size`/`event`/`close`) are for OUR OWN
- *  parent page and must not be posted at an MCP host. */
+const bridge: McpAppHost = { connected: false };
+
+const app = new App(
+  { name: "unoverse-websdk", version: "0.0.1" },
+  // The display modes this window can show (the spec's MUST).
+  { availableDisplayModes: ["inline", "fullscreen"] },
+  // The SDK reports the content's size to the host, so the frame fits it (spec: size-changed).
+  { autoResize: true },
+);
+
+/** Whether ANY MCP app host owns this iframe. The embed-host messages are for OUR OWN parent page. */
 export function hasMcpHost(): boolean {
   return bridge.connected || Boolean((window as { openai?: unknown }).openai);
 }
 
-const bridge: McpAppHost = { connected: false };
-
-/** Post an `unoverse:*` message to OUR OWN embed host's parent page (status badge, size,
- *  close, analytics). At an MCP host these are noise — the sandbox validates every inbound
- *  postMessage as JSON-RPC and logs each of ours as an error (observed live in ChatGPT) —
- *  so the post is skipped entirely there. `window.openai` counts as host detection ONLY;
- *  no config is read from it (the legacy boot path was removed 2026-08-13). */
+/** Post an `unoverse:*` message to OUR OWN embed host's parent page; skipped at an MCP host. */
 export function postToEmbedHost(msg: Record<string, unknown>): void {
   if (hasMcpHost()) return;
   window.parent?.postMessage(msg, "*");
 }
 
+const modeListeners = new Set<(mode: string) => void>();
+const currentMode = () => String(app.getHostContext()?.displayMode ?? "inline");
+
 /**
- * Open the standard door: send ui/initialize, resolve boot facts from the first
- * tool-result. `onToolResult` fires for EVERY result the host pushes (the first one
+ * THE HOST'S ROOM FOR THIS WINDOW, by where the host shows it: in `fullscreen` (ChatGPT's side
+ * panel) the page fills the window; in the chat it fits its content, up to the host's
+ * `maxHeight`, and `autoResize` reports that height. Decided by the display mode, never by a
+ * fixed `height` in containerDimensions: a page held at the window's height cannot be
+ * measured smaller (`autoResize` watches only <html> and <body>), so a task closing back to
+ * its chip kept the panel's height in the chat.
+ */
+function applyContainer(): void {
+  const dim = app.getHostContext()?.containerDimensions as Record<string, unknown> | undefined;
+  const html = document.documentElement;
+  if (currentMode() === "fullscreen") {
+    html.style.height = "100vh";
+    html.style.maxHeight = "";
+  } else {
+    html.style.height = "auto";
+    html.style.maxHeight = typeof dim?.maxHeight === "number" ? `${dim.maxHeight}px` : "";
+  }
+}
+
+/** The window's room follows its mode, then everyone who follows the mode hears it. */
+const announceMode = () => {
+  applyContainer();
+  modeListeners.forEach((fn) => fn(currentMode()));
+};
+
+/** Where an MCP Apps host shows this window (`inline`, `fullscreen`), or null when no host has
+ *  connected (our own pages), where there is no mode to follow. */
+export function hostMode(): string | null {
+  return bridge.connected ? currentMode() : null;
+}
+
+/** Where the host is showing this window now, and every later move. */
+export function onDisplayMode(fn: (mode: string) => void): () => void {
+  modeListeners.add(fn);
+  fn(currentMode());
+  return () => {
+    modeListeners.delete(fn);
+  };
+}
+
+/**
+ * SHOW THE WINDOW THE WAY THE TASK IS: its `inline` face in the chat, any other face (the
+ * task open) in the host's `fullscreen`, which on ChatGPT Desktop is the side panel. Only a
+ * mode the host offers, and only on a change. Resolves to the mode the host GRANTED (the spec:
+ * the host answers with the mode it chose), or undefined when nothing was asked.
+ */
+export function showAs(view: string): Promise<string | undefined> {
+  if (!bridge.connected) return Promise.resolve(undefined);
+  const mode = view === "inline" ? "inline" : "fullscreen";
+  if (!app.getHostContext()?.availableDisplayModes?.includes(mode) || currentMode() === mode) return Promise.resolve(undefined);
+  console.info(`[unoverse:mode] ask ${mode} (showing ${currentMode()})`);
+  return app.requestDisplayMode({ mode }).then(
+    (r) => {
+      console.info(`[unoverse:mode] answer ${String((r as { mode?: unknown })?.mode)} (showing ${currentMode()})`);
+      announceMode();
+      return String((r as { mode?: unknown })?.mode ?? currentMode());
+    },
+    (e) => {
+      console.info(`[unoverse:mode] refused ${mode}: ${String((e as Error)?.message ?? e)} (showing ${currentMode()})`);
+      return undefined;
+    },
+  );
+}
+
+/**
+ * Open the standard door. `onToolResult` fires for EVERY result the host pushes (the first one
  * carries the boot facts; later ones are re-renders of the same app instance).
  */
 export function connectMcpAppHost(onToolResult: (r: ToolResult) => void): McpAppHost {
-  const INIT_ID = "unoverse-ui-init";
-  // DIAGNOSTIC-FIRST (main.tsx doctrine): we implement the SPEC's dialect, but the live
-  // hosts are the ground truth — log a compact line for EVERY inbound message and every
-  // handshake attempt so one browser reproduction shows exactly what the host speaks.
-  const log = (label: string, extra?: unknown) =>
-    // eslint-disable-next-line no-console
-    console.log(`[unoverse:bridge] ${label}`, extra ?? "");
-  window.addEventListener("message", (e: MessageEvent) => {
-    const m = e?.data as
-      | { jsonrpc?: string; id?: unknown; result?: unknown; error?: unknown; method?: string; params?: unknown }
-      | undefined;
-    if (m && typeof m === "object") {
-      log("inbound", {
-        jsonrpc: m.jsonrpc,
-        method: m.method,
-        id: m.id,
-        // FULL bodies, stringified: the first diagnostics run summarized these to booleans
-        // and the one fact that mattered — WHY the host rejected ui/initialize — was in the
-        // unprinted error object. Never summarize the field you are debugging.
-        result: m.result !== undefined ? JSON.stringify(m.result).slice(0, 600) : undefined,
-        error: m.error !== undefined ? JSON.stringify(m.error).slice(0, 600) : undefined,
-        params: m.params !== undefined ? JSON.stringify(m.params).slice(0, 300) : undefined,
-        ports: e.ports?.length ?? 0,
-        origin: e.origin,
-      });
-    }
-    if (m?.jsonrpc !== "2.0") return; // not the host bridge (our own unoverse:config etc.)
-    if (m.id === INIT_ID && m.result) {
-      bridge.connected = true;
-      bridge.hostContext = (m.result as { hostContext?: Record<string, unknown> }).hostContext;
-      log("ui/initialize answered", bridge.hostContext);
-      // Complete the handshake — the reference App sends this notification after the
-      // result (ext-apps src/app.ts `connect`); hosts may hold tool-input/result until it.
-      window.parent?.postMessage({ jsonrpc: "2.0", method: "ui/notifications/initialized" }, "*");
-      return;
-    }
-    // Answer pings so the host's liveness check never times the app out.
-    if (m.method === "ping" && m.id !== undefined) {
-      (e.source as WindowProxy | null)?.postMessage({ jsonrpc: "2.0", id: m.id, result: {} }, "*");
-      return;
-    }
-    if (m.method === "ui/notifications/tool-result") {
-      // Per spec the result rides params (CallToolResult); tolerate a bare shape.
-      const p = (m.params ?? {}) as { result?: ToolResult } & ToolResult;
-      log("tool-result", { metaKeys: Object.keys((p.result ?? p)._meta ?? {}) });
-      onToolResult(p.result ?? p);
-    }
-  });
-  const sendInit = () => {
-    if (bridge.connected) return;
-    log("ui/initialize →");
-    window.parent?.postMessage(
-      {
-        jsonrpc: "2.0",
-        id: INIT_ID,
-        method: "ui/initialize",
-        // Field names per the REFERENCE App (ext-apps src/app.ts), not the docs' prose:
-        // `appInfo` + `appCapabilities`. The first cut sent MCP-core's `clientInfo` +
-        // `capabilities` and ChatGPT's Zod schema answered -32603 "Invalid input".
-        params: {
-          protocolVersion: UI_PROTOCOL_VERSION,
-          appCapabilities: {},
-          appInfo: { name: "unoverse-websdk", version: "0.0.1" },
-        },
-      },
-      "*",
-    );
+  // Handlers BEFORE connect: the SDK delivers the tool notifications once.
+  app.ontoolresult = (result) => {
+    const r = result as ToolResult;
+    const asks = (r.structuredContent as { asks?: unknown } | undefined)?.asks;
+    bridge.asks = Array.isArray(asks) && asks.every((k) => typeof k === "string") ? (asks as string[]) : undefined;
+    onToolResult(r);
+  };
+  app.onhostcontextchanged = (change) => {
+    // WHAT THE HOST REPORTED, as it reported it: the record to read before reasoning about modes.
+    if ("displayMode" in (change ?? {})) console.info(`[unoverse:mode] host says ${String((change as { displayMode?: unknown }).displayMode)}`);
+    announceMode();
   };
-  // The host's listener can attach after our module runs (web hosts boot a sandbox proxy
-  // first — `ui/notifications/sandbox-*`), so retry until answered.
-  sendInit();
-  for (const ms of [250, 1000, 3000]) setTimeout(sendInit, ms);
+  app.connect().then(
+    () => {
+      bridge.connected = true;
+      announceMode();
+    },
+    // Not inside an MCP Apps host (our own embed and pages): nothing to connect to.
+    () => {},
+  );
   return bridge;
 }
+
+/**
+ * THE PERSON'S ANSWER, BACK TO THE HOST'S MODEL (`ui/update-model-context` + `ui/message`). An
+ * outside host draws the app only after its tool call returns, so the call cannot wait for the
+ * answer; the server named the keys in `asks`. True when it was handed back.
+ */
+export function handAnswerToHost(state: Record<string, unknown>): boolean {
+  if (!bridge.connected || !bridge.asks?.length) return false;
+  const answer = Object.fromEntries(bridge.asks.filter((k) => state[k] !== undefined).map((k) => [k, state[k]]));
+  if (!Object.keys(answer).length) return false;
+  const lines = Object.entries(answer).map(([k, v]) => `${k}: ${typeof v === "string" ? v : JSON.stringify(v)}`);
+  void app.updateModelContext({ structuredContent: answer });
+  void app.sendMessage({ role: "user", content: [{ type: "text", text: `My answer:\n${lines.join("\n")}` }] });
+  return true;
+}