Align spec terminology to teardown/termination instead of close/clearnup

Author: fredericbarthelet

specification/draft/apps.mdx

@@ -1285,9 +1285,11 @@ Host MUST send this notification if the tool execution was cancelled, for any re
 }
 ```
 
-Host MUST send this notification before tearing down the UI resource, for any reason, including user action, resource re-allocation, etc. The Host MAY specify the reason.
+Host MUST send this notification before tearing down the UI resource, for any reason, including user action, view-initiated teardown, resource re-allocation, etc. The Host MAY specify the reason.
 Host SHOULD wait for a response before tearing down the resource (to prevent data loss).
 
+#### Notifications (View → Host)
+
 `ui/notifications/size-changed` - View's size changed
 
 ```typescript
@@ -1303,30 +1305,25 @@ Host SHOULD wait for a response before tearing down the resource (to prevent dat
 
 The View SHOULD send this notification when rendered content body size changes (e.g. using ResizeObserver API to report up to date size).
 
-#### Notifications (View → Host)
-
-`ui/notifications/request-close` - View requests host to close it
+`ui/notifications/request-teardown` - View requests host to tear it down
 
 ```typescript
 {
   jsonrpc: "2.0",
-  method: "ui/notifications/request-close",
+  method: "ui/notifications/request-teardown",
   params: {}
 }
 ```
 
-The View MAY send this notification to request that the host close it. This enables View-initiated close flows (e.g., user clicks a "Done" button in the View).
+The View MAY send this notification to request that the host tear it down. This enables View-initiated teardown flows (e.g., user clicks a "Done" button in the View).
 
 **Host behavior:**
-- Host decides whether to proceed with the close
-- If approved, Host MUST send `ui/resource-teardown` to allow the View to perform cleanup
-- Host MUST wait for the View's teardown response before unmounting the iframe
-- Host MAY deny or defer the close request (e.g., if there are unsaved changes elsewhere)
+- Host decides whether to proceed with the teardown
+- If the Host accepts the request, it MUST follow the graceful termination process by sending `ui/resource-teardown` to the View. The Host SHOULD wait for a response before tearing down the resource (to prevent data loss).
 
 **View behavior:**
-- View SHOULD NOT perform cleanup before sending this notification
-- View SHOULD handle cleanup in its `ui/resource-teardown` handler
-- This ensures the View has a single cleanup procedure regardless of whether the close was initiated by the View or the Host
+- View MAY persist unsaved state before sending this notification.  processes MUST be completed before responding to `ui/resource-teardown` Host request.
+- View SHOULD NOT teardown its UI and assume it's going to be removed when sending this notification. Final teardown decision and timing remains Host responsibility.
 
 `ui/notifications/host-context-changed` - Host context has changed
 
@@ -1480,24 +1477,24 @@ sequenceDiagram
   end
 ```
 
-#### 4. Cleanup
+#### 4. Teardown
 
-Cleanup can be initiated by either the Host or the View. In both cases, the Host sends `ui/resource-teardown` to allow the View to perform cleanup before unmounting.
+The Host can tear down Views. Views may request teardown by sending `ui/notifications/request-teardown` to the Host. In any case, the Host MUST send `ui/resource-teardown` to allow the View to terminate gracefully.
 
 ```mermaid
 sequenceDiagram
   participant H as Host
   participant UI as View (iframe)
-  opt View-initiated close
-    UI ->> H: ui/notifications/request-close
+  opt View-initiated teardown
+    UI ->> H: ui/notifications/request-teardown
   end
   H ->> UI: ui/resource-teardown
   UI --> UI: Graceful termination
   UI -->> H: ui/resource-teardown response
   H -x H: Tear down iframe and listeners
 ```
 
-Note: Cleanup may be triggered at any point in the lifecycle following View initialization. If the View sends `ui/notifications/request-close`, the Host MAY deny or defer the request.
+Note: Teardown may be triggered at any point in the lifecycle following View initialization.
 
 #### Key Differences from Pre-SEP MCP-UI:
 

src/app-bridge.test.ts

@@ -521,30 +521,26 @@ describe("App <-> AppBridge integration", () => {
       ).rejects.toThrow("Context update failed");
     });
 
-    it("app.requestClose allows host to initiate teardown flow", async () => {
+    it("app.requestTeardown allows host to initiate teardown flow", async () => {
       const events: string[] = [];
 
-      // Host handles close request by initiating teardown
-      bridge.onrequestclose = async () => {
-        events.push("close-requested");
-        // Host decides to proceed with close - initiate teardown
+      bridge.onrequestteardown = async () => {
+        events.push("teardown-requested");
         await bridge.teardownResource({});
         events.push("teardown-complete");
       };
 
-      // App handles teardown (cleanup before unmount)
       app.onteardown = async () => {
         events.push("app-cleanup");
         return {};
       };
 
       await app.connect(appTransport);
-      await app.requestClose();
+      await app.requestTeardown();
       await flush();
 
-      // Verify the full flow: request → teardown → cleanup
       expect(events).toEqual([
-        "close-requested",
+        "teardown-requested",
         "app-cleanup",
         "teardown-complete",
       ]);

src/app-bridge.ts

@@ -74,8 +74,8 @@ import {
   McpUiDownloadFileResult,
   McpUiResourceTeardownRequest,
   McpUiResourceTeardownResultSchema,
-  McpUiRequestCloseNotification,
-  McpUiRequestCloseNotificationSchema,
+  McpUiRequestTeardownNotification,
+  McpUiRequestTeardownNotificationSchema,
   McpUiSandboxProxyReadyNotification,
   McpUiSandboxProxyReadyNotificationSchema,
   McpUiSizeChangedNotificationSchema,
@@ -676,36 +676,36 @@ export class AppBridge extends Protocol<
   }
 
   /**
-   * Register a handler for app-initiated close request notifications from the view.
+   * Register a handler for app-initiated teardown request notifications from the view.
    *
-   * The view sends `ui/notifications/request-close` when it wants the host to close it.
-   * If the host decides to proceed with the close, it should send
+   * The view sends `ui/notifications/request-teardown` when it wants the host to tear it down.
+   * If the host decides to proceed, it should send
    * `ui/resource-teardown` (via {@link teardownResource `teardownResource`}) to allow
-   * the view to perform cleanup, then unmount the iframe after the view responds.
+   * the view to perform gracefull termination, then unmount the iframe after the view responds.
    *
-   * @param callback - Handler that receives close request params
+   * @param callback - Handler that receives teardown request params
    *   - params - Empty object (reserved for future use)
    *
    * @example
    * ```typescript
-   * bridge.onrequestclose = async (params) => {
-   *   console.log("App requested close");
-   *   // Initiate teardown to allow the app to clean up
+   * bridge.onrequestteardown = async (params) => {
+   *   console.log("App requested teardown");
+   *   // Initiate teardown to allow the app to persist unsaved state
    *   // Alternatively, the callback can early return to prevent teardown
    *   await bridge.teardownResource({});
    *   // Now safe to unmount the iframe
    *   iframe.remove();
    * };
    * ```
    *
-   * @see {@link McpUiRequestCloseNotification `McpUiRequestCloseNotification`} for the notification type
+   * @see {@link McpUiRequestTeardownNotification `McpUiRequestTeardownNotification`} for the notification type
    * @see {@link teardownResource `teardownResource`} for initiating teardown
    */
-  set onrequestclose(
-    callback: (params: McpUiRequestCloseNotification["params"]) => void,
+  set onrequestteardown(
+    callback: (params: McpUiRequestTeardownNotification["params"]) => void,
   ) {
     this.setNotificationHandler(
-      McpUiRequestCloseNotificationSchema,
+      McpUiRequestTeardownNotificationSchema,
       (request) => callback(request.params),
     );
   }

src/app.ts

@@ -44,7 +44,7 @@ import {
   McpUiResourceTeardownRequest,
   McpUiResourceTeardownRequestSchema,
   McpUiResourceTeardownResult,
-  McpUiRequestCloseNotification,
+  McpUiRequestTeardownNotification,
   McpUiSizeChangedNotification,
   McpUiToolCancelledNotification,
   McpUiToolCancelledNotificationSchema,
@@ -178,7 +178,7 @@ type RequestHandlerExtra = Parameters<
  * 1. **Create**: Instantiate App with info and capabilities
  * 2. **Connect**: Call `connect()` to establish transport and perform handshake
  * 3. **Interactive**: Send requests, receive notifications, call tools
- * 4. **Cleanup**: Host sends teardown request before unmounting
+ * 4. **Teardown**: Host sends teardown request before unmounting
  *
  * ## Inherited Methods
  *
@@ -1136,45 +1136,45 @@ export class App extends Protocol<AppRequest, AppNotification, AppResult> {
   }
 
   /**
-   * Request the host to close this app.
+   * Request the host to tear down this app.
    *
-   * Apps call this method to request that the host close them. The host decides
-   * whether to proceed with the close - if approved, the host will send
-   * `ui/resource-teardown` to allow the app to perform cleanup before being
+   * Apps call this method to request that the host tear them down. The host
+   * decides whether to proceed - if approved, the host will send
+   * `ui/resource-teardown` to allow the app to perform gracefull termination before being
    * unmounted. This piggybacks on the existing teardown mechanism, ensuring
    * the app only needs a single shutdown procedure (via {@link onteardown `onteardown`})
-   * regardless of whether the close was initiated by the app or the host.
+   * regardless of whether the teardown was initiated by the app or the host.
    *
    * This is a fire-and-forget notification - no response is expected.
-   * If the host approves the close, the app will receive a `ui/resource-teardown`
-   * request via the {@link onteardown `onteardown`} handler to perform cleanup.
+   * If the host approves, the app will receive a `ui/resource-teardown`
+   * request via the {@link onteardown `onteardown`} handler to persist unsaved state.
    *
    * @param params - Empty params object (reserved for future use)
    * @returns Promise that resolves when the notification is sent
    *
-   * @example App-initiated close after user action
+   * @example App-initiated teardown after user action
    * ```typescript
    * // User clicks "Done" button in the app
    * async function handleDoneClick() {
-   *   // Request the host to close the app
-   *   await app.requestClose();
-   *   // If host approves, onteardown handler will be called for cleanup
+   *   // Request the host to tear down the app
+   *   await app.requestTeardown();
+   *   // If host approves, onteardown handler will be called for termination
    * }
    *
-   * // Set up teardown handler (called for both app-initiated and host-initiated close)
+   * // Set up teardown handler (called for both app-initiated and host-initiated teardown)
    * app.onteardown = async () => {
    *   await saveState();
    *   closeConnections();
    *   return {};
    * };
    * ```
    *
-   * @see {@link McpUiRequestCloseNotification `McpUiRequestCloseNotification`} for notification structure
-   * @see {@link onteardown `onteardown`} for the cleanup handler
+   * @see {@link McpUiRequestTeardownNotification `McpUiRequestTeardownNotification`} for notification structure
+   * @see {@link onteardown `onteardown`} for the graceful termination handler
    */
-  requestClose(params: McpUiRequestCloseNotification["params"] = {}) {
-    return this.notification(<McpUiRequestCloseNotification>{
-      method: "ui/notifications/request-close",
+  requestTeardown(params: McpUiRequestTeardownNotification["params"] = {}) {
+    return this.notification(<McpUiRequestTeardownNotification>{
+      method: "ui/notifications/request-teardown",
       params,
     });
   }

src/generated/schema.json

@@ -475,15 +475,15 @@ export interface McpUiSupportedContentBlockModalities {
 }
 
 /**
- * @description Notification for app-initiated close request (View -> Host).
- * Views send this to request that the host close them. The host decides
- * whether to proceed with the close - if approved, the host will send
+ * @description Notification for app-initiated teardown request (View -> Host).
+ * Views send this to request that the host tear them down. The host decides
+ * whether to proceed - if approved, the host will send
  * `ui/resource-teardown` to allow the view to perform cleanup before being
  * unmounted.
- * @see {@link app.App.requestClose} for the app method that sends this
+ * @see {@link app.App.requestTeardown} for the app method that sends this
  */
-export interface McpUiRequestCloseNotification {
-  method: "ui/notifications/request-close";
+export interface McpUiRequestTeardownNotification {
+  method: "ui/notifications/request-teardown";
   params?: {};
 }
 
@@ -813,8 +813,8 @@ export const TOOL_CANCELLED_METHOD: McpUiToolCancelledNotification["method"] =
   "ui/notifications/tool-cancelled";
 export const HOST_CONTEXT_CHANGED_METHOD: McpUiHostContextChangedNotification["method"] =
   "ui/notifications/host-context-changed";
-export const REQUEST_CLOSE_METHOD: McpUiRequestCloseNotification["method"] =
-  "ui/notifications/request-close";
+export const REQUEST_TEARDOWN_METHOD: McpUiRequestTeardownNotification["method"] =
+  "ui/notifications/request-teardown";
 export const RESOURCE_TEARDOWN_METHOD: McpUiResourceTeardownRequest["method"] =
   "ui/resource-teardown";
 export const INITIALIZE_METHOD: McpUiInitializeRequest["method"] =