@ggui-ai/mcp-server 0.1.0-rc.3 → 0.2.0-alpha.1

package/dist/mcp-apps-outbound.d.ts

@@ -1,16 +1,16 @@
 /**
  * MCP Apps outbound wiring — the server-side half of the
- * `ggui_push -> ui://ggui/session -> iframe -> live channel` delivery path.
+ * `ggui_render -> ui://ggui/render -> iframe -> live channel` delivery path.
  *
  * Responsibilities of this module (and nothing else):
  *
  *   1. Advertise the `io.modelcontextprotocol/ui` capability on every
  *      fresh `McpServer` instance so MCP Apps hosts know the server
  *      speaks the UI extension.
- *   2. Register `ui://ggui/session` as a static resource servable via
+ *   2. Register `ui://ggui/render` as a static resource servable via
  *      MCP `resources/read`. The resource body is the thin-shell HTML
  *      hosts sandbox-render when they see `_meta.ui.resourceUri` on a
- *      `ggui_push` result.
+ *      `ggui_render` result.
  *
  * Boundary discipline:
  *
@@ -31,13 +31,13 @@
  *   build target — per the design lock, the shell is served by the
  *   same `@ggui-ai/mcp-server` instance that mints the bootstrap.
  */
-import { type McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { SessionStore, VectorStore } from '@ggui-ai/mcp-server-core';
-import { type GguiBootstrapMeta } from '@ggui-ai/protocol/integrations/mcp-apps';
-export declare const GGUI_SESSION_SHELL_HTML = "<!doctype html>\n<html lang=\"en\" style=\"height:100%\"><head><meta charset=\"utf-8\"><title>ggui session</title></head>\n<body style=\"margin:0;height:100%;min-height:480px\"><div id=\"ggui-root\" data-ggui-shell=\"thin\" style=\"height:100%;min-height:480px\"></div>\n<script>\n(function(){'use strict';\n// MCP Apps shell. Speaks the canonical postMessage protocol from\n// @modelcontextprotocol/ext-apps:\n//   1. iframe -> host: ui/initialize\n//   2. iframe -> host: ui/notifications/initialized\n//   3. host -> iframe: ui/notifications/tool-result (per CallToolResult)\n// On tool-result, derive base URL + shortCode from structuredContent,\n// fetch JSON bootstrap (componentCode + ids + runtimeUrl), set\n// window.__GGUI_BOOTSTRAP__, fetch runtime as blob, inject as script.\n// Runtime auto-mounts inline. No nested iframe (claudemcpcontent.com\n// CSP frame-src forbids cross-origin frames). State machine matches\n// buildSelfContainedShell so the same runtime mounts both paths.\nvar rpcId=1,pending={};\nvar rootEl=document.getElementById('ggui-root');\nrootEl.style.cssText='display:flex;flex-direction:column;height:100%;min-height:300px;margin:0';\nvar mounted=false;\nfunction setOverlay(text){\n  if(mounted)return;\n  rootEl.innerHTML='<div style=\"font:14px system-ui,sans-serif;padding:24px;color:#666\">'+text+'</div>';\n}\nfunction postNotification(method,params){\n  try{window.parent.postMessage({jsonrpc:'2.0',method:method,params:params||{}},'*');}catch(e){}\n}\nfunction postRpc(method,params){\n  return new Promise(function(res,rej){\n    var id=rpcId++;pending[id]={res:res,rej:rej};\n    try{window.parent.postMessage({jsonrpc:'2.0',id:id,method:method,params:params||{}},'*');}\n    catch(e){delete pending[id];rej(e);}\n  });\n}\nfunction readToolResult(p){\n  if(!p)return null;\n  var sc=p.structuredContent;\n  if(sc&&typeof sc.url==='string'&&typeof sc.shortCode==='string'){\n    return {url:sc.url,shortCode:sc.shortCode};\n  }\n  if(Array.isArray(p.content)){\n    for(var i=0;i<p.content.length;i++){\n      var c=p.content[i];\n      if(c&&c.type==='text'&&typeof c.text==='string'){\n        try{var j=JSON.parse(c.text);\n          if(j&&typeof j.url==='string'&&typeof j.shortCode==='string'){\n            return {url:j.url,shortCode:j.shortCode};\n          }\n        }catch(e){}\n      }\n    }\n  }\n  return null;\n}\nfunction deriveBase(url){\n  try{var u=new URL(url);return u.origin;}catch(e){return null;}\n}\nfunction postBootstrapFailed(reason,message){\n  // Surface every shell-layer bootstrap-failure path as a typed\n  // RendererBootFailedMessage envelope so hosts pinning the C9\n  // error pane (McpAppIframe onError, IframeErrorPane) see the\n  // failure instead of staring at the inert overlay until the test\n  // times out. Reason codes match BootstrapFailureReason.\n  try{window.parent.postMessage({type:'ggui:bootstrap-failed',reason:reason,message:message},'*');}catch(e){}\n}\nasync function mountFromBootstrap(bootstrap){\n  if(mounted)return;\n  // runtimeUrl is the only load-bearing field at the shell layer \u2014\n  // it tells us which iframe-runtime bundle to fetch. componentCode\n  // is OPTIONAL: present in self-contained-mode bootstraps (the\n  // runtime renders the inlined code without WS), absent in\n  // GguiBootstrapMeta-shaped bootstraps (the runtime opens the WS\n  // subscription via wsUrl+token to receive the stack). Either is\n  // valid; the runtime decides at boot time. Rejecting on missing\n  // componentCode silently breaks every Path B GguiBootstrapMeta\n  // delivery, which is the whole point of the inline-bootstrap path.\n  if(!bootstrap||typeof bootstrap.runtimeUrl!=='string'){\n    setOverlay('Bootstrap payload malformed.');\n    postBootstrapFailed('BOOTSTRAP_MALFORMED','Bootstrap payload malformed.');\n    return;\n  }\n  setOverlay('Loading UI\u2026');\n  window.__GGUI_BOOTSTRAP__=bootstrap;\n  // Load the runtime bundle via a direct cross-origin script tag\n  // (governed by CSP script-src) instead of fetch + Blob (governed by\n  // CSP connect-src). claude.ai's claudemcpcontent.com iframe CSP\n  // forbids cross-origin connect-src so fetch throws TypeError\n  // 'Failed to fetch', but allows cross-origin script-src when the\n  // bundle responds with the right CORS headers (the iframe-runtime\n  // mount sets them). The self-contained shell already uses this\n  // pattern; legacy postMessage shell now matches it.\n  try{\n    var s=document.createElement('script');\n    s.type='module';\n    // crossorigin=anonymous opts into CORS-mode error reporting.\n    // Without it, cross-origin script tags get a sanitized\n    // \"script error\" with no details, masking the real cause\n    // (CSP block, CORS reject, module-evaluation throw). With it,\n    // the error event surfaces the actual message in the iframe\n    // console -- the bundle ships ACAO=* so credentialed mode is\n    // unnecessary.\n    s.crossOrigin='anonymous';\n    s.src=bootstrap.runtimeUrl;\n    s.onload=function(){mounted=true;};\n    s.onerror=function(e){\n      var msg='Runtime bundle failed to load: '+(e&&e.message||'script error');\n      setOverlay(msg);\n      postBootstrapFailed('BUNDLE_FETCH_FAILED',msg);\n    };\n    rootEl.innerHTML='';\n    document.body.appendChild(s);\n  }catch(e){\n    var msg='Runtime bundle failed to load: '+(e&&e.message||e);\n    setOverlay(msg);\n    postBootstrapFailed('BUNDLE_FETCH_FAILED',msg);\n  }\n}\nasync function mount(toolResult){\n  if(mounted)return;\n  var base=deriveBase(toolResult.url);\n  if(!base){setOverlay('Invalid URL in tool result.');return;}\n  setOverlay('Loading UI\u2026');\n  var bootstrap;\n  try{\n    var bRes=await fetch(base+'/api/bootstrap/'+encodeURIComponent(toolResult.shortCode),{\n      cache:'no-store',\n      headers:{accept:'application/json'},\n    });\n    if(!bRes.ok){setOverlay('Bootstrap fetch failed: HTTP '+bRes.status);return;}\n    bootstrap=await bRes.json();\n  }catch(e){setOverlay('Bootstrap fetch error: '+(e&&e.message||e));return;}\n  return mountFromBootstrap(bootstrap);\n}\nfunction readBootstrapFromInitResult(result){\n  if(!result||typeof result!=='object')return null;\n  var toolOutput=result.toolOutput;\n  if(!toolOutput||typeof toolOutput!=='object')return null;\n  var meta=toolOutput._meta;\n  if(!meta||typeof meta!=='object')return null;\n  var ggui=meta.ggui;\n  if(!ggui||typeof ggui!=='object')return null;\n  var b=ggui.bootstrap;\n  if(!b||typeof b!=='object')return null;\n  // Same loosening as mountFromBootstrap: only runtimeUrl is required\n  // here. GguiBootstrapMeta forwarded by first-party McpAppIframe\n  // hosts omits componentCode by design (the runtime fetches the\n  // stack via\n  // wsUrl+token). Requiring componentCode at the shell layer turned\n  // every Path B inline-bootstrap delivery into a silent reject.\n  if(typeof b.runtimeUrl!=='string')return null;\n  return b;\n}\nfunction hasGguiMetaPlaceholder(result){\n  // Detect the protocol-violation case where the host signaled\n  // \"I tried to deliver bootstrap\" (toolOutput._meta.ggui exists)\n  // but the bootstrap field itself is absent or malformed. In that\n  // shape, we fail-fast with BOOTSTRAP_META_MISSING rather than\n  // sitting in the Path-A waiting state forever.\n  if(!result||typeof result!=='object')return false;\n  var toolOutput=result.toolOutput;\n  if(!toolOutput||typeof toolOutput!=='object')return false;\n  var meta=toolOutput._meta;\n  if(!meta||typeof meta!=='object')return false;\n  var ggui=meta.ggui;\n  return !!ggui&&typeof ggui==='object';\n}\nfunction readBootstrapFromCallToolResult(params){\n  // MCP Apps spec (specification/2026-01-26/apps.mdx:1145-1155):\n  //   ui/notifications/tool-result\n  //   params: CallToolResult  // Standard MCP type\n  // So params IS the CallToolResult and _meta lives at the top\n  // level (NOT under params.toolOutput, which is where the\n  // first-party McpAppIframe convention wraps it). Spec-compliant\n  // hosts (Claude Desktop, claude.ai Connector, Claude Code) deliver\n  // bootstrap material here.\n  if(!params||typeof params!=='object')return null;\n  var meta=params._meta;\n  if(!meta||typeof meta!=='object')return null;\n  var ggui=meta.ggui;\n  if(!ggui||typeof ggui!=='object')return null;\n  var b=ggui.bootstrap;\n  if(!b||typeof b!=='object')return null;\n  // Same loosening as readBootstrapFromInitResult / mountFromBootstrap:\n  // only runtimeUrl is required at the shell layer. componentCode is\n  // optional (absent for GguiBootstrapMeta-shaped bootstraps that\n  // open WS via wsUrl+token).\n  if(typeof b.runtimeUrl!=='string')return null;\n  return b;\n}\nwindow.addEventListener('message',function(ev){\n  var m=ev&&ev.data;\n  if(!m||m.jsonrpc!=='2.0')return;\n  if(m.id!=null&&pending[m.id]){\n    var p=pending[m.id];delete pending[m.id];\n    if(m.error)p.rej(m.error);else p.res(m.result);\n    return;\n  }\n  if(m.method==='ui/notifications/tool-result'){\n    // Spec-compliant hosts: m.params IS the CallToolResult; _meta is\n    // at the top level. Try this FIRST so Claude Desktop / claude.ai\n    // Connector / Claude Code land here.\n    var specB=readBootstrapFromCallToolResult(m.params);\n    if(specB){mountFromBootstrap(specB);return;}\n    // First-party McpAppIframe convention: bootstrap nested under\n    // params.toolOutput._meta. First-party hosts (Studio, Portal,\n    // console) use this shape for both init-response and post-init\n    // notification.\n    var bb=readBootstrapFromInitResult(m.params);\n    if(bb){mountFromBootstrap(bb);return;}\n    // Path A (last-resort fallback): host posts structuredContent.\n    // {url, shortCode}; shell fetches /api/bootstrap/<shortCode>\n    // over HTTP. The OSS server doesn't mount that endpoint, so this\n    // path is effectively dead unless a hosted operator wires it.\n    var tr=readToolResult(m.params);\n    if(tr)mount(tr);\n  }\n});\nsetOverlay('Initializing\u2026');\nvar initTimer=setTimeout(function(){\n  setOverlay('Host did not respond to ui/initialize within 3s.');\n},3000);\npostRpc('ui/initialize',{\n  appCapabilities:{},\n  appInfo:{name:'ggui-session',version:'1.0.0'},\n  protocolVersion:'2026-01-26'\n}).then(function(result){\n  clearTimeout(initTimer);\n  postNotification('ui/notifications/initialized',{});\n  // Path B: bootstrap inline in ui/initialize result. Hosts using\n  // <McpAppIframe>'s first-party dispatch deliver bootstrap meta here\n  // and never send a separate ui/notifications/tool-result.\n  var b=readBootstrapFromInitResult(result);\n  if(b){mountFromBootstrap(b);return;}\n  // Protocol-violation surface: host signalled an attempt\n  // (toolOutput._meta.ggui exists) but bootstrap is missing or\n  // malformed. Fail fast so hosts pinning a typed error envelope\n  // don't sit on the Path-A waiting overlay forever. Only fires\n  // when the meta placeholder is present \u2014 a fully absent _meta.ggui\n  // still falls through to Path A waiting.\n  if(hasGguiMetaPlaceholder(result)){\n    var msg='ui/initialize result missing _meta.ggui.bootstrap or runtimeUrl';\n    setOverlay(msg);\n    postBootstrapFailed('BOOTSTRAP_META_MISSING',msg);\n    return;\n  }\n  // Path A: wait for the host to send ui/notifications/tool-result\n  // with structuredContent.{url, shortCode}. MCP Apps hosts that don't\n  // implement the reading-B inline-bootstrap convention land here.\n  setOverlay('Waiting for tool result\u2026');\n}).catch(function(e){\n  clearTimeout(initTimer);\n  setOverlay('ui/initialize failed: '+(e&&e.message||JSON.stringify(e)));\n});\n})();\n</script></body></html>";
+import type { RenderStore, VectorStore } from "@ggui-ai/mcp-server-core";
+import { type McpAppAiGguiRenderMeta } from "@ggui-ai/protocol/integrations/mcp-apps";
+import { type McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare const GGUI_RENDER_SHELL_HTML = "<!doctype html>\n<html lang=\"en\" style=\"height:100%\"><head><meta charset=\"utf-8\"><title>ggui render</title></head>\n<body style=\"margin:0;height:100%;min-height:480px\"><div id=\"ggui-root\" data-ggui-shell=\"thin\" style=\"height:100%;min-height:480px\"></div>\n<script>\n(function(){'use strict';\n// MCP Apps shell. Speaks the canonical postMessage protocol from\n// @modelcontextprotocol/ext-apps:\n//   1. iframe -> host: ui/initialize\n//   2. iframe -> host: ui/notifications/initialized\n//   3. host -> iframe: ui/notifications/tool-result (per CallToolResult)\n// On tool-result, read the slice envelope from _meta (spec-canonical\n// CallToolResult _meta at the top level, or the first-party\n// params.toolOutput._meta shape), set window.__GGUI_META__ to the\n// envelope, fetch runtime as blob, inject as script.\n// Runtime auto-mounts inline. No nested iframe (claudemcpcontent.com\n// CSP frame-src forbids cross-origin frames). State machine matches\n// buildSelfContainedShell so the same runtime mounts both paths.\n//\n// R5 (2026-05-26): the historic /r/<shortCode> HTTP fallback was\n// removed along with the bearer-by-obscurity model -- hosts that strip\n// _meta no longer have a recovery path here. Spec-canonical hosts\n// deliver _meta inline and are unaffected.\n//\n// Phase B (2026-05-27): the historic two-slice envelope\n// (`ai.ggui/session` + `ai.ggui/stack-item`) collapsed to ONE flat\n// `ai.ggui/render` slice. runtimeUrl now lives directly on the\n// render slice; renderId is the canonical identity.\nvar rpcId=1,pending={};\nvar rootEl=document.getElementById('ggui-root');\nrootEl.style.cssText='display:flex;flex-direction:column;height:100%;min-height:300px;margin:0';\nvar mounted=false;\nfunction setOverlay(text){\n  if(mounted)return;\n  rootEl.innerHTML='<div style=\"font:14px system-ui,sans-serif;padding:24px;color:#666\">'+text+'</div>';\n}\nfunction postNotification(method,params){\n  try{window.parent.postMessage({jsonrpc:'2.0',method:method,params:params||{}},'*');}catch(e){}\n}\nfunction postRpc(method,params){\n  return new Promise(function(res,rej){\n    var id=rpcId++;pending[id]={res:res,rej:rej};\n    try{window.parent.postMessage({jsonrpc:'2.0',id:id,method:method,params:params||{}},'*');}\n    catch(e){delete pending[id];rej(e);}\n  });\n}\nfunction postBootstrapFailed(reason,message){\n  // Surface every shell-layer bootstrap-failure path as a typed\n  // RendererBootFailedMessage envelope so hosts pinning the C9\n  // error pane (McpAppIframe onError, IframeErrorPane) see the\n  // failure instead of staring at the inert overlay until the test\n  // times out. Reason codes match BootstrapFailureReason.\n  try{window.parent.postMessage({type:'ggui:bootstrap-failed',reason:reason,message:message},'*');}catch(e){}\n}\nasync function mountFromMeta(envelope){\n  if(mounted)return;\n  // Slice envelope shape (Phase B): { \"ai.ggui/render\": { renderId,\n  // appId, runtimeUrl, ... } }. runtimeUrl on the render slice is\n  // the only load-bearing field at the shell layer \u2014 it tells us\n  // which iframe-runtime bundle to fetch. Everything else is\n  // optional; the runtime decides at boot time based on the meta\n  // it reads from window.__GGUI_META__.\n  var renderSlice=envelope&&envelope['ai.ggui/render'];\n  var runtimeUrl=renderSlice&&renderSlice.runtimeUrl;\n  if(!envelope||typeof runtimeUrl!=='string'){\n    setOverlay('Bootstrap payload malformed.');\n    postBootstrapFailed('BOOTSTRAP_MALFORMED','Bootstrap payload malformed.');\n    return;\n  }\n  setOverlay('Loading UI\u2026');\n  window.__GGUI_META__=envelope;\n  // Load the runtime bundle via a direct cross-origin script tag\n  // (governed by CSP script-src) instead of fetch + Blob (governed by\n  // CSP connect-src). claude.ai's claudemcpcontent.com iframe CSP\n  // forbids cross-origin connect-src so fetch throws TypeError\n  // 'Failed to fetch', but allows cross-origin script-src when the\n  // bundle responds with the right CORS headers (the iframe-runtime\n  // mount sets them). The self-contained shell already uses this\n  // pattern; legacy postMessage shell now matches it.\n  try{\n    var s=document.createElement('script');\n    s.type='module';\n    // crossorigin=anonymous opts into CORS-mode error reporting.\n    // Without it, cross-origin script tags get a sanitized\n    // \"script error\" with no details, masking the real cause\n    // (CSP block, CORS reject, module-evaluation throw). With it,\n    // the error event surfaces the actual message in the iframe\n    // console -- the bundle ships ACAO=* so credentialed mode is\n    // unnecessary.\n    s.crossOrigin='anonymous';\n    s.src=runtimeUrl;\n    s.onload=function(){mounted=true;};\n    s.onerror=function(e){\n      var msg='Runtime bundle failed to load: '+(e&&e.message||'script error');\n      setOverlay(msg);\n      postBootstrapFailed('BUNDLE_FETCH_FAILED',msg);\n    };\n    rootEl.innerHTML='';\n    document.body.appendChild(s);\n  }catch(e){\n    var msg='Runtime bundle failed to load: '+(e&&e.message||e);\n    setOverlay(msg);\n    postBootstrapFailed('BUNDLE_FETCH_FAILED',msg);\n  }\n}\nfunction readMetaFromInitResult(result){\n  if(!result||typeof result!=='object')return null;\n  var toolOutput=result.toolOutput;\n  if(!toolOutput||typeof toolOutput!=='object')return null;\n  var meta=toolOutput._meta;\n  if(!meta||typeof meta!=='object')return null;\n  // Single slice-envelope key (Phase B: ai.ggui/render). Only the\n  // render slice's runtimeUrl is load-bearing at the shell layer;\n  // the runtime reads everything else off window.__GGUI_META__\n  // after we set it.\n  var renderSlice=meta['ai.ggui/render'];\n  if(!renderSlice||typeof renderSlice!=='object')return null;\n  if(typeof renderSlice.runtimeUrl!=='string')return null;\n  return meta;\n}\nfunction hasAiGguiMetaPlaceholder(result){\n  // Detect the protocol-violation case where the host signaled\n  // \"I tried to deliver meta\" (toolOutput._meta carries an\n  // ai.ggui/render key) but it's malformed. Fail-fast with\n  // BOOTSTRAP_META_MISSING rather than waiting forever.\n  if(!result||typeof result!=='object')return false;\n  var toolOutput=result.toolOutput;\n  if(!toolOutput||typeof toolOutput!=='object')return false;\n  var meta=toolOutput._meta;\n  if(!meta||typeof meta!=='object')return false;\n  return 'ai.ggui/render' in meta;\n}\nfunction readMetaFromCallToolResult(params){\n  // MCP Apps spec (specification/2026-01-26/apps.mdx:1145-1155):\n  //   ui/notifications/tool-result\n  //   params: CallToolResult  // Standard MCP type\n  // So params IS the CallToolResult and _meta lives at the top\n  // level (NOT under params.toolOutput, which is where the\n  // first-party McpAppIframe convention wraps it). Spec-compliant\n  // hosts (Claude Desktop, claude.ai Connector, Claude Code) deliver\n  // slice-envelope material here.\n  if(!params||typeof params!=='object')return null;\n  var meta=params._meta;\n  if(!meta||typeof meta!=='object')return null;\n  var renderSlice=meta['ai.ggui/render'];\n  if(!renderSlice||typeof renderSlice!=='object')return null;\n  if(typeof renderSlice.runtimeUrl!=='string')return null;\n  return meta;\n}\nwindow.addEventListener('message',function(ev){\n  var m=ev&&ev.data;\n  if(!m||m.jsonrpc!=='2.0')return;\n  if(m.id!=null&&pending[m.id]){\n    var p=pending[m.id];delete pending[m.id];\n    if(m.error)p.rej(m.error);else p.res(m.result);\n    return;\n  }\n  if(m.method==='ui/notifications/tool-result'){\n    // Spec-compliant hosts: m.params IS the CallToolResult; _meta is\n    // at the top level. Try this FIRST so Claude Desktop / claude.ai\n    // Connector / Claude Code land here.\n    var specB=readMetaFromCallToolResult(m.params);\n    if(specB){mountFromMeta(specB);return;}\n    // First-party McpAppIframe convention: slice envelope nested under\n    // params.toolOutput._meta. First-party hosts (Studio, Portal,\n    // console) use this shape for both init-response and post-init\n    // notification.\n    var bb=readMetaFromInitResult(m.params);\n    if(bb){mountFromMeta(bb);return;}\n    // R5 (2026-05-26) -- the /r/<shortCode> HTTP fallback was removed\n    // along with the bearer-by-obscurity model. Hosts that strip\n    // _meta on the tool-result wire have no fallback path here;\n    // spec-canonical hosts deliver meta inline and land in the two\n    // branches above.\n  }\n});\nsetOverlay('Initializing\u2026');\nvar initTimer=setTimeout(function(){\n  setOverlay('Host did not respond to ui/initialize within 3s.');\n},3000);\npostRpc('ui/initialize',{\n  appCapabilities:{},\n  appInfo:{name:'ggui-session',version:'1.0.0'},\n  protocolVersion:'2026-01-26'\n}).then(function(result){\n  clearTimeout(initTimer);\n  postNotification('ui/notifications/initialized',{});\n  // Path B: slice envelope inline in ui/initialize result. Hosts\n  // using <McpAppIframe>'s first-party dispatch deliver meta here\n  // and never send a separate ui/notifications/tool-result.\n  var b=readMetaFromInitResult(result);\n  if(b){mountFromMeta(b);return;}\n  // Protocol-violation surface: host signalled an attempt\n  // (toolOutput._meta carries ai.ggui/render) but it's malformed.\n  // Fail fast so hosts pinning a typed error envelope don't sit on\n  // the Path-A waiting overlay forever.\n  if(hasAiGguiMetaPlaceholder(result)){\n    var msg='ui/initialize result missing valid ai.ggui/render.runtimeUrl';\n    setOverlay(msg);\n    postBootstrapFailed('BOOTSTRAP_META_MISSING',msg);\n    return;\n  }\n  // Path A: wait for the host to send ui/notifications/tool-result\n  // with structuredContent.{url, shortCode}. MCP Apps hosts that don't\n  // implement the reading-B inline-meta convention land here.\n  setOverlay('Waiting for tool result\u2026');\n}).catch(function(e){\n  clearTimeout(initTimer);\n  setOverlay('ui/initialize failed: '+(e&&e.message||JSON.stringify(e)));\n});\n})();\n</script></body></html>";
 /**
  * CSP `script-src` source expression that authorises the inline
- * `<script>` block of {@link GGUI_SESSION_SHELL_HTML} when it executes
+ * `<script>` block of {@link GGUI_RENDER_SHELL_HTML} when it executes
  * inside an iframe whose CSP is inherited from a parent host.
  *
  * # Why this exists
@@ -74,8 +74,8 @@ export declare const GGUI_SESSION_SHELL_HTML = "<!doctype html>\n<html lang=\"en
  * path where the host is `<McpAppIframe>` and the parent SPA owns
  * the CSP it inherits.
  */
-export declare const GGUI_SESSION_SHELL_SCRIPT_HASH: string;
-export declare function registerGguiSessionResource(server: McpServer, shellHtml?: string, publicBaseUrl?: string): void;
+export declare const GGUI_RENDER_SHELL_SCRIPT_HASH: string;
+export declare function registerGguiRenderResource(server: McpServer, shellHtml?: string, publicBaseUrl?: string): void;
 /**
  * Advertise the `io.modelcontextprotocol/ui` extension capability on
  * an `McpServer`'s underlying `Server`. Idempotent - calling twice on
@@ -94,9 +94,9 @@ export declare function advertiseMcpAppsUiCapability(server: McpServer): void;
  * @public
  */
 export interface SelfContainedShellInputs {
-    /** Session id whose top-of-stack render is being inlined. */
-    readonly sessionId: string;
-    /** App / tenant id the session is scoped to. */
+    /** Render id whose visible-bits surface is being inlined. */
+    readonly renderId: string;
+    /** App / tenant id the render is scoped to. */
     readonly appId: string;
     /**
      * Content-addressable URL the iframe fetches the compiled ES module
@@ -124,22 +124,11 @@ export interface SelfContainedShellInputs {
      * `<script type="module" src=...>`. MUST be absolute (or root-
      * relative resolvable from the host's iframe origin) — `srcdoc`
      * iframes have `about:srcdoc` as their URL so a bare relative path
-     * cannot resolve. Also inlined on the `__GGUI_BOOTSTRAP__` global so
+     * cannot resolve. Also inlined on the `__GGUI_META__` global so
      * the iframe-runtime's bootstrap validator (which requires
      * `runtimeUrl` across all modes) accepts the envelope.
      */
     readonly runtimeUrl: string;
-    /** Optional stack-item id forwarded to the renderer for parity
-     *  with single-item-mode bootstrap selectors. */
-    readonly stackItemId?: string;
-    /**
-     * Canvas-mode flag. When `true`, the
-     * bootstrap is built as session-scoped (no stackItemId, no
-     * codeUrl/systemKind — live-mode trio MUST be supplied) and the
-     * iframe-runtime mounts {@link CanvasShell} instead of a single
-     * stack item. Mutually exclusive with {@link stackItemId}.
-     */
-    readonly canvasMode?: boolean;
     /** Optional theme id forwarded to the renderer. */
     readonly themeId?: string;
     /**
@@ -150,7 +139,7 @@ export interface SelfContainedShellInputs {
      * `LoadedTheme.mode` for preset/file forms; default-source themes
      * omit this field entirely.
      */
-    readonly themeMode?: 'light' | 'dark';
+    readonly themeMode?: "light" | "dark";
     /**
      * Optional pre-serialized props (must be a JSON string) forwarded
      * to the renderer. Server inlines the string verbatim — the
@@ -159,7 +148,7 @@ export interface SelfContainedShellInputs {
     readonly propsJson?: string;
     /**
      * Names of same-server tools whose `_meta.ui.visibility` includes
-     * `"app"`, mirrored from {@link GguiBootstrapMeta.appCallableTools}.
+     * `"app"`, mirrored from {@link McpAppAiGguiRenderMeta.appCallableTools}.
      * Forwarded to the iframe-runtime so its dispatch closure can choose
      * Pattern α (direct `tools/call`) over Pattern β (3-message bridge)
      * per wired action — even on the self-contained `/r/<shortCode>`
@@ -169,23 +158,23 @@ export interface SelfContainedShellInputs {
      * Empty / absent → no fallout: the runtime's dispatch routes every
      * action through Pattern β.
      */
-    readonly appCallableTools?: GguiBootstrapMeta['appCallableTools'];
+    readonly appCallableTools?: McpAppAiGguiRenderMeta["appCallableTools"];
     /**
-     * Per-action wired-tool mapping for the active stack item, mirrored
-     * from {@link GguiBootstrapMeta.actionNextSteps}.
+     * Per-action wired-tool mapping for the active render, mirrored
+     * from {@link McpAppAiGguiRenderMeta.actionNextSteps}.
      */
-    readonly actionNextSteps?: GguiBootstrapMeta['actionNextSteps'];
+    readonly actionNextSteps?: McpAppAiGguiRenderMeta["actionNextSteps"];
     /**
-     * Per-slot data for the active stack item's `contextSpec`, mirrored
-     * from {@link GguiBootstrapMeta.contextSlots}. The runtime
+     * Per-slot data for the active render's `contextSpec`, mirrored
+     * from {@link McpAppAiGguiRenderMeta.contextSlots}. The runtime
      * synthesizes one `React.createContext(default)` per entry at boot.
      * Without this field, contextSpec UIs render with un-seeded
      * Providers.
      */
-    readonly contextSlots?: GguiBootstrapMeta['contextSlots'];
+    readonly contextSlots?: McpAppAiGguiRenderMeta["contextSlots"];
     /**
-     * Permissions-Policy directive list derived from the active stack
-     * item's `clientCapabilities.gadgets[*].permission`.
+     * Permissions-Policy directive list derived from the active render's
+     * `clientCapabilities.gadgets[*].permission`.
      * When present (non-empty), inlined onto the bootstrap as
      * `permissionsPolicy` so the iframe-runtime can surface the gate set
      * to in-iframe consumers (debug overlay, permission-aware UI). The
@@ -199,33 +188,38 @@ export interface SelfContainedShellInputs {
     /**
      * Resolved gadget catalog the iframe runtime dynamically imports at
      * boot. Each entry is `{hook,
-     * package?, bundleUrl?}`. The MCP-Apps `_meta.ggui.bootstrap`
-     * channel already forwards this via `push.ts`; this field is the
+     * package?, bundleUrl?}`. The MCP-Apps `_meta` slice channel already
+     * forwards this via the render-mutation handler; this field is the
      * symmetric forward for the self-contained shell so `/r/<shortCode>`
-     * and `resources/read` iframes don't render as STDLIB-only when
-     * the contract declares wrappers.
+     * and `resources/read` iframes don't render as STDLIB-only when the
+     * contract declares wrappers.
+     */
+    readonly gadgets?: McpAppAiGguiRenderMeta["gadgets"];
+    /**
+     * Content-addressable hash for the active render's compiled
+     * contract validators, mirrored from
+     * {@link McpAppAiGguiRenderMeta.contractHash}. The iframe-runtime
+     * resolves validators via `fetch({@link validatorsUrl})` + dynamic
+     * import. Paired with {@link validatorsUrl} — present together or
+     * absent together.
      */
-    readonly gadgets?: GguiBootstrapMeta['gadgets'];
+    readonly contractHash?: McpAppAiGguiRenderMeta["contractHash"];
     /**
-     * Precompiled, eval-free contract validators (one ESM validator-
-     * module source per `propsSpec` / `actionSpec` / `streamSpec` /
-     * `contextSpec`), mirrored from
-     * {@link GguiBootstrapMeta.compiledValidators}. The renderer iframe's
-     * strict CSP (no `'unsafe-eval'`) blocks runtime `ajv.compile()`, so
-     * the iframe loads these precompiled modules via `blob:` import
-     * instead. Symmetric forward for the self-contained shell so
-     * `/r/<shortCode>` and `resources/read` iframes validate wire
-     * traffic exactly as the MCP-Apps postMessage path does.
+     * URL serving the content-addressable contract-validator bundle,
+     * mirrored from {@link McpAppAiGguiRenderMeta.validatorsUrl}.
+     * Symmetric forward for the self-contained shell so `/r/<shortCode>`
+     * and `resources/read` iframes resolve validators exactly as the
+     * MCP-Apps postMessage path does.
      */
-    readonly compiledValidators?: GguiBootstrapMeta['compiledValidators'];
+    readonly validatorsUrl?: McpAppAiGguiRenderMeta["validatorsUrl"];
     /**
      * Server-filtered public env values that declared wrappers'
      * `requires` cover (minimum-disclosure subset of `App.publicEnv`).
-     * Symmetric with the `_meta.ggui.bootstrap` channel — every
-     * transport that produces a `GguiBootstrapMeta` envelope MUST
-     * forward this field so wrappers' `getPublicEnv()` reads land.
+     * Symmetric with the `ai.ggui/render` slice channel — every
+     * transport that produces the meta MUST forward this field so
+     * wrappers' `getPublicEnv()` reads land.
      */
-    readonly publicEnv?: GguiBootstrapMeta['publicEnv'];
+    readonly publicEnv?: McpAppAiGguiRenderMeta["publicEnv"];
     /**
      * Live-mode WebSocket URL the iframe-runtime opens to receive
      * `props_update` / `stack_*` frames. When set alongside `token` +
@@ -238,7 +232,9 @@ export interface SelfContainedShellInputs {
     /**
      * Single-use bootstrap token authorising the WS subscribe. Paired
      * with {@link wsUrl} — half-live envelopes (one without the other)
-     * are rejected as MALFORMED by `parseBootstrap`. Server-minted via
+     * are rejected as MALFORMED by the iframe-runtime slice-meta
+     * extractors (`parseMetaFromGlobal`, `parseMetaFromToolResult`).
+     * Server-minted via
      * the same `mintBootstrap` minter the JSON `/api/bootstrap/<shortCode>`
      * route uses, so both transports share replay-cache state.
      */
@@ -249,12 +245,32 @@ export interface SelfContainedShellInputs {
      * live updates silently no-op until a fresh push refreshes creds.
      */
     readonly expiresAt?: string;
+    /**
+     * Monotonic RenderEvent ledger cursor at emit time, mirrored from
+     * {@link McpAppAiGguiRenderMeta.lastSequence}. Polling clients
+     * initialize the R7 `/events?sinceSequence=N` cursor from this.
+     * Absent in pre-R7 envelopes (back-compat); post-R7 it MUST be
+     * present.
+     */
+    readonly lastSequence?: McpAppAiGguiRenderMeta["lastSequence"];
+    /**
+     * Wire-stamped polling fallback URL — `${base}/api/renders/<id>/events?wsToken=<...>`.
+     * When the iframe-runtime's WS transport reaches `'failed'` (CSP
+     * blocks `ws://`, corporate firewall, etc.), `@ggui-ai/live-channel`
+     * fails over to cursor-based event polling against this URL using
+     * `{@link lastSequence}` as the initial cursor.
+     *
+     * Absent ⇒ runtime stays in WS-only mode. Operators that want the
+     * fallback path lit up MUST thread this through (the canvas/inline
+     * shell builders do; callers composing their own shells SHOULD).
+     */
+    readonly pollingUrl?: McpAppAiGguiRenderMeta["pollingUrl"];
 }
 /**
  * Build the self-contained shell HTML for a given session.
  *
  * The returned HTML is a complete, standalone document: it inlines the
- * compiled component (base64) + session ids in a `window.__GGUI_BOOTSTRAP__`
+ * compiled component (base64) + session ids in a `window.__GGUI_META__`
  * global, then loads the iframe-runtime bundle via `<script type="module"
  * src={runtimeUrl}>`. The runtime takes over synchronously on import,
  * mounts the component, and the iframe paints WITHOUT any further server
@@ -276,40 +292,40 @@ export interface SelfContainedShellInputs {
  */
 export declare function buildSelfContainedShell(opts: SelfContainedShellInputs): string;
 /**
- * Minimal "loading" HTML served when a per-session resource is fetched
- * for a session whose top stack item has no componentCode yet
+ * Minimal "loading" HTML served when a per-render resource is fetched
+ * for a render whose visible-bits surface has no componentCode yet
  * (placeholder, generation in flight). Renders a tiny status surface
  * so hosts that pin lifecycle selectors don't see a blank document.
  *
- * Hosts SHOULD re-fetch when they observe additional `ggui_push`
- * results on the same session — the per-call `_meta.ui.resourceUri`
- * value stays stable across pushes for a session, so re-fetching the
+ * Hosts SHOULD re-fetch when they observe additional `ggui_render`
+ * results on the same render — the per-call `_meta.ui.resourceUri`
+ * value stays stable across commits for a render, so re-fetching the
  * same URI returns fresher HTML on the second try.
  *
  * @public
  */
-export declare function buildSelfContainedLoadingShell(sessionId: string): string;
+export declare function buildSelfContainedLoadingShell(renderId: string): string;
 /**
- * Options for {@link registerGguiSessionResourceTemplate}.
+ * Options for {@link registerGguiRenderResourceTemplate}.
  *
  * @public
  */
-export interface GguiSessionResourceTemplateOptions {
-    /** SessionStore the template handler reads to find the topmost
-     *  stack item's componentCode. */
-    readonly sessionStore: SessionStore;
+export interface GguiRenderResourceTemplateOptions {
+    /** RenderStore the template handler reads to find the render's
+     *  componentCode. */
+    readonly renderStore: RenderStore;
     /** Absolute URL of the iframe-runtime bundle inlined in the shell. */
     readonly runtimeUrl: string;
     /**
      * Content-addressable code-blob store. When wired alongside
-     * {@link codeBaseUrl}, the resource template hashes the top stack
-     * item's componentCode, writes it to the store, and inlines the
-     * resulting `codeUrl` into the shell bootstrap. Without these deps
-     * the resource path emits the loading shell when the top item is a
+     * {@link codeBaseUrl}, the resource template hashes the render's
+     * componentCode, writes it to the store, and inlines the resulting
+     * `codeUrl` into the shell bootstrap. Without these deps the
+     * resource path emits the loading shell when the render is a
      * compiled component (the static-component channel cannot deliver
      * without a URL).
      */
-    readonly codeStore?: import('@ggui-ai/mcp-server-core').CodeStore;
+    readonly codeStore?: import("@ggui-ai/mcp-server-core").CodeStore;
     /**
      * Base URL the code-blob route resolves to. Paired with {@link codeStore}.
      */
@@ -323,7 +339,7 @@ export interface GguiSessionResourceTemplateOptions {
      */
     readonly themeId?: string;
     /** Theme color mode resolved from `ggui.json#theme.mode`. */
-    readonly themeMode?: 'light' | 'dark';
+    readonly themeMode?: "light" | "dark";
     /**
      * Per-app metadata store the resource handler reads to resolve
      * `App.publicEnv` for the bootstrap projection.
@@ -332,17 +348,17 @@ export interface GguiSessionResourceTemplateOptions {
      * resource-served bootstrap (wrappers calling `getPublicEnv` throw
      * at hook-mount with a clear "not provided" message).
      */
-    readonly appMetadataStore?: import('@ggui-ai/mcp-server-core').AppMetadataStore;
+    readonly appMetadataStore?: import("@ggui-ai/mcp-server-core").AppMetadataStore;
     /**
      * Vector store backing the blueprint registry. When wired alongside
      * `defaultAppIdFallback`, the resource handler runs a registry-only
      * rehydrate fallback for the two-segment URI shape
-     * (`ui://ggui/session/{sessionId}/{blueprintKey}`): if the session is
+     * (`ui://ggui/render/{renderId}/{blueprintKey}`): if the render is
      * gone but the blueprint registry still holds the entry, return the
      * static initial render (default props + default context) instead of
      * the dead "Generating UI…" loading shell. Single-tenant OSS sees
      * meaningful improvement; multi-tenant deployments leave both options
-     * undefined to keep the loading-shell behavior on session miss.
+     * undefined to keep the loading-shell behavior on render miss.
      */
     readonly vectorStore?: VectorStore;
     /**
@@ -354,72 +370,72 @@ export interface GguiSessionResourceTemplateOptions {
      * and rehydrate works across session expiry / process restart.
      */
     readonly defaultAppIdFallback?: string;
-    /**
-     * Bootstrap minter for canvas-mode
-     * sessions. Supplied by the deployment (cloud wires it to the
-     * AppSync-bound minter; OSS wires it to the in-process minter
-     * already used by /api/bootstrap/<shortCode>).
-     *
-     * When the resource handler observes `session.mcpAppsMode ===
-     * 'canvas'`, it calls this to obtain `wsUrl` + `token` + `expiresAt`
-     * and inlines them on the canvas shell's bootstrap. Without this
-     * dep wired, the handler falls back to the legacy single-item path
-     * (no canvas).
-     *
-     * Returning `null` / throwing here degrades to the legacy path
-     * silently — the caller has no way to deliver a working canvas
-     * without WS credentials, but pinning a stackItem render is
-     * strictly better than serving a dead-loading shell.
-     */
-    readonly mintBootstrap?: (sessionId: string, appId: string) => Promise<{
-        readonly wsUrl: string;
-        readonly token: string;
-        readonly expiresAt: string;
-    } | null>;
     /**
      * Operator-supplied public origin. When present, every
      * `resources/read` response from this template carries
      * `_meta.ui.csp.{connectDomains,resourceDomains}` so claude.ai's
      * cross-origin iframe CSP allows the runtime bundle, codeUrl
      * fetches, and the live-channel WebSocket. Symmetric with the
-     * declaration on the static `ui://ggui/session` resource. Absent ⇒
+     * declaration on the static `ui://ggui/render` resource. Absent ⇒
      * `_meta.ui.csp` omitted and the host's default CSP applies
      * (`connect-src 'none'` in claude.ai — runtime bundle fails to
      * load with a generic "script error").
      */
     readonly publicBaseUrl?: string;
+    /**
+     * Live-channel WebSocket bootstrap minter. When wired, every
+     * `resources/read` response embeds `{wsUrl, wsToken}` in the shell
+     * so the iframe-runtime opens a WebSocket immediately on mount and
+     * receives `props_update` frames for in-place re-renders.
+     *
+     * Without this, the per-render resource shell mounts in
+     * static-component mode (codeUrl only) — initial render works but
+     * server-side state mutations (`ggui_update`) never visibly update
+     * the iframe. Spec-compliant MCP-Apps hosts can still re-fetch
+     * `resources/read` per-tool-result to get fresh HTML, but in-place
+     * live updates require the WS pipe.
+     *
+     * Mirrors the `mintWsToken` plumbed into the handler-side render
+     * machinery in `server.ts`; the resource template owns its own
+     * call here because it runs OUTSIDE the per-tool-call context.
+     */
+    readonly mintWsToken?: (renderId: string, appId: string) => {
+        readonly wsUrl: string;
+        readonly token: string;
+        readonly expiresAt: string;
+    };
 }
 /**
- * Register a `ui://ggui/session/{sessionId}` resource template. Each
- * `resources/read` request is resolved by looking up the session in the
- * store, picking the topmost component stack item, and returning the
- * self-contained shell with that componentCode inlined.
+ * Register a `ui://ggui/render/{renderId}` resource template. Each
+ * `resources/read` request is resolved by looking up the render in the
+ * store and returning the self-contained shell with that
+ * componentCode inlined.
  *
- * Per-call `_meta.ui.resourceUri` (stamped by `ggui_push.resultMeta`)
- * pins the URI to a specific sessionId; hosts fetch THAT URI rather
- * than the static `ui://ggui/session` one. Both registrations co-exist:
+ * Per-call `_meta.ui.resourceUri` (stamped by `ggui_render.resultMeta`)
+ * pins the URI to a specific renderId; hosts fetch THAT URI rather
+ * than the static `ui://ggui/render` one. Both registrations co-exist:
  * legacy postMessage shell at the static URI, self-contained shell at
  * the templated URI.
  *
  * Failure modes:
- *   - Session not found → loading shell (host re-fetches; absent
- *     session is a transient state immediately after `ggui_push`).
- *   - Session found, no componentCode yet → loading shell.
- *   - Session found, componentCode present → self-contained shell.
+ *   - Render not found → loading shell (host re-fetches; absent
+ *     render is a transient state immediately after `ggui_render`).
+ *   - Render found, no componentCode yet → loading shell.
+ *   - Render found, componentCode present → self-contained shell.
  *
  * Returns nothing; mutates the server in place.
  *
  * @public
  */
-export declare function registerGguiSessionResourceTemplate(server: McpServer, opts: GguiSessionResourceTemplateOptions): void;
+export declare function registerGguiRenderResourceTemplate(server: McpServer, opts: GguiRenderResourceTemplateOptions): void;
 /**
  * Apply the full MCP Apps outbound wiring to a fresh `McpServer` - both
- * the capability advertisement and the `ui://ggui/session` resource. The
+ * the capability advertisement and the `ui://ggui/render` resource. The
  * single entry-point `build-mcp.ts` calls so request-path wiring stays
  * one line.
  *
- * When `selfContained` is supplied, ALSO registers the per-session
- * `ui://ggui/session/{sessionId}` resource template that serves the
+ * When `selfContained` is supplied, ALSO registers the per-render
+ * `ui://ggui/render/{renderId}` resource template that serves the
  * self-contained shell (the path third-party MCP Apps hosts use). The
  * legacy static URI registration is unconditional — first-party hosts
  * (Studio, Portal, console) still rely on the postMessage path.
@@ -427,16 +443,15 @@ export declare function registerGguiSessionResourceTemplate(server: McpServer, o
 export declare function installMcpAppsOutbound(server: McpServer, opts?: {
     readonly shellHtml?: string;
     /**
-     * Per-session self-contained shell registration. When supplied,
-     * `ui://ggui/session/{sessionId}` becomes a readable resource
+     * Per-render self-contained shell registration. When supplied,
+     * `ui://ggui/render/{renderId}` becomes a readable resource
      * template whose body inlines the compiled componentCode from the
-     * session's topmost stack item. Absent → only the legacy
-     * postMessage shell is registered.
+     * render. Absent → only the legacy postMessage shell is registered.
      */
-    readonly selfContained?: GguiSessionResourceTemplateOptions;
+    readonly selfContained?: GguiRenderResourceTemplateOptions;
     /**
      * Public origin the server is reachable at — forwarded to
-     * `registerGguiSessionResource` so the static `ui://ggui/session`
+     * `registerGguiRenderResource` so the static `ui://ggui/render`
      * resource carries `_meta.ui.csp.{connectDomains,resourceDomains}`
      * authorising the iframe to fetch the runtime bundle and open a
      * WebSocket. Omit when running same-origin behind a first-party

package/dist/mcp-apps-outbound.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp-apps-outbound.d.ts","sourceRoot":"","sources":["../src/mcp-apps-outbound.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"mcp-apps-outbound.d.ts","sourceRoot":"","sources":["../src/mcp-apps-outbound.ts"],"names":[],"mappings":"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"}