@frontmcp/ui 0.5.1 → 0.6.1

package/src/registry/tool-ui.registry.js

@@ -1,438 +0,0 @@
-"use strict";
-/**
- * Tool UI Registry
- *
- * Manages UI template rendering for tool responses.
- * Provides platform-specific metadata generation for MCP clients.
- *
- * Three serving modes:
- * - **inline**: HTML is rendered per-request and embedded in _meta['ui/html']
- * - **static**: Static widget is pre-compiled at startup, client fetches via resources/read
- * - **hybrid**: Shell (React + renderer) cached at startup, component + data in response
- *
- * @packageDocumentation
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ToolUIRegistry = void 0;
-const crypto_1 = require("crypto");
-const render_template_1 = require("./render-template");
-const adapters_1 = require("../adapters");
-const wrapper_1 = require("../runtime/wrapper");
-const build_1 = require("../build");
-class ToolUIRegistry {
-    /**
-     * Cache for static widgets (keyed by tool name).
-     * Static widgets are pre-compiled at server startup for tools with servingMode: 'static'.
-     * These widgets read data from the FrontMCP Bridge at runtime (window.openai.toolOutput).
-     */
-    staticWidgetCache = new Map();
-    /**
-     * Cache for widget manifests (keyed by tool name).
-     * Manifests describe the widget's renderer type, CSP, and other metadata.
-     */
-    manifestCache = new Map();
-    /**
-     * Cache for build results (keyed by tool name).
-     * Includes HTML, manifest, and hash for cache validation.
-     */
-    buildResultCache = new Map();
-    /**
-     * Compile a static widget template for a tool at server startup.
-     *
-     * For tools with `servingMode: 'static'`, the widget HTML is pre-compiled
-     * WITHOUT embedded data. The widget reads data from the FrontMCP Bridge at runtime
-     * (via window.openai.toolOutput or window.__frontmcp.toolOutput).
-     *
-     * This is called during tool registration, not during tool calls.
-     *
-     * @param options - Static widget compilation options
-     */
-    async compileStaticWidgetAsync(options) {
-        const { toolName, template, uiConfig } = options;
-        // Try to use the new manifest builder first
-        try {
-            // Detect uiType if not provided (using type assertion for extended config)
-            const extendedConfig = uiConfig;
-            const detectedType = (0, build_1.detectUIType)(template);
-            // Convert UITemplateConfig to WidgetConfig format for the manifest builder
-            const widgetConfig = {
-                template: template,
-                uiType: (extendedConfig.uiType ?? detectedType),
-                displayMode: (uiConfig.displayMode ?? 'inline'),
-                bundlingMode: (extendedConfig.bundlingMode ?? 'static'),
-                resourceMode: (extendedConfig.resourceMode ?? 'cdn'),
-                widgetAccessible: uiConfig.widgetAccessible,
-                widgetDescription: uiConfig.widgetDescription,
-                csp: uiConfig.csp
-                    ? {
-                        scriptSrc: uiConfig.csp.resourceDomains ?? [],
-                        styleSrc: uiConfig.csp.resourceDomains ?? [],
-                        connectSrc: uiConfig.csp.connectDomains ?? [],
-                        imgSrc: uiConfig.csp.resourceDomains ?? [],
-                    }
-                    : undefined,
-                mdxComponents: uiConfig.mdxComponents,
-                runtimeOptions: extendedConfig.runtimeOptions,
-            };
-            const result = await (0, build_1.buildToolWidgetManifest)({
-                toolName,
-                uiConfig: widgetConfig,
-                schema: {},
-            });
-            // For React/MDX components, we need to use wrapStaticWidgetUniversal
-            // to include the React runtime and rendering script
-            if (result.componentCode && (result.rendererType === 'react' || result.rendererType === 'mdx')) {
-                // Re-wrap with wrapStaticWidgetUniversal to include React runtime + rendering
-                const widgetHtml = (0, wrapper_1.wrapStaticWidgetUniversal)({
-                    toolName,
-                    ssrContent: result.content,
-                    uiConfig,
-                    rendererType: result.rendererType,
-                    componentCode: result.componentCode,
-                });
-                this.staticWidgetCache.set(toolName, widgetHtml);
-            }
-            else {
-                // Use the pre-built HTML for non-React templates
-                this.staticWidgetCache.set(toolName, result.html);
-            }
-            this.manifestCache.set(toolName, result.manifest);
-            this.buildResultCache.set(toolName, result);
-            return;
-        }
-        catch (error) {
-            // Fall back to legacy compilation
-            console.warn(`[ToolUIRegistry] Manifest build failed for ${toolName}, using legacy method:`, error);
-        }
-        // Legacy fallback: Render the template SSR'd WITHOUT data
-        // The widget will read data from Bridge at runtime
-        const ssrContent = await (0, render_template_1.renderToolTemplateAsync)({
-            template,
-            input: {}, // Empty - data comes from Bridge at runtime
-            output: undefined,
-            structuredContent: undefined,
-            mdxComponents: uiConfig.mdxComponents,
-        });
-        // Wrap in a complete HTML document with FrontMCP Bridge
-        // The Bridge will read data from window.openai.toolOutput at runtime
-        const widgetHtml = (0, wrapper_1.wrapStaticWidgetUniversal)({
-            toolName,
-            ssrContent,
-            uiConfig,
-        });
-        // Cache the static widget HTML
-        this.staticWidgetCache.set(toolName, widgetHtml);
-    }
-    /**
-     * Compile a lean widget shell for inline mode tools at server startup.
-     *
-     * For tools with `servingMode: 'inline'`, we create a minimal HTML shell that:
-     * - Contains only HTML structure, theme CSS, and fonts
-     * - NO React runtime, NO component code, NO bridge
-     * - OpenAI caches this at discovery time
-     * - The actual React widget comes in each tool response with embedded data
-     *
-     * @param options - Options for lean widget compilation
-     */
-    compileLeanWidgetAsync(options) {
-        const { toolName, uiConfig } = options;
-        // Create a lean HTML shell with just theme and structure
-        const leanHtml = (0, wrapper_1.wrapLeanWidgetShell)({
-            toolName,
-            uiConfig: {
-                widgetAccessible: uiConfig.widgetAccessible,
-            },
-        });
-        // Cache the lean widget HTML
-        this.staticWidgetCache.set(toolName, leanHtml);
-    }
-    /**
-     * Compile a hybrid widget shell at server startup.
-     *
-     * For tools with `servingMode: 'hybrid'`, we create a shell that:
-     * - Contains React 19 runtime from esm.sh CDN
-     * - Contains FrontMCP Bridge (universal)
-     * - Contains all FrontMCP hooks (useMcpBridgeContext, useToolOutput, etc.)
-     * - Contains all FrontMCP UI components (Card, Badge, Button)
-     * - Contains dynamic renderer script that imports components via blob URL
-     * - NO component code (comes at tool call time via `_meta['ui/component']`)
-     *
-     * The shell listens for `ui/component` in tool response metadata and dynamically
-     * imports the transpiled component code, then renders it with tool output data.
-     *
-     * @param options - Options for hybrid widget compilation
-     */
-    compileHybridWidgetAsync(options) {
-        const { toolName, uiConfig } = options;
-        // Create a hybrid shell with React runtime and dynamic renderer
-        const hybridHtml = (0, wrapper_1.wrapHybridWidgetShell)({
-            toolName,
-            uiConfig: {
-                widgetAccessible: uiConfig.widgetAccessible,
-                csp: uiConfig.csp,
-            },
-        });
-        // Cache the hybrid widget HTML
-        this.staticWidgetCache.set(toolName, hybridHtml);
-    }
-    /**
-     * Build a component payload for hybrid mode tool responses.
-     *
-     * For tools with `servingMode: 'hybrid'`, this method is called at tool call time
-     * to build the transpiled component code that gets delivered in `_meta['ui/component']`.
-     *
-     * The component code is in ES module format so it can be dynamically imported
-     * via blob URL in the hybrid shell's renderer.
-     *
-     * @param options - Options for building the component payload
-     * @returns The hybrid component payload, or undefined if template is not a function
-     */
-    buildHybridComponentPayload(options) {
-        const { toolName, template } = options;
-        // Detect the UI type
-        const detectedType = this.detectUIType(template);
-        // Only support function templates (React components) for hybrid mode
-        if (typeof template !== 'function') {
-            // For HTML strings, return undefined - hybrid mode is designed for React components
-            // HTML templates should use inline mode instead
-            return undefined;
-        }
-        // Get the component function as a string
-        const componentSource = template.toString();
-        // Sanitize tool name for JavaScript variable name
-        const safeName = toolName.replace(/[^a-zA-Z0-9_]/g, '_');
-        // Build ES module compatible component code
-        // The component is exported as default and also registered globally
-        // for the hybrid shell's dynamic renderer
-        const code = `
-// FrontMCP Hybrid Widget Component: ${toolName}
-// Type: ${detectedType}
-
-// The component function
-const ${safeName} = ${componentSource};
-
-// Register component globally for dynamic rendering
-window.__frontmcp_component = ${safeName};
-
-// Also register in __frontmcp_components for multiple components
-window.__frontmcp_components = window.__frontmcp_components || {};
-window.__frontmcp_components['${toolName}'] = ${safeName};
-
-// Export as default for ES module import
-export default ${safeName};
-`.trim();
-        // Generate hash for cache validation
-        const hash = (0, crypto_1.createHash)('sha256').update(code).digest('hex').substring(0, 16);
-        // Determine renderer type
-        const type = detectedType === 'react' || detectedType === 'mdx' ? detectedType : 'react'; // Default to react for function templates
-        return {
-            code,
-            type,
-            toolName,
-            hash,
-        };
-    }
-    /**
-     * Get the pre-compiled static widget HTML for a tool.
-     *
-     * @param toolName - The tool name to look up
-     * @returns Pre-compiled widget HTML, or undefined if not cached
-     */
-    getStaticWidget(toolName) {
-        return this.staticWidgetCache.get(toolName);
-    }
-    /**
-     * Check if a tool has a pre-compiled static widget.
-     *
-     * @param toolName - The tool name to check
-     * @returns true if the tool has a cached static widget
-     */
-    hasStaticWidget(toolName) {
-        return this.staticWidgetCache.has(toolName);
-    }
-    /**
-     * Get the widget manifest for a tool.
-     *
-     * @param toolName - The tool name to look up
-     * @returns Widget manifest, or undefined if not cached
-     */
-    getManifest(toolName) {
-        return this.manifestCache.get(toolName);
-    }
-    /**
-     * Check if a tool has a cached manifest.
-     *
-     * @param toolName - The tool name to check
-     * @returns true if the tool has a cached manifest
-     */
-    hasManifest(toolName) {
-        return this.manifestCache.has(toolName);
-    }
-    /**
-     * Get the full build result for a tool.
-     *
-     * @param toolName - The tool name to look up
-     * @returns Build result, or undefined if not cached
-     */
-    getBuildResult(toolName) {
-        return this.buildResultCache.get(toolName);
-    }
-    /**
-     * Detect the UI type for a template.
-     *
-     * @param template - The template to analyze
-     * @returns Detected UI type
-     */
-    detectUIType(template) {
-        // Use the imported detectUIType function from build module
-        return (0, build_1.detectUIType)(template);
-    }
-    /**
-     * Render a tool's UI template for inline mode.
-     *
-     * This version supports all template types including React components.
-     * The rendered HTML is embedded directly in _meta['ui/html'] for the client.
-     *
-     * For React/MDX components, the output is wrapped using wrapStaticWidgetUniversal
-     * which includes the React 19 CDN, client-side rendering script, and all the
-     * FrontMCP hooks/components. This provides the same rendering capability as
-     * static mode, but with data embedded in each response.
-     *
-     * @param options - Rendering options
-     * @returns Promise resolving to render result with HTML and metadata
-     */
-    async renderAndRegisterAsync(options) {
-        const { toolName, input, output, structuredContent, uiConfig, platformType, token, directUrl } = options;
-        // Detect if this is a React component
-        const detectedType = this.detectUIType(uiConfig.template);
-        const isReactBased = detectedType === 'react' || detectedType === 'mdx';
-        let html;
-        if (isReactBased && typeof uiConfig.template === 'function') {
-            // For React/MDX components: Use wrapStaticWidgetUniversal with component code
-            // This includes the React 19 CDN, client-side renderer, and all FrontMCP hooks
-            // Same approach as static mode, but with data embedded
-            // 1. Build the component code that will be embedded in the HTML
-            const componentCode = this.buildComponentCode(uiConfig.template, toolName);
-            // 2. Render SSR content (optional, for initial display)
-            const ssrContent = await (0, render_template_1.renderToolTemplateAsync)({
-                template: uiConfig.template,
-                input,
-                output,
-                structuredContent,
-                mdxComponents: uiConfig.mdxComponents,
-            });
-            // 3. Wrap with React runtime + component code
-            // This creates a complete HTML document with:
-            // - React 19 CDN imports
-            // - FrontMCP hooks (useMcpBridgeContext, useToolOutput, etc.)
-            // - FrontMCP UI components (Card, Badge, Button)
-            // - The component code registered as window.__frontmcp_component
-            // - Client-side rendering script that hydrates with the embedded data
-            html = (0, wrapper_1.wrapStaticWidgetUniversal)({
-                toolName,
-                ssrContent,
-                uiConfig,
-                rendererType: detectedType,
-                componentCode,
-                // For inline mode, we embed the data in the HTML so the component
-                // can render immediately without waiting for window.openai.toolOutput
-                embeddedData: {
-                    input: input,
-                    output,
-                    structuredContent,
-                },
-                // Self-contained mode: no bridge, React manages state internally
-                // This prevents OpenAI's wrapper from interfering with React re-renders
-                selfContained: true,
-            });
-        }
-        else {
-            // For HTML templates: Use the original wrapToolUIUniversal approach
-            // which embeds the pre-rendered content with the Bridge runtime
-            // 1. Render the template
-            const renderedContent = await (0, render_template_1.renderToolTemplateAsync)({
-                template: uiConfig.template,
-                input,
-                output,
-                structuredContent,
-                mdxComponents: uiConfig.mdxComponents,
-            });
-            // 2. Wrap in a complete HTML document with FrontMCP Bridge runtime.
-            // For OpenAI platform, we skip the CSP meta tag because OpenAI handles CSP
-            // through `_meta['openai/widgetCSP']` in the MCP response, not HTML meta tags.
-            const isOpenAIPlatform = platformType === 'openai';
-            html = (0, wrapper_1.wrapToolUIUniversal)({
-                content: renderedContent,
-                toolName,
-                input: input,
-                output,
-                structuredContent,
-                csp: uiConfig.csp,
-                widgetAccessible: uiConfig.widgetAccessible,
-                includeBridge: true,
-                skipCspMeta: isOpenAIPlatform,
-            });
-        }
-        // Get manifest info if available (from static widget compilation)
-        const manifest = this.manifestCache.get(toolName);
-        const buildResult = this.buildResultCache.get(toolName);
-        // Determine renderer type
-        const rendererType = manifest?.uiType ?? detectedType ?? 'auto';
-        // Build platform-specific metadata
-        // For inline mode, HTML is embedded in _meta['ui/html']
-        const meta = (0, adapters_1.buildUIMeta)({
-            uiConfig,
-            platformType,
-            html,
-            token,
-            directUrl,
-            rendererType,
-            contentHash: buildResult?.hash,
-            manifestUri: manifest?.uri,
-        });
-        return { html, meta };
-    }
-    /**
-     * Build component code string for embedding in widget HTML.
-     *
-     * @param template - The React component
-     * @param toolName - Tool name for naming the component
-     * @returns JavaScript code string that defines and registers the component
-     */
-    buildComponentCode(template, toolName) {
-        if (typeof template !== 'function') {
-            return undefined;
-        }
-        // Get the component function as a string
-        const componentSource = template.toString();
-        // Sanitize tool name for JavaScript variable name
-        const safeName = toolName.replace(/[^a-zA-Z0-9_]/g, '_');
-        // Build the component code that will be embedded in the HTML
-        // The component is registered on window.__frontmcp_component for the render script
-        return `
-// FrontMCP Widget Component: ${toolName}
-(function() {
-  // The component function
-  var ${safeName} = ${componentSource};
-
-  // Register component globally for client-side rendering
-  window.__frontmcp_component = ${safeName};
-
-  // Also register in __frontmcp_components for multiple components
-  window.__frontmcp_components = window.__frontmcp_components || {};
-  window.__frontmcp_components['${toolName}'] = ${safeName};
-})();
-`.trim();
-    }
-    /**
-     * Check if a template requires async rendering (e.g., React components).
-     *
-     * @param template - The template to check
-     * @returns true if the template requires async rendering
-     */
-    requiresAsyncRendering(template) {
-        return (0, render_template_1.isReactComponent)(template);
-    }
-}
-exports.ToolUIRegistry = ToolUIRegistry;
-//# sourceMappingURL=tool-ui.registry.js.map

package/src/registry/tool-ui.registry.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tool-ui.registry.js","sourceRoot":"","sources":["../../../src/registry/tool-ui.registry.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Tool UI Registry\n *\n * Manages UI template rendering for tool responses.\n * Provides platform-specific metadata generation for MCP clients.\n *\n * Three serving modes:\n * - **inline**: HTML is rendered per-request and embedded in _meta['ui/html']\n * - **static**: Static widget is pre-compiled at startup, client fetches via resources/read\n * - **hybrid**: Shell (React + renderer) cached at startup, component + data in response\n *\n * @packageDocumentation\n */\n\nimport { createHash } from 'crypto';\nimport type { UITemplateConfig, WidgetManifest, BuildManifestResult } from '../types';\nimport type { AIPlatformType, UIMetadata } from '../adapters';\nimport { renderToolTemplateAsync, isReactComponent } from './render-template';\nimport { buildUIMeta } from '../adapters';\nimport {\n  wrapToolUIUniversal,\n  wrapStaticWidgetUniversal,\n  wrapLeanWidgetShell,\n  wrapHybridWidgetShell,\n} from '../runtime/wrapper';\nimport { buildToolWidgetManifest, detectUIType } from '../build';\n\n/**\n * Options for renderAndRegisterAsync (inline mode).\n */\nexport interface RenderOptions {\n  /** Tool name */\n  toolName: string;\n  /** Unique request identifier */\n  requestId: string;\n  /** Tool input arguments */\n  input: Record<string, unknown>;\n  /** Raw tool output */\n  output: unknown;\n  /** Structured content (parsed from output) */\n  structuredContent?: unknown;\n  /** Tool UI configuration */\n  uiConfig: UITemplateConfig;\n  /** Detected platform type */\n  platformType: AIPlatformType;\n  /** Widget access token (optional) */\n  token?: string;\n  /** Direct URL for widget serving (optional) */\n  directUrl?: string;\n}\n\n/**\n * Result of rendering UI for inline mode.\n */\nexport interface UIRenderResult {\n  /** Rendered HTML content */\n  html: string;\n  /** Platform-specific metadata for _meta field */\n  meta: UIMetadata;\n}\n\n/**\n * ToolUIRegistry manages UI template rendering for tool responses.\n *\n * It provides:\n * - Static widget compilation for static mode (pre-compiled at startup)\n * - Per-request HTML rendering for inline mode (embedded in _meta)\n * - Platform-specific _meta generation\n * - Widget manifest management\n *\n * @example\n * ```typescript\n * const registry = new ToolUIRegistry();\n *\n * // For inline mode: render HTML per-request\n * const result = await registry.renderAndRegisterAsync({\n *   toolName: 'get_weather',\n *   requestId: 'abc123',\n *   input: { location: 'London' },\n *   output: { temp: 72, conditions: 'Sunny' },\n *   uiConfig: tool.metadata.ui,\n *   platformType: 'openai',\n * });\n *\n * // result.meta can be spread into tool result _meta\n * return { content: [...], _meta: { ...result.meta } };\n * ```\n */\n\n/**\n * Options for compiling a static widget.\n */\nexport interface CompileStaticWidgetOptions {\n  /** Tool name (used for cache key and URI) */\n  toolName: string;\n  /** The template to compile (React component, HTML string, or builder function) */\n  template: UITemplateConfig['template'];\n  /** Tool UI configuration */\n  uiConfig: UITemplateConfig;\n}\n\n/**\n * Payload for hybrid mode component delivery.\n * Sent in `_meta['ui/component']` at tool call time.\n */\nexport interface HybridComponentPayload {\n  /** Transpiled component JavaScript code (ES module format) */\n  code: string;\n  /** Renderer type for the component */\n  type: 'react' | 'mdx' | 'html';\n  /** Tool name for identification */\n  toolName: string;\n  /** Content hash for cache validation */\n  hash: string;\n}\n\n/**\n * Options for building a hybrid component payload.\n */\nexport interface BuildHybridComponentPayloadOptions {\n  /** Tool name */\n  toolName: string;\n  /** The template to transpile */\n  template: UITemplateConfig['template'];\n  /** Tool UI configuration */\n  uiConfig: UITemplateConfig;\n}\n\nexport class ToolUIRegistry {\n  /**\n   * Cache for static widgets (keyed by tool name).\n   * Static widgets are pre-compiled at server startup for tools with servingMode: 'static'.\n   * These widgets read data from the FrontMCP Bridge at runtime (window.openai.toolOutput).\n   */\n  private readonly staticWidgetCache = new Map<string, string>();\n\n  /**\n   * Cache for widget manifests (keyed by tool name).\n   * Manifests describe the widget's renderer type, CSP, and other metadata.\n   */\n  private readonly manifestCache = new Map<string, WidgetManifest>();\n\n  /**\n   * Cache for build results (keyed by tool name).\n   * Includes HTML, manifest, and hash for cache validation.\n   */\n  private readonly buildResultCache = new Map<string, BuildManifestResult>();\n\n  /**\n   * Compile a static widget template for a tool at server startup.\n   *\n   * For tools with `servingMode: 'static'`, the widget HTML is pre-compiled\n   * WITHOUT embedded data. The widget reads data from the FrontMCP Bridge at runtime\n   * (via window.openai.toolOutput or window.__frontmcp.toolOutput).\n   *\n   * This is called during tool registration, not during tool calls.\n   *\n   * @param options - Static widget compilation options\n   */\n  async compileStaticWidgetAsync(options: CompileStaticWidgetOptions): Promise<void> {\n    const { toolName, template, uiConfig } = options;\n\n    // Try to use the new manifest builder first\n    try {\n      // Detect uiType if not provided (using type assertion for extended config)\n      const extendedConfig = uiConfig as UITemplateConfig & {\n        uiType?: string;\n        bundlingMode?: string;\n        resourceMode?: 'cdn' | 'inline';\n        runtimeOptions?: { hydrate?: boolean };\n      };\n      const detectedType = detectUIType(template as Parameters<typeof detectUIType>[0]);\n\n      // Convert UITemplateConfig to WidgetConfig format for the manifest builder\n      const widgetConfig = {\n        template: template as Parameters<typeof buildToolWidgetManifest>[0]['uiConfig']['template'],\n        uiType: (extendedConfig.uiType ?? detectedType) as 'html' | 'react' | 'mdx' | 'markdown' | 'auto',\n        displayMode: (uiConfig.displayMode ?? 'inline') as 'inline' | 'fullscreen' | 'pip',\n        bundlingMode: (extendedConfig.bundlingMode ?? 'static') as 'static' | 'dynamic',\n        resourceMode: (extendedConfig.resourceMode ?? 'cdn') as 'cdn' | 'inline',\n        widgetAccessible: uiConfig.widgetAccessible,\n        widgetDescription: uiConfig.widgetDescription,\n        csp: uiConfig.csp\n          ? {\n              scriptSrc: uiConfig.csp.resourceDomains ?? [],\n              styleSrc: uiConfig.csp.resourceDomains ?? [],\n              connectSrc: uiConfig.csp.connectDomains ?? [],\n              imgSrc: uiConfig.csp.resourceDomains ?? [],\n            }\n          : undefined,\n        mdxComponents: uiConfig.mdxComponents,\n        runtimeOptions: extendedConfig.runtimeOptions,\n      };\n\n      const result = await buildToolWidgetManifest({\n        toolName,\n        uiConfig: widgetConfig,\n        schema: {},\n      });\n\n      // For React/MDX components, we need to use wrapStaticWidgetUniversal\n      // to include the React runtime and rendering script\n      if (result.componentCode && (result.rendererType === 'react' || result.rendererType === 'mdx')) {\n        // Re-wrap with wrapStaticWidgetUniversal to include React runtime + rendering\n        const widgetHtml = wrapStaticWidgetUniversal({\n          toolName,\n          ssrContent: result.content,\n          uiConfig,\n          rendererType: result.rendererType,\n          componentCode: result.componentCode,\n        });\n        this.staticWidgetCache.set(toolName, widgetHtml);\n      } else {\n        // Use the pre-built HTML for non-React templates\n        this.staticWidgetCache.set(toolName, result.html);\n      }\n\n      this.manifestCache.set(toolName, result.manifest);\n      this.buildResultCache.set(toolName, result);\n      return;\n    } catch (error) {\n      // Fall back to legacy compilation\n      console.warn(`[ToolUIRegistry] Manifest build failed for ${toolName}, using legacy method:`, error);\n    }\n\n    // Legacy fallback: Render the template SSR'd WITHOUT data\n    // The widget will read data from Bridge at runtime\n    const ssrContent = await renderToolTemplateAsync({\n      template,\n      input: {}, // Empty - data comes from Bridge at runtime\n      output: undefined,\n      structuredContent: undefined,\n      mdxComponents: uiConfig.mdxComponents,\n    });\n\n    // Wrap in a complete HTML document with FrontMCP Bridge\n    // The Bridge will read data from window.openai.toolOutput at runtime\n    const widgetHtml = wrapStaticWidgetUniversal({\n      toolName,\n      ssrContent,\n      uiConfig,\n    });\n\n    // Cache the static widget HTML\n    this.staticWidgetCache.set(toolName, widgetHtml);\n  }\n\n  /**\n   * Compile a lean widget shell for inline mode tools at server startup.\n   *\n   * For tools with `servingMode: 'inline'`, we create a minimal HTML shell that:\n   * - Contains only HTML structure, theme CSS, and fonts\n   * - NO React runtime, NO component code, NO bridge\n   * - OpenAI caches this at discovery time\n   * - The actual React widget comes in each tool response with embedded data\n   *\n   * @param options - Options for lean widget compilation\n   */\n  compileLeanWidgetAsync(options: { toolName: string; uiConfig: UITemplateConfig }): void {\n    const { toolName, uiConfig } = options;\n\n    // Create a lean HTML shell with just theme and structure\n    const leanHtml = wrapLeanWidgetShell({\n      toolName,\n      uiConfig: {\n        widgetAccessible: uiConfig.widgetAccessible,\n      },\n    });\n\n    // Cache the lean widget HTML\n    this.staticWidgetCache.set(toolName, leanHtml);\n  }\n\n  /**\n   * Compile a hybrid widget shell at server startup.\n   *\n   * For tools with `servingMode: 'hybrid'`, we create a shell that:\n   * - Contains React 19 runtime from esm.sh CDN\n   * - Contains FrontMCP Bridge (universal)\n   * - Contains all FrontMCP hooks (useMcpBridgeContext, useToolOutput, etc.)\n   * - Contains all FrontMCP UI components (Card, Badge, Button)\n   * - Contains dynamic renderer script that imports components via blob URL\n   * - NO component code (comes at tool call time via `_meta['ui/component']`)\n   *\n   * The shell listens for `ui/component` in tool response metadata and dynamically\n   * imports the transpiled component code, then renders it with tool output data.\n   *\n   * @param options - Options for hybrid widget compilation\n   */\n  compileHybridWidgetAsync(options: { toolName: string; uiConfig: UITemplateConfig }): void {\n    const { toolName, uiConfig } = options;\n\n    // Create a hybrid shell with React runtime and dynamic renderer\n    const hybridHtml = wrapHybridWidgetShell({\n      toolName,\n      uiConfig: {\n        widgetAccessible: uiConfig.widgetAccessible,\n        csp: uiConfig.csp,\n      },\n    });\n\n    // Cache the hybrid widget HTML\n    this.staticWidgetCache.set(toolName, hybridHtml);\n  }\n\n  /**\n   * Build a component payload for hybrid mode tool responses.\n   *\n   * For tools with `servingMode: 'hybrid'`, this method is called at tool call time\n   * to build the transpiled component code that gets delivered in `_meta['ui/component']`.\n   *\n   * The component code is in ES module format so it can be dynamically imported\n   * via blob URL in the hybrid shell's renderer.\n   *\n   * @param options - Options for building the component payload\n   * @returns The hybrid component payload, or undefined if template is not a function\n   */\n  buildHybridComponentPayload(options: BuildHybridComponentPayloadOptions): HybridComponentPayload | undefined {\n    const { toolName, template } = options;\n\n    // Detect the UI type\n    const detectedType = this.detectUIType(template);\n\n    // Only support function templates (React components) for hybrid mode\n    if (typeof template !== 'function') {\n      // For HTML strings, return undefined - hybrid mode is designed for React components\n      // HTML templates should use inline mode instead\n      return undefined;\n    }\n\n    // Get the component function as a string\n    const componentSource = template.toString();\n\n    // Sanitize tool name for JavaScript variable name\n    const safeName = toolName.replace(/[^a-zA-Z0-9_]/g, '_');\n\n    // Build ES module compatible component code\n    // The component is exported as default and also registered globally\n    // for the hybrid shell's dynamic renderer\n    const code = `\n// FrontMCP Hybrid Widget Component: ${toolName}\n// Type: ${detectedType}\n\n// The component function\nconst ${safeName} = ${componentSource};\n\n// Register component globally for dynamic rendering\nwindow.__frontmcp_component = ${safeName};\n\n// Also register in __frontmcp_components for multiple components\nwindow.__frontmcp_components = window.__frontmcp_components || {};\nwindow.__frontmcp_components['${toolName}'] = ${safeName};\n\n// Export as default for ES module import\nexport default ${safeName};\n`.trim();\n\n    // Generate hash for cache validation\n    const hash = createHash('sha256').update(code).digest('hex').substring(0, 16);\n\n    // Determine renderer type\n    const type = detectedType === 'react' || detectedType === 'mdx' ? (detectedType as 'react' | 'mdx') : 'react'; // Default to react for function templates\n\n    return {\n      code,\n      type,\n      toolName,\n      hash,\n    };\n  }\n\n  /**\n   * Get the pre-compiled static widget HTML for a tool.\n   *\n   * @param toolName - The tool name to look up\n   * @returns Pre-compiled widget HTML, or undefined if not cached\n   */\n  getStaticWidget(toolName: string): string | undefined {\n    return this.staticWidgetCache.get(toolName);\n  }\n\n  /**\n   * Check if a tool has a pre-compiled static widget.\n   *\n   * @param toolName - The tool name to check\n   * @returns true if the tool has a cached static widget\n   */\n  hasStaticWidget(toolName: string): boolean {\n    return this.staticWidgetCache.has(toolName);\n  }\n\n  /**\n   * Get the widget manifest for a tool.\n   *\n   * @param toolName - The tool name to look up\n   * @returns Widget manifest, or undefined if not cached\n   */\n  getManifest(toolName: string): WidgetManifest | undefined {\n    return this.manifestCache.get(toolName);\n  }\n\n  /**\n   * Check if a tool has a cached manifest.\n   *\n   * @param toolName - The tool name to check\n   * @returns true if the tool has a cached manifest\n   */\n  hasManifest(toolName: string): boolean {\n    return this.manifestCache.has(toolName);\n  }\n\n  /**\n   * Get the full build result for a tool.\n   *\n   * @param toolName - The tool name to look up\n   * @returns Build result, or undefined if not cached\n   */\n  getBuildResult(toolName: string): BuildManifestResult | undefined {\n    return this.buildResultCache.get(toolName);\n  }\n\n  /**\n   * Detect the UI type for a template.\n   *\n   * @param template - The template to analyze\n   * @returns Detected UI type\n   */\n  detectUIType(template: UITemplateConfig['template']): string {\n    // Use the imported detectUIType function from build module\n    return detectUIType(template as Parameters<typeof detectUIType>[0]);\n  }\n\n  /**\n   * Render a tool's UI template for inline mode.\n   *\n   * This version supports all template types including React components.\n   * The rendered HTML is embedded directly in _meta['ui/html'] for the client.\n   *\n   * For React/MDX components, the output is wrapped using wrapStaticWidgetUniversal\n   * which includes the React 19 CDN, client-side rendering script, and all the\n   * FrontMCP hooks/components. This provides the same rendering capability as\n   * static mode, but with data embedded in each response.\n   *\n   * @param options - Rendering options\n   * @returns Promise resolving to render result with HTML and metadata\n   */\n  async renderAndRegisterAsync(options: RenderOptions): Promise<UIRenderResult> {\n    const { toolName, input, output, structuredContent, uiConfig, platformType, token, directUrl } = options;\n\n    // Detect if this is a React component\n    const detectedType = this.detectUIType(uiConfig.template);\n    const isReactBased = detectedType === 'react' || detectedType === 'mdx';\n\n    let html: string;\n\n    if (isReactBased && typeof uiConfig.template === 'function') {\n      // For React/MDX components: Use wrapStaticWidgetUniversal with component code\n      // This includes the React 19 CDN, client-side renderer, and all FrontMCP hooks\n      // Same approach as static mode, but with data embedded\n\n      // 1. Build the component code that will be embedded in the HTML\n      const componentCode = this.buildComponentCode(uiConfig.template, toolName);\n\n      // 2. Render SSR content (optional, for initial display)\n      const ssrContent = await renderToolTemplateAsync({\n        template: uiConfig.template,\n        input,\n        output,\n        structuredContent,\n        mdxComponents: uiConfig.mdxComponents,\n      });\n\n      // 3. Wrap with React runtime + component code\n      // This creates a complete HTML document with:\n      // - React 19 CDN imports\n      // - FrontMCP hooks (useMcpBridgeContext, useToolOutput, etc.)\n      // - FrontMCP UI components (Card, Badge, Button)\n      // - The component code registered as window.__frontmcp_component\n      // - Client-side rendering script that hydrates with the embedded data\n      html = wrapStaticWidgetUniversal({\n        toolName,\n        ssrContent,\n        uiConfig,\n        rendererType: detectedType,\n        componentCode,\n        // For inline mode, we embed the data in the HTML so the component\n        // can render immediately without waiting for window.openai.toolOutput\n        embeddedData: {\n          input: input as Record<string, unknown>,\n          output,\n          structuredContent,\n        },\n        // Self-contained mode: no bridge, React manages state internally\n        // This prevents OpenAI's wrapper from interfering with React re-renders\n        selfContained: true,\n      });\n    } else {\n      // For HTML templates: Use the original wrapToolUIUniversal approach\n      // which embeds the pre-rendered content with the Bridge runtime\n\n      // 1. Render the template\n      const renderedContent = await renderToolTemplateAsync({\n        template: uiConfig.template,\n        input,\n        output,\n        structuredContent,\n        mdxComponents: uiConfig.mdxComponents,\n      });\n\n      // 2. Wrap in a complete HTML document with FrontMCP Bridge runtime.\n      // For OpenAI platform, we skip the CSP meta tag because OpenAI handles CSP\n      // through `_meta['openai/widgetCSP']` in the MCP response, not HTML meta tags.\n      const isOpenAIPlatform = platformType === 'openai';\n      html = wrapToolUIUniversal({\n        content: renderedContent,\n        toolName,\n        input: input as Record<string, unknown>,\n        output,\n        structuredContent,\n        csp: uiConfig.csp,\n        widgetAccessible: uiConfig.widgetAccessible,\n        includeBridge: true,\n        skipCspMeta: isOpenAIPlatform,\n      });\n    }\n\n    // Get manifest info if available (from static widget compilation)\n    const manifest = this.manifestCache.get(toolName);\n    const buildResult = this.buildResultCache.get(toolName);\n\n    // Determine renderer type\n    const rendererType = manifest?.uiType ?? detectedType ?? 'auto';\n\n    // Build platform-specific metadata\n    // For inline mode, HTML is embedded in _meta['ui/html']\n    const meta = buildUIMeta({\n      uiConfig,\n      platformType,\n      html,\n      token,\n      directUrl,\n      rendererType,\n      contentHash: buildResult?.hash,\n      manifestUri: manifest?.uri,\n    });\n\n    return { html, meta };\n  }\n\n  /**\n   * Build component code string for embedding in widget HTML.\n   *\n   * @param template - The React component\n   * @param toolName - Tool name for naming the component\n   * @returns JavaScript code string that defines and registers the component\n   */\n  private buildComponentCode(template: unknown, toolName: string): string | undefined {\n    if (typeof template !== 'function') {\n      return undefined;\n    }\n\n    // Get the component function as a string\n    const componentSource = template.toString();\n\n    // Sanitize tool name for JavaScript variable name\n    const safeName = toolName.replace(/[^a-zA-Z0-9_]/g, '_');\n\n    // Build the component code that will be embedded in the HTML\n    // The component is registered on window.__frontmcp_component for the render script\n    return `\n// FrontMCP Widget Component: ${toolName}\n(function() {\n  // The component function\n  var ${safeName} = ${componentSource};\n\n  // Register component globally for client-side rendering\n  window.__frontmcp_component = ${safeName};\n\n  // Also register in __frontmcp_components for multiple components\n  window.__frontmcp_components = window.__frontmcp_components || {};\n  window.__frontmcp_components['${toolName}'] = ${safeName};\n})();\n`.trim();\n  }\n\n  /**\n   * Check if a template requires async rendering (e.g., React components).\n   *\n   * @param template - The template to check\n   * @returns true if the template requires async rendering\n   */\n  requiresAsyncRendering(template: UITemplateConfig['template']): boolean {\n    return isReactComponent(template);\n  }\n}\n"]}

package/src/registry/uri-utils.d.ts

@@ -1,55 +0,0 @@
-/**
- * UI Resource URI Utilities
- *
- * Standalone utilities for parsing and building ui:// resource URIs.
- * Used for static widget serving mode where widgets are pre-compiled
- * at startup and fetched via resources/read.
- *
- * @packageDocumentation
- */
-import type { AIPlatformType } from '../adapters';
-/**
- * UI resource URI scheme
- */
-export declare const UI_RESOURCE_SCHEME = "ui://";
-/**
- * Parsed static widget URI
- */
-export interface ParsedWidgetUri {
-    toolName: string;
-    fullUri: string;
-}
-/**
- * Check if a URI is a UI resource URI
- *
- * @param uri - URI to check
- * @returns True if the URI starts with ui://
- */
-export declare function isUIResourceUri(uri: string): boolean;
-/**
- * Parse a static widget URI into its components
- *
- * @param uri - URI to parse (format: ui://widget/{toolName}.html)
- * @returns Parsed components or undefined if invalid
- */
-export declare function parseWidgetUri(uri: string): ParsedWidgetUri | undefined;
-/**
- * Check if URI is a static widget URI (ui://widget/{toolName}.html)
- */
-export declare function isStaticWidgetUri(uri: string): boolean;
-/**
- * Build a static widget URI from tool name
- *
- * @param toolName - Name of the tool
- * @returns Static widget URI (ui://widget/{toolName}.html)
- */
-export declare function buildStaticWidgetUri(toolName: string): string;
-/**
- * Get the MIME type for UI resources based on platform.
- *
- * Per user requirement: OpenAI or default uses 'text/html+skybridge'
- *
- * @param platformType - The detected platform type
- * @returns The appropriate MIME type
- */
-export declare function getUIResourceMimeType(platformType?: AIPlatformType): string;

package/src/registry/uri-utils.js

@@ -1,97 +0,0 @@
-"use strict";
-/**
- * UI Resource URI Utilities
- *
- * Standalone utilities for parsing and building ui:// resource URIs.
- * Used for static widget serving mode where widgets are pre-compiled
- * at startup and fetched via resources/read.
- *
- * @packageDocumentation
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UI_RESOURCE_SCHEME = void 0;
-exports.isUIResourceUri = isUIResourceUri;
-exports.parseWidgetUri = parseWidgetUri;
-exports.isStaticWidgetUri = isStaticWidgetUri;
-exports.buildStaticWidgetUri = buildStaticWidgetUri;
-exports.getUIResourceMimeType = getUIResourceMimeType;
-/**
- * UI resource URI scheme
- */
-exports.UI_RESOURCE_SCHEME = 'ui://';
-/**
- * Pattern for static widget URIs: ui://widget/{toolName}.html
- * This format is used by OpenAI at discovery time (tools/list)
- */
-const UI_WIDGET_PATTERN = /^ui:\/\/widget\/([^/]+)\.html$/;
-/**
- * Check if a URI is a UI resource URI
- *
- * @param uri - URI to check
- * @returns True if the URI starts with ui://
- */
-function isUIResourceUri(uri) {
-    return uri.startsWith(exports.UI_RESOURCE_SCHEME);
-}
-/**
- * Parse a static widget URI into its components
- *
- * @param uri - URI to parse (format: ui://widget/{toolName}.html)
- * @returns Parsed components or undefined if invalid
- */
-function parseWidgetUri(uri) {
-    const match = uri.match(UI_WIDGET_PATTERN);
-    if (!match) {
-        return undefined;
-    }
-    return {
-        toolName: decodeURIComponent(match[1]),
-        fullUri: uri,
-    };
-}
-/**
- * Check if URI is a static widget URI (ui://widget/{toolName}.html)
- */
-function isStaticWidgetUri(uri) {
-    return UI_WIDGET_PATTERN.test(uri);
-}
-/**
- * Build a static widget URI from tool name
- *
- * @param toolName - Name of the tool
- * @returns Static widget URI (ui://widget/{toolName}.html)
- */
-function buildStaticWidgetUri(toolName) {
-    return `ui://widget/${encodeURIComponent(toolName)}.html`;
-}
-/**
- * Get the MIME type for UI resources based on platform.
- *
- * Per user requirement: OpenAI or default uses 'text/html+skybridge'
- *
- * @param platformType - The detected platform type
- * @returns The appropriate MIME type
- */
-function getUIResourceMimeType(platformType) {
-    // Per requirement: "for openai or default text/html+skybridge"
-    // This aligns with OpenAI's skybridge widget protocol
-    switch (platformType) {
-        case 'claude':
-            // Claude uses standard text/html (network-blocked environment)
-            return 'text/html';
-        case 'gemini':
-            // Gemini uses standard text/html
-            return 'text/html';
-        case 'openai':
-        case 'cursor':
-        case 'continue':
-        case 'cody':
-        case 'generic-mcp':
-        case 'ext-apps':
-        case 'unknown':
-        default:
-            // OpenAI and default use skybridge MIME type
-            return 'text/html+skybridge';
-    }
-}
-//# sourceMappingURL=uri-utils.js.map

package/src/registry/uri-utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"uri-utils.js","sourceRoot":"","sources":["../../../src/registry/uri-utils.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;;AA6BH,0CAEC;AAQD,wCAUC;AAKD,8CAEC;AAQD,oDAEC;AAUD,sDAqBC;AA7FD;;GAEG;AACU,QAAA,kBAAkB,GAAG,OAAO,CAAC;AAE1C;;;GAGG;AACH,MAAM,iBAAiB,GAAG,gCAAgC,CAAC;AAU3D;;;;;GAKG;AACH,SAAgB,eAAe,CAAC,GAAW;IACzC,OAAO,GAAG,CAAC,UAAU,CAAC,0BAAkB,CAAC,CAAC;AAC5C,CAAC;AAED;;;;;GAKG;AACH,SAAgB,cAAc,CAAC,GAAW;IACxC,MAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC;IAC3C,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,OAAO;QACL,QAAQ,EAAE,kBAAkB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACtC,OAAO,EAAE,GAAG;KACb,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,SAAgB,iBAAiB,CAAC,GAAW;IAC3C,OAAO,iBAAiB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AACrC,CAAC;AAED;;;;;GAKG;AACH,SAAgB,oBAAoB,CAAC,QAAgB;IACnD,OAAO,eAAe,kBAAkB,CAAC,QAAQ,CAAC,OAAO,CAAC;AAC5D,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,qBAAqB,CAAC,YAA6B;IACjE,+DAA+D;IAC/D,sDAAsD;IACtD,QAAQ,YAAY,EAAE,CAAC;QACrB,KAAK,QAAQ;YACX,+DAA+D;YAC/D,OAAO,WAAW,CAAC;QACrB,KAAK,QAAQ;YACX,iCAAiC;YACjC,OAAO,WAAW,CAAC;QACrB,KAAK,QAAQ,CAAC;QACd,KAAK,QAAQ,CAAC;QACd,KAAK,UAAU,CAAC;QAChB,KAAK,MAAM,CAAC;QACZ,KAAK,aAAa,CAAC;QACnB,KAAK,UAAU,CAAC;QAChB,KAAK,SAAS,CAAC;QACf;YACE,6CAA6C;YAC7C,OAAO,qBAAqB,CAAC;IACjC,CAAC;AACH,CAAC","sourcesContent":["/**\n * UI Resource URI Utilities\n *\n * Standalone utilities for parsing and building ui:// resource URIs.\n * Used for static widget serving mode where widgets are pre-compiled\n * at startup and fetched via resources/read.\n *\n * @packageDocumentation\n */\n\nimport type { AIPlatformType } from '../adapters';\n\n/**\n * UI resource URI scheme\n */\nexport const UI_RESOURCE_SCHEME = 'ui://';\n\n/**\n * Pattern for static widget URIs: ui://widget/{toolName}.html\n * This format is used by OpenAI at discovery time (tools/list)\n */\nconst UI_WIDGET_PATTERN = /^ui:\\/\\/widget\\/([^/]+)\\.html$/;\n\n/**\n * Parsed static widget URI\n */\nexport interface ParsedWidgetUri {\n  toolName: string;\n  fullUri: string;\n}\n\n/**\n * Check if a URI is a UI resource URI\n *\n * @param uri - URI to check\n * @returns True if the URI starts with ui://\n */\nexport function isUIResourceUri(uri: string): boolean {\n  return uri.startsWith(UI_RESOURCE_SCHEME);\n}\n\n/**\n * Parse a static widget URI into its components\n *\n * @param uri - URI to parse (format: ui://widget/{toolName}.html)\n * @returns Parsed components or undefined if invalid\n */\nexport function parseWidgetUri(uri: string): ParsedWidgetUri | undefined {\n  const match = uri.match(UI_WIDGET_PATTERN);\n  if (!match) {\n    return undefined;\n  }\n\n  return {\n    toolName: decodeURIComponent(match[1]),\n    fullUri: uri,\n  };\n}\n\n/**\n * Check if URI is a static widget URI (ui://widget/{toolName}.html)\n */\nexport function isStaticWidgetUri(uri: string): boolean {\n  return UI_WIDGET_PATTERN.test(uri);\n}\n\n/**\n * Build a static widget URI from tool name\n *\n * @param toolName - Name of the tool\n * @returns Static widget URI (ui://widget/{toolName}.html)\n */\nexport function buildStaticWidgetUri(toolName: string): string {\n  return `ui://widget/${encodeURIComponent(toolName)}.html`;\n}\n\n/**\n * Get the MIME type for UI resources based on platform.\n *\n * Per user requirement: OpenAI or default uses 'text/html+skybridge'\n *\n * @param platformType - The detected platform type\n * @returns The appropriate MIME type\n */\nexport function getUIResourceMimeType(platformType?: AIPlatformType): string {\n  // Per requirement: \"for openai or default text/html+skybridge\"\n  // This aligns with OpenAI's skybridge widget protocol\n  switch (platformType) {\n    case 'claude':\n      // Claude uses standard text/html (network-blocked environment)\n      return 'text/html';\n    case 'gemini':\n      // Gemini uses standard text/html\n      return 'text/html';\n    case 'openai':\n    case 'cursor':\n    case 'continue':\n    case 'cody':\n    case 'generic-mcp':\n    case 'ext-apps':\n    case 'unknown':\n    default:\n      // OpenAI and default use skybridge MIME type\n      return 'text/html+skybridge';\n  }\n}\n"]}