@modelcontextprotocol/ext-apps 0.4.1 → 0.4.2

package/dist/src/app-bridge.d.ts

@@ -49,12 +49,12 @@ export declare function getToolUiResourceUri(tool: Partial<Tool>): string | unde
  */
 export declare function buildAllowAttribute(permissions: McpUiResourcePermissions | undefined): string;
 /**
- * Options for configuring {@link AppBridge} behavior.
+ * Options for configuring {@link AppBridge `AppBridge`} behavior.
  *
- * @property hostContext - Optional initial host context to provide to the Guest UI
+ * @property hostContext - Optional initial host context to provide to the view
  *
  * @see `ProtocolOptions` from @modelcontextprotocol/sdk for available options
- * @see {@link McpUiHostContext} for the hostContext structure
+ * @see {@link McpUiHostContext `McpUiHostContext`} for the hostContext structure
  */
 export type HostOptions = ProtocolOptions & {
     hostContext?: McpUiHostContext;
@@ -77,35 +77,32 @@ export declare const SUPPORTED_PROTOCOL_VERSIONS: string[];
  */
 type RequestHandlerExtra = Parameters<Parameters<AppBridge["setRequestHandler"]>[1]>[1];
 /**
- * Host-side bridge for communicating with a single Guest UI ({@link app!App}).
+ * Host-side bridge for communicating with a single View ({@link app!App `App`}).
  *
  * `AppBridge` extends the MCP SDK's `Protocol` class and acts as a proxy between
- * the host application and a Guest UI running in an iframe. When an MCP client
+ * the host application and a view running in an iframe. When an MCP client
  * is provided to the constructor, it automatically forwards MCP server capabilities
- * (tools, resources, prompts) to the Guest UI. It also handles the initialization
+ * (tools, resources, prompts) to the view. It also handles the initialization
  * handshake.
  *
  * ## Architecture
  *
- * **Guest UI ↔ AppBridge ↔ Host ↔ MCP Server**
+ * **View ↔ AppBridge ↔ Host ↔ MCP Server**
  *
- * The bridge proxies requests from the Guest UI to the MCP server and forwards
+ * The bridge proxies requests from the view to the MCP server and forwards
  * responses back. It also sends host-initiated notifications like tool input
- * and results to the Guest UI.
+ * and results to the view.
  *
  * ## Lifecycle
  *
  * 1. **Create**: Instantiate `AppBridge` with MCP client and capabilities
  * 2. **Connect**: Call `connect()` with transport to establish communication
- * 3. **Wait for init**: Guest UI sends initialize request, bridge responds
- * 4. **Send data**: Call {@link sendToolInput}, {@link sendToolResult}, etc.
- * 5. **Teardown**: Call {@link teardownResource} before unmounting iframe
+ * 3. **Wait for init**: View sends initialize request, bridge responds
+ * 4. **Send data**: Call {@link sendToolInput `sendToolInput`}, {@link sendToolResult `sendToolResult`}, etc.
+ * 5. **Teardown**: Call {@link teardownResource `teardownResource`} before unmounting iframe
  *
  * @example Basic usage
- * ```typescript
- * import { AppBridge, PostMessageTransport } from '@modelcontextprotocol/ext-apps/app-bridge';
- * import { Client } from '@modelcontextprotocol/sdk/client/index.js';
- *
+ * ```ts source="./app-bridge.examples.ts#AppBridge_basicUsage"
  * // Create MCP client for the server
  * const client = new Client({
  *   name: "MyHost",
@@ -113,22 +110,22 @@ type RequestHandlerExtra = Parameters<Parameters<AppBridge["setRequestHandler"]>
  * });
  * await client.connect(serverTransport);
  *
- * // Create bridge for the Guest UI
+ * // Create bridge for the View
  * const bridge = new AppBridge(
  *   client,
  *   { name: "MyHost", version: "1.0.0" },
- *   { openLinks: {}, serverTools: {}, logging: {} }
+ *   { openLinks: {}, serverTools: {}, logging: {} },
  * );
  *
  * // Set up iframe and connect
- * const iframe = document.getElementById('app') as HTMLIFrameElement;
+ * const iframe = document.getElementById("app") as HTMLIFrameElement;
  * const transport = new PostMessageTransport(
  *   iframe.contentWindow!,
  *   iframe.contentWindow!,
  * );
  *
  * bridge.oninitialized = () => {
- *   console.log("Guest UI initialized");
+ *   console.log("View initialized");
  *   // Now safe to send tool input
  *   bridge.sendToolInput({ arguments: { location: "NYC" } });
  * };
@@ -147,79 +144,82 @@ export declare class AppBridge extends Protocol<AppRequest, AppNotification, App
      * Create a new AppBridge instance.
      *
      * @param _client - MCP client connected to the server, or `null`. When provided,
-     *   {@link connect} will automatically set up forwarding of MCP requests/notifications
-     *   between the Guest UI and the server. When `null`, you must register handlers
-     *   manually using the {@link oncalltool}, {@link onlistresources}, etc. setters.
+     *   {@link connect `connect`} will automatically set up forwarding of MCP requests/notifications
+     *   between the View and the server. When `null`, you must register handlers
+     *   manually using the {@link oncalltool `oncalltool`}, {@link onlistresources `onlistresources`}, etc. setters.
      * @param _hostInfo - Host application identification (name and version)
      * @param _capabilities - Features and capabilities the host supports
      * @param options - Configuration options (inherited from Protocol)
      *
      * @example With MCP client (automatic forwarding)
-     * ```typescript
+     * ```ts source="./app-bridge.examples.ts#AppBridge_constructor_withMcpClient"
      * const bridge = new AppBridge(
      *   mcpClient,
      *   { name: "MyHost", version: "1.0.0" },
-     *   { openLinks: {}, serverTools: {}, logging: {} }
+     *   { openLinks: {}, serverTools: {}, logging: {} },
      * );
      * ```
      *
      * @example Without MCP client (manual handlers)
-     * ```typescript
+     * ```ts source="./app-bridge.examples.ts#AppBridge_constructor_withoutMcpClient"
      * const bridge = new AppBridge(
      *   null,
      *   { name: "MyHost", version: "1.0.0" },
-     *   { openLinks: {}, serverTools: {}, logging: {} }
+     *   { openLinks: {}, serverTools: {}, logging: {} },
      * );
-     * bridge.oncalltool = async (params, extra) => { ... };
+     * bridge.oncalltool = async (params, extra) => {
+     *   // Handle tool calls manually
+     *   return { content: [] };
+     * };
      * ```
      */
     constructor(_client: Client | null, _hostInfo: Implementation, _capabilities: McpUiHostCapabilities, options?: HostOptions);
     /**
-     * Get the Guest UI's capabilities discovered during initialization.
+     * Get the view's capabilities discovered during initialization.
      *
-     * Returns the capabilities that the Guest UI advertised during its
+     * Returns the capabilities that the view advertised during its
      * initialization request. Returns `undefined` if called before
      * initialization completes.
      *
-     * @returns Guest UI capabilities, or `undefined` if not yet initialized
+     * @returns view capabilities, or `undefined` if not yet initialized
      *
-     * @example Check Guest UI capabilities after initialization
-     * ```typescript
+     * @example Check view capabilities after initialization
+     * ```ts source="./app-bridge.examples.ts#AppBridge_getAppCapabilities_checkAfterInit"
      * bridge.oninitialized = () => {
      *   const caps = bridge.getAppCapabilities();
      *   if (caps?.tools) {
-     *     console.log("Guest UI provides tools");
+     *     console.log("View provides tools");
      *   }
      * };
      * ```
      *
-     * @see {@link McpUiAppCapabilities} for the capabilities structure
+     * @see {@link McpUiAppCapabilities `McpUiAppCapabilities`} for the capabilities structure
      */
     getAppCapabilities(): McpUiAppCapabilities | undefined;
     /**
-     * Get the Guest UI's implementation info discovered during initialization.
+     * Get the view's implementation info discovered during initialization.
      *
-     * Returns the Guest UI's name and version as provided in its initialization
+     * Returns the view's name and version as provided in its initialization
      * request. Returns `undefined` if called before initialization completes.
      *
-     * @returns Guest UI implementation info, or `undefined` if not yet initialized
+     * @returns view implementation info, or `undefined` if not yet initialized
      *
-     * @example Log Guest UI information after initialization
-     * ```typescript
+     * @example Log view information after initialization
+     * ```ts source="./app-bridge.examples.ts#AppBridge_getAppVersion_logAfterInit"
      * bridge.oninitialized = () => {
      *   const appInfo = bridge.getAppVersion();
      *   if (appInfo) {
-     *     console.log(`Guest UI: ${appInfo.name} v${appInfo.version}`);
+     *     console.log(`View: ${appInfo.name} v${appInfo.version}`);
      *   }
      * };
      * ```
      */
     getAppVersion(): Implementation | undefined;
     /**
-     * Optional handler for ping requests from the Guest UI.
+     * Optional handler for ping requests from the view.
      *
-     * The Guest UI can send standard MCP `ping` requests to verify the connection
-     * is alive. The {@link AppBridge} automatically responds with an empty object, but this
+     * The View can send standard MCP `ping` requests to verify the connection
+     * is alive. The {@link AppBridge `AppBridge`} automatically responds with an empty object, but this
      * handler allows the host to observe or log ping activity.
      *
      * Unlike the other handlers which use setters, this is a direct property
@@ -229,25 +229,25 @@ export declare class AppBridge extends Protocol<AppRequest, AppNotification, App
      * @param extra - Request metadata (abort signal, session info)
      *
      * @example
-     * ```typescript
+     * ```ts source="./app-bridge.examples.ts#AppBridge_onping_handleRequest"
      * bridge.onping = (params, extra) => {
-     *   console.log("Received ping from Guest UI");
+     *   console.log("Received ping from view");
      * };
      * ```
      */
     onping?: (params: PingRequest["params"], extra: RequestHandlerExtra) => void;
     /**
-     * Register a handler for size change notifications from the Guest UI.
+     * Register a handler for size change notifications from the view.
      *
-     * The Guest UI sends `ui/notifications/size-changed` when its rendered content
+     * The view sends `ui/notifications/size-changed` when its rendered content
      * size changes, typically via `ResizeObserver`. Set this callback to dynamically
-     * adjust the iframe container dimensions based on the Guest UI's content.
+     * adjust the iframe container dimensions based on the view's content.
      *
-     * Note: This is for Guest UI → Host communication. To notify the Guest UI of
-     * host container dimension changes, use {@link setHostContext}.
+     * Note: This is for View → Host communication. To notify the View of
+     * host container dimension changes, use {@link setHostContext `setHostContext`}.
      *
      * @example
-     * ```typescript
+     * ```ts source="./app-bridge.examples.ts#AppBridge_onsizechange_handleResize"
      * bridge.onsizechange = ({ width, height }) => {
      *   if (width != null) {
      *     iframe.style.width = `${width}px`;
@@ -258,8 +258,8 @@ export declare class AppBridge extends Protocol<AppRequest, AppNotification, App
      * };
      * ```
      *
-     * @see {@link McpUiSizeChangedNotification} for the notification type
-     * @see {@link app!App.sendSizeChanged} - the Guest UI method that sends these notifications
+     * @see {@link McpUiSizeChangedNotification `McpUiSizeChangedNotification`} for the notification type
+     * @see {@link app!App.sendSizeChanged `App.sendSizeChanged`} - the View method that sends these notifications
      */
     set onsizechange(callback: (params: McpUiSizeChangedNotification["params"]) => void);
     /**
@@ -270,7 +270,7 @@ export declare class AppBridge extends Protocol<AppRequest, AppNotification, App
      * `ui/notifications/sandbox-proxy-ready` after it loads and is ready to receive
      * HTML content.
      *
-     * When this fires, the host should call {@link sendSandboxResourceReady} with
+     * When this fires, the host should call {@link sendSandboxResourceReady `sendSandboxResourceReady`} with
      * the HTML content to load into the inner sandboxed iframe.
      *
      * @example
@@ -289,32 +289,32 @@ export declare class AppBridge extends Protocol<AppRequest, AppNotification, App
      * ```
      *
      * @internal
-     * @see {@link McpUiSandboxProxyReadyNotification} for the notification type
-     * @see {@link sendSandboxResourceReady} for sending content to the sandbox
+     * @see {@link McpUiSandboxProxyReadyNotification `McpUiSandboxProxyReadyNotification`} for the notification type
+     * @see {@link sendSandboxResourceReady `sendSandboxResourceReady`} for sending content to the sandbox
      */
     set onsandboxready(callback: (params: McpUiSandboxProxyReadyNotification["params"]) => void);
     /**
-     * Called when the Guest UI completes initialization.
+     * Called when the view completes initialization.
      *
-     * Set this callback to be notified when the Guest UI has finished its
+     * Set this callback to be notified when the view has finished its
      * initialization handshake and is ready to receive tool input and other data.
      *
      * @example
-     * ```typescript
+     * ```ts source="./app-bridge.examples.ts#AppBridge_oninitialized_sendToolInput"
      * bridge.oninitialized = () => {
-     *   console.log("Guest UI ready");
+     *   console.log("View ready");
      *   bridge.sendToolInput({ arguments: toolArgs });
      * };
      * ```
      *
-     * @see {@link McpUiInitializedNotification} for the notification type
-     * @see {@link sendToolInput} for sending tool arguments to the Guest UI
+     * @see {@link McpUiInitializedNotification `McpUiInitializedNotification`} for the notification type
+     * @see {@link sendToolInput `sendToolInput`} for sending tool arguments to the View
      */
     set oninitialized(callback: (params: McpUiInitializedNotification["params"]) => void);
     /**
-     * Register a handler for message requests from the Guest UI.
+     * Register a handler for message requests from the view.
      *
-     * The Guest UI sends `ui/message` requests when it wants to add a message to
+     * The view sends `ui/message` requests when it wants to add a message to
      * the host's chat interface. This enables interactive apps to communicate with
      * the user through the conversation thread.
      *
@@ -330,7 +330,7 @@ export declare class AppBridge extends Protocol<AppRequest, AppNotification, App
      *   - Returns: `Promise<McpUiMessageResult>` with optional `isError` flag
      *
      * @example
-     * ```typescript
+     * ```ts source="./app-bridge.examples.ts#AppBridge_onmessage_logMessage"
      * bridge.onmessage = async ({ role, content }, extra) => {
      *   try {
      *     await chatManager.addMessage({ role, content, source: "app" });
@@ -342,14 +342,14 @@ export declare class AppBridge extends Protocol<AppRequest, AppNotification, App
      * };
      * ```
      *
-     * @see {@link McpUiMessageRequest} for the request type
-     * @see {@link McpUiMessageResult} for the result type
+     * @see {@link McpUiMessageRequest `McpUiMessageRequest`} for the request type
+     * @see {@link McpUiMessageResult `McpUiMessageResult`} for the result type
      */
     set onmessage(callback: (params: McpUiMessageRequest["params"], extra: RequestHandlerExtra) => Promise<McpUiMessageResult>);
     /**
-     * Register a handler for external link requests from the Guest UI.
+     * Register a handler for external link requests from the view.
      *
-     * The Guest UI sends `ui/open-link` requests when it wants to open an external
+     * The view sends `ui/open-link` requests when it wants to open an external
      * URL in the host's default browser. The handler should validate the URL and
      * open it according to the host's security policy and user preferences.
      *
@@ -365,7 +365,7 @@ export declare class AppBridge extends Protocol<AppRequest, AppNotification, App
      *   - Returns: `Promise<McpUiOpenLinkResult>` with optional `isError` flag
      *
      * @example
-     * ```typescript
+     * ```ts source="./app-bridge.examples.ts#AppBridge_onopenlink_handleRequest"
      * bridge.onopenlink = async ({ url }, extra) => {
      *   if (!isAllowedDomain(url)) {
      *     console.warn("Blocked external link:", url);
@@ -374,7 +374,7 @@ export declare class AppBridge extends Protocol<AppRequest, AppNotification, App
      *
      *   const confirmed = await showDialog({
      *     message: `Open external link?\n${url}`,
-     *     buttons: ["Open", "Cancel"]
+     *     buttons: ["Open", "Cancel"],
      *   });
      *
      *   if (confirmed) {
@@ -386,14 +386,14 @@ export declare class AppBridge extends Protocol<AppRequest, AppNotification, App
      * };
      * ```
      *
-     * @see {@link McpUiOpenLinkRequest} for the request type
-     * @see {@link McpUiOpenLinkResult} for the result type
+     * @see {@link McpUiOpenLinkRequest `McpUiOpenLinkRequest`} for the request type
+     * @see {@link McpUiOpenLinkResult `McpUiOpenLinkResult`} for the result type
      */
     set onopenlink(callback: (params: McpUiOpenLinkRequest["params"], extra: RequestHandlerExtra) => Promise<McpUiOpenLinkResult>);
     /**
-     * Register a handler for display mode change requests from the Guest UI.
+     * Register a handler for display mode change requests from the view.
      *
-     * The Guest UI sends `ui/request-display-mode` requests when it wants to change
+     * The view sends `ui/request-display-mode` requests when it wants to change
      * its display mode (e.g., from "inline" to "fullscreen"). The handler should
      * check if the requested mode is in `availableDisplayModes` from the host context,
      * update the display mode if supported, and return the actual mode that was set.
@@ -410,28 +410,23 @@ export declare class AppBridge extends Protocol<AppRequest, AppNotification, App
      *   - Returns: `Promise<McpUiRequestDisplayModeResult>` with the actual mode set
      *
      * @example
-     * ```typescript
-     * let currentDisplayMode: McpUiDisplayMode = "inline";
-     *
+     * ```ts source="./app-bridge.examples.ts#AppBridge_onrequestdisplaymode_handleRequest"
      * bridge.onrequestdisplaymode = async ({ mode }, extra) => {
-     *   const availableModes = hostContext.availableDisplayModes ?? ["inline"];
-     *   if (availableModes.includes(mode)) {
+     *   if (availableDisplayModes.includes(mode)) {
      *     currentDisplayMode = mode;
-     *     return { mode };
      *   }
-     *   // Return current mode if requested mode not available
      *   return { mode: currentDisplayMode };
      * };
      * ```
      *
-     * @see {@link McpUiRequestDisplayModeRequest} for the request type
-     * @see {@link McpUiRequestDisplayModeResult} for the result type
+     * @see {@link McpUiRequestDisplayModeRequest `McpUiRequestDisplayModeRequest`} for the request type
+     * @see {@link McpUiRequestDisplayModeResult `McpUiRequestDisplayModeResult`} for the result type
      */
     set onrequestdisplaymode(callback: (params: McpUiRequestDisplayModeRequest["params"], extra: RequestHandlerExtra) => Promise<McpUiRequestDisplayModeResult>);
     /**
-     * Register a handler for logging messages from the Guest UI.
+     * Register a handler for logging messages from the view.
      *
-     * The Guest UI sends standard MCP `notifications/message` (logging) notifications
+     * The view sends standard MCP `notifications/message` (logging) notifications
      * to report debugging information, errors, warnings, and other telemetry to the
      * host. The host can display these in a console, log them to a file, or send
      * them to a monitoring service.
@@ -445,22 +440,21 @@ export declare class AppBridge extends Protocol<AppRequest, AppNotification, App
      *   - `params.data` - Log message and optional structured data
      *
      * @example
-     * ```typescript
+     * ```ts source="./app-bridge.examples.ts#AppBridge_onloggingmessage_handleLog"
      * bridge.onloggingmessage = ({ level, logger, data }) => {
-     *   const prefix = logger ? `[${logger}]` : "[Guest UI]";
      *   console[level === "error" ? "error" : "log"](
-     *     `${prefix} ${level.toUpperCase()}:`,
-     *     data
+     *     `[${logger ?? "View"}] ${level.toUpperCase()}:`,
+     *     data,
      *   );
      * };
      * ```
      */
     set onloggingmessage(callback: (params: LoggingMessageNotification["params"]) => void);
     /**
-     * Register a handler for model context updates from the Guest UI.
+     * Register a handler for model context updates from the view.
      *
-     * The Guest UI sends `ui/update-model-context` requests to update the Host's
-     * model context. Each request overwrites the previous context stored by the Guest UI.
+     * The view sends `ui/update-model-context` requests to update the Host's
+     * model context. Each request overwrites the previous context stored by the view.
      * Unlike logging messages, context updates are intended to be available to
      * the model in future turns. Unlike messages, context updates do not trigger follow-ups.
      *
@@ -469,26 +463,24 @@ export declare class AppBridge extends Protocol<AppRequest, AppNotification, App
      * update received.
      *
      * @example
-     * ```typescript
-     * bridge.onupdatemodelcontext = async ({ content, structuredContent }, extra) => {
-     *   // Update the model context with the new snapshot
-     *   modelContext = {
-     *     type: "app_context",
-     *     content,
-     *     structuredContent,
-     *     timestamp: Date.now()
-     *   };
+     * ```ts source="./app-bridge.examples.ts#AppBridge_onupdatemodelcontext_storeContext"
+     * bridge.onupdatemodelcontext = async (
+     *   { content, structuredContent },
+     *   extra,
+     * ) => {
+     *   // Store the context snapshot for inclusion in the next model request
+     *   modelContextManager.update({ content, structuredContent });
      *   return {};
      * };
      * ```
      *
-     * @see {@link McpUiUpdateModelContextRequest} for the request type
+     * @see {@link McpUiUpdateModelContextRequest `McpUiUpdateModelContextRequest`} for the request type
      */
     set onupdatemodelcontext(callback: (params: McpUiUpdateModelContextRequest["params"], extra: RequestHandlerExtra) => Promise<EmptyResult>);
     /**
-     * Register a handler for tool call requests from the Guest UI.
+     * Register a handler for tool call requests from the view.
      *
-     * The Guest UI sends `tools/call` requests to execute MCP server tools. This
+     * The view sends `tools/call` requests to execute MCP server tools. This
      * handler allows the host to intercept and process these requests, typically
      * by forwarding them to the MCP server.
      *
@@ -498,12 +490,12 @@ export declare class AppBridge extends Protocol<AppRequest, AppNotification, App
      *   - `extra` - Request metadata (abort signal, session info)
      *
      * @example
-     * ```typescript
-     * bridge.oncalltool = async ({ name, arguments: args }, extra) => {
+     * ```ts source="./app-bridge.examples.ts#AppBridge_oncalltool_forwardToServer"
+     * bridge.oncalltool = async (params, extra) => {
      *   return mcpClient.request(
-     *     { method: "tools/call", params: { name, arguments: args } },
+     *     { method: "tools/call", params },
      *     CallToolResultSchema,
-     *     { signal: extra.signal }
+     *     { signal: extra.signal },
      *   );
      * };
      * ```
@@ -513,10 +505,10 @@ export declare class AppBridge extends Protocol<AppRequest, AppNotification, App
      */
     set oncalltool(callback: (params: CallToolRequest["params"], extra: RequestHandlerExtra) => Promise<CallToolResult>);
     /**
-     * Notify the Guest UI that the MCP server's tool list has changed.
+     * Notify the view that the MCP server's tool list has changed.
      *
-     * The host sends `notifications/tools/list_changed` to the Guest UI when it
-     * receives this notification from the MCP server. This allows the Guest UI
+     * The host sends `notifications/tools/list_changed` to the view when it
+     * receives this notification from the MCP server. This allows the view
      * to refresh its tool cache or UI accordingly.
      *
      * @param params - Optional notification params (typically empty)
@@ -533,9 +525,9 @@ export declare class AppBridge extends Protocol<AppRequest, AppNotification, App
      */
     sendToolListChanged(params?: ToolListChangedNotification["params"]): Promise<void>;
     /**
-     * Register a handler for list resources requests from the Guest UI.
+     * Register a handler for list resources requests from the view.
      *
-     * The Guest UI sends `resources/list` requests to enumerate available MCP
+     * The view sends `resources/list` requests to enumerate available MCP
      * resources. This handler allows the host to intercept and process these
      * requests, typically by forwarding them to the MCP server.
      *
@@ -545,12 +537,12 @@ export declare class AppBridge extends Protocol<AppRequest, AppNotification, App
      *   - `extra` - Request metadata (abort signal, session info)
      *
      * @example
-     * ```typescript
+     * ```ts source="./app-bridge.examples.ts#AppBridge_onlistresources_returnResources"
      * bridge.onlistresources = async (params, extra) => {
      *   return mcpClient.request(
      *     { method: "resources/list", params },
      *     ListResourcesResultSchema,
-     *     { signal: extra.signal }
+     *     { signal: extra.signal },
      *   );
      * };
      * ```
@@ -560,9 +552,9 @@ export declare class AppBridge extends Protocol<AppRequest, AppNotification, App
      */
     set onlistresources(callback: (params: ListResourcesRequest["params"], extra: RequestHandlerExtra) => Promise<ListResourcesResult>);
     /**
-     * Register a handler for list resource templates requests from the Guest UI.
+     * Register a handler for list resource templates requests from the view.
      *
-     * The Guest UI sends `resources/templates/list` requests to enumerate available
+     * The view sends `resources/templates/list` requests to enumerate available
      * MCP resource templates. This handler allows the host to intercept and process
      * these requests, typically by forwarding them to the MCP server.
      *
@@ -587,9 +579,9 @@ export declare class AppBridge extends Protocol<AppRequest, AppNotification, App
      */
     set onlistresourcetemplates(callback: (params: ListResourceTemplatesRequest["params"], extra: RequestHandlerExtra) => Promise<ListResourceTemplatesResult>);
     /**
-     * Register a handler for read resource requests from the Guest UI.
+     * Register a handler for read resource requests from the view.
      *
-     * The Guest UI sends `resources/read` requests to retrieve the contents of an
+     * The view sends `resources/read` requests to retrieve the contents of an
      * MCP resource. This handler allows the host to intercept and process these
      * requests, typically by forwarding them to the MCP server.
      *
@@ -599,12 +591,12 @@ export declare class AppBridge extends Protocol<AppRequest, AppNotification, App
      *   - `extra` - Request metadata (abort signal, session info)
      *
      * @example
-     * ```typescript
-     * bridge.onreadresource = async ({ uri }, extra) => {
+     * ```ts source="./app-bridge.examples.ts#AppBridge_onreadresource_returnResource"
+     * bridge.onreadresource = async (params, extra) => {
      *   return mcpClient.request(
-     *     { method: "resources/read", params: { uri } },
+     *     { method: "resources/read", params },
      *     ReadResourceResultSchema,
-     *     { signal: extra.signal }
+     *     { signal: extra.signal },
      *   );
      * };
      * ```
@@ -614,10 +606,10 @@ export declare class AppBridge extends Protocol<AppRequest, AppNotification, App
      */
     set onreadresource(callback: (params: ReadResourceRequest["params"], extra: RequestHandlerExtra) => Promise<ReadResourceResult>);
     /**
-     * Notify the Guest UI that the MCP server's resource list has changed.
+     * Notify the view that the MCP server's resource list has changed.
      *
-     * The host sends `notifications/resources/list_changed` to the Guest UI when it
-     * receives this notification from the MCP server. This allows the Guest UI
+     * The host sends `notifications/resources/list_changed` to the view when it
+     * receives this notification from the MCP server. This allows the view
      * to refresh its resource cache or UI accordingly.
      *
      * @param params - Optional notification params (typically empty)
@@ -634,9 +626,9 @@ export declare class AppBridge extends Protocol<AppRequest, AppNotification, App
      */
     sendResourceListChanged(params?: ResourceListChangedNotification["params"]): Promise<void>;
     /**
-     * Register a handler for list prompts requests from the Guest UI.
+     * Register a handler for list prompts requests from the view.
      *
-     * The Guest UI sends `prompts/list` requests to enumerate available MCP
+     * The view sends `prompts/list` requests to enumerate available MCP
      * prompts. This handler allows the host to intercept and process these
      * requests, typically by forwarding them to the MCP server.
      *
@@ -646,12 +638,12 @@ export declare class AppBridge extends Protocol<AppRequest, AppNotification, App
      *   - `extra` - Request metadata (abort signal, session info)
      *
      * @example
-     * ```typescript
+     * ```ts source="./app-bridge.examples.ts#AppBridge_onlistprompts_returnPrompts"
      * bridge.onlistprompts = async (params, extra) => {
      *   return mcpClient.request(
      *     { method: "prompts/list", params },
      *     ListPromptsResultSchema,
-     *     { signal: extra.signal }
+     *     { signal: extra.signal },
      *   );
      * };
      * ```
@@ -661,10 +653,10 @@ export declare class AppBridge extends Protocol<AppRequest, AppNotification, App
      */
     set onlistprompts(callback: (params: ListPromptsRequest["params"], extra: RequestHandlerExtra) => Promise<ListPromptsResult>);
     /**
-     * Notify the Guest UI that the MCP server's prompt list has changed.
+     * Notify the view that the MCP server's prompt list has changed.
      *
-     * The host sends `notifications/prompts/list_changed` to the Guest UI when it
-     * receives this notification from the MCP server. This allows the Guest UI
+     * The host sends `notifications/prompts/list_changed` to the view when it
+     * receives this notification from the MCP server. This allows the view
      * to refresh its prompt cache or UI accordingly.
      *
      * @param params - Optional notification params (typically empty)
@@ -710,7 +702,7 @@ export declare class AppBridge extends Protocol<AppRequest, AppNotification, App
      *
      * @returns Host capabilities object
      *
-     * @see {@link McpUiHostCapabilities} for the capabilities structure
+     * @see {@link McpUiHostCapabilities `McpUiHostCapabilities`} for the capabilities structure
      */
     getCapabilities(): McpUiHostCapabilities;
     /**
@@ -719,14 +711,14 @@ export declare class AppBridge extends Protocol<AppRequest, AppNotification, App
      */
     private _oninitialize;
     /**
-     * Update the host context and notify the Guest UI of changes.
+     * Update the host context and notify the view of changes.
      *
      * Compares fields present in the new context with the current context and sends a
      * `ui/notifications/host-context-changed` notification containing only fields
      * that have been added or modified. If no fields have changed, no notification is sent.
      * The new context fully replaces the internal state.
      *
-     * Common use cases include notifying the Guest UI when:
+     * Common use cases include notifying the view when:
      * - Theme changes (light/dark mode toggle)
      * - Viewport size changes (window resize)
      * - Display mode changes (inline/fullscreen)
@@ -735,26 +727,26 @@ export declare class AppBridge extends Protocol<AppRequest, AppNotification, App
      * @param hostContext - The complete new host context state
      *
      * @example Update theme when user toggles dark mode
-     * ```typescript
+     * ```ts source="./app-bridge.examples.ts#AppBridge_setHostContext_updateTheme"
      * bridge.setHostContext({ theme: "dark" });
      * ```
      *
      * @example Update multiple context fields
-     * ```typescript
+     * ```ts source="./app-bridge.examples.ts#AppBridge_setHostContext_updateMultiple"
      * bridge.setHostContext({
      *   theme: "dark",
-     *   containerDimensions: { maxHeight: 600, width: 800 }
+     *   containerDimensions: { maxHeight: 600, width: 800 },
      * });
      * ```
      *
-     * @see {@link McpUiHostContext} for the context structure
-     * @see {@link McpUiHostContextChangedNotification} for the notification type
+     * @see {@link McpUiHostContext `McpUiHostContext`} for the context structure
+     * @see {@link McpUiHostContextChangedNotification `McpUiHostContextChangedNotification`} for the notification type
      */
     setHostContext(hostContext: McpUiHostContext): void;
     /**
-     * Low-level method to notify the Guest UI of host context changes.
+     * Low-level method to notify the view of host context changes.
      *
-     * Most hosts should use {@link setHostContext} instead, which automatically
+     * Most hosts should use {@link setHostContext `setHostContext`} instead, which automatically
      * detects changes and calls this method with only the modified fields.
      * Use this directly only when you need fine-grained control over change detection.
      *
@@ -762,100 +754,100 @@ export declare class AppBridge extends Protocol<AppRequest, AppNotification, App
      */
     sendHostContextChange(params: McpUiHostContextChangedNotification["params"]): Promise<void> | void;
     /**
-     * Send complete tool arguments to the Guest UI.
+     * Send complete tool arguments to the view.
      *
-     * The host MUST send this notification after the Guest UI completes initialization
-     * (after {@link oninitialized} callback fires) and complete tool arguments become available.
-     * This notification is sent exactly once and is required before {@link sendToolResult}.
+     * The host MUST send this notification after the View completes initialization
+     * (after {@link oninitialized `oninitialized`} callback fires) and complete tool arguments become available.
+     * This notification is sent exactly once and is required before {@link sendToolResult `sendToolResult`}.
      *
      * @param params - Complete tool call arguments
      *
      * @example
-     * ```typescript
+     * ```ts source="./app-bridge.examples.ts#AppBridge_sendToolInput_afterInit"
      * bridge.oninitialized = () => {
      *   bridge.sendToolInput({
-     *     arguments: { location: "New York", units: "metric" }
+     *     arguments: { location: "New York", units: "metric" },
      *   });
      * };
      * ```
      *
-     * @see {@link McpUiToolInputNotification} for the notification type
-     * @see {@link oninitialized} for the initialization callback
-     * @see {@link sendToolResult} for sending results after execution
+     * @see {@link McpUiToolInputNotification `McpUiToolInputNotification`} for the notification type
+     * @see {@link oninitialized `oninitialized`} for the initialization callback
+     * @see {@link sendToolResult `sendToolResult`} for sending results after execution
      */
     sendToolInput(params: McpUiToolInputNotification["params"]): Promise<void>;
     /**
-     * Send streaming partial tool arguments to the Guest UI.
+     * Send streaming partial tool arguments to the view.
      *
      * The host MAY send this notification zero or more times while tool arguments
-     * are being streamed, before {@link sendToolInput} is called with complete
+     * are being streamed, before {@link sendToolInput `sendToolInput`} is called with complete
      * arguments. This enables progressive rendering of tool arguments in the
-     * Guest UI.
+     * view.
      *
-     * The arguments represent best-effort recovery of incomplete JSON. Guest UIs
+     * The arguments represent best-effort recovery of incomplete JSON. views
      * SHOULD handle missing or changing fields gracefully between notifications.
      *
      * @param params - Partial tool call arguments (may be incomplete)
      *
      * @example Stream partial arguments as they arrive
-     * ```typescript
+     * ```ts source="./app-bridge.examples.ts#AppBridge_sendToolInputPartial_streaming"
      * // As streaming progresses...
      * bridge.sendToolInputPartial({ arguments: { loc: "N" } });
      * bridge.sendToolInputPartial({ arguments: { location: "New" } });
      * bridge.sendToolInputPartial({ arguments: { location: "New York" } });
      *
      * // When complete, send final input
-     * bridge.sendToolInput({ arguments: { location: "New York", units: "metric" } });
+     * bridge.sendToolInput({
+     *   arguments: { location: "New York", units: "metric" },
+     * });
      * ```
      *
-     * @see {@link McpUiToolInputPartialNotification} for the notification type
-     * @see {@link sendToolInput} for sending complete arguments
+     * @see {@link McpUiToolInputPartialNotification `McpUiToolInputPartialNotification`} for the notification type
+     * @see {@link sendToolInput `sendToolInput`} for sending complete arguments
      */
     sendToolInputPartial(params: McpUiToolInputPartialNotification["params"]): Promise<void>;
     /**
-     * Send tool execution result to the Guest UI.
+     * Send tool execution result to the view.
      *
      * The host MUST send this notification when tool execution completes successfully,
-     * provided the UI is still displayed. If the UI was closed before execution
+     * provided the view is still displayed. If the view was closed before execution
      * completes, the host MAY skip this notification. This must be sent after
-     * {@link sendToolInput}.
+     * {@link sendToolInput `sendToolInput`}.
      *
      * @param params - Standard MCP tool execution result
      *
      * @example
-     * ```typescript
-     * import { CallToolResultSchema } from '@modelcontextprotocol/sdk/types.js';
-     *
+     * ```ts source="./app-bridge.examples.ts#AppBridge_sendToolResult_afterExecution"
      * const result = await mcpClient.request(
      *   { method: "tools/call", params: { name: "get_weather", arguments: args } },
-     *   CallToolResultSchema
+     *   CallToolResultSchema,
      * );
      * bridge.sendToolResult(result);
      * ```
      *
-     * @see {@link McpUiToolResultNotification} for the notification type
-     * @see {@link sendToolInput} for sending tool arguments before results
+     * @see {@link McpUiToolResultNotification `McpUiToolResultNotification`} for the notification type
+     * @see {@link sendToolInput `sendToolInput`} for sending tool arguments before results
      */
     sendToolResult(params: McpUiToolResultNotification["params"]): Promise<void>;
     /**
-     * Notify the Guest UI that tool execution was cancelled.
+     * Notify the view that tool execution was cancelled.
      *
      * The host MUST send this notification if tool execution was cancelled for any
      * reason, including user action, sampling error, classifier intervention, or
-     * any other interruption. This allows the Guest UI to update its state and
+     * any other interruption. This allows the view to update its state and
      * display appropriate feedback to the user.
      *
      * @param params - Cancellation details object
      *   - `reason`: Human-readable explanation for why the tool was cancelled
      *
      * @example User-initiated cancellation
-     * ```typescript
+     * ```ts source="./app-bridge.examples.ts#AppBridge_sendToolCancelled_userInitiated"
      * // User clicked "Cancel" button
      * bridge.sendToolCancelled({ reason: "User cancelled the operation" });
      * ```
      *
      * @example System-level cancellation
-     * ```typescript
+     * ```ts source="./app-bridge.examples.ts#AppBridge_sendToolCancelled_systemLevel"
      * // Sampling error or timeout
      * bridge.sendToolCancelled({ reason: "Request timeout after 30 seconds" });
      *
@@ -863,9 +855,9 @@ export declare class AppBridge extends Protocol<AppRequest, AppNotification, App
      * bridge.sendToolCancelled({ reason: "Content policy violation detected" });
      * ```
      *
-     * @see {@link McpUiToolCancelledNotification} for the notification type
-     * @see {@link sendToolResult} for sending successful results
-     * @see {@link sendToolInput} for sending tool arguments
+     * @see {@link McpUiToolCancelledNotification `McpUiToolCancelledNotification`} for the notification type
+     * @see {@link sendToolResult `sendToolResult`} for sending successful results
+     * @see {@link sendToolInput `sendToolInput`} for sending tool arguments
      */
     sendToolCancelled(params: McpUiToolCancelledNotification["params"]): Promise<void>;
     /**
@@ -881,27 +873,27 @@ export declare class AppBridge extends Protocol<AppRequest, AppNotification, App
      *   - `sandbox`: Optional sandbox attribute value (e.g., "allow-scripts")
      *
      * @internal
-     * @see {@link onsandboxready} for handling the sandbox proxy ready notification
+     * @see {@link onsandboxready `onsandboxready`} for handling the sandbox proxy ready notification
      */
     sendSandboxResourceReady(params: McpUiSandboxResourceReadyNotification["params"]): Promise<void>;
     /**
-     * Request graceful shutdown of the Guest UI.
+     * Request graceful shutdown of the view.
      *
      * The host MUST send this request before tearing down the UI resource (before
-     * unmounting the iframe). This gives the Guest UI an opportunity to save state,
+     * unmounting the iframe). This gives the view an opportunity to save state,
      * cancel pending operations, or show confirmation dialogs.
      *
      * The host SHOULD wait for the response before unmounting to prevent data loss.
      *
      * @param params - Empty params object
      * @param options - Request options (timeout, etc.)
-     * @returns Promise resolving when Guest UI confirms readiness for teardown
+     * @returns Promise resolving when view confirms readiness for teardown
      *
      * @example
-     * ```typescript
+     * ```ts source="./app-bridge.examples.ts#AppBridge_teardownResource_gracefulShutdown"
      * try {
      *   await bridge.teardownResource({});
-     *   // Guest UI is ready, safe to unmount iframe
+     *   // View is ready, safe to unmount iframe
      *   iframe.remove();
      * } catch (error) {
      *   console.error("Teardown failed:", error);
@@ -909,26 +901,26 @@ export declare class AppBridge extends Protocol<AppRequest, AppNotification, App
      * ```
      */
     teardownResource(params: McpUiResourceTeardownRequest["params"], options?: RequestOptions): Promise<Record<string, unknown>>;
-    /** @deprecated Use {@link teardownResource} instead */
+    /** @deprecated Use {@link teardownResource `teardownResource`} instead */
     sendResourceTeardown: AppBridge["teardownResource"];
     /**
-     * Connect to the Guest UI via transport and optionally set up message forwarding.
+     * Connect to the view via transport and optionally set up message forwarding.
      *
      * This method establishes the transport connection. If an MCP client was passed
      * to the constructor, it also automatically sets up request/notification forwarding
-     * based on the MCP server's capabilities, proxying the following to the Guest UI:
+     * based on the MCP server's capabilities, proxying the following to the view:
      * - Tools (tools/call, notifications/tools/list_changed)
      * - Resources (resources/list, resources/read, resources/templates/list, notifications/resources/list_changed)
      * - Prompts (prompts/list, notifications/prompts/list_changed)
      *
      * If no client was passed to the constructor, no automatic forwarding is set up
-     * and you must register handlers manually using the {@link oncalltool}, {@link onlistresources},
+     * and you must register handlers manually using the {@link oncalltool `oncalltool`}, {@link onlistresources `onlistresources`},
      * etc. setters.
      *
-     * After calling connect, wait for the {@link oninitialized} callback before sending
-     * tool input and other data to the Guest UI.
+     * After calling connect, wait for the {@link oninitialized `oninitialized`} callback before sending
+     * tool input and other data to the View.
      *
-     * @param transport - Transport layer (typically {@link PostMessageTransport})
+     * @param transport - Transport layer (typically {@link PostMessageTransport `PostMessageTransport`})
      * @returns Promise resolving when connection is established
      *
      * @throws {Error} If a client was passed but server capabilities are not available.
@@ -937,7 +929,7 @@ export declare class AppBridge extends Protocol<AppRequest, AppNotification, App
      *   before calling `bridge.connect()`.
      *
      * @example With MCP client (automatic forwarding)
-     * ```typescript
+     * ```ts source="./app-bridge.examples.ts#AppBridge_connect_withMcpClient"
      * const bridge = new AppBridge(mcpClient, hostInfo, capabilities);
      * const transport = new PostMessageTransport(
      *   iframe.contentWindow!,
@@ -945,7 +937,7 @@ export declare class AppBridge extends Protocol<AppRequest, AppNotification, App
      * );
      *
      * bridge.oninitialized = () => {
-     *   console.log("Guest UI ready");
+     *   console.log("View ready");
      *   bridge.sendToolInput({ arguments: toolArgs });
      * };
      *
@@ -953,12 +945,13 @@ export declare class AppBridge extends Protocol<AppRequest, AppNotification, App
      * ```
      *
      * @example Without MCP client (manual handlers)
-     * ```typescript
+     * ```ts source="./app-bridge.examples.ts#AppBridge_connect_withoutMcpClient"
      * const bridge = new AppBridge(null, hostInfo, capabilities);
      *
      * // Register handlers manually
      * bridge.oncalltool = async (params, extra) => {
      *   // Custom tool call handling
+     *   return { content: [] };
      * };
      *
      * await bridge.connect(transport);