Update to update-model-context

Author: idosal

specification/draft/apps.mdx

@@ -533,14 +533,14 @@ Host SHOULD open the URL in the user's default browser or a new tab.
 
 Host SHOULD add the message to the conversation thread, preserving the specified role.
 
-`ui/update-context` - Update the agent's conversation context
+`ui/update-model-context` - Update the model context
 
 ```typescript
 // Request
 {
   jsonrpc: "2.0",
   id: 3,
-  method: "ui/update-context",
+  method: "ui/update-model-context",
   params: {
     role: "user",
     content: ContentBlock[]
@@ -565,12 +565,13 @@ Host SHOULD add the message to the conversation thread, preserving the specified
 }
 ```
 
-Guest UI MAY send this request to inform the agent about app state changes that should be stored in the conversation context for future reasoning. This event serves a different use case from `notifications/message` (logging) and `ui/message` (which also trigger follow-ups).
+Guest UI MAY send this request to update the Host's model context. This context will be used in future turns. Each request overwrites the previous context sent by the Guest UI.
+This event serves a different use case from `notifications/message` (logging) and `ui/message` (which also trigger follow-ups).
 
 Host behavior:
-- SHOULD store the context update in the conversation context
+- SHOULD store the context snapshot in the conversation context
+- SHOULD overwrite the previous model context with the new update
 - MAY display context updates to the user
-- MAY filter or aggregate context updates
 
 #### Notifications (Host → UI)
 
@@ -806,9 +807,9 @@ sequenceDiagram
       H -->> UI: ui/message response
       H -->> H: Process message and follow up
     else Context update
-      UI ->> H: ui/update-context
-      H ->> H: Store in conversation context
-      H -->> UI: ui/update-context response
+      UI ->> H: ui/update-model-context
+      H ->> H: Store model context (overwrite existing)
+      H -->> UI: ui/update-model-context response
     else Log
       UI ->> H: notifications/message
       H ->> H: Record log for debugging/telemetry

src/app-bridge.test.ts

@@ -213,15 +213,15 @@ describe("App <-> AppBridge integration", () => {
       });
     });
 
-    it("app.sendUpdateContext triggers bridge.onupdatecontext and returns result", async () => {
+    it("app.sendUpdateModelContext triggers bridge.onupdatemodelcontext and returns result", async () => {
       const receivedContexts: unknown[] = [];
-      bridge.onupdatecontext = async (params) => {
+      bridge.onupdatemodelcontext = async (params) => {
         receivedContexts.push(params);
         return {};
       };
 
       await app.connect(appTransport);
-      const result = await app.sendUpdateContext({
+      const result = await app.sendUpdateModelContext({
         role: "user",
         content: [{ type: "text", text: "User selected 3 items" }],
       });
@@ -234,15 +234,15 @@ describe("App <-> AppBridge integration", () => {
       expect(result).toEqual({});
     });
 
-    it("app.sendUpdateContext works with multiple content blocks", async () => {
+    it("app.sendUpdateModelContext works with multiple content blocks", async () => {
       const receivedContexts: unknown[] = [];
-      bridge.onupdatecontext = async (params) => {
+      bridge.onupdatemodelcontext = async (params) => {
         receivedContexts.push(params);
         return {};
       };
 
       await app.connect(appTransport);
-      const result = await app.sendUpdateContext({
+      const result = await app.sendUpdateModelContext({
         role: "user",
         content: [
           { type: "text", text: "Filter applied" },
@@ -261,13 +261,13 @@ describe("App <-> AppBridge integration", () => {
       expect(result).toEqual({});
     });
 
-    it("app.sendUpdateContext returns error result when handler indicates error", async () => {
-      bridge.onupdatecontext = async () => {
+    it("app.sendUpdateModelContext returns error result when handler indicates error", async () => {
+      bridge.onupdatemodelcontext = async () => {
         return { isError: true };
       };
 
       await app.connect(appTransport);
-      const result = await app.sendUpdateContext({
+      const result = await app.sendUpdateModelContext({
         role: "user",
         content: [{ type: "text", text: "Test" }],
       });

src/app-bridge.ts

@@ -39,9 +39,9 @@ import {
   type McpUiToolResultNotification,
   LATEST_PROTOCOL_VERSION,
   McpUiAppCapabilities,
-  McpUiUpdateContextRequest,
-  McpUiUpdateContextRequestSchema,
-  McpUiUpdateContextResult,
+  McpUiUpdateModelContextRequest,
+  McpUiUpdateModelContextRequestSchema,
+  McpUiUpdateModelContextResult,
   McpUiHostCapabilities,
   McpUiHostContext,
   McpUiHostContextChangedNotification,
@@ -506,30 +506,24 @@ export class AppBridge extends Protocol<Request, Notification, Result> {
   }
 
   /**
-   * Register a handler for context updates from the Guest UI.
+   * Register a handler for model context updates from the Guest UI.
    *
-   * The Guest UI sends `ui/update-context` requests to inform the agent
-   * about app state changes that should be stored in the conversation context for
-   * future reasoning. Unlike logging messages, context updates are intended to be
-   * available to the agent for decision making.
-   *
-   * @param callback - Handler that receives context update params and returns a result
-   *   - params.role - Message role (currently only "user")
-   *   - params.content - Content blocks (text, image, etc.)
-   *   - extra - Request metadata (abort signal, session info)
-   *   - Returns: Promise<McpUiUpdateContextResult> with optional isError flag
+   * 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.
+   * 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
    *
    * @example
    * ```typescript
-   * bridge.onupdatecontext = async ({ role, content }, extra) => {
+   * bridge.onupdatemodelcontext = async ({ role, content }, extra) => {
    *   try {
-   *     // Store context update for agent reasoning
-   *     conversationContext.push({
+   *     // Update the model context with the new snapshot
+   *     modelContext = {
    *       type: "app_context",
    *       role,
    *       content,
    *       timestamp: Date.now()
-   *     });
+   *     };
    *     return {};
    *   } catch (err) {
    *     // Handle error and signal failure to the app
@@ -538,17 +532,17 @@ export class AppBridge extends Protocol<Request, Notification, Result> {
    * };
    * ```
    *
-   * @see {@link McpUiUpdateContextRequest} for the request type
-   * @see {@link McpUiUpdateContextResult} for the result type
+   * @see {@link McpUiUpdateModelContextRequest} for the request type
+   * @see {@link McpUiUpdateModelContextResult} for the result type
    */
-  set onupdatecontext(
+  set onupdatemodelcontext(
     callback: (
-      params: McpUiUpdateContextRequest["params"],
+      params: McpUiUpdateModelContextRequest["params"],
       extra: RequestHandlerExtra,
-    ) => Promise<McpUiUpdateContextResult>,
+    ) => Promise<McpUiUpdateModelContextResult>,
   ) {
     this.setRequestHandler(
-      McpUiUpdateContextRequestSchema,
+      McpUiUpdateModelContextRequestSchema,
       async (request, extra) => {
         return callback(request.params, extra);
       },

src/app.ts

@@ -21,8 +21,8 @@ import {
 import {
   LATEST_PROTOCOL_VERSION,
   McpUiAppCapabilities,
-  McpUiUpdateContextRequest,
-  McpUiUpdateContextResultSchema,
+  McpUiUpdateModelContextRequest,
+  McpUiUpdateModelContextResultSchema,
   McpUiHostCapabilities,
   McpUiHostContextChangedNotification,
   McpUiHostContextChangedNotificationSchema,
@@ -676,35 +676,35 @@ export class App extends Protocol<Request, Notification, Result> {
   }
 
   /**
-   * Send context updates to the host for storage in the agent's conversation context.
+   * Send context updates to the host to be included in the agent's context.
    *
-   * Unlike `sendLog` which is for debugging/telemetry, context updates are intended
-   * to inform the agent about app state changes that should be available for future
-   * reasoning without requiring a follow-up action (like `sendMessage`).
+   * Unlike `sendLog`, which is for debugging/telemetry, context updates
+   * are inteded to be available to the model in future reasoning,
+   * without requiring a follow-up action (like `sendMessage`).
    *
    * @param params - Context role and content (same structure as ui/message)
    * @param options - Request options (timeout, etc.)
    *
-   * @example Notify agent of significant state change
+   * @example Update model context with current app state
    * ```typescript
-   * await app.sendUpdateContext({
+   * await app.sendUpdateModelContext({
    *   role: "user",
    *   content: [{ type: "text", text: "User selected 3 items totaling $150.00" }]
    * });
    * ```
    *
    * @returns Promise that resolves when the context update is acknowledged
    */
-  sendUpdateContext(
-    params: McpUiUpdateContextRequest["params"],
+  sendUpdateModelContext(
+    params: McpUiUpdateModelContextRequest["params"],
     options?: RequestOptions,
   ) {
     return this.request(
-      <McpUiUpdateContextRequest>{
-        method: "ui/update-context",
+      <McpUiUpdateModelContextRequest>{
+        method: "ui/update-model-context",
         params,
       },
-      McpUiUpdateContextResultSchema,
+      McpUiUpdateModelContextResultSchema,
       options,
     );
   }