@frontmcp/ui 0.5.0

package/package.json

@@ -0,0 +1,147 @@
+{
+  "name": "@frontmcp/ui",
+  "version": "0.5.0",
+  "description": "FrontMCP UI - Comprehensive UI library for authentication and authorization flows with multi-framework support (HTML, React, MDX)",
+  "author": "AgentFront <info@agentfront.dev>",
+  "homepage": "https://docs.agentfront.dev",
+  "license": "Apache-2.0",
+  "keywords": [
+    "mcp",
+    "ui",
+    "tailwind",
+    "htmx",
+    "oauth",
+    "authentication",
+    "authorization",
+    "consent",
+    "agentfront",
+    "frontmcp",
+    "framework",
+    "typescript",
+    "react",
+    "mdx",
+    "jsx",
+    "ssr"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/agentfront/frontmcp.git"
+  },
+  "bugs": {
+    "url": "https://github.com/agentfront/frontmcp/issues"
+  },
+  "main": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js",
+      "default": "./src/index.js"
+    },
+    "./types": {
+      "types": "./src/types/index.d.ts",
+      "import": "./src/types/index.js",
+      "default": "./src/types/index.js"
+    },
+    "./adapters": {
+      "types": "./src/adapters/index.d.ts",
+      "import": "./src/adapters/index.js",
+      "default": "./src/adapters/index.js"
+    },
+    "./build": {
+      "types": "./src/build/index.d.ts",
+      "import": "./src/build/index.js",
+      "default": "./src/build/index.js"
+    },
+    "./renderers": {
+      "types": "./src/renderers/index.d.ts",
+      "import": "./src/renderers/index.js",
+      "default": "./src/renderers/index.js"
+    },
+    "./components": {
+      "types": "./src/components/index.d.ts",
+      "import": "./src/components/index.js",
+      "default": "./src/components/index.js"
+    },
+    "./runtime": {
+      "types": "./src/runtime/index.d.ts",
+      "import": "./src/runtime/index.js",
+      "default": "./src/runtime/index.js"
+    },
+    "./theme": {
+      "types": "./src/theme/index.d.ts",
+      "import": "./src/theme/index.js",
+      "default": "./src/theme/index.js"
+    },
+    "./bridge": {
+      "types": "./src/bridge/index.d.ts",
+      "import": "./src/bridge/index.js",
+      "default": "./src/bridge/index.js"
+    },
+    "./web-components": {
+      "types": "./src/web-components/index.d.ts",
+      "import": "./src/web-components/index.js",
+      "default": "./src/web-components/index.js"
+    },
+    "./react": {
+      "types": "./src/react/index.d.ts",
+      "import": "./src/react/index.js",
+      "default": "./src/react/index.js"
+    },
+    "./render": {
+      "types": "./src/render/index.d.ts",
+      "import": "./src/render/index.js",
+      "default": "./src/render/index.js"
+    },
+    "./styles": {
+      "types": "./src/styles/index.d.ts",
+      "import": "./src/styles/index.js",
+      "default": "./src/styles/index.js"
+    },
+    "./bundler": {
+      "types": "./src/bundler/index.d.ts",
+      "import": "./src/bundler/index.js",
+      "default": "./src/bundler/index.js"
+    },
+    "./handlebars": {
+      "types": "./src/handlebars/index.d.ts",
+      "import": "./src/handlebars/index.js",
+      "default": "./src/handlebars/index.js"
+    },
+    "./registry": {
+      "types": "./src/registry/index.d.ts",
+      "import": "./src/registry/index.js",
+      "default": "./src/registry/index.js"
+    }
+  },
+  "dependencies": {
+    "@swc/core": "^1.5.0",
+    "enclave-vm": "^1.0.1",
+    "esbuild": "^0.24.0",
+    "handlebars": "^4.7.8",
+    "tslib": "^2.3.0",
+    "zod": "^4.0.0"
+  },
+  "peerDependencies": {
+    "react": "^18.0.0 || ^19.0.0",
+    "react-dom": "^18.0.0 || ^19.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    },
+    "react-dom": {
+      "optional": true
+    }
+  },
+  "optionalDependencies": {
+    "@mdx-js/mdx": "^3.1.0"
+  },
+  "devDependencies": {
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "typescript": "^5.9.3"
+  },
+  "type": "commonjs"
+}

package/src/adapters/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @frontmcp/ui Adapters
+ *
+ * Platform-specific adapters for building UI metadata.
+ * These adapters are SDK-independent and can be used by external systems
+ * like AgentLink without requiring @frontmcp/sdk.
+ *
+ * @packageDocumentation
+ */
+export { type AIPlatformType, type UIMetadata, type BuildUIMetaOptions, type BuildToolDiscoveryMetaOptions, buildUIMeta, buildToolDiscoveryMeta, buildOpenAICSP, } from './platform-meta';

package/src/adapters/index.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * @frontmcp/ui Adapters
+ *
+ * Platform-specific adapters for building UI metadata.
+ * These adapters are SDK-independent and can be used by external systems
+ * like AgentLink without requiring @frontmcp/sdk.
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildOpenAICSP = exports.buildToolDiscoveryMeta = exports.buildUIMeta = void 0;
+var platform_meta_1 = require("./platform-meta");
+// Builder Functions
+Object.defineProperty(exports, "buildUIMeta", { enumerable: true, get: function () { return platform_meta_1.buildUIMeta; } });
+Object.defineProperty(exports, "buildToolDiscoveryMeta", { enumerable: true, get: function () { return platform_meta_1.buildToolDiscoveryMeta; } });
+Object.defineProperty(exports, "buildOpenAICSP", { enumerable: true, get: function () { return platform_meta_1.buildOpenAICSP; } });
+//# sourceMappingURL=index.js.map

package/src/adapters/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/adapters/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;;AAEH,iDAWyB;AAJvB,oBAAoB;AACpB,4GAAA,WAAW,OAAA;AACX,uHAAA,sBAAsB,OAAA;AACtB,+GAAA,cAAc,OAAA","sourcesContent":["/**\n * @frontmcp/ui Adapters\n *\n * Platform-specific adapters for building UI metadata.\n * These adapters are SDK-independent and can be used by external systems\n * like AgentLink without requiring @frontmcp/sdk.\n *\n * @packageDocumentation\n */\n\nexport {\n  // Platform Types\n  type AIPlatformType,\n  // Metadata Types\n  type UIMetadata,\n  type BuildUIMetaOptions,\n  type BuildToolDiscoveryMetaOptions,\n  // Builder Functions\n  buildUIMeta,\n  buildToolDiscoveryMeta,\n  buildOpenAICSP,\n} from './platform-meta';\n"]}

package/src/adapters/platform-meta.d.ts

@@ -0,0 +1,165 @@
+/**
+ * Platform Metadata Adapters
+ *
+ * Build platform-specific _meta fields for tool UI responses.
+ * Adapts the UI configuration to the format expected by each
+ * AI platform (OpenAI, Claude, Gemini, etc.).
+ *
+ * This module is SDK-independent and can be used by external systems
+ * like AgentLink without requiring @frontmcp/sdk.
+ *
+ * @packageDocumentation
+ */
+import type { UITemplateConfig, UIContentSecurityPolicy } from '../types';
+/**
+ * Supported AI platform types.
+ * Used to determine which metadata format to generate.
+ */
+export type AIPlatformType = 'openai' | 'claude' | 'gemini' | 'cursor' | 'continue' | 'cody' | 'generic-mcp' | 'ext-apps' | 'unknown';
+/**
+ * UI metadata to include in tool response _meta field.
+ * Contains both universal fields and platform-specific annotations.
+ */
+export interface UIMetadata {
+    /** Inline rendered HTML (universal) */
+    'ui/html'?: string;
+    /** MIME type for the HTML content */
+    'ui/mimeType'?: string;
+    /** Widget token for authenticated operations */
+    'ui/widgetToken'?: string;
+    /** Direct URL to widget (for direct-url serving mode) */
+    'ui/directUrl'?: string;
+    /** Renderer type for the widget (html, react, mdx, markdown, auto) */
+    'ui/type'?: string;
+    /** Manifest URI for accessing widget configuration */
+    'ui/manifestUri'?: string;
+    /** Hash of the widget content for cache validation */
+    'ui/contentHash'?: string;
+    /** Required renderer assets for lazy loading */
+    'ui/requiredRenderers'?: string[];
+    /** OpenAI: Resource URI for widget template */
+    'openai/outputTemplate'?: string;
+    /** OpenAI: Whether widget can invoke tools */
+    'openai/widgetAccessible'?: boolean;
+    /** OpenAI: Whether tool result can produce a widget (CRITICAL for ChatGPT) */
+    'openai/resultCanProduceWidget'?: boolean;
+    /** OpenAI: CSP configuration */
+    'openai/widgetCSP'?: {
+        connect_domains?: string[];
+        resource_domains?: string[];
+    };
+    /** OpenAI: Display mode preference */
+    'openai/displayMode'?: string;
+    /** OpenAI: Widget description */
+    'openai/widgetDescription'?: string;
+    /** OpenAI: Status text while tool is executing */
+    'openai/toolInvocation/invoking'?: string;
+    /** OpenAI: Status text after tool execution completes */
+    'openai/toolInvocation/invoked'?: string;
+    /** Claude: Widget description */
+    'claude/widgetDescription'?: string;
+    /** Gemini: Widget description */
+    'gemini/widgetDescription'?: string;
+    /** IDE: Resource URI for widget template */
+    'ide/outputTemplate'?: string;
+    /** IDE: Widget description */
+    'ide/widgetDescription'?: string;
+    /** MCP Apps: Resource URI for UI template */
+    'ui/resourceUri'?: string;
+    /** MCP Apps: CSP configuration */
+    'ui/csp'?: {
+        connectDomains?: string[];
+        resourceDomains?: string[];
+    };
+    /** MCP Apps: Dedicated sandbox domain */
+    'ui/domain'?: string;
+    /** MCP Apps: Whether to show border around UI */
+    'ui/prefersBorder'?: boolean;
+    /** MCP Apps: Display mode */
+    'ui/displayMode'?: 'inline' | 'fullscreen' | 'pip';
+    /** Allow additional platform-specific fields */
+    [key: string]: unknown;
+}
+/**
+ * Options for building UI metadata.
+ */
+export interface BuildUIMetaOptions<In = unknown, Out = unknown> {
+    /** Tool UI configuration */
+    uiConfig: UITemplateConfig<In, Out>;
+    /** Detected platform type */
+    platformType: AIPlatformType;
+    /** Rendered HTML content */
+    html: string;
+    /** Widget access token */
+    token?: string;
+    /** Direct URL for widget serving */
+    directUrl?: string;
+    /** Renderer type for the widget (html, react, mdx, markdown, auto) */
+    rendererType?: string;
+    /** Hash of the widget content for cache validation */
+    contentHash?: string;
+    /** Manifest URI for accessing widget configuration */
+    manifestUri?: string;
+}
+/**
+ * Build platform-specific UI metadata for tool response.
+ *
+ * For inline serving mode (default), HTML is embedded directly in `_meta['ui/html']`.
+ * For static mode, the static widget URI is provided in tools/list
+ * and the tool response contains only structured data.
+ *
+ * @example
+ * ```typescript
+ * import { buildUIMeta } from '@frontmcp/ui/adapters';
+ *
+ * const meta = buildUIMeta({
+ *   uiConfig: { template: (ctx) => `<div>${ctx.output.value}</div>` },
+ *   platformType: 'openai',
+ *   html: '<div>Hello World</div>',
+ * });
+ * ```
+ */
+export declare function buildUIMeta<In = unknown, Out = unknown>(options: BuildUIMetaOptions<In, Out>): UIMetadata;
+/**
+ * Build OpenAI CSP format.
+ */
+export declare function buildOpenAICSP(csp: UIContentSecurityPolicy): {
+    connect_domains?: string[];
+    resource_domains?: string[];
+};
+/**
+ * Build metadata for tool discovery (tools/list response).
+ * This includes fields that should be present at discovery time,
+ * not in individual tool call responses.
+ *
+ * @example
+ * ```typescript
+ * import { buildToolDiscoveryMeta } from '@frontmcp/ui/adapters';
+ *
+ * const toolMeta = buildToolDiscoveryMeta({
+ *   uiConfig: { template: MyWidget, widgetAccessible: true },
+ *   platformType: 'openai',
+ *   staticWidgetUri: 'ui://widget/my_tool.html',
+ * });
+ *
+ * // Use in tools/list response
+ * const tool = {
+ *   name: 'my_tool',
+ *   description: '...',
+ *   inputSchema: {...},
+ *   _meta: toolMeta,
+ * };
+ * ```
+ */
+export interface BuildToolDiscoveryMetaOptions<In = unknown, Out = unknown> {
+    /** Tool UI configuration */
+    uiConfig: UITemplateConfig<In, Out>;
+    /** Detected platform type */
+    platformType: AIPlatformType;
+    /** Static widget URI (e.g., ui://widget/my_tool.html) */
+    staticWidgetUri: string;
+}
+/**
+ * Build tool discovery metadata (for tools/list response).
+ */
+export declare function buildToolDiscoveryMeta<In = unknown, Out = unknown>(options: BuildToolDiscoveryMetaOptions<In, Out>): UIMetadata;

package/src/adapters/platform-meta.js

@@ -0,0 +1,310 @@
+"use strict";
+/**
+ * Platform Metadata Adapters
+ *
+ * Build platform-specific _meta fields for tool UI responses.
+ * Adapts the UI configuration to the format expected by each
+ * AI platform (OpenAI, Claude, Gemini, etc.).
+ *
+ * This module is SDK-independent and can be used by external systems
+ * like AgentLink without requiring @frontmcp/sdk.
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildUIMeta = buildUIMeta;
+exports.buildOpenAICSP = buildOpenAICSP;
+exports.buildToolDiscoveryMeta = buildToolDiscoveryMeta;
+// ============================================
+// Main Builder Function
+// ============================================
+/**
+ * Build platform-specific UI metadata for tool response.
+ *
+ * For inline serving mode (default), HTML is embedded directly in `_meta['ui/html']`.
+ * For static mode, the static widget URI is provided in tools/list
+ * and the tool response contains only structured data.
+ *
+ * @example
+ * ```typescript
+ * import { buildUIMeta } from '@frontmcp/ui/adapters';
+ *
+ * const meta = buildUIMeta({
+ *   uiConfig: { template: (ctx) => `<div>${ctx.output.value}</div>` },
+ *   platformType: 'openai',
+ *   html: '<div>Hello World</div>',
+ * });
+ * ```
+ */
+function buildUIMeta(options) {
+    const { uiConfig, platformType, html, token, directUrl, rendererType, contentHash, manifestUri } = options;
+    const meta = {};
+    // Add manifest-related fields if provided
+    if (rendererType) {
+        meta['ui/type'] = rendererType;
+    }
+    if (contentHash) {
+        meta['ui/contentHash'] = contentHash;
+    }
+    if (manifestUri) {
+        meta['ui/manifestUri'] = manifestUri;
+    }
+    // For inline mode, embed HTML directly in response
+    // This is the only serving mode that uses buildUIMeta
+    // (static mode returns structured data only, no UI _meta)
+    meta['ui/html'] = html;
+    // Always include MIME type for platforms that need it
+    meta['ui/mimeType'] = getMimeType(platformType);
+    // Include token if provided
+    if (token) {
+        meta['ui/widgetToken'] = token;
+    }
+    // Include direct URL if provided
+    if (directUrl) {
+        meta['ui/directUrl'] = directUrl;
+    }
+    // Platform-specific fields
+    switch (platformType) {
+        case 'openai':
+            return buildOpenAIMeta(meta, uiConfig);
+        case 'claude':
+            return buildClaudeMeta(meta, uiConfig);
+        case 'gemini':
+            return buildGeminiMeta(meta, uiConfig);
+        case 'cursor':
+        case 'continue':
+        case 'cody':
+            return buildIDEMeta(meta, uiConfig);
+        case 'generic-mcp':
+            return buildGenericMeta(meta, uiConfig);
+        case 'ext-apps':
+            return buildExtAppsMeta(meta, uiConfig);
+        default:
+            // Unknown platform - just return universal fields
+            return meta;
+    }
+}
+// ============================================
+// Helper Functions
+// ============================================
+/**
+ * Get MIME type based on platform.
+ */
+function getMimeType(platformType) {
+    switch (platformType) {
+        case 'openai':
+            return 'text/html+skybridge';
+        default:
+            return 'text/html+mcp';
+    }
+}
+/**
+ * Build OpenAI-specific metadata for tool CALL response (inline mode).
+ *
+ * NOTE: Per OpenAI's pizzaz example, the call response should only include
+ * invocation status in _meta. The outputTemplate, resultCanProduceWidget, etc.
+ * are discovery-time fields that belong in tools/list _meta, NOT in call response.
+ *
+ * For static mode: OpenAI fetches the widget HTML from the outputTemplate URI
+ * (set in tools/list) and injects structuredContent as window.openai.toolOutput.
+ * For inline mode: HTML is embedded directly in _meta['ui/html'].
+ */
+function buildOpenAIMeta(meta, uiConfig) {
+    // Only include invocation status in call response _meta
+    // (per pizzaz example - they don't include outputTemplate in call response)
+    if (uiConfig.invocationStatus?.invoking) {
+        meta['openai/toolInvocation/invoking'] = uiConfig.invocationStatus.invoking;
+    }
+    if (uiConfig.invocationStatus?.invoked) {
+        meta['openai/toolInvocation/invoked'] = uiConfig.invocationStatus.invoked;
+    }
+    return meta;
+}
+/**
+ * Build OpenAI CSP format.
+ */
+function buildOpenAICSP(csp) {
+    const result = {};
+    if (csp.connectDomains?.length) {
+        result.connect_domains = csp.connectDomains;
+    }
+    if (csp.resourceDomains?.length) {
+        result.resource_domains = csp.resourceDomains;
+    }
+    return result;
+}
+/**
+ * Build Claude-specific metadata.
+ * Claude widgets are network-blocked, so we don't include URI references.
+ */
+function buildClaudeMeta(meta, uiConfig) {
+    // Claude uses inline HTML only (network-blocked)
+    // Don't include resource URI since Claude can't fetch it
+    if (uiConfig.widgetDescription) {
+        meta['claude/widgetDescription'] = uiConfig.widgetDescription;
+    }
+    return meta;
+}
+/**
+ * Build Gemini-specific metadata.
+ */
+function buildGeminiMeta(meta, uiConfig) {
+    // Gemini support is limited - include inline HTML
+    // Future: Add Gemini-specific fields when they're defined
+    if (uiConfig.widgetDescription) {
+        meta['gemini/widgetDescription'] = uiConfig.widgetDescription;
+    }
+    return meta;
+}
+/**
+ * Build IDE-specific metadata (Cursor, Continue, Cody).
+ * For inline mode, HTML is embedded directly in _meta['ui/html'].
+ */
+function buildIDEMeta(meta, uiConfig) {
+    if (uiConfig.widgetDescription) {
+        meta['ide/widgetDescription'] = uiConfig.widgetDescription;
+    }
+    return meta;
+}
+/**
+ * Build generic MCP client metadata.
+ * For inline mode, HTML is embedded directly in _meta['ui/html'].
+ */
+function buildGenericMeta(meta, uiConfig) {
+    if (uiConfig.widgetAccessible) {
+        meta['openai/widgetAccessible'] = true;
+    }
+    if (uiConfig.csp) {
+        meta['openai/widgetCSP'] = buildOpenAICSP(uiConfig.csp);
+    }
+    return meta;
+}
+/**
+ * Build MCP Apps (ext-apps) metadata per specification.
+ * For inline mode, HTML is embedded directly in _meta['ui/html'].
+ *
+ * Per MCP Apps spec: https://github.com/modelcontextprotocol/ext-apps
+ * - ui/csp: Content security policy for sandboxed iframe
+ * - ui/displayMode: How the UI should be displayed
+ * - ui/prefersBorder: Whether to show border around UI
+ * - ui/domain: Optional dedicated sandbox domain
+ */
+function buildExtAppsMeta(meta, uiConfig) {
+    // MCP Apps uses text/html+mcp MIME type
+    meta['ui/mimeType'] = 'text/html+mcp';
+    // CSP configuration (uses camelCase per MCP Apps spec)
+    if (uiConfig.csp) {
+        const csp = {};
+        if (uiConfig.csp.connectDomains?.length) {
+            csp.connectDomains = uiConfig.csp.connectDomains;
+        }
+        if (uiConfig.csp.resourceDomains?.length) {
+            csp.resourceDomains = uiConfig.csp.resourceDomains;
+        }
+        if (Object.keys(csp).length > 0) {
+            meta['ui/csp'] = csp;
+        }
+    }
+    // Display mode preference
+    if (uiConfig.displayMode) {
+        // Map generic display modes to MCP Apps specific values
+        const displayModeMap = {
+            inline: 'inline',
+            fullscreen: 'fullscreen',
+            pip: 'pip',
+            // Map OpenAI-style values
+            widget: 'inline',
+            panel: 'fullscreen',
+        };
+        const mappedMode = displayModeMap[uiConfig.displayMode];
+        if (mappedMode) {
+            meta['ui/displayMode'] = mappedMode;
+        }
+    }
+    // Border preference (default: true for visual clarity in sandbox)
+    if (uiConfig.prefersBorder !== undefined) {
+        meta['ui/prefersBorder'] = uiConfig.prefersBorder;
+    }
+    // Dedicated sandbox domain (optional)
+    if (uiConfig.sandboxDomain) {
+        meta['ui/domain'] = uiConfig.sandboxDomain;
+    }
+    return meta;
+}
+/**
+ * Build tool discovery metadata (for tools/list response).
+ */
+function buildToolDiscoveryMeta(options) {
+    const { uiConfig, platformType, staticWidgetUri } = options;
+    const meta = {};
+    switch (platformType) {
+        case 'openai':
+            // OpenAI-specific discovery fields
+            meta['openai/outputTemplate'] = staticWidgetUri;
+            meta['openai/resultCanProduceWidget'] = true;
+            if (uiConfig.widgetAccessible) {
+                meta['openai/widgetAccessible'] = true;
+            }
+            if (uiConfig.csp) {
+                meta['openai/widgetCSP'] = buildOpenAICSP(uiConfig.csp);
+            }
+            if (uiConfig.displayMode) {
+                meta['openai/displayMode'] = uiConfig.displayMode;
+            }
+            if (uiConfig.widgetDescription) {
+                meta['openai/widgetDescription'] = uiConfig.widgetDescription;
+            }
+            break;
+        case 'generic-mcp':
+            // Generic MCP uses OpenAI-like format
+            meta['openai/outputTemplate'] = staticWidgetUri;
+            meta['openai/resultCanProduceWidget'] = true;
+            if (uiConfig.widgetAccessible) {
+                meta['openai/widgetAccessible'] = true;
+            }
+            if (uiConfig.csp) {
+                meta['openai/widgetCSP'] = buildOpenAICSP(uiConfig.csp);
+            }
+            break;
+        case 'ext-apps':
+            // MCP Apps discovery metadata per specification
+            meta['ui/resourceUri'] = staticWidgetUri;
+            meta['ui/mimeType'] = 'text/html+mcp';
+            if (uiConfig.csp) {
+                const csp = {};
+                if (uiConfig.csp.connectDomains?.length) {
+                    csp.connectDomains = uiConfig.csp.connectDomains;
+                }
+                if (uiConfig.csp.resourceDomains?.length) {
+                    csp.resourceDomains = uiConfig.csp.resourceDomains;
+                }
+                if (Object.keys(csp).length > 0) {
+                    meta['ui/csp'] = csp;
+                }
+            }
+            if (uiConfig.displayMode) {
+                const displayModeMap = {
+                    inline: 'inline',
+                    fullscreen: 'fullscreen',
+                    pip: 'pip',
+                };
+                const mappedMode = displayModeMap[uiConfig.displayMode];
+                if (mappedMode) {
+                    meta['ui/displayMode'] = mappedMode;
+                }
+            }
+            if (uiConfig.prefersBorder !== undefined) {
+                meta['ui/prefersBorder'] = uiConfig.prefersBorder;
+            }
+            if (uiConfig.sandboxDomain) {
+                meta['ui/domain'] = uiConfig.sandboxDomain;
+            }
+            break;
+        // Claude, Gemini, IDEs don't need discovery metadata
+        // They use inline HTML at call time
+        default:
+            break;
+    }
+    return meta;
+}
+//# sourceMappingURL=platform-meta.js.map