@frontmcp/ui 0.5.1 → 0.6.0

package/adapters/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @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';
+export { type ResolvedServingMode, type ResolveServingModeOptions, resolveServingMode, isPlatformModeSupported, getDefaultServingMode, platformUsesStructuredContent, platformSupportsWidgets, } from './serving-mode';
+export { type TextContentBlock, type BuildToolResponseOptions, type ToolResponseContent, buildToolResponseContent, } from './response-builder';
+//# sourceMappingURL=index.d.ts.map

package/adapters/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/adapters/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAEL,KAAK,cAAc,EAEnB,KAAK,UAAU,EACf,KAAK,kBAAkB,EACvB,KAAK,6BAA6B,EAElC,WAAW,EACX,sBAAsB,EACtB,cAAc,GACf,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAEL,KAAK,mBAAmB,EACxB,KAAK,yBAAyB,EAE9B,kBAAkB,EAClB,uBAAuB,EACvB,qBAAqB,EACrB,6BAA6B,EAC7B,uBAAuB,GACxB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,wBAAwB,EAC7B,KAAK,mBAAmB,EAExB,wBAAwB,GACzB,MAAM,oBAAoB,CAAC"}

package/adapters/index.js

@@ -0,0 +1,462 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// libs/ui/src/adapters/index.ts
+var adapters_exports = {};
+__export(adapters_exports, {
+  buildOpenAICSP: () => buildOpenAICSP,
+  buildToolDiscoveryMeta: () => buildToolDiscoveryMeta,
+  buildToolResponseContent: () => buildToolResponseContent,
+  buildUIMeta: () => buildUIMeta,
+  getDefaultServingMode: () => getDefaultServingMode,
+  isPlatformModeSupported: () => isPlatformModeSupported,
+  platformSupportsWidgets: () => platformSupportsWidgets,
+  platformUsesStructuredContent: () => platformUsesStructuredContent,
+  resolveServingMode: () => resolveServingMode
+});
+module.exports = __toCommonJS(adapters_exports);
+
+// libs/ui/src/adapters/platform-meta.ts
+function buildUIMeta(options) {
+  const { uiConfig, platformType, html, token, directUrl, rendererType, contentHash, manifestUri } = options;
+  const meta = {};
+  switch (platformType) {
+    case "openai":
+      meta["openai/html"] = html;
+      meta["openai/mimeType"] = "text/html+skybridge";
+      if (rendererType) meta["openai/type"] = rendererType;
+      if (contentHash) meta["openai/contentHash"] = contentHash;
+      if (manifestUri) meta["openai/manifestUri"] = manifestUri;
+      if (token) meta["openai/widgetToken"] = token;
+      if (directUrl) meta["openai/directUrl"] = directUrl;
+      return buildOpenAIMeta(meta, uiConfig);
+    case "ext-apps":
+      meta["ui/html"] = html;
+      meta["ui/mimeType"] = "text/html+mcp";
+      if (rendererType) meta["ui/type"] = rendererType;
+      if (contentHash) meta["ui/contentHash"] = contentHash;
+      if (manifestUri) meta["ui/manifestUri"] = manifestUri;
+      if (token) meta["ui/widgetToken"] = token;
+      if (directUrl) meta["ui/directUrl"] = directUrl;
+      return buildExtAppsMeta(meta, uiConfig);
+    case "claude":
+    case "cursor":
+    case "continue":
+    case "cody":
+    case "generic-mcp":
+    case "gemini":
+    default:
+      meta["frontmcp/html"] = html;
+      meta["frontmcp/mimeType"] = "text/html+mcp";
+      if (rendererType) meta["frontmcp/type"] = rendererType;
+      if (contentHash) meta["frontmcp/contentHash"] = contentHash;
+      if (manifestUri) meta["frontmcp/manifestUri"] = manifestUri;
+      if (token) meta["frontmcp/widgetToken"] = token;
+      if (directUrl) meta["frontmcp/directUrl"] = directUrl;
+      meta["ui/html"] = html;
+      meta["ui/mimeType"] = "text/html+mcp";
+      if (rendererType) meta["ui/type"] = rendererType;
+      if (platformType === "claude") {
+        return buildClaudeMeta(meta, uiConfig);
+      } else if (platformType === "gemini") {
+        return buildGeminiMeta(meta, uiConfig);
+      } else if (platformType === "cursor" || platformType === "continue" || platformType === "cody") {
+        return buildIDEMeta(meta, uiConfig);
+      } else if (platformType === "generic-mcp") {
+        return buildGenericMeta(meta, uiConfig);
+      }
+      return meta;
+  }
+}
+function buildOpenAIMeta(meta, uiConfig) {
+  if (uiConfig.invocationStatus?.invoking) {
+    meta["openai/toolInvocation/invoking"] = uiConfig.invocationStatus.invoking;
+  }
+  if (uiConfig.invocationStatus?.invoked) {
+    meta["openai/toolInvocation/invoked"] = uiConfig.invocationStatus.invoked;
+  }
+  return meta;
+}
+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;
+}
+function buildClaudeMeta(meta, uiConfig) {
+  if (uiConfig.widgetDescription) {
+    meta["claude/widgetDescription"] = uiConfig.widgetDescription;
+  }
+  return meta;
+}
+function buildGeminiMeta(meta, uiConfig) {
+  if (uiConfig.widgetDescription) {
+    meta["gemini/widgetDescription"] = uiConfig.widgetDescription;
+  }
+  return meta;
+}
+function buildIDEMeta(meta, uiConfig) {
+  if (uiConfig.widgetDescription) {
+    meta["ide/widgetDescription"] = uiConfig.widgetDescription;
+  }
+  return meta;
+}
+function buildGenericMeta(meta, uiConfig) {
+  if (uiConfig.widgetAccessible) {
+    meta["openai/widgetAccessible"] = true;
+  }
+  if (uiConfig.csp) {
+    meta["openai/widgetCSP"] = buildOpenAICSP(uiConfig.csp);
+  }
+  return meta;
+}
+function buildExtAppsMeta(meta, uiConfig) {
+  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",
+      // Map OpenAI-style values
+      widget: "inline",
+      panel: "fullscreen"
+    };
+    const mappedMode = displayModeMap[uiConfig.displayMode];
+    if (mappedMode) {
+      meta["ui/displayMode"] = mappedMode;
+    }
+  }
+  if (uiConfig.prefersBorder !== void 0) {
+    meta["ui/prefersBorder"] = uiConfig.prefersBorder;
+  }
+  if (uiConfig.sandboxDomain) {
+    meta["ui/domain"] = uiConfig.sandboxDomain;
+  }
+  return meta;
+}
+function buildToolDiscoveryMeta(options) {
+  const { uiConfig, platformType, staticWidgetUri } = options;
+  const meta = {};
+  switch (platformType) {
+    case "openai":
+      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":
+      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":
+      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 !== void 0) {
+        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;
+}
+
+// libs/ui/src/adapters/serving-mode.ts
+var PLATFORM_CAPABILITIES = {
+  openai: {
+    supportsWidgets: true,
+    useStructuredContent: true,
+    supportedModes: ["inline", "static", "hybrid", "direct-url", "custom-url"],
+    defaultMode: "inline"
+  },
+  "ext-apps": {
+    supportsWidgets: true,
+    useStructuredContent: true,
+    supportedModes: ["inline", "static", "hybrid", "direct-url", "custom-url"],
+    defaultMode: "inline"
+  },
+  claude: {
+    supportsWidgets: true,
+    useStructuredContent: true,
+    // Claude supports inline only (no resource fetching for static)
+    supportedModes: ["inline"],
+    defaultMode: "inline"
+  },
+  cursor: {
+    // Cursor (IDE) - similar to OpenAI, supports widgets
+    supportsWidgets: true,
+    useStructuredContent: true,
+    supportedModes: ["inline", "static", "hybrid", "direct-url", "custom-url"],
+    defaultMode: "inline"
+  },
+  continue: {
+    // Continue (IDE extension) - basic widget support
+    supportsWidgets: true,
+    useStructuredContent: true,
+    supportedModes: ["inline"],
+    defaultMode: "inline"
+  },
+  cody: {
+    // Sourcegraph Cody - basic widget support
+    supportsWidgets: true,
+    useStructuredContent: true,
+    supportedModes: ["inline"],
+    defaultMode: "inline"
+  },
+  "generic-mcp": {
+    // Generic MCP clients - assume widget support
+    supportsWidgets: true,
+    useStructuredContent: true,
+    supportedModes: ["inline", "static"],
+    defaultMode: "inline"
+  },
+  gemini: {
+    supportsWidgets: false,
+    useStructuredContent: false,
+    supportedModes: [],
+    defaultMode: "inline"
+    // Not used since supportsWidgets is false
+  },
+  unknown: {
+    // Unknown clients: assume widget support, return ui/html + text/html+mcp
+    // This allows generic MCP clients to receive and render widget UI
+    supportsWidgets: true,
+    useStructuredContent: true,
+    supportedModes: ["inline"],
+    defaultMode: "inline"
+  }
+};
+function resolveServingMode(options) {
+  const { configuredMode = "auto", platformType } = options;
+  const capabilities = PLATFORM_CAPABILITIES[platformType] || PLATFORM_CAPABILITIES.unknown;
+  if (!capabilities.supportsWidgets) {
+    return {
+      effectiveMode: null,
+      useStructuredContent: false,
+      supportsUI: false,
+      reason: `Platform '${platformType}' does not support widget UI`
+    };
+  }
+  if (configuredMode === "auto") {
+    return {
+      effectiveMode: capabilities.defaultMode,
+      useStructuredContent: capabilities.useStructuredContent,
+      supportsUI: true,
+      reason: `Auto-selected '${capabilities.defaultMode}' for platform '${platformType}'`
+    };
+  }
+  if (capabilities.supportedModes.includes(configuredMode)) {
+    return {
+      effectiveMode: configuredMode,
+      useStructuredContent: capabilities.useStructuredContent,
+      supportsUI: true,
+      reason: `Using configured mode '${configuredMode}' (supported by '${platformType}')`
+    };
+  }
+  return {
+    effectiveMode: null,
+    useStructuredContent: false,
+    supportsUI: false,
+    reason: `Mode '${configuredMode}' not supported by platform '${platformType}'. Supported: ${capabilities.supportedModes.join(", ") || "none"}`
+  };
+}
+function isPlatformModeSupported(platformType, mode) {
+  const capabilities = PLATFORM_CAPABILITIES[platformType] || PLATFORM_CAPABILITIES.unknown;
+  if (mode === "auto") {
+    return capabilities.supportsWidgets;
+  }
+  return capabilities.supportedModes.includes(mode);
+}
+function getDefaultServingMode(platformType) {
+  const capabilities = PLATFORM_CAPABILITIES[platformType] || PLATFORM_CAPABILITIES.unknown;
+  return capabilities.supportsWidgets ? capabilities.defaultMode : null;
+}
+function platformUsesStructuredContent(platformType) {
+  const capabilities = PLATFORM_CAPABILITIES[platformType] || PLATFORM_CAPABILITIES.unknown;
+  return capabilities.useStructuredContent;
+}
+function platformSupportsWidgets(platformType) {
+  const capabilities = PLATFORM_CAPABILITIES[platformType] || PLATFORM_CAPABILITIES.unknown;
+  return capabilities.supportsWidgets;
+}
+
+// libs/ui/src/utils/safe-stringify.ts
+function safeStringify(value, space) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  try {
+    return JSON.stringify(
+      value,
+      (_key, val) => {
+        if (typeof val === "object" && val !== null) {
+          if (seen.has(val)) return "[Circular]";
+          seen.add(val);
+        }
+        return val;
+      },
+      space
+    );
+  } catch {
+    return JSON.stringify({ error: "Output could not be serialized" });
+  }
+}
+
+// libs/ui/src/adapters/response-builder.ts
+function buildToolResponseContent(options) {
+  const { rawOutput, htmlContent, servingMode, useStructuredContent, platformType } = options;
+  if (servingMode === "static") {
+    return {
+      content: [{ type: "text", text: safeStringify(rawOutput) }],
+      structuredContent: useStructuredContent ? rawOutput : void 0,
+      contentCleared: false,
+      format: "json-only"
+    };
+  }
+  if (servingMode === "hybrid") {
+    return {
+      content: [{ type: "text", text: safeStringify(rawOutput) }],
+      structuredContent: useStructuredContent ? rawOutput : void 0,
+      contentCleared: false,
+      format: "json-only"
+    };
+  }
+  if (useStructuredContent) {
+    if (htmlContent) {
+      return {
+        content: [{ type: "text", text: htmlContent }],
+        structuredContent: rawOutput,
+        contentCleared: false,
+        format: "structured-content"
+      };
+    }
+    return {
+      content: [{ type: "text", text: safeStringify(rawOutput) }],
+      structuredContent: rawOutput,
+      contentCleared: false,
+      format: "json-only"
+    };
+  }
+  const supportsWidgets = platformSupportsWidgets(platformType);
+  if (supportsWidgets) {
+    return {
+      content: [],
+      contentCleared: true,
+      format: "widget"
+    };
+  }
+  if (htmlContent) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `## Data
+\`\`\`json
+${safeStringify(
+            rawOutput,
+            2
+          )}
+\`\`\`
+
+## Visual Template (for artifact rendering)
+\`\`\`html
+${htmlContent}
+\`\`\``
+        }
+      ],
+      contentCleared: false,
+      format: "markdown"
+    };
+  }
+  return {
+    content: [{ type: "text", text: safeStringify(rawOutput, 2) }],
+    contentCleared: false,
+    format: "json-only"
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildOpenAICSP,
+  buildToolDiscoveryMeta,
+  buildToolResponseContent,
+  buildUIMeta,
+  getDefaultServingMode,
+  isPlatformModeSupported,
+  platformSupportsWidgets,
+  platformUsesStructuredContent,
+  resolveServingMode
+});

package/adapters/platform-meta.d.ts

@@ -0,0 +1,166 @@
+/**
+ * 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;
+//# sourceMappingURL=platform-meta.d.ts.map

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

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