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

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

@@ -1,61 +0,0 @@
-import { McpAppHostCapabilities, McpAppHostContext, McpAppResourceCsp, McpAppResourcePermissions, ToolCall } from '../../ai-chatbot';
-import { IMcpAppBridge, McpAppViewToolResult } from './mcp-app-bridge-types.js';
-/**
- * The view→host handler slots the element supplies; registered on the bridge BEFORE
- * `connect()` so they are live for the very first widget request.
- */
-export type McpAppHandlers = Pick<IMcpAppBridge, 'oncalltool' | 'onreadresource' | 'onopenlink' | 'onmessage' | 'onloggingmessage' | 'onsizechange' | 'onrequestdisplaymode' | 'onupdatemodelcontext' | 'onrequestteardown'>;
-export interface McpAppConnectConfig {
-    iframe: HTMLIFrameElement;
-    sandboxUrl: string;
-    html: string;
-    hostContext: McpAppHostContext;
-    hostCapabilities: McpAppHostCapabilities;
-    csp: McpAppResourceCsp;
-    permissions: McpAppResourcePermissions;
-    sandbox?: string;
-    handlers: McpAppHandlers;
-}
-/**
- * Compose the CSP header value the sandbox server expects on `?csp=` (spec "CSP
- * Construction from Metadata"). Empty allow-lists produce the restrictive default:
- * `connect-src 'none'`, `frame-src 'none'`, `base-uri 'self'`, `object-src 'none'`.
- */
-export declare function buildCspHeader(csp: McpAppResourceCsp): string;
-/**
- * The requested permissions the sandbox can enforce, normalized to the spec shape. A key
- * is requested when present (`{ camera: {} }`); `false`/`null` values are ignored.
- */
-export declare function enforcedPermissions(permissions: McpAppResourcePermissions): McpAppResourcePermissions;
-/** Map requested permissions onto the iframe `allow` attribute. */
-export declare function buildAllowAttribute(permissions: McpAppResourcePermissions): string;
-/**
- * Build the View's `CallToolResult` from the raw MCP result + structured content — never
- * from the model-facing `result`. When the backend omitted a field (size caps) the View
- * gets what remains; when both are missing it gets an empty `content` array, flagged
- * `isError` only if the tool call itself errored.
- */
-export declare function buildViewToolResult(toolCall: ToolCall): McpAppViewToolResult;
-/**
- * Drives an {@link IMcpAppBridge} through the sandbox handshake and the streaming
- * tool-call lifecycle. Bridge-agnostic — talks to the interface only.
- *
- * The controller owns the OUTER sandbox iframe DOM (its `src` with the `?csp=` param and
- * its `allow` attribute); the bridge owns the postMessage lifecycle.
- */
-export declare class McpAppBridgeController {
-    #private;
-    constructor(bridge: IMcpAppBridge);
-    connect(config: McpAppConnectConfig): Promise<void>;
-    /**
-     * Reconcile the widget with the current tool-call state. Streams partial args, sends
-     * final args once, then exactly one of `tool-result` (complete/error) or
-     * `tool-cancelled` — all gated on the `initialized` handshake. Safe to call on every
-     * `toolCall` update.
-     */
-    syncToolCall(toolCall: ToolCall): void;
-    /** Forward a host-context change; the bridge holds it until the View is initialized. */
-    sendHostContextChange(hostContext: McpAppHostContext): void;
-    /** Send `ui/resource-teardown` and release the bridge; the iframe is removed without waiting for the ack. */
-    teardown(): void;
-}

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

@@ -1,156 +0,0 @@
-const PERMISSION_FEATURES = {
-  camera: "camera",
-  microphone: "microphone",
-  geolocation: "geolocation",
-  clipboardWrite: "clipboard-write"
-};
-const UNSAFE_CSP_SOURCE = /[\s;,'"]/;
-function cspSources(domains, fallback) {
-  const safe = (domains ?? []).filter((domain) => !!domain && !UNSAFE_CSP_SOURCE.test(domain));
-  return safe.length ? safe.join(" ") : fallback;
-}
-function buildCspHeader(csp) {
-  const resource = cspSources(csp.resourceDomains, "");
-  const extra = resource ? ` ${resource}` : "";
-  return [
-    "default-src 'none'",
-    `script-src 'self' 'unsafe-inline'${extra}`,
-    `style-src 'self' 'unsafe-inline'${extra}`,
-    `img-src 'self' data:${extra}`,
-    `media-src 'self' data:${extra}`,
-    `font-src 'self' data:${extra}`,
-    `connect-src ${cspSources(csp.connectDomains, "'none'")}`,
-    `frame-src ${cspSources(csp.frameDomains, "'none'")}`,
-    `base-uri ${cspSources(csp.baseUriDomains, "'self'")}`,
-    "object-src 'none'"
-  ].join("; ");
-}
-function enforcedPermissions(permissions) {
-  const keys = Object.keys(PERMISSION_FEATURES).filter((key) => {
-    const value = permissions[key];
-    return value !== void 0 && value !== null && value !== false;
-  });
-  return Object.fromEntries(keys.map((key) => [key, {}]));
-}
-function buildAllowAttribute(permissions) {
-  return Object.keys(enforcedPermissions(permissions)).map((key) => PERMISSION_FEATURES[key]).join("; ");
-}
-function buildViewToolResult(toolCall) {
-  const mcpResult = toolCall.mcpResultOmitted ? void 0 : toolCall.mcpResult;
-  const structuredContent = toolCall.structuredContentOmitted ? void 0 : toolCall.structuredContent;
-  const isError = mcpResult?.isError ?? (toolCall.status === "error" || void 0);
-  return {
-    content: Array.isArray(mcpResult?.content) ? mcpResult.content : [],
-    ...structuredContent !== void 0 ? { structuredContent } : {},
-    ...isError !== void 0 ? { isError } : {},
-    ...mcpResult?._meta !== void 0 ? { _meta: mcpResult._meta } : {}
-  };
-}
-class McpAppBridgeController {
-  #bridge;
-  #connected = null;
-  #lastArgsSent = null;
-  #inputSent = false;
-  #outcome = "pending";
-  constructor(bridge) {
-    this.#bridge = bridge;
-  }
-  connect(config) {
-    if (this.#connected) {
-      return this.#connected;
-    }
-    Object.assign(this.#bridge, config.handlers);
-    const { iframe, sandboxUrl, csp, permissions } = config;
-    const outerAllow = buildAllowAttribute(permissions);
-    if (outerAllow) {
-      iframe.setAttribute("allow", outerAllow);
-    } else {
-      iframe.removeAttribute("allow");
-    }
-    const sandboxWindow = iframe.contentWindow;
-    if (!sandboxWindow) {
-      return Promise.reject(new Error("sandbox iframe has no contentWindow"));
-    }
-    let sandboxOrigin;
-    try {
-      sandboxOrigin = new URL(sandboxUrl, window.location.href).origin;
-    } catch {
-      return Promise.reject(new Error(`invalid sandbox URL: ${sandboxUrl}`));
-    }
-    if (sandboxOrigin === "null" || sandboxOrigin === window.location.origin) {
-      return Promise.reject(new Error("sandbox URL must be on a distinct, non-opaque origin"));
-    }
-    this.#connected = this.#bridge.connect({
-      sandboxWindow,
-      sandboxOrigin,
-      html: config.html,
-      hostContext: config.hostContext,
-      hostCapabilities: config.hostCapabilities,
-      permissions: enforcedPermissions(permissions),
-      sandbox: config.sandbox
-    });
-    const separator = sandboxUrl.includes("?") ? "&" : "?";
-    iframe.src = `${sandboxUrl}${separator}csp=${encodeURIComponent(buildCspHeader(csp))}`;
-    return this.#connected;
-  }
-  /**
-   * Reconcile the widget with the current tool-call state. Streams partial args, sends
-   * final args once, then exactly one of `tool-result` (complete/error) or
-   * `tool-cancelled` — all gated on the `initialized` handshake. Safe to call on every
-   * `toolCall` update.
-   */
-  syncToolCall(toolCall) {
-    if (!this.#connected || this.#outcome !== "pending") {
-      return;
-    }
-    void this.#connected.then(() => {
-      if (this.#outcome !== "pending") {
-        return;
-      }
-      if (toolCall.status === "cancelled") {
-        this.#outcome = "cancel-sent";
-        this.#bridge.sendToolCancelled();
-        return;
-      }
-      const partialArgs = this.#coerceArgs(toolCall.args);
-      const partialString = JSON.stringify(partialArgs);
-      if (!this.#inputSent && Object.keys(partialArgs).length && partialString !== this.#lastArgsSent) {
-        this.#lastArgsSent = partialString;
-        this.#bridge.sendToolInputPartial(partialArgs);
-      }
-      const isFinished = toolCall.status === "complete" || toolCall.status === "error";
-      if ((toolCall.status === "executing" || isFinished) && !this.#inputSent) {
-        this.#inputSent = true;
-        this.#bridge.sendToolInput(this.#coerceArgs(toolCall.args));
-      }
-      if (isFinished) {
-        this.#outcome = "result-sent";
-        this.#bridge.sendToolResult(buildViewToolResult(toolCall));
-      }
-    });
-  }
-  /** Forward a host-context change; the bridge holds it until the View is initialized. */
-  sendHostContextChange(hostContext) {
-    if (this.#connected) {
-      this.#bridge.sendHostContextChange(hostContext);
-    }
-  }
-  /** Send `ui/resource-teardown` and release the bridge; the iframe is removed without waiting for the ack. */
-  teardown() {
-    if (!this.#connected) {
-      return;
-    }
-    this.#outcome = "torn-down";
-    this.#bridge.sendTeardown();
-  }
-  #coerceArgs(args) {
-    return args && typeof args === "object" ? args : {};
-  }
-}
-export {
-  McpAppBridgeController,
-  buildAllowAttribute,
-  buildCspHeader,
-  buildViewToolResult,
-  enforcedPermissions
-};

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

@@ -1,123 +0,0 @@
-import { McpAppDisplayMode, McpAppHostCapabilities, McpAppHostContext, McpAppResourcePermissions, McpModelContextUpdateParams, McpResourceReadParams, McpToolCallParams, McpToolResult } from '../../ai-chatbot';
-/**
- * The host-side bridge surface `mcp-app-bridge.ts` (`McpAppBridge`) implements. The
- * element + controller depend on this interface only.
- */
-/**
- * A View's `tools/call` as received by the bridge. The bridge has no widget identity;
- * the element adds its `toolCallId` before forwarding to the host.
- */
-export type McpAppToolCallRequest = Omit<McpToolCallParams, 'toolCallId'>;
-/** A View's `resources/read` as received by the bridge (no widget identity). */
-export type McpAppResourceReadRequest = Omit<McpResourceReadParams, 'toolCallId'>;
-/** The `CallToolResult` delivered to the View via `ui/notifications/tool-result`. */
-export interface McpAppViewToolResult extends McpToolResult {
-    structuredContent?: unknown;
-}
-/** Parameters a widget passes to `ui/open-link`. */
-export interface McpAppOpenLinkParams {
-    url: string;
-}
-/**
- * Result of a View request the host may decline (`ui/open-link`, `ui/message`): `{}` on
- * success, `{ isError: true }` when the host refused or could not deliver it.
- */
-export interface McpAppRequestResult {
-    isError?: boolean;
-}
-/** Parameters a widget passes to `ui/message`. `role` is always `user` (never trusted from the View). */
-export interface McpAppMessageParams {
-    /** The View's MCP content blocks, unvalidated. */
-    content: unknown[];
-    role: 'user';
-}
-/** Parameters a widget passes to `ui/update-model-context` (no widget identity). */
-export type McpAppUpdateModelContextParams = Omit<McpModelContextUpdateParams, 'toolCallId'>;
-/** Parameters a widget passes to `ui/request-display-mode`. */
-export interface McpAppRequestDisplayModeParams {
-    mode: McpAppDisplayMode;
-    /** Modes the View declared in `ui/initialize` (`appCapabilities.availableDisplayModes`). */
-    appDisplayModes: McpAppDisplayMode[];
-}
-/** Result the host returns for a display-mode request — echoes the mode actually set. */
-export interface McpAppRequestDisplayModeResult {
-    mode: McpAppDisplayMode;
-}
-/** Payload for a widget `notifications/message` (logging). */
-export interface McpAppLoggingMessage {
-    level: string;
-    data?: unknown;
-    logger?: string;
-}
-/** Payload for a widget `size-changed` notification. */
-export interface McpAppSizeChange {
-    width?: number;
-    height: number;
-}
-/**
- * Config for the `ui/initialize` handshake and injecting the resource into the sandbox.
- *
- * The controller owns the outer sandbox iframe DOM (setting `src` with the `?csp=` query
- * param + the outer `allow` attribute); it hands the bridge the loaded iframe's
- * `contentWindow` so the bridge can scope its transport to that window and drive the
- * `sandbox-proxy-ready` → `sandbox-resource-ready` → `initialized` handshake. All fields
- * are bridge-agnostic (no ext-apps types leak through this surface).
- */
-export interface McpAppBridgeConnectConfig {
-    /** The loaded outer sandbox proxy iframe's window; the bridge scopes its transport here. */
-    sandboxWindow: Window;
-    /** Origin of the sandbox proxy; only messages from it are accepted and all posts target it. */
-    sandboxOrigin: string;
-    /** The complete standalone app HTML to inject into the inner sandboxed frame. */
-    html: string;
-    /** Initial host context sent to the widget on `ui/initialize`. */
-    hostContext: McpAppHostContext;
-    /** Iframe permission policy forwarded to the inner frame via `sandbox-resource-ready`. */
-    permissions?: McpAppResourcePermissions;
-    /** Optional override for the inner iframe's `sandbox` attribute. */
-    sandbox?: string;
-    /** Advertised to the View in the `ui/initialize` result. */
-    hostCapabilities: McpAppHostCapabilities;
-}
-export interface IMcpAppBridge {
-    /**
-     * Connect to the loaded sandbox proxy: perform the `ui/initialize` handshake and send
-     * the resource in via `sandbox-resource-ready`. Resolves once the widget has sent
-     * `initialized`. The host MUST NOT send tool input before this resolves.
-     */
-    connect(config: McpAppBridgeConnectConfig): Promise<void>;
-    /** Streaming partial tool arguments (each args delta). */
-    sendToolInputPartial(args: Record<string, unknown>): void;
-    /** Final, complete tool arguments (args complete). */
-    sendToolInput(args: Record<string, unknown>): void;
-    /** The final tool result, built from the raw MCP result + structured content. */
-    sendToolResult(result: McpAppViewToolResult): void;
-    /** Notify the widget its tool call was cancelled. */
-    sendToolCancelled(reason?: string): void;
-    /**
-     * Push an updated host context (e.g. theme or container-size change). Before the View
-     * is initialized the change is held and returned from `ui/initialize` / flushed on
-     * `initialized` instead of being sent.
-     */
-    sendHostContextChange(hostContext: McpAppHostContext): void;
-    /** Notify the widget it is being torn down (`ui/resource-teardown`) and release the bridge without waiting for the ack. */
-    sendTeardown(): void;
-    /** Widget forwarded a `tools/call` to the server. Rejections become JSON-RPC errors. */
-    oncalltool?: (params: McpAppToolCallRequest) => Promise<unknown>;
-    /** Widget forwarded a `resources/read` to the server. Rejections become JSON-RPC errors. */
-    onreadresource?: (params: McpAppResourceReadRequest) => Promise<unknown>;
-    /** Widget requested opening an external link. Absent → `{ isError: true }`. */
-    onopenlink?: (params: McpAppOpenLinkParams) => Promise<McpAppRequestResult>;
-    /** Widget sent a chat message (`ui/message`). Absent → `{ isError: true }`. */
-    onmessage?: (params: McpAppMessageParams) => Promise<McpAppRequestResult>;
-    /** Widget emitted a logging message (`notifications/message`). */
-    onloggingmessage?: (params: McpAppLoggingMessage) => void;
-    /** Widget reported a size change. */
-    onsizechange?: (params: McpAppSizeChange) => void;
-    /** Widget requested a display-mode change; the host echoes the resulting mode. */
-    onrequestdisplaymode?: (params: McpAppRequestDisplayModeParams) => Promise<McpAppRequestDisplayModeResult>;
-    /** Widget requested a silent model-context update. */
-    onupdatemodelcontext?: (params: McpAppUpdateModelContextParams) => Promise<void>;
-    /** Widget asked the host to tear it down (`ui/notifications/request-teardown`). */
-    onrequestteardown?: () => void;
-}

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

@@ -1,41 +0,0 @@
-import { McpAppHostContext } from '../../ai-chatbot';
-import { IMcpAppBridge, McpAppBridgeConnectConfig, McpAppViewToolResult } from './mcp-app-bridge-types.js';
-/**
- * Hand-rolled, zero-dependency {@link IMcpAppBridge}. A `postMessage` listener speaking
- * JSON-RPC 2.0 directly: no SDK, no zod, no schema validation. The cross-origin sandbox
- * iframe is the security boundary here, not message-schema checking — every inbound
- * field is narrowed defensively before use.
- *
- * Drives the handshake against the sandbox proxy (`packages/ai/sandbox/sandbox.js`):
- * `sandbox-proxy-ready` -> `sandbox-resource-ready` -> `ui/initialize` ->
- * `ui/notifications/initialized`, then streaming `ui/notifications/*`. Forwards
- * non-`ui/` methods (`tools/call`, `resources/read`) to the same handler slots the
- * interface defines.
- */
-export declare class McpAppBridge implements IMcpAppBridge {
-    #private;
-    oncalltool?: IMcpAppBridge['oncalltool'];
-    onreadresource?: IMcpAppBridge['onreadresource'];
-    onopenlink?: IMcpAppBridge['onopenlink'];
-    onmessage?: IMcpAppBridge['onmessage'];
-    onloggingmessage?: IMcpAppBridge['onloggingmessage'];
-    onsizechange?: IMcpAppBridge['onsizechange'];
-    onrequestdisplaymode?: IMcpAppBridge['onrequestdisplaymode'];
-    onupdatemodelcontext?: IMcpAppBridge['onupdatemodelcontext'];
-    onrequestteardown?: IMcpAppBridge['onrequestteardown'];
-    constructor(hostInfo: {
-        name: string;
-        version: string;
-    });
-    connect(config: McpAppBridgeConnectConfig): Promise<void>;
-    sendToolInputPartial(args: Record<string, unknown>): void;
-    sendToolInput(args: Record<string, unknown>): void;
-    sendToolResult(result: McpAppViewToolResult): void;
-    sendToolCancelled(reason?: string): void;
-    sendHostContextChange(hostContext: McpAppHostContext): void;
-    /**
-     * Send `ui/resource-teardown` and dispose immediately; the host doesn't wait for the ack,
-     * so the iframe is removed right away. A View that never initialized isn't messaged.
-     */
-    sendTeardown(): void;
-}

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

@@ -1,293 +0,0 @@
-const PROTOCOL_VERSION = "2026-01-26";
-const METHOD_NOT_FOUND = -32601;
-const INVALID_PARAMS = -32602;
-const SERVER_ERROR = -32e3;
-const DISPLAY_MODES = ["inline", "fullscreen", "pip"];
-class JsonRpcError extends Error {
-  constructor(config) {
-    super(config.message);
-    this.code = config.code;
-  }
-}
-function invalidParams(message) {
-  return new JsonRpcError({ code: INVALID_PARAMS, message });
-}
-function methodNotFound(method) {
-  return new JsonRpcError({ code: METHOD_NOT_FOUND, message: `Method not found: ${method}` });
-}
-function asParams(params) {
-  if (params === void 0 || params === null) {
-    return {};
-  }
-  if (typeof params !== "object" || Array.isArray(params)) {
-    throw invalidParams("params must be an object");
-  }
-  return params;
-}
-function asJsonRpc(data) {
-  if (!data || typeof data !== "object") {
-    return null;
-  }
-  const payload = data;
-  return payload.jsonrpc === "2.0" ? payload : null;
-}
-function asDisplayModes(value) {
-  return Array.isArray(value) ? DISPLAY_MODES.filter((mode) => value.includes(mode)) : [];
-}
-class McpAppBridge {
-  #hostInfo;
-  #capabilities = {};
-  #phase = "idle";
-  #sandboxWindow = null;
-  #sandboxOrigin = "";
-  #hostContext = { theme: "light" };
-  /** The host context the View last received (in the `ui/initialize` result or a change notification). */
-  #deliveredHostContext = null;
-  #appDisplayModes = [];
-  #nextId = 1;
-  #pending = /* @__PURE__ */ new Map();
-  #resolveProxyReady;
-  #initialized = null;
-  #resolveInitialized;
-  constructor(hostInfo) {
-    this.#hostInfo = hostInfo;
-  }
-  connect(config) {
-    if (this.#phase !== "idle") {
-      throw new Error("Bridge has already been connected; create a new bridge per widget.");
-    }
-    this.#phase = "connecting";
-    this.#capabilities = config.hostCapabilities;
-    this.#hostContext = config.hostContext;
-    this.#sandboxWindow = config.sandboxWindow;
-    this.#sandboxOrigin = config.sandboxOrigin;
-    window.addEventListener("message", this.#handleMessage);
-    const proxyReady = new Promise((resolve) => {
-      this.#resolveProxyReady = resolve;
-    });
-    this.#initialized = new Promise((resolve) => {
-      this.#resolveInitialized = resolve;
-    }).then(() => {
-      this.#phase = "ready";
-      this.#flushHostContext();
-    });
-    return proxyReady.then(
-      () => this.#sendNotification("ui/notifications/sandbox-resource-ready", {
-        html: config.html,
-        permissions: config.permissions,
-        sandbox: config.sandbox
-      })
-    ).then(() => this.#initialized);
-  }
-  sendToolInputPartial(args) {
-    this.#sendNotification("ui/notifications/tool-input-partial", { arguments: args });
-  }
-  sendToolInput(args) {
-    this.#sendNotification("ui/notifications/tool-input", { arguments: args });
-  }
-  sendToolResult(result) {
-    this.#sendNotification("ui/notifications/tool-result", result);
-  }
-  sendToolCancelled(reason) {
-    this.#sendNotification("ui/notifications/tool-cancelled", { reason: reason ?? "cancelled" });
-  }
-  sendHostContextChange(hostContext) {
-    this.#hostContext = hostContext;
-    if (this.#phase === "ready") {
-      this.#flushHostContext();
-    }
-  }
-  /**
-   * Send `ui/resource-teardown` and dispose immediately; the host doesn't wait for the ack,
-   * so the iframe is removed right away. A View that never initialized isn't messaged.
-   */
-  sendTeardown() {
-    if (this.#phase === "ready") {
-      this.#sendRequest("ui/resource-teardown", {}).catch(() => void 0);
-    }
-    this.#dispose();
-  }
-  #flushHostContext() {
-    if (this.#hostContext === this.#deliveredHostContext) {
-      return;
-    }
-    this.#deliveredHostContext = this.#hostContext;
-    this.#sendNotification("ui/notifications/host-context-changed", this.#hostContext);
-  }
-  /** Release the `message` listener + reject any in-flight requests. Idempotent. */
-  #dispose() {
-    this.#phase = "disposed";
-    window.removeEventListener("message", this.#handleMessage);
-    for (const pending of this.#pending.values()) {
-      pending.reject(new Error("Bridge disposed"));
-    }
-    this.#pending.clear();
-    this.#sandboxWindow = null;
-  }
-  #handleMessage = (event) => {
-    if (event.source !== this.#sandboxWindow || event.origin !== this.#sandboxOrigin) {
-      return;
-    }
-    const payload = asJsonRpc(event.data);
-    if (!payload || typeof payload.method !== "string") {
-      if (payload && payload.id !== void 0) {
-        this.#handleResponse(payload);
-      } else if (payload) {
-        console.warn("[forge-ai-mcp-app] Ignoring malformed JSON-RPC message", event.data);
-      }
-      return;
-    }
-    if (payload.id !== void 0) {
-      void this.#handleRequest(payload.method, payload.params, payload.id);
-    } else {
-      this.#handleNotification(payload.method, payload.params);
-    }
-  };
-  #handleResponse(payload) {
-    const id = payload.id;
-    const pending = this.#pending.get(id);
-    if (!pending) {
-      return;
-    }
-    this.#pending.delete(id);
-    if (payload.error) {
-      pending.reject(new Error(payload.error.message));
-    } else {
-      pending.resolve(payload.result);
-    }
-  }
-  async #handleRequest(method, params, id) {
-    try {
-      const result = await this.#dispatchRequest(method, params);
-      this.#post({ jsonrpc: "2.0", id, result: result ?? {} });
-    } catch (error) {
-      this.#post({
-        jsonrpc: "2.0",
-        id,
-        error: {
-          code: error instanceof JsonRpcError ? error.code : SERVER_ERROR,
-          message: error instanceof Error ? error.message : "Request failed"
-        }
-      });
-    }
-  }
-  /** Unknown or unadvertised methods (`tools/list`, `sampling/createMessage`, `ui/download-file`, …) reject with -32601. */
-  async #dispatchRequest(method, params) {
-    const p = asParams(params);
-    switch (method) {
-      case "ui/initialize": {
-        const appCapabilities = p.appCapabilities ?? {};
-        this.#appDisplayModes = asDisplayModes(appCapabilities.availableDisplayModes);
-        this.#deliveredHostContext = this.#hostContext;
-        return {
-          protocolVersion: PROTOCOL_VERSION,
-          hostInfo: this.#hostInfo,
-          hostCapabilities: this.#capabilities,
-          hostContext: this.#hostContext
-        };
-      }
-      case "ui/open-link":
-        if (typeof p.url !== "string") {
-          throw invalidParams("ui/open-link requires a string url");
-        }
-        return await this.onopenlink?.({ url: p.url }) ?? { isError: true };
-      case "ui/message":
-        if (!Array.isArray(p.content)) {
-          throw invalidParams("ui/message requires a content array");
-        }
-        return await this.onmessage?.({ content: p.content, role: "user" }) ?? { isError: true };
-      case "ui/update-model-context":
-        await this.onupdatemodelcontext?.({
-          content: Array.isArray(p.content) ? p.content : void 0,
-          structuredContent: p.structuredContent
-        });
-        return {};
-      case "ui/request-display-mode": {
-        const current = this.#hostContext.displayMode ?? "inline";
-        const [mode] = asDisplayModes([p.mode]);
-        if (!mode || !this.onrequestdisplaymode) {
-          return { mode: current };
-        }
-        return this.onrequestdisplaymode({ mode, appDisplayModes: this.#appDisplayModes });
-      }
-      case "ui/resource-teardown":
-      case "ping":
-        return {};
-      case "tools/call":
-        if (!this.oncalltool || !this.#capabilities.serverTools) {
-          throw methodNotFound(method);
-        }
-        this.#assertReady(method);
-        if (typeof p.name !== "string" || !p.name) {
-          throw invalidParams("tools/call requires a tool name");
-        }
-        return this.oncalltool({ name: p.name, arguments: asParams(p.arguments) });
-      case "resources/read":
-        if (!this.onreadresource) {
-          throw methodNotFound(method);
-        }
-        this.#assertReady(method);
-        if (typeof p.uri !== "string" || !p.uri) {
-          throw invalidParams("resources/read requires a uri");
-        }
-        return this.onreadresource({ uri: p.uri });
-      default:
-        throw methodNotFound(method);
-    }
-  }
-  /** Server-bound requests reach the adapter only after the View completes the handshake. */
-  #assertReady(method) {
-    if (this.#phase !== "ready") {
-      throw new JsonRpcError({
-        code: SERVER_ERROR,
-        message: `${method} is not allowed before ui/notifications/initialized`
-      });
-    }
-  }
-  #handleNotification(method, params) {
-    const p = params && typeof params === "object" ? params : {};
-    switch (method) {
-      case "ui/notifications/sandbox-proxy-ready":
-        this.#resolveProxyReady?.();
-        return;
-      case "ui/notifications/initialized":
-        this.#resolveInitialized?.();
-        return;
-      case "ui/notifications/size-changed":
-        this.onsizechange?.({
-          width: typeof p.width === "number" ? p.width : void 0,
-          height: typeof p.height === "number" ? p.height : 0
-        });
-        return;
-      case "notifications/message":
-        this.onloggingmessage?.({
-          level: typeof p.level === "string" ? p.level : "info",
-          logger: typeof p.logger === "string" ? p.logger : void 0,
-          data: p.data
-        });
-        return;
-      case "ui/notifications/request-teardown":
-        this.onrequestteardown?.();
-        return;
-      default:
-        console.warn(`[forge-ai-mcp-app] Unhandled notification method: ${method}`);
-        return;
-    }
-  }
-  #sendNotification(method, params) {
-    this.#post({ jsonrpc: "2.0", method, params });
-  }
-  #sendRequest(method, params) {
-    const id = this.#nextId++;
-    return new Promise((resolve, reject) => {
-      this.#pending.set(id, { resolve, reject });
-      this.#post({ jsonrpc: "2.0", id, method, params });
-    });
-  }
-  #post(data) {
-    this.#sandboxWindow?.postMessage(data, this.#sandboxOrigin);
-  }
-}
-export {
-  McpAppBridge
-};