@tylertech/forge-ai 0.15.1 → 0.15.3-dev.0

package/dist/tools/ai-mcp-app/ai-mcp-app.d.ts

@@ -0,0 +1,69 @@
+import { LitElement, PropertyValues, TemplateResult, nothing, CSSResult } from 'lit';
+import { IToolRenderer, McpAppDisplayMode, McpModelContextUpdateParams, ToolCall, ToolDefinition } from '../../ai-chatbot';
+import { McpAppLoggingMessage } from './mcp-app-bridge-types.js';
+import { McpAppHost } from './mcp-app-context.js';
+declare global {
+    interface HTMLElementTagNameMap {
+        'forge-ai-mcp-app': McpAppToolElement;
+    }
+    interface HTMLElementEventMap {
+        'forge-ai-mcp-app-open-link': CustomEvent<{
+            url: string;
+        }>;
+        'forge-ai-mcp-app-message': CustomEvent<{
+            content: unknown[];
+            role: 'user';
+        }>;
+        'forge-ai-mcp-app-logging-message': CustomEvent<McpAppLoggingMessage>;
+        'forge-ai-mcp-app-request-teardown': CustomEvent<{
+            toolCallId: string;
+        }>;
+        'forge-ai-mcp-app-request-display-mode': CustomEvent<{
+            mode: McpAppDisplayMode;
+        }>;
+        'forge-ai-mcp-app-update-model-context': CustomEvent<McpModelContextUpdateParams>;
+    }
+}
+/**
+ * Renders an MCP-app UI resource stamped onto a {@link ToolCall} as a sandboxed,
+ * cross-origin widget. The iframe + bridge are mounted once and survive every `toolCall`
+ * delta (Lit reuses this node at its keyed position), so args stream live without
+ * remounting.
+ *
+ * The cross-origin sandbox is mandatory: when no `sandboxUrl` is available the element
+ * renders an error artifact rather than an insecure same-origin iframe.
+ *
+ * @tag forge-ai-mcp-app
+ * @internal
+ *
+ * @event {CustomEvent<{ url: string }>} forge-ai-mcp-app-open-link - Fired (cancelable) when the app requests to open an http(s)/mailto link; unless `preventDefault()` is called, the user is asked to confirm and the link opens in a new tab
+ * @event {CustomEvent<{ content: unknown[]; role: 'user' }>} forge-ai-mcp-app-message - Fired when the app sends a `ui/message`, before its text is placed in the prompt for the user to send
+ * @event {CustomEvent<McpAppLoggingMessage>} forge-ai-mcp-app-logging-message - Fired (cancelable) when the app sends a logging message; logged to the console unless `preventDefault()` is called
+ * @event {CustomEvent<{ toolCallId: string }>} forge-ai-mcp-app-request-teardown - Fired (cancelable) when the app asks to be torn down; the host tears the widget down unless `preventDefault()` is called
+ * @event {CustomEvent<{ mode: McpAppDisplayMode }>} forge-ai-mcp-app-request-display-mode - Fired when the app's display mode changes
+ * @event {CustomEvent<McpModelContextUpdateParams>} forge-ai-mcp-app-update-model-context - Fired when the app updates model context; detail carries `toolCallId`, `content` and `structuredContent`
+ */
+export declare class McpAppToolElement extends LitElement implements IToolRenderer {
+    #private;
+    static styles: CSSResult;
+    toolCall: ToolCall;
+    /** Client-side definition of the tool, when one is registered; supplies `toolInfo.tool`. */
+    toolDefinition?: ToolDefinition;
+    host?: McpAppHost;
+    private _iframe;
+    private _container;
+    private _displayMode;
+    private _lifecycle;
+    private _pendingLink;
+    firstUpdated(): void;
+    updated(changedProperties: PropertyValues): void;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    /**
+     * Send `ui/resource-teardown` to the View and release the bridge without waiting for the
+     * ack. The chatbot calls this when removing widgets; it also runs on disconnect as a
+     * fallback. A later `toolCall` update remounts the widget.
+     */
+    teardown(): void;
+    render(): TemplateResult | typeof nothing;
+}

package/dist/tools/ai-mcp-app/ai-mcp-app.mjs

@@ -0,0 +1,574 @@
+import { consume } from "@lit/context";
+import { unsafeCSS, LitElement, html, nothing } from "lit";
+import { property, query, state, customElement } from "lit/decorators.js";
+import { classMap } from "lit/directives/class-map.js";
+import { inertOutside } from "../../utils/inert-outside.mjs";
+import { McpAppBridge } from "./mcp-app-bridge.mjs";
+import { mcpAppHostContext } from "./mcp-app-context.mjs";
+import { McpAppBridgeController, enforcedPermissions } from "./mcp-app-bridge-controller.mjs";
+import "../../ai-empty-state/ai-empty-state.mjs";
+import "../../ai-confirmation-prompt/ai-confirmation-prompt.mjs";
+import styles from "./ai-mcp-app.scss.mjs";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var _controller, _lastHostContext, _unregisterView, _containerDimensions, _hostStyles, _restorePage, _resizeFrame, _resizeObserver, _McpAppToolElement_instances, uiResource_get, hasPolicy_get, canRender_get, canConnect_get, errorBody_get, hostContext_get, toolInfo_get, hostCapabilities_get, handlers_get, setDisplayMode_fn, applyDisplayMode_fn, releasePage_fn, connect_fn, syncHostContext_fn, resolveHostStyles_fn, scheduleContainerMeasure_fn, cancelContainerMeasure_fn, readContainerDimensions_fn, measureContainer_fn, openLink_fn, settlePendingLink_fn, confirmLink_fn, dispatchMessage_fn, handleLoggingMessage_fn, handleRequestTeardown_fn, dispatchRequestDisplayMode_fn, dispatchUpdateModelContext_fn, _iframe, _promotedToolbar, linkConfirmation_get, isPromoted_get, exitToInline_fn, handleContainerKeydown_fn, bordered_get, errorArtifact_get;
+const HOST_INFO = { name: "forge-ai", version: "1.0.0" };
+const MAX_INLINE_HEIGHT = 2e3;
+const OPEN_LINK_PROTOCOLS = ["http:", "https:", "mailto:"];
+const HOST_STYLE_KEYS = [
+  "color-background-primary",
+  "color-background-secondary",
+  "color-background-tertiary",
+  "color-background-inverse",
+  "color-background-info",
+  "color-background-danger",
+  "color-background-success",
+  "color-background-warning",
+  "color-text-primary",
+  "color-text-secondary",
+  "color-text-tertiary",
+  "color-text-inverse",
+  "color-text-info",
+  "color-text-danger",
+  "color-text-success",
+  "color-text-warning",
+  "color-text-disabled",
+  "color-border-primary",
+  "color-border-secondary",
+  "color-border-info",
+  "color-border-danger",
+  "color-border-success",
+  "color-border-warning",
+  "color-ring-primary",
+  "font-sans",
+  "font-weight-normal",
+  "font-weight-medium",
+  "font-weight-bold",
+  "font-text-xs-size",
+  "font-text-sm-size",
+  "font-text-md-size",
+  "font-text-lg-size",
+  "font-text-xs-line-height",
+  "font-text-sm-line-height",
+  "font-text-md-line-height",
+  "font-text-lg-line-height",
+  "font-heading-sm-size",
+  "font-heading-md-size",
+  "font-heading-lg-size",
+  "font-heading-xl-size",
+  "font-heading-2xl-size",
+  "font-heading-3xl-size",
+  "font-heading-sm-line-height",
+  "font-heading-md-line-height",
+  "font-heading-lg-line-height",
+  "font-heading-xl-line-height",
+  "font-heading-2xl-line-height",
+  "font-heading-3xl-line-height",
+  "border-radius-xs",
+  "border-radius-sm",
+  "border-radius-md",
+  "border-radius-lg",
+  "border-radius-xl",
+  "border-radius-full",
+  "border-width-regular",
+  "shadow-sm",
+  "shadow-md",
+  "shadow-lg"
+];
+const CONSOLE_LEVELS = {
+  debug: "debug",
+  info: "info",
+  notice: "info",
+  warning: "warn",
+  error: "error",
+  critical: "error",
+  alert: "error",
+  emergency: "error"
+};
+function asOpenableUrl(url) {
+  try {
+    const parsed = new URL(url);
+    return OPEN_LINK_PROTOCOLS.includes(parsed.protocol) ? parsed.href : null;
+  } catch {
+    return null;
+  }
+}
+let McpAppToolElement = class extends LitElement {
+  constructor() {
+    super(...arguments);
+    __privateAdd(this, _McpAppToolElement_instances);
+    this._displayMode = "inline";
+    this._lifecycle = "live";
+    this._pendingLink = null;
+    __privateAdd(this, _controller, null);
+    __privateAdd(this, _lastHostContext, null);
+    __privateAdd(this, _unregisterView, null);
+    __privateAdd(this, _containerDimensions, { maxHeight: MAX_INLINE_HEIGHT });
+    __privateAdd(this, _hostStyles, {});
+    __privateAdd(this, _restorePage, null);
+    __privateAdd(this, _resizeFrame, null);
+    __privateAdd(this, _resizeObserver, new ResizeObserver(() => __privateMethod(this, _McpAppToolElement_instances, scheduleContainerMeasure_fn).call(this)));
+    __privateAdd(this, _iframe, html`<iframe title="MCP application" sandbox="allow-scripts allow-same-origin"></iframe>`);
+    __privateAdd(this, _promotedToolbar, html`
+    <div class="promoted-toolbar">
+      <button
+        class="forge-icon-button forge-icon-button--medium exit-button"
+        aria-label="Exit to inline view"
+        @click=${() => __privateMethod(this, _McpAppToolElement_instances, exitToInline_fn).call(this)}>
+        <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" aria-hidden="true">
+          <path fill="none" d="M0 0h24v24H0z" />
+          <path
+            d="M19 6.41 17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z" />
+        </svg>
+      </button>
+    </div>
+  `);
+  }
+  firstUpdated() {
+    __privateMethod(this, _McpAppToolElement_instances, connect_fn).call(this);
+  }
+  updated(changedProperties) {
+    if (!__privateGet(this, _controller)) {
+      __privateMethod(this, _McpAppToolElement_instances, connect_fn).call(this);
+      return;
+    }
+    __privateGet(this, _controller).syncToolCall(this.toolCall);
+    if (changedProperties.has("_displayMode")) {
+      __privateMethod(this, _McpAppToolElement_instances, applyDisplayMode_fn).call(this);
+      __privateSet(this, _containerDimensions, __privateMethod(this, _McpAppToolElement_instances, readContainerDimensions_fn).call(this) ?? __privateGet(this, _containerDimensions));
+    }
+    __privateMethod(this, _McpAppToolElement_instances, syncHostContext_fn).call(this, changedProperties);
+  }
+  connectedCallback() {
+    super.connectedCallback();
+    if (this.hasUpdated && !__privateGet(this, _controller)) {
+      this.requestUpdate();
+    }
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback();
+    __privateGet(this, _resizeObserver).disconnect();
+    __privateMethod(this, _McpAppToolElement_instances, cancelContainerMeasure_fn).call(this);
+    __privateMethod(this, _McpAppToolElement_instances, releasePage_fn).call(this);
+    this.teardown();
+  }
+  /**
+   * Send `ui/resource-teardown` to the View and release the bridge without waiting for the
+   * ack. The chatbot calls this when removing widgets; it also runs on disconnect as a
+   * fallback. A later `toolCall` update remounts the widget.
+   */
+  teardown() {
+    var _a;
+    __privateMethod(this, _McpAppToolElement_instances, settlePendingLink_fn).call(this, { isError: true });
+    (_a = __privateGet(this, _unregisterView)) == null ? void 0 : _a.call(this);
+    __privateSet(this, _unregisterView, null);
+    const controller = __privateGet(this, _controller);
+    __privateSet(this, _controller, null);
+    controller?.teardown();
+  }
+  render() {
+    if (this._lifecycle === "closed") {
+      return nothing;
+    }
+    if (!__privateGet(this, _McpAppToolElement_instances, canRender_get)) {
+      return __privateGet(this, _McpAppToolElement_instances, errorArtifact_get);
+    }
+    return html`
+      <div
+        class=${classMap({
+      container: true,
+      bordered: __privateGet(this, _McpAppToolElement_instances, bordered_get),
+      fullscreen: this._displayMode === "fullscreen",
+      pip: this._displayMode === "pip"
+    })}
+        popover="manual"
+        role=${__privateGet(this, _McpAppToolElement_instances, isPromoted_get) ? "dialog" : nothing}
+        aria-label=${__privateGet(this, _McpAppToolElement_instances, isPromoted_get) ? "MCP application" : nothing}
+        data-handles-escape
+        @keydown=${__privateMethod(this, _McpAppToolElement_instances, handleContainerKeydown_fn)}>
+        ${__privateGet(this, _McpAppToolElement_instances, isPromoted_get) ? __privateGet(this, _promotedToolbar) : nothing} ${__privateGet(this, _iframe)} ${__privateGet(this, _McpAppToolElement_instances, linkConfirmation_get)}
+      </div>
+    `;
+  }
+};
+_controller = /* @__PURE__ */ new WeakMap();
+_lastHostContext = /* @__PURE__ */ new WeakMap();
+_unregisterView = /* @__PURE__ */ new WeakMap();
+_containerDimensions = /* @__PURE__ */ new WeakMap();
+_hostStyles = /* @__PURE__ */ new WeakMap();
+_restorePage = /* @__PURE__ */ new WeakMap();
+_resizeFrame = /* @__PURE__ */ new WeakMap();
+_resizeObserver = /* @__PURE__ */ new WeakMap();
+_McpAppToolElement_instances = /* @__PURE__ */ new WeakSet();
+uiResource_get = function() {
+  return this.toolCall?.uiResource;
+};
+hasPolicy_get = function() {
+  const resource = __privateGet(this, _McpAppToolElement_instances, uiResource_get);
+  return !!resource && resource.csp !== void 0 && resource.permissions !== void 0;
+};
+canRender_get = function() {
+  return !!__privateGet(this, _McpAppToolElement_instances, uiResource_get)?.html && !!this.host?.sandboxUrl && __privateGet(this, _McpAppToolElement_instances, hasPolicy_get);
+};
+canConnect_get = function() {
+  return this._lifecycle === "live" && __privateGet(this, _McpAppToolElement_instances, canRender_get);
+};
+errorBody_get = function() {
+  if (!this.host?.sandboxUrl) {
+    return "This interactive app can't be shown because no secure sandbox is configured.";
+  }
+  return "This interactive app can't be shown because its security policy is missing.";
+};
+hostContext_get = function() {
+  return {
+    ...this.host?.hostContext ?? { theme: "light" },
+    styles: __privateGet(this, _hostStyles),
+    toolInfo: __privateGet(this, _McpAppToolElement_instances, toolInfo_get),
+    containerDimensions: __privateGet(this, _containerDimensions),
+    displayMode: this._displayMode
+  };
+};
+toolInfo_get = function() {
+  const definition = this.toolDefinition;
+  return {
+    id: this.toolCall.id,
+    tool: {
+      name: this.toolCall.name,
+      ...definition?.description ? { description: definition.description } : {},
+      ...definition?.displayName ? { title: definition.displayName } : {},
+      inputSchema: { ...definition?.parameters, type: "object" }
+    }
+  };
+};
+hostCapabilities_get = function() {
+  const resource = __privateGet(this, _McpAppToolElement_instances, uiResource_get);
+  return {
+    ...this.host?.hostCapabilities,
+    sandbox: {
+      csp: resource?.csp ?? {},
+      permissions: enforcedPermissions(resource?.permissions ?? {})
+    }
+  };
+};
+handlers_get = function() {
+  const unavailable = () => Promise.reject(new Error("MCP app host is unavailable"));
+  return {
+    oncalltool: (params) => this.host?.callTool({ ...params, toolCallId: this.toolCall.id }) ?? unavailable(),
+    onreadresource: (params) => this.host?.readResource({ ...params, toolCallId: this.toolCall.id }) ?? unavailable(),
+    onopenlink: ({ url }) => __privateMethod(this, _McpAppToolElement_instances, openLink_fn).call(this, url),
+    onmessage: async ({ content, role }) => {
+      __privateMethod(this, _McpAppToolElement_instances, dispatchMessage_fn).call(this, content, role);
+      return this.host?.draftMessage({ toolCallId: this.toolCall.id, content }) ?? { isError: true };
+    },
+    onloggingmessage: (message) => __privateMethod(this, _McpAppToolElement_instances, handleLoggingMessage_fn).call(this, message),
+    onsizechange: ({ height }) => {
+      if (height > 0 && this._displayMode === "inline") {
+        this.style.height = `${Math.min(height, MAX_INLINE_HEIGHT)}px`;
+      }
+    },
+    onrequestdisplaymode: async ({ mode, appDisplayModes }) => {
+      const resultMode = __privateMethod(this, _McpAppToolElement_instances, setDisplayMode_fn).call(this, mode, appDisplayModes);
+      __privateMethod(this, _McpAppToolElement_instances, dispatchRequestDisplayMode_fn).call(this, resultMode);
+      return { mode: resultMode };
+    },
+    onupdatemodelcontext: async ({ content, structuredContent }) => {
+      const params = { toolCallId: this.toolCall.id, content, structuredContent };
+      __privateMethod(this, _McpAppToolElement_instances, dispatchUpdateModelContext_fn).call(this, params);
+      await this.host?.updateModelContext(params);
+    },
+    onrequestteardown: () => __privateMethod(this, _McpAppToolElement_instances, handleRequestTeardown_fn).call(this)
+  };
+};
+setDisplayMode_fn = function(requested, appDisplayModes) {
+  const hostModes = this.host?.hostContext.availableDisplayModes ?? [];
+  const allowed = requested === "inline" || hostModes.includes(requested) && appDisplayModes.includes(requested);
+  if (allowed) {
+    this._displayMode = requested;
+  }
+  return this._displayMode;
+};
+applyDisplayMode_fn = function() {
+  const container = this._container;
+  if (!container) {
+    return;
+  }
+  if (this._displayMode === "inline") {
+    if (container.matches(":popover-open")) {
+      container.hidePopover();
+    }
+  } else if (!container.matches(":popover-open")) {
+    container.showPopover();
+  }
+  __privateMethod(this, _McpAppToolElement_instances, releasePage_fn).call(this);
+  if (this._displayMode === "fullscreen") {
+    __privateSet(this, _restorePage, inertOutside(this));
+  }
+  if (__privateGet(this, _McpAppToolElement_instances, isPromoted_get)) {
+    this.updateComplete.then(() => this.renderRoot.querySelector(".exit-button")?.focus());
+  }
+};
+releasePage_fn = function() {
+  var _a;
+  (_a = __privateGet(this, _restorePage)) == null ? void 0 : _a.call(this);
+  __privateSet(this, _restorePage, null);
+};
+connect_fn = function() {
+  if (__privateGet(this, _controller) || !__privateGet(this, _McpAppToolElement_instances, canConnect_get)) {
+    return;
+  }
+  const iframe = this._iframe;
+  const resource = __privateGet(this, _McpAppToolElement_instances, uiResource_get);
+  const host = this.host;
+  if (!iframe || !resource || !host?.sandboxUrl) {
+    return;
+  }
+  const controller = new McpAppBridgeController(new McpAppBridge(HOST_INFO));
+  __privateSet(this, _controller, controller);
+  __privateSet(this, _containerDimensions, __privateMethod(this, _McpAppToolElement_instances, readContainerDimensions_fn).call(this) ?? __privateGet(this, _containerDimensions));
+  if (this._container) {
+    __privateGet(this, _resizeObserver).observe(this._container);
+  }
+  __privateSet(this, _lastHostContext, host.hostContext);
+  __privateSet(this, _hostStyles, __privateMethod(this, _McpAppToolElement_instances, resolveHostStyles_fn).call(this));
+  __privateSet(this, _unregisterView, host.registerView({ toolCallId: this.toolCall.id, teardown: () => this.teardown() }));
+  controller.connect({
+    iframe,
+    sandboxUrl: host.sandboxUrl,
+    html: resource.html,
+    hostContext: __privateGet(this, _McpAppToolElement_instances, hostContext_get),
+    hostCapabilities: __privateGet(this, _McpAppToolElement_instances, hostCapabilities_get),
+    csp: resource.csp,
+    permissions: resource.permissions,
+    handlers: __privateGet(this, _McpAppToolElement_instances, handlers_get)
+  }).then(() => controller.syncToolCall(this.toolCall)).catch((error) => console.warn("[forge-ai-mcp-app] Failed to connect widget:", error));
+};
+syncHostContext_fn = function(changedProperties) {
+  const next = this.host?.hostContext;
+  if (next && (next !== __privateGet(this, _lastHostContext) || changedProperties.has("_displayMode"))) {
+    __privateSet(this, _lastHostContext, next);
+    __privateSet(this, _hostStyles, __privateMethod(this, _McpAppToolElement_instances, resolveHostStyles_fn).call(this));
+    __privateGet(this, _controller)?.sendHostContextChange(__privateGet(this, _McpAppToolElement_instances, hostContext_get));
+  }
+};
+resolveHostStyles_fn = function() {
+  const computed = getComputedStyle(this);
+  const variables = {};
+  for (const key of HOST_STYLE_KEYS) {
+    const value = computed.getPropertyValue(`--_mcp-host-${key}`).trim();
+    if (value) {
+      variables[`--${key}`] = value;
+    }
+  }
+  return { variables };
+};
+scheduleContainerMeasure_fn = function() {
+  if (__privateGet(this, _resizeFrame) !== null) {
+    return;
+  }
+  __privateSet(this, _resizeFrame, requestAnimationFrame(() => {
+    __privateSet(this, _resizeFrame, null);
+    __privateMethod(this, _McpAppToolElement_instances, measureContainer_fn).call(this);
+  }));
+};
+cancelContainerMeasure_fn = function() {
+  if (__privateGet(this, _resizeFrame) !== null) {
+    cancelAnimationFrame(__privateGet(this, _resizeFrame));
+    __privateSet(this, _resizeFrame, null);
+  }
+};
+readContainerDimensions_fn = function() {
+  const container = this._container;
+  if (!container) {
+    return null;
+  }
+  const width = Math.round(container.clientWidth);
+  return this._displayMode === "inline" ? { width, maxHeight: MAX_INLINE_HEIGHT } : { width, height: Math.round(this._iframe?.clientHeight ?? container.clientHeight) };
+};
+measureContainer_fn = function() {
+  const next = __privateMethod(this, _McpAppToolElement_instances, readContainerDimensions_fn).call(this);
+  if (!next || JSON.stringify(next) === JSON.stringify(__privateGet(this, _containerDimensions))) {
+    return;
+  }
+  __privateSet(this, _containerDimensions, next);
+  __privateGet(this, _controller)?.sendHostContextChange(__privateGet(this, _McpAppToolElement_instances, hostContext_get));
+};
+openLink_fn = function(url) {
+  const href = asOpenableUrl(url);
+  if (!href) {
+    return Promise.resolve({ isError: true });
+  }
+  const event = new CustomEvent("forge-ai-mcp-app-open-link", {
+    detail: { url: href },
+    bubbles: true,
+    composed: true,
+    cancelable: true
+  });
+  if (!this.dispatchEvent(event)) {
+    return Promise.resolve({});
+  }
+  __privateMethod(this, _McpAppToolElement_instances, settlePendingLink_fn).call(this, { isError: true });
+  return new Promise((settle) => {
+    this._pendingLink = { href, settle };
+  });
+};
+settlePendingLink_fn = function(result) {
+  this._pendingLink?.settle(result);
+  this._pendingLink = null;
+};
+confirmLink_fn = function() {
+  const href = this._pendingLink?.href;
+  if (href) {
+    window.open(href, "_blank", "noopener,noreferrer");
+  }
+  __privateMethod(this, _McpAppToolElement_instances, settlePendingLink_fn).call(this, {});
+};
+dispatchMessage_fn = function(content, role) {
+  this.dispatchEvent(
+    new CustomEvent("forge-ai-mcp-app-message", { detail: { content, role }, bubbles: true, composed: true })
+  );
+};
+handleLoggingMessage_fn = function(message) {
+  const event = new CustomEvent("forge-ai-mcp-app-logging-message", {
+    detail: message,
+    bubbles: true,
+    composed: true,
+    cancelable: true
+  });
+  if (this.dispatchEvent(event)) {
+    const method = CONSOLE_LEVELS[message.level] ?? "info";
+    console[method](`[forge-ai-mcp-app]${message.logger ? ` [${message.logger}]` : ""}`, message.data);
+  }
+};
+handleRequestTeardown_fn = function() {
+  if (this._lifecycle !== "live") {
+    return;
+  }
+  const event = new CustomEvent("forge-ai-mcp-app-request-teardown", {
+    detail: { toolCallId: this.toolCall.id },
+    bubbles: true,
+    composed: true,
+    cancelable: true
+  });
+  if (!this.dispatchEvent(event)) {
+    return;
+  }
+  this._lifecycle = "closing";
+  __privateGet(this, _resizeObserver).disconnect();
+  __privateMethod(this, _McpAppToolElement_instances, cancelContainerMeasure_fn).call(this);
+  if (this.host) {
+    this.host.teardownView({ toolCallId: this.toolCall.id });
+  } else {
+    this.teardown();
+  }
+  this.style.removeProperty("height");
+  this._lifecycle = "closed";
+};
+dispatchRequestDisplayMode_fn = function(mode) {
+  this.dispatchEvent(
+    new CustomEvent("forge-ai-mcp-app-request-display-mode", { detail: { mode }, bubbles: true, composed: true })
+  );
+};
+dispatchUpdateModelContext_fn = function(detail) {
+  this.dispatchEvent(
+    new CustomEvent("forge-ai-mcp-app-update-model-context", { detail, bubbles: true, composed: true })
+  );
+};
+_iframe = /* @__PURE__ */ new WeakMap();
+_promotedToolbar = /* @__PURE__ */ new WeakMap();
+linkConfirmation_get = function() {
+  const link = this._pendingLink;
+  if (!link) {
+    return nothing;
+  }
+  return html`
+      <forge-ai-confirmation-prompt
+        text=${`Open this link in a new tab? ${link.href}`}
+        confirm-text="Open"
+        deny-text="Cancel"
+        @forge-ai-confirmation-prompt-confirm=${() => __privateMethod(this, _McpAppToolElement_instances, confirmLink_fn).call(this)}
+        @forge-ai-confirmation-prompt-deny=${() => __privateMethod(this, _McpAppToolElement_instances, settlePendingLink_fn).call(this, { isError: true })}>
+      </forge-ai-confirmation-prompt>
+    `;
+};
+isPromoted_get = function() {
+  return this._displayMode !== "inline";
+};
+exitToInline_fn = function() {
+  if (!__privateGet(this, _McpAppToolElement_instances, isPromoted_get)) {
+    return;
+  }
+  this._displayMode = "inline";
+  __privateMethod(this, _McpAppToolElement_instances, dispatchRequestDisplayMode_fn).call(this, "inline");
+};
+handleContainerKeydown_fn = function(evt) {
+  if (evt.key === "Escape" && __privateGet(this, _McpAppToolElement_instances, isPromoted_get)) {
+    evt.stopPropagation();
+    evt.preventDefault();
+    __privateMethod(this, _McpAppToolElement_instances, exitToInline_fn).call(this);
+  }
+};
+bordered_get = function() {
+  return __privateGet(this, _McpAppToolElement_instances, uiResource_get)?.prefersBorder !== false;
+};
+errorArtifact_get = function() {
+  return html`
+      <div class="container bordered">
+        <forge-ai-empty-state>
+          <svg slot="icon" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" class="error-icon" aria-hidden="true">
+            <path fill="none" d="M0 0h24v24H0z" />
+            <path d="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2m1 15h-2v-2h2zm0-4h-2V7h2z" />
+          </svg>
+          <h3 slot="heading">Unable to display app</h3>
+          <p slot="body">${__privateGet(this, _McpAppToolElement_instances, errorBody_get)}</p>
+        </forge-ai-empty-state>
+      </div>
+    `;
+};
+McpAppToolElement.styles = unsafeCSS(styles);
+__decorateClass([
+  property({ attribute: false })
+], McpAppToolElement.prototype, "toolCall", 2);
+__decorateClass([
+  property({ attribute: false })
+], McpAppToolElement.prototype, "toolDefinition", 2);
+__decorateClass([
+  consume({ context: mcpAppHostContext, subscribe: true }),
+  property({ attribute: false })
+], McpAppToolElement.prototype, "host", 2);
+__decorateClass([
+  query("iframe")
+], McpAppToolElement.prototype, "_iframe", 2);
+__decorateClass([
+  query(".container")
+], McpAppToolElement.prototype, "_container", 2);
+__decorateClass([
+  state()
+], McpAppToolElement.prototype, "_displayMode", 2);
+__decorateClass([
+  state()
+], McpAppToolElement.prototype, "_lifecycle", 2);
+__decorateClass([
+  state()
+], McpAppToolElement.prototype, "_pendingLink", 2);
+McpAppToolElement = __decorateClass([
+  customElement("forge-ai-mcp-app")
+], McpAppToolElement);
+export {
+  McpAppToolElement
+};