Browser-based graphical shell and control plane for a Linux server you own — real terminal, file manager, live metrics and BYOK AI in one mobile-first workspace. Next.js 16 · React 19 · node-pty · Tailwind v4 · shadcn/ui. Public alpha, self-hosted.
TypeScript browser-shellcontrol-planefile-managerhomelabmobile-firstnextjsptyreactself-hostedserver-managementshadcn-uisysadmintailwindcssterminaltypescriptvpsweb-desktopweb-terminal
fix(mcp): negotiate native app ui
Rahmancec8b012bd38
diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.mdindex 23f23659..9164649b 100644--- a/docs/CHANGELOG.md+++ b/docs/CHANGELOG.md@@ -4,6 +4,12 @@Newest first. `docs/PROGRESS.md` is the source of truth for *why* a change was made;this is the *what*, and it is what Settings → About shows as “What's new”.+## 2026-09-21++**Fixed**++- `mcp` negotiate native app ui+## 2026-09-20**Added**diff --git a/docs/CHATGPT-PLUGIN.md b/docs/CHATGPT-PLUGIN.mdindex 988f8c49..6de2cfaa 100644--- a/docs/CHATGPT-PLUGIN.md+++ b/docs/CHATGPT-PLUGIN.md@@ -62,6 +62,8 @@ Project-owned MCP names and Convex's own dynamic schemas still load on demand thChatGPT presentation is explicit rather than attached to every operation. `workflow_start` is headless. `render_mso_list` renders a compact searchable list/grid from data already fetched by ordinary tools; it is the default lightweight surface for projects, files, sessions, workflows, apps, integrations and agents. `render_mso_block` opens the compact validation/action/CRUD component and accepts only bounded fields, checks, outputs, and follow-up actions; a button cannot execute a mutation inside either compact widget. `render_mso_page` opens native MSO views or a code-reviewed development/preview/production app. It accepts only MSO-style routes and server-owned app ids, never arbitrary HTML or an external URL. `mso_surface_apps_list` exposes the reviewed Page catalog. Apps outside the reviewed Page catalog use the remote browser. Nested frames are limited to code-reviewed exact origins and registry policy; arbitrary third-party URLs are never accepted. User-installed runtime HTML apps do not inherit this trust automatically. `render_mso_surface` and `workflow_status` remain app-only compatibility shims for cached clients.+The MCP server also advertises `capabilities.extensions["io.modelcontextprotocol/ui"]` with the MCP App HTML MIME in legacy `initialize` and modern `server/discover`. Native presentation is therefore negotiated explicitly with a host that advertises the same extension; an orchestration/function wrapper may still call the tool while omitting that host-owned presentation context.+`render_mso_list`, `render_mso_page` and `integration_setup_open` use the standard MCP Apps `ui.resourceUri` binding. List and Page intentionally omit the legacy `openai/outputTemplate`; Block retains it only for compatibility. Do not mirror `openai/outputTemplate` onto Page tools: the current ChatGPT host already supports the standard binding, and dual Page bindings can mount the same UI twice. The current Page therefore uses one modern binding and keeps earlier Page URIs only as non-advertised read aliases.Page enters in **inline** mode and fills standard MCP Apps `containerDimensions.height` or `maxHeight`, with legacy `maxHeight` and a 680 px fallback. Measured size notifications resize flexible host frames without viewport feedback. Fullscreen and supported PiP remain explicit user actions. See [the UI contract](integrations/CHATGPT-UI.md).diff --git a/docs/MCP.md b/docs/MCP.mdindex 012c70e5..c8eb8c00 100644--- a/docs/MCP.md+++ b/docs/MCP.md@@ -457,6 +457,21 @@ Run `bun run bench:cognitive` for the reproducible provider-neutral routing/footHermes is compared only where an equivalent offline `prompt-size` metric exists; OpenClaw isreported but is not declared beaten on a non-comparable metric.+## MCP Apps UI extension++MSO advertises `capabilities.extensions["io.modelcontextprotocol/ui"]` with+`mimeTypes: ["text/html;profile=mcp-app"]` during legacy `initialize` and modern+`server/discover`. MCP Apps is negotiated bilaterally: a capable host advertises the+same extension/MIME in its client capabilities, while clients that do not negotiate it+continue to receive ordinary structured/text tool results. The UI tools still bind+their exact `ui://` resources through `_meta.ui.resourceUri`; capability negotiation+does not grant extra tool scope or bypass OAuth.++The private MCP activity stream records only the protocol lifecycle needed to debug+host mounting: initialize/discover records whether the client advertised compatible UI+support, and `resources/list` / `resources/read` record bounded URI/MIME/status metadata.+Resource HTML, bearer credentials and tool payloads are never copied into that telemetry.+## OpenAI/MCP static skill extensionIn addition to the live `skills_*` actions, MSO advertises `capabilities.extensions["io.modelcontextprotocol/skills"]` for ChatGPT/OpenAI plugin scans. The extension is intentionally **static and bounded**: it publishes at most five general official skills from `claude-skills/`, then serves the same complete entry through `skills/list` and `skills/get` and every declared `skill://mso/...` resource through `resources/read`. Each resource is read with `O_NOFOLLOW`, capped before allocation, path-normalized, included in the per-skill 100-file / 5 MiB budget, and hashed as `sha256:<hex>`.diff --git a/docs/PROGRESS.md b/docs/PROGRESS.mdindex ac3f4250..758fe3e5 100644--- a/docs/PROGRESS.md+++ b/docs/PROGRESS.md@@ -1,3 +1,11 @@+## 2026-09-22 — Negotiate MCP Apps UI and expose host-boundary telemetry++The Native UI probe proved that MSO's tool descriptor, `ui://` resource, MCP App MIME and static HTML were valid, yet direct host acceptance still returned the structured fallback. The missing server-side contract was capability negotiation: MSO advertised its Skills extension but never declared `io.modelcontextprotocol/ui` during either legacy `initialize` or modern `server/discover`. A host could therefore execute the tool successfully without having a negotiated MCP Apps presentation channel.++MSO now advertises the UI extension with `text/html;profile=mcp-app` in both protocol eras while preserving ordinary structured/text fallback for non-UI clients. Owner-private protocol telemetry records only whether initialize/discover saw compatible client UI capabilities and whether `resources/list` / `resources/read` occurred, including bounded URI/MIME/state/duration metadata but never resource HTML or credentials. Regression covers bilateral negotiation and redacted resource lifecycle. The reference MCP Inspector reports the minimal probe as `hasApp:true` with the expected URI, model/app visibility, CSP and MCP App MIME.++This release fixes the MSO-owned negotiation gap; it does not redefine visual acceptance. A generic Code Mode/function wrapper can still unwrap the inner tool result and cannot prove host mounting. Final ChatGPT acceptance remains a direct registered-app invocation after the refreshed server descriptor is active, with success defined by a visibly host-mounted `MSO NATIVE UI WORKS` component and then a real List → Page interaction round-trip.+## 2026-09-21 — Add bounded Repeat Until for reusable Session workflowsWorkflow Graph could already save successful/reviewable Session action history as a private workflow draft and invoke saved workflows through Subflow, but its graph schema deliberately rejected cyclic edges and the existing `loop` node only iterated arrays. That left ordinary automation patterns such as “run this saved task, inspect its result, and try again until ready” without a native bounded control-flow primitive.diff --git a/docs/generated/MCP-CATALOG.md b/docs/generated/MCP-CATALOG.mdindex 1ed223d7..32c43acd 100644--- a/docs/generated/MCP-CATALOG.md+++ b/docs/generated/MCP-CATALOG.md@@ -4,13 +4,13 @@## Full MSO catalog-<!-- mcp-toolset: server=1.15.1 version=2026.09.20.2 tools=114 read=56 write=35 exec=23 -->+<!-- mcp-toolset: server=1.15.2 version=2026.09.22.1 tools=114 read=56 write=35 exec=23 -->| Fact | Current source value ||---|---:|-| MCP server | `1.15.1` |-| Toolset | `2026.09.20.2` |-| Toolset changed at | `2026-09-20T14:51:00+07:00` |+| MCP server | `1.15.2` |+| Toolset | `2026.09.22.1` |+| Toolset changed at | `2026-09-22T06:29:53+07:00` || Transport tools | **116** || Model/operator tools | **114** || Read | **56** |@@ -148,7 +148,7 @@## ChatGPT model profile-<!-- mcp-chatgpt-profile: server=1.15.1 version=2026.09.20.2 tools=114 read=56 write=35 exec=23 app-only=2 total=116 -->+<!-- mcp-chatgpt-profile: server=1.15.2 version=2026.09.22.1 tools=114 read=56 write=35 exec=23 app-only=2 total=116 -->The ChatGPT profile automatically projects the complete MSO-owned generic model/operator catalog. OAuth scope is still enforced independently; app-only compatibility bridges stay app-only, and project-owned MCP tool names remain dynamic data behind the generic project bridge.diff --git a/docs/integrations/CHATGPT-UI.md b/docs/integrations/CHATGPT-UI.mdindex 7f00c8f7..bd00b50e 100644--- a/docs/integrations/CHATGPT-UI.md+++ b/docs/integrations/CHATGPT-UI.md@@ -74,6 +74,19 @@ retains its framing protections; external sites keep their own authentication bo## Bridge, metadata and compatibility+The MCP transport advertises the standard `io.modelcontextprotocol/ui` extension with+`mimeTypes: ["text/html;profile=mcp-app"]` in both legacy `initialize` and modern+`server/discover`. A native host must advertise the matching extension/MIME in its+client capabilities for MCP Apps presentation to be negotiated. Without that bilateral+capability, MSO remains usable as a normal structured/text MCP server instead of+assuming that a `ui.resourceUri` descriptor alone proves host support.++For host-boundary debugging, the owner-private MCP activity stream records+`protocol.initialize` / `protocol.discover` with `client-ui=true|false` plus+`resources.list` / `resources.read` URI, MIME, result state and duration. It never+records the resource HTML itself. This makes a missing host resource fetch observable+without exposing widget bytes, OAuth material or tool arguments.+Page initializes MCP Apps protocol `2026-01-26`, then sends`ui/notifications/initialized`. Only parent-source messages are accepted. Tool resultnotifications and legacy wrapped `window.openai.toolOutput` use the same route validator.diff --git a/lib/mcp/dispatch-types.ts b/lib/mcp/dispatch-types.tsindex b723e2ee..1783861b 100644--- a/lib/mcp/dispatch-types.ts+++ b/lib/mcp/dispatch-types.ts@@ -10,6 +10,8 @@ export interface RpcRequest {name?: string;arguments?: Record<string, unknown>;protocolVersion?: string;+ capabilities?: Record<string, unknown>;+ clientInfo?: Record<string, unknown>;uri?: string;cursor?: string;_meta?: Record<string, unknown>;diff --git a/lib/mcp/dispatch.ts b/lib/mcp/dispatch.tsindex f83484cb..8522160f 100644--- a/lib/mcp/dispatch.ts+++ b/lib/mcp/dispatch.ts@@ -1,7 +1,7 @@import type { Scope } from "./scope";import { MCP_SERVER_VERSION, toolsetInfo } from "./toolset";import { TOOLS } from "./tools";-import { listUiResources, readUiResource } from "./ui-resources";+import { MCP_APP_MIME_TYPE, MCP_UI_EXTENSION, MCP_UI_EXTENSION_CAPABILITY, listUiResources, readUiResource } from "./ui-resources";import { MCP_SKILLS_EXTENSION, getMcpSkill, listMcpSkills, readMcpSkillResource } from "./skills-extension";import { dispatchToolCall } from "./dispatch-tools";import { readMcpFileResource } from "./file-transfer-resource";@@ -9,6 +9,7 @@ import { toolDescriptor, visibleToolsForProfile, type McpToolProfile } from "./timport { MCP_PROTOCOL_LATEST, MCP_PROTOCOLS, negotiateMcpProtocol } from "./protocol";import { mcpInstructions } from "./instructions";import { rpcFail, rpcOk, type McpAgentContext, type RpcRequest } from "./dispatch-types";+import { newActivityId, recordMcpActivity } from "./activity";export type { McpAgentContext, RpcRequest } from "./dispatch-types";export const UNAUTHORIZED = -32001;@@ -27,24 +28,68 @@ const toolList = (scope: Scope, profile: McpToolProfile = "full", allowedTools?:const instructions = mcpInstructions;+const object = (value: unknown): value is Record<string, unknown> =>+ Boolean(value && typeof value === "object" && !Array.isArray(value));+const serverExtensions = {+ [MCP_SKILLS_EXTENSION]: {},+ [MCP_UI_EXTENSION]: MCP_UI_EXTENSION_CAPABILITY,+} as const;+function clientSupportsUi(req: RpcRequest, modern: boolean): boolean {+ const meta = object(req.params?._meta) ? req.params?._meta : undefined;+ const capabilities = modern+ ? (object(meta?.["io.modelcontextprotocol/clientCapabilities"]) ? meta?.["io.modelcontextprotocol/clientCapabilities"] : undefined)+ : req.params?.capabilities;+ if (!object(capabilities) || !object(capabilities.extensions)) return false;+ const ui = capabilities.extensions[MCP_UI_EXTENSION];+ return object(ui) && Array.isArray(ui.mimeTypes) && ui.mimeTypes.includes(MCP_APP_MIME_TYPE);+}+function activityStart(tool: string, scope: Scope, actor: string | undefined, target?: string) {+ const id = newActivityId(), startedAt = Date.now();+ void recordMcpActivity({ id, tool, state: "started", actor, scope, target });+ return { id, startedAt };+}+function activityFinish(+ activity: { id: string; startedAt: number },+ tool: string,+ scope: Scope,+ actor: string | undefined,+ state: "completed" | "failed" | "invalid_args",+ target?: string,+ detail?: string,+) {+ void recordMcpActivity({+ id: activity.id, tool, state, actor, scope, target,+ durationMs: Date.now() - activity.startedAt, detail,+ });+}++export async function dispatch(req: RpcRequest, scope: Scope, actor?: string, agentContext?: McpAgentContext): Promise<Record<string, unknown>> {const id = req.id ?? null;const modern = req.params?._meta?.["io.modelcontextprotocol/protocolVersion"] === MCP_PROTOCOL_LATEST;if (modern && (req.method === "initialize" || req.method === "notifications/initialized")) return rpcFail(id, -32601, "initialize is only supported in the legacy MCP era");switch (req.method) {- case "server/discover":+ case "server/discover": {if (!modern) return rpcFail(id, -32601, "server/discover requires modern per-request metadata");- return rpcOk(id, { resultType: "complete", supportedVersions: [...MCP_PROTOCOLS], capabilities: { tools: {}, resources: {} },+ const activity = activityStart("protocol.discover", scope, actor);+ const ui = clientSupportsUi(req, true);+ activityFinish(activity, "protocol.discover", scope, actor, "completed", undefined, "client-ui=" + ui + ";server-ui=true");+ return rpcOk(id, { resultType: "complete", supportedVersions: [...MCP_PROTOCOLS],+ capabilities: { tools: {}, resources: {}, extensions: serverExtensions },_meta: { "io.modelcontextprotocol/serverInfo": { name: "mso", version: MCP_SERVER_VERSION } },instructions: instructions(scope, agentContext?.toolProfile, agentContext?.allowedTools), ttlMs: 30_000, cacheScope: "private" });+ }case "initialize": {const profile = agentContext?.toolProfile ?? "full";const allowedTools = agentContext?.allowedTools;const tools = visibleTools(scope, profile, allowedTools), toolset = toolsetInfo(tools, scope, profile);+ const activity = activityStart("protocol.initialize", scope, actor);+ const ui = clientSupportsUi(req, false);+ activityFinish(activity, "protocol.initialize", scope, actor, "completed", undefined, "client-ui=" + ui + ";server-ui=true");return rpcOk(id, {protocolVersion: negotiateMcpProtocol(req.params?.protocolVersion),- capabilities: { tools: { listChanged: false }, resources: { listChanged: false }, extensions: { [MCP_SKILLS_EXTENSION]: {} } },+ capabilities: { tools: { listChanged: false }, resources: { listChanged: false }, extensions: serverExtensions },serverInfo: { name: "mso", version: MCP_SERVER_VERSION }, instructions: instructions(scope, profile, allowedTools),_meta: { toolset, ...(agentContext?.sessionId ? { agentSessionId: agentContext.sessionId } : {}) },});@@ -57,21 +102,48 @@ export async function dispatch(req: RpcRequest, scope: Scope, actor?: string, agconst tools = visibleTools(scope, profile, allowedTools);return rpcOk(id, { tools: toolList(scope, profile, allowedTools), _meta: { toolset: toolsetInfo(tools, scope, profile) } });}- case "resources/list": return rpcOk(id, { resources: await listUiResources() });+ case "resources/list": {+ const activity = activityStart("resources.list", scope, actor);+ const resources = await listUiResources();+ activityFinish(activity, "resources.list", scope, actor, "completed", undefined, "count=" + resources.length);+ return rpcOk(id, { resources });+ }case "resources/read": {const uri = String(req.params?.uri ?? "");- if (!uri) return rpcFail(id, -32602, "resources/read needs { uri }");+ const activity = activityStart("resources.read", scope, actor, uri || undefined);+ if (!uri) {+ activityFinish(activity, "resources.read", scope, actor, "invalid_args", undefined, "missing uri");+ return rpcFail(id, -32602, "resources/read needs { uri }");+ }const resource = await readUiResource(uri);- if (resource) return rpcOk(id, { contents: [{ uri: resource.uri, mimeType: resource.mimeType, text: resource.text, _meta: resource._meta }] });+ if (resource) {+ activityFinish(activity, "resources.read", scope, actor, "completed", uri, "ui mime=" + resource.mimeType);+ return rpcOk(id, { contents: [{ uri: resource.uri, mimeType: resource.mimeType, text: resource.text, _meta: resource._meta }] });+ }try {const fileResource = await readMcpFileResource(uri, agentContext?.principal, agentContext?.sessionId);- if (fileResource) return rpcOk(id, { contents: [{ uri: fileResource.uri, mimeType: fileResource.mimeType, blob: fileResource.data.toString("base64") }] });- } catch (error) { return rpcFail(id, -32602, error instanceof Error ? error.message : String(error)); }+ if (fileResource) {+ activityFinish(activity, "resources.read", scope, actor, "completed", uri, "file mime=" + fileResource.mimeType);+ return rpcOk(id, { contents: [{ uri: fileResource.uri, mimeType: fileResource.mimeType, blob: fileResource.data.toString("base64") }] });+ }+ } catch (error) {+ const message = error instanceof Error ? error.message : String(error);+ activityFinish(activity, "resources.read", scope, actor, "failed", uri, message);+ return rpcFail(id, -32602, message);+ }try {const skillResource = await readMcpSkillResource(uri);- if (skillResource) return rpcOk(id, { contents: [skillResource] });- } catch (error) { return rpcFail(id, -32602, error instanceof Error ? error.message : String(error)); }- return rpcFail(id, -32602, `unknown resource: ${uri}`);+ if (skillResource) {+ activityFinish(activity, "resources.read", scope, actor, "completed", uri, "skill mime=" + skillResource.mimeType);+ return rpcOk(id, { contents: [skillResource] });+ }+ } catch (error) {+ const message = error instanceof Error ? error.message : String(error);+ activityFinish(activity, "resources.read", scope, actor, "failed", uri, message);+ return rpcFail(id, -32602, message);+ }+ activityFinish(activity, "resources.read", scope, actor, "failed", uri, "unknown resource");+ return rpcFail(id, -32602, "unknown resource: " + uri);}case "skills/list": {try { return rpcOk(id, await listMcpSkills(typeof req.params?.cursor === "string" ? req.params.cursor : undefined)); }diff --git a/lib/mcp/toolset.ts b/lib/mcp/toolset.tsindex 8fa95e75..cf62f2a5 100644--- a/lib/mcp/toolset.ts+++ b/lib/mcp/toolset.ts@@ -3,9 +3,9 @@ import type { Scope } from "./scope";import type { McpTool } from "./tool-kit";import { toolDescriptor, type McpToolProfile } from "./tool-contract";-export const MCP_SERVER_VERSION = "1.15.1";-export const MCP_TOOLSET_VERSION = "2026.09.20.2";-export const MCP_TOOLSET_CHANGED_AT = "2026-09-20T14:51:00+07:00";+export const MCP_SERVER_VERSION = "1.15.2";+export const MCP_TOOLSET_VERSION = "2026.09.22.1";+export const MCP_TOOLSET_CHANGED_AT = "2026-09-22T06:29:53+07:00";export type McpToolsetInfo = {serverVersion: string;diff --git a/lib/mcp/ui-observability.test.ts b/lib/mcp/ui-observability.test.tsnew file mode 100644index 00000000..5677705f--- /dev/null+++ b/lib/mcp/ui-observability.test.ts@@ -0,0 +1,61 @@+import { afterAll, describe, expect, it, vi } from "vitest";+import { promises as fs } from "node:fs";+import os from "node:os";+import path from "node:path";++vi.mock("server-only", () => ({}));+const activityDir = await fs.mkdtemp(path.join(os.homedir(), ".mso-ui-observability-"));+const activityLog = path.join(activityDir, "activity.jsonl");+vi.stubEnv("OS_MCP_ACTIVITY_LOG", activityLog);+vi.stubEnv("OS_PUBLIC_ORIGIN", "https://mso.example.test");+vi.stubEnv("OS_MCP_UI_ORIGIN", "");++const { dispatch } = await import("./dispatch");+const { readMcpActivity } = await import("./activity");+const { MCP_APP_MIME_TYPE, MCP_UI_EXTENSION, MSO_NATIVE_UI_PROBE_URI } = await import("./ui-resources");++afterAll(async () => {+ await fs.rm(activityDir, { recursive: true, force: true });+ vi.unstubAllEnvs();+});++describe("MCP Apps protocol observability", () => {+ it("negotiates UI and records the redacted resource lifecycle", async () => {+ const capability = { mimeTypes: [MCP_APP_MIME_TYPE] };+ const legacy = await dispatch({ id: 90, method: "initialize", params: {+ protocolVersion: "2025-06-18", capabilities: { extensions: { [MCP_UI_EXTENSION]: capability } },+ } }, "read", "mcp:ui-observability");+ expect(legacy.result).toMatchObject({ capabilities: { extensions: { [MCP_UI_EXTENSION]: capability } } });++ const modern = await dispatch({ jsonrpc: "2.0", id: 91, method: "server/discover", params: { _meta: {+ "io.modelcontextprotocol/protocolVersion": "2026-07-28",+ "io.modelcontextprotocol/clientCapabilities": { extensions: { [MCP_UI_EXTENSION]: capability } },+ } } }, "read", "mcp:ui-observability");+ expect(modern.result).toMatchObject({ capabilities: { extensions: { [MCP_UI_EXTENSION]: capability } } });++ await dispatch({ id: 2, method: "resources/list" }, "read", "mcp:ui-observability");+ await dispatch({ id: 3, method: "resources/read", params: { uri: MSO_NATIVE_UI_PROBE_URI } }, "read", "mcp:ui-observability");++ let rows = await readMcpActivity(20);+ const complete = () => rows.some((row) => row.tool === "resources.list" && row.state === "completed")+ && rows.some((row) => row.tool === "resources.read" && row.state === "completed");+ for (let attempt = 0; attempt < 30 && !complete(); attempt++) {+ await new Promise((resolve) => setTimeout(resolve, 10));+ rows = await readMcpActivity(20);+ }++ expect(rows).toEqual(expect.arrayContaining([+ expect.objectContaining({ tool: "protocol.initialize", state: "completed", detail: "client-ui=true;server-ui=true" }),+ expect.objectContaining({ tool: "protocol.discover", state: "completed", detail: "client-ui=true;server-ui=true" }),+ expect.objectContaining({ tool: "resources.list", state: "completed", detail: "count=4" }),+ expect.objectContaining({+ tool: "resources.read", state: "completed", target: MSO_NATIVE_UI_PROBE_URI,+ detail: "ui mime=" + MCP_APP_MIME_TYPE,+ }),+ ]));++ const raw = await fs.readFile(activityLog, "utf8");+ expect(raw).not.toContain("MSO NATIVE UI WORKS");+ expect(raw).not.toContain("<main");+ });+});diff --git a/lib/mcp/ui-resources.ts b/lib/mcp/ui-resources.tsindex 476591f7..38b3e220 100644--- a/lib/mcp/ui-resources.ts+++ b/lib/mcp/ui-resources.ts@@ -5,6 +5,8 @@ import { MSO_NATIVE_UI_PROBE_RESOURCE, MSO_NATIVE_UI_PROBE_URI } from "./ui-natiexport { MSO_BLOCK_URI, MSO_LIST_URI, MSO_NATIVE_UI_PROBE_URI, MSO_PAGE_URI };export const MCP_APP_MIME_TYPE = "text/html;profile=mcp-app";+export const MCP_UI_EXTENSION = "io.modelcontextprotocol/ui";+export const MCP_UI_EXTENSION_CAPABILITY = { mimeTypes: [MCP_APP_MIME_TYPE] } as const;// Read-only aliases keep already-cached ChatGPT action descriptors functional// across the UI-contract migration. They are intentionally not advertised by