@qwen-code/qwen-code 0.22.0 → 0.22.2-nightly.20260828.7357136dd1

package/chunks/{chunk-FDD2IUEL.js → chunk-SZLBBZH4.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   defaultModalities
-} from "./chunk-YRLW2MSX.js";
+} from "./chunk-XBVNNDPK.js";
 import {
   Mutex
 } from "./chunk-VGC4I5JJ.js";
@@ -14,23 +14,23 @@ import {
   isCacheableReadResult,
   parsePDFPageRange,
   processSingleFileContent
-} from "./chunk-IWOWEENB.js";
+} from "./chunk-BKWNKLZB.js";
 import {
   isAnyAutoMemPath
-} from "./chunk-HIK2OF33.js";
+} from "./chunk-6PJOTWAN.js";
 import {
   runSideQuery
-} from "./chunk-ZRYQMWEP.js";
+} from "./chunk-BWORX6FA.js";
 import {
   generateLegacyMcpToolName,
   normalizeToolNameForProvider
 } from "./chunk-WZAD4ZNJ.js";
 import {
   InstallationManager
-} from "./chunk-JGUBDRBC.js";
+} from "./chunk-6DIGWMGT.js";
 import {
   atomicWriteFile
-} from "./chunk-HDKCKCYO.js";
+} from "./chunk-23RFD54N.js";
 import {
   safeJsonStringify
 } from "./chunk-HHJLM3WQ.js";
@@ -102,7 +102,7 @@ import {
   recordTokenUsageMetrics,
   recordToolCallMetrics,
   recordToolExecutionMetrics
-} from "./chunk-GAHYKJPV.js";
+} from "./chunk-B5PHIJGI.js";
 import {
   SemanticAttributes,
   init_esm,
@@ -110,14 +110,14 @@ import {
 } from "./chunk-74TONY4F.js";
 import {
   STRUCTURED_OUTPUT_REDACTED_ARGS
-} from "./chunk-XL5K4SVK.js";
+} from "./chunk-XF63PKEN.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   StructuredToolError,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-6NFAEG54.js";
+} from "./chunk-UTLCH2FK.js";
 import {
   Storage,
   createDebugLogger,
@@ -128,7 +128,7 @@ import {
   realpathNearestExisting,
   shortenPath,
   unescapePath
-} from "./chunk-A5F2YNO6.js";
+} from "./chunk-UHQFIS7N.js";
 import {
   require_dist
 } from "./chunk-75DOP5OR.js";
@@ -2757,6 +2757,7 @@ init_esbuild_shims();
 import { AsyncLocalStorage } from "node:async_hooks";
 var MAIN_SOURCE = "main";
 var subagentNameContext = new AsyncLocalStorage();
+var subagentIdentityContext = new AsyncLocalStorage();
 
 // packages/core/src/telemetry/uiTelemetry.ts
 var createInitialModelMetricsCore = /* @__PURE__ */ __name(() => ({
@@ -2777,6 +2778,34 @@ var createInitialModelMetrics = /* @__PURE__ */ __name(() => ({
   ...createInitialModelMetricsCore(),
   bySource: /* @__PURE__ */ Object.create(null)
 }), "createInitialModelMetrics");
+var cloneSessionMetrics = /* @__PURE__ */ __name((metrics) => {
+  const clone = structuredClone(metrics);
+  for (const model of Object.values(clone.models)) {
+    model.bySource = Object.assign(
+      /* @__PURE__ */ Object.create(null),
+      model.bySource
+    );
+  }
+  if (clone.sourceMeta) {
+    clone.sourceMeta = Object.assign(
+      /* @__PURE__ */ Object.create(null),
+      clone.sourceMeta
+    );
+  }
+  if (clone.sourceMetrics) {
+    clone.sourceMetrics = Object.assign(
+      /* @__PURE__ */ Object.create(null),
+      clone.sourceMetrics
+    );
+  }
+  if (clone.statsModels) {
+    clone.statsModels = Object.assign(
+      /* @__PURE__ */ Object.create(null),
+      clone.statsModels
+    );
+  }
+  return clone;
+}, "cloneSessionMetrics");
 var createInitialSkillMetrics = /* @__PURE__ */ __name(() => ({
   totalCalls: 0,
   totalSuccess: 0,
@@ -2789,6 +2818,21 @@ var createInitialGenerationMetrics = /* @__PURE__ */ __name(() => ({
   totalGenerationDurationMs: 0,
   totalThroughputOutputTokens: 0
 }), "createInitialGenerationMetrics");
+var getEventTotalTokenCount = /* @__PURE__ */ __name((event) => {
+  if (event.total_token_count > 0) return event.total_token_count;
+  const input = event.input_token_count > 0 ? event.input_token_count : event.cached_content_token_count;
+  const thoughtsIncludedInOutput = event.auth_type === "openai" || event.auth_type === "qwen-oauth";
+  return input + event.output_token_count + (thoughtsIncludedInOutput ? 0 : event.thoughts_token_count);
+}, "getEventTotalTokenCount");
+var getLegacySubagentId = /* @__PURE__ */ __name((event, sessionId) => {
+  if (!sessionId || !event.subagent_name || !event.prompt_id || isInternalPromptId(event.prompt_id)) {
+    return void 0;
+  }
+  const parts = event.prompt_id.split("#");
+  if (parts.length !== 3) return void 0;
+  const [promptSessionId, subagentId, round] = parts;
+  return promptSessionId === sessionId && subagentId && /^\d+$/.test(round) ? subagentId : void 0;
+}, "getLegacySubagentId");
 var createInitialMetrics = /* @__PURE__ */ __name(() => ({
   models: {},
   tools: {
@@ -2827,7 +2871,11 @@ var UiTelemetryService = class _UiTelemetryService extends EventEmitter {
       if (!this.#sessionMetrics.has(sessionId)) {
         this.#sessionMetrics.set(sessionId, createInitialMetrics());
       }
-      this.#accumulateEvent(this.#sessionMetrics.get(sessionId), event);
+      this.#accumulateEvent(
+        this.#sessionMetrics.get(sessionId),
+        event,
+        sessionId
+      );
     }
     this.emit("update", {
       metrics: this.#metrics,
@@ -2876,6 +2924,80 @@ var UiTelemetryService = class _UiTelemetryService extends EventEmitter {
   setLastCachedContentTokenCount(count) {
     this.#lastCachedContentTokenCount = count;
   }
+  /**
+   * Captures everything a session replay is about to overwrite, so a session
+   * swap that fails after replaying can put the state back. See
+   * {@link UiTelemetryReplaySnapshot} for why a snapshot is the only
+   * compensation available (no subtraction API).
+   *
+   * `outgoingSessionId` is the session the process was on when the replay
+   * begins — the swap transaction's begin-time `outgoingHint`, falling back
+   * to `GeminiClient.initializedSessionId`. An earlier failed swap's abort
+   * clears `initializedSessionId`, so keying on it alone would capture no
+   * outgoing session and lose the live bucket (#9844 review). Its bucket and
+   * closed flag are captured too: the `/branch` rollback re-initializes that
+   * session, and the re-initialize's `resetSession` wipes its live bucket —
+   * only what the transcript persists comes back (skill invocations never
+   * do), so restore must put the captured bucket back.
+   */
+  snapshotForReplay(sessionId, outgoingSessionId) {
+    const outgoing = outgoingSessionId && outgoingSessionId !== sessionId ? outgoingSessionId : void 0;
+    const sessionMetrics = this.#sessionMetrics.get(sessionId);
+    const outgoingSessionMetrics = outgoing ? this.#sessionMetrics.get(outgoing) : void 0;
+    return {
+      metrics: cloneSessionMetrics(this.#metrics),
+      sessionId,
+      sessionMetrics: sessionMetrics ? cloneSessionMetrics(sessionMetrics) : void 0,
+      sessionWasClosed: this.#closedSessions.has(sessionId),
+      outgoingSessionId: outgoing,
+      outgoingSessionMetrics: outgoingSessionMetrics ? cloneSessionMetrics(outgoingSessionMetrics) : void 0,
+      outgoingSessionWasClosed: outgoing ? this.#closedSessions.has(outgoing) : void 0,
+      lastPromptTokenCount: this.#lastPromptTokenCount,
+      lastCachedContentTokenCount: this.#lastCachedContentTokenCount
+    };
+  }
+  /**
+   * Puts back the state {@link snapshotForReplay} captured, undoing the
+   * replay of an abandoned session swap. Overwrites rather than subtracts,
+   * so it stays correct when applied after the rollback's own re-initialize
+   * replayed something else on top. Only the snapshotted sessions' buckets
+   * are touched — every other session's live data survives, which is what
+   * makes this usable on a rollback path where the old session is still
+   * live. Emits `update` so keyed displays re-render the restored state.
+   */
+  restoreFromReplaySnapshot(snapshot) {
+    this.#metrics = cloneSessionMetrics(snapshot.metrics);
+    this.#restoreSessionState(
+      snapshot.sessionId,
+      snapshot.sessionMetrics,
+      snapshot.sessionWasClosed
+    );
+    if (snapshot.outgoingSessionId) {
+      this.#restoreSessionState(
+        snapshot.outgoingSessionId,
+        snapshot.outgoingSessionMetrics,
+        snapshot.outgoingSessionWasClosed
+      );
+    }
+    this.#lastPromptTokenCount = snapshot.lastPromptTokenCount;
+    this.#lastCachedContentTokenCount = snapshot.lastCachedContentTokenCount;
+    this.emit("update", {
+      metrics: this.#metrics,
+      lastPromptTokenCount: this.#lastPromptTokenCount
+    });
+  }
+  #restoreSessionState(sessionId, metrics, wasClosed) {
+    if (metrics) {
+      this.#sessionMetrics.set(sessionId, cloneSessionMetrics(metrics));
+    } else {
+      this.#sessionMetrics.delete(sessionId);
+    }
+    if (wasClosed) {
+      this.#closedSessions.add(sessionId);
+    } else {
+      this.#closedSessions.delete(sessionId);
+    }
+  }
   /**
    * Resets metrics to the initial state (used when resuming a session).
    */
@@ -2903,13 +3025,13 @@ var UiTelemetryService = class _UiTelemetryService extends EventEmitter {
       if (oldest) this.#closedSessions.delete(oldest);
     }
   }
-  #accumulateEvent(metrics, event) {
+  #accumulateEvent(metrics, event, sessionId) {
     switch (event["event.name"]) {
       case EVENT_API_RESPONSE:
-        this.#accumulateApiResponse(metrics, event);
+        this.#accumulateApiResponse(metrics, event, sessionId);
         return true;
       case EVENT_API_ERROR:
-        this.#accumulateApiError(metrics, event);
+        this.#accumulateApiError(metrics, event, sessionId);
         return true;
       case EVENT_TOOL_CALL:
         this.#accumulateToolCall(metrics, event);
@@ -2918,20 +3040,40 @@ var UiTelemetryService = class _UiTelemetryService extends EventEmitter {
         return false;
     }
   }
-  #accumulateApiResponse(metrics, event) {
+  #accumulateApiResponse(metrics, event, sessionId) {
     const modelMetrics = this.#getOrCreateModelMetrics(metrics, event.model);
+    const statsModelMetrics = sessionId ? this.#getOrCreateStatsModelMetrics(metrics, event.model) : void 0;
     const sourceMetrics = this.#getOrCreateSourceMetrics(
       modelMetrics,
       event.subagent_name ?? MAIN_SOURCE
     );
-    for (const bucket of [modelMetrics, sourceMetrics]) {
+    const invocationMetrics = sessionId ? this.#getOrCreateInvocationMetrics(metrics, event, sessionId) : void 0;
+    const normalizedPromptTokens = event.input_token_count > 0 ? event.input_token_count : event.cached_content_token_count;
+    const normalizedTotalTokens = getEventTotalTokenCount(event);
+    const accumulate = /* @__PURE__ */ __name((bucket, prompt, total) => {
       bucket.api.totalRequests++;
       bucket.api.totalLatencyMs += event.duration_ms;
-      bucket.tokens.prompt += event.input_token_count;
+      bucket.tokens.prompt += prompt;
       bucket.tokens.candidates += event.output_token_count;
-      bucket.tokens.total += event.total_token_count;
+      bucket.tokens.total += total;
       bucket.tokens.cached += event.cached_content_token_count;
       bucket.tokens.thoughts += event.thoughts_token_count;
+    }, "accumulate");
+    accumulate(modelMetrics, event.input_token_count, event.total_token_count);
+    accumulate(sourceMetrics, event.input_token_count, event.total_token_count);
+    if (statsModelMetrics) {
+      accumulate(
+        statsModelMetrics,
+        normalizedPromptTokens,
+        normalizedTotalTokens
+      );
+    }
+    if (invocationMetrics) {
+      accumulate(
+        invocationMetrics,
+        normalizedPromptTokens,
+        normalizedTotalTokens
+      );
     }
     if (event.ttft_ms === void 0 || !Number.isFinite(event.ttft_ms) || event.ttft_ms < 0 || isInternalPromptId(event.prompt_id)) {
       return;
@@ -2951,18 +3093,40 @@ var UiTelemetryService = class _UiTelemetryService extends EventEmitter {
       outputTokens: event.output_token_count
     };
   }
-  #accumulateApiError(metrics, event) {
+  #accumulateApiError(metrics, event, sessionId) {
     const modelMetrics = this.#getOrCreateModelMetrics(metrics, event.model);
+    const statsModelMetrics = sessionId ? this.#getOrCreateStatsModelMetrics(metrics, event.model) : void 0;
     const sourceMetrics = this.#getOrCreateSourceMetrics(
       modelMetrics,
       event.subagent_name ?? MAIN_SOURCE
     );
-    for (const bucket of [modelMetrics, sourceMetrics]) {
+    const invocationMetrics = sessionId ? this.#getOrCreateInvocationMetrics(metrics, event, sessionId) : void 0;
+    const buckets = [
+      modelMetrics,
+      ...statsModelMetrics ? [statsModelMetrics] : [],
+      sourceMetrics,
+      ...invocationMetrics ? [invocationMetrics] : []
+    ];
+    for (const bucket of buckets) {
       bucket.api.totalRequests++;
       bucket.api.totalErrors++;
       bucket.api.totalLatencyMs += event.duration_ms;
     }
   }
+  #getOrCreateInvocationMetrics(metrics, event, sessionId) {
+    const id = event.subagent_id ?? getLegacySubagentId(event, sessionId);
+    if (!id) return void 0;
+    const meta = metrics.sourceMeta ??= /* @__PURE__ */ Object.create(null);
+    const existingMeta = meta[id];
+    meta[id] = {
+      name: event.subagent_task_name ?? existingMeta?.name ?? event.subagent_name ?? id,
+      type: event.subagent_type ?? existingMeta?.type ?? event.subagent_name ?? ""
+    };
+    const sourceMetrics = metrics.sourceMetrics ??= /* @__PURE__ */ Object.create(
+      null
+    );
+    return sourceMetrics[id] ??= createInitialModelMetricsCore();
+  }
   #accumulateToolCall(metrics, event) {
     const { tools, files } = metrics;
     tools.totalCalls++;
@@ -3045,6 +3209,10 @@ var UiTelemetryService = class _UiTelemetryService extends EventEmitter {
     }
     return metrics.models[modelName];
   }
+  #getOrCreateStatsModelMetrics(metrics, modelName) {
+    const statsModels = metrics.statsModels ??= /* @__PURE__ */ Object.create(null);
+    return statsModels[modelName] ??= createInitialModelMetricsCore();
+  }
   #getOrCreateSourceMetrics(modelMetrics, source) {
     if (!modelMetrics.bySource[source]) {
       modelMetrics.bySource[source] = createInitialModelMetricsCore();
@@ -4003,9 +4171,14 @@ function logRipgrepRuntimeRecovery(config, event) {
   logger.emit(logRecord);
 }
 __name(logRipgrepRuntimeRecovery, "logRipgrepRuntimeRecovery");
-function logApiError(config, event, sessionId) {
+function logApiError(config, event, sessionId, uiSubagentIdentity) {
   const uiEvent = {
     ...event,
+    ...uiSubagentIdentity ? {
+      subagent_id: uiSubagentIdentity.id,
+      subagent_type: uiSubagentIdentity.type,
+      subagent_task_name: uiSubagentIdentity.taskName
+    } : {},
     "event.name": EVENT_API_ERROR,
     "event.timestamp": (/* @__PURE__ */ new Date()).toISOString()
   };
@@ -4069,9 +4242,14 @@ function logApiCancel(config, event) {
   logger.emit(logRecord);
 }
 __name(logApiCancel, "logApiCancel");
-function logApiResponse(config, event, sessionId) {
+function logApiResponse(config, event, sessionId, uiSubagentIdentity) {
   const uiEvent = {
     ...event,
+    ...uiSubagentIdentity ? {
+      subagent_id: uiSubagentIdentity.id,
+      subagent_type: uiSubagentIdentity.type,
+      subagent_task_name: uiSubagentIdentity.taskName
+    } : {},
     "event.name": EVENT_API_RESPONSE,
     "event.timestamp": (/* @__PURE__ */ new Date()).toISOString()
   };
@@ -4827,7 +5005,7 @@ init_esbuild_shims();
 // packages/core/src/tools/mcp-tool.ts
 init_esbuild_shims();
 
-// packages/core/src/utils/truncation.ts
+// packages/core/src/tools/truncation.ts
 init_esbuild_shims();
 import * as fs3 from "node:fs/promises";
 import * as path5 from "node:path";
@@ -5131,6 +5309,15 @@ __name(buildStub, "buildStub");
 // packages/core/src/tools/mcp-status.ts
 init_esbuild_shims();
 var serverStatuses = /* @__PURE__ */ new Map();
+var serverLastErrors = /* @__PURE__ */ new Map();
+function recordMCPServerLastError(serverName, message) {
+  serverLastErrors.set(serverName, message);
+}
+__name(recordMCPServerLastError, "recordMCPServerLastError");
+function getMCPServerLastError(serverName) {
+  return serverLastErrors.get(serverName);
+}
+__name(getMCPServerLastError, "getMCPServerLastError");
 var statusChangeListeners = [];
 function addMCPStatusChangeListener(listener) {
   statusChangeListeners.push(listener);
@@ -5145,12 +5332,16 @@ function removeMCPStatusChangeListener(listener) {
 __name(removeMCPStatusChangeListener, "removeMCPStatusChangeListener");
 function updateMCPServerStatus(serverName, status) {
   serverStatuses.set(serverName, status);
+  if (status === "connected" /* CONNECTED */) {
+    serverLastErrors.delete(serverName);
+  }
   for (const listener of [...statusChangeListeners]) {
     listener(serverName, status);
   }
 }
 __name(updateMCPServerStatus, "updateMCPServerStatus");
 function removeMCPServerStatus(serverName) {
+  serverLastErrors.delete(serverName);
   if (!serverStatuses.has(serverName)) {
     return;
   }
@@ -5292,6 +5483,7 @@ __name(collectText, "collectText");
 
 // packages/core/src/tools/mcp-tool.ts
 var debugLogger5 = createDebugLogger("MCP_TOOL");
+var MCP_DEAD_SESSION_ERROR_PATTERN = /session (not found|terminated|expired)/i;
 var MCP_CONNECTION_ERROR_PATTERNS = [
   /ECONNREFUSED/i,
   /ENOTFOUND/i,
@@ -5300,16 +5492,28 @@ var MCP_CONNECTION_ERROR_PATTERNS = [
   /connection (closed|lost)/i,
   /not connected/i,
   /disconnected/i,
-  /transport closed/i
+  /transport closed/i,
+  // The server no longer knows our session id (see
+  // `MCP_DEAD_SESSION_ERROR_PATTERN`) — the canonical failure right after an
+  // HTTP server restart. Reconnect (a fresh `initialize`) is the remedy.
+  MCP_DEAD_SESSION_ERROR_PATTERN
 ];
 var MCP_REQUEST_TIMEOUT_CODE = -32001;
+var MCP_DEAD_SESSION_HTTP_CODE = 404;
 function isMcpRequestTimeout(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === MCP_REQUEST_TIMEOUT_CODE;
 }
 __name(isMcpRequestTimeout, "isMcpRequestTimeout");
+function isMcpDeadSessionHttpError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === MCP_DEAD_SESSION_HTTP_CODE;
+}
+__name(isMcpDeadSessionHttpError, "isMcpDeadSessionHttpError");
 function isExecutionTimeoutFailure(error, serverName, signal) {
   if (signal.aborted) return false;
   if (!isMcpRequestTimeout(error)) return false;
+  if (MCP_DEAD_SESSION_ERROR_PATTERN.test(getErrorMessage(error))) {
+    return false;
+  }
   const statuses = getAllMCPServerStatuses();
   return !(statuses.has(serverName) && statuses.get(serverName) === "disconnected" /* DISCONNECTED */);
 }
@@ -5347,8 +5551,11 @@ function createParentAbortRace(signal, forwardAbort) {
   };
 }
 __name(createParentAbortRace, "createParentAbortRace");
+var MCP_APP_RESOURCE_MIME_TYPE = "text/html;profile=mcp-app";
+var MCP_APP_RESOURCE_MAX_BYTES = 1024 * 1024;
+var MCP_APP_RESOURCE_TIMEOUT_MS = 1e4;
 var DiscoveredMCPToolInvocation = class _DiscoveredMCPToolInvocation extends BaseToolInvocation {
-  constructor(mcpTool, serverName, serverToolName, displayName, registeredToolName, permissionAliases, trust, params = {}, cliConfig, mcpClient, mcpTimeout, mcpToolIdleTimeoutMs, annotations, allowInvocationContext = false, retryCount = 0) {
+  constructor(mcpTool, serverName, serverToolName, displayName, registeredToolName, permissionAliases, trust, params = {}, cliConfig, mcpClient, mcpTimeout, mcpToolIdleTimeoutMs, annotations, allowInvocationContext = false, appResourceUri, appResourceUi, retryCount = 0) {
     super(params);
     this.mcpTool = mcpTool;
     this.serverName = serverName;
@@ -5363,6 +5570,8 @@ var DiscoveredMCPToolInvocation = class _DiscoveredMCPToolInvocation extends Bas
     this.mcpToolIdleTimeoutMs = mcpToolIdleTimeoutMs;
     this.annotations = annotations;
     this.allowInvocationContext = allowInvocationContext;
+    this.appResourceUri = appResourceUri;
+    this.appResourceUi = appResourceUi;
     this.retryCount = retryCount;
   }
   static {
@@ -5449,6 +5658,7 @@ var DiscoveredMCPToolInvocation = class _DiscoveredMCPToolInvocation extends Bas
       throw error;
     }
     if (!this.canSafelyReplay()) {
+      await this.attemptReconnect();
       throw new Error(_DiscoveredMCPToolInvocation.UNSAFE_REPLAY_ERROR_MESSAGE);
     }
     if (this.retryCount < _DiscoveredMCPToolInvocation.MAX_RECONNECT_RETRIES) {
@@ -5472,6 +5682,8 @@ var DiscoveredMCPToolInvocation = class _DiscoveredMCPToolInvocation extends Bas
           this.mcpToolIdleTimeoutMs,
           newTool.annotations,
           newTool["allowInvocationContext"] === true,
+          newTool["appResourceUri"],
+          newTool.appResourceUi,
           this.retryCount + 1
         );
         if (!newInvocation.canSafelyReplay()) {
@@ -5507,6 +5719,9 @@ var DiscoveredMCPToolInvocation = class _DiscoveredMCPToolInvocation extends Bas
     if (getMCPServerStatus(this.serverName) === "disconnected" /* DISCONNECTED */) {
       return true;
     }
+    if (isMcpDeadSessionHttpError(error)) {
+      return true;
+    }
     const message = getErrorMessage(error);
     return MCP_CONNECTION_ERROR_PATTERNS.some(
       (pattern) => pattern.test(message)
@@ -5572,7 +5787,6 @@ var DiscoveredMCPToolInvocation = class _DiscoveredMCPToolInvocation extends Bas
             }
           } : {}
         },
-        void 0,
         {
           onprogress: /* @__PURE__ */ __name((progress) => {
             resetIdleTimeout();
@@ -5598,6 +5812,10 @@ var DiscoveredMCPToolInvocation = class _DiscoveredMCPToolInvocation extends Bas
         throw outcome.reason;
       }
       const callToolResult = outcome;
+      if (idleTimeoutId) {
+        clearTimeout(idleTimeoutId);
+        idleTimeoutId = void 0;
+      }
       const rawResponseParts = wrapMcpCallToolResultAsParts(
         this.serverToolName,
         callToolResult
@@ -5610,12 +5828,18 @@ var DiscoveredMCPToolInvocation = class _DiscoveredMCPToolInvocation extends Bas
       }
       const transformedParts = transformMcpContentToParts(rawResponseParts);
       const truncated = await this.truncateTextParts(transformedParts);
+      const fallbackText = getDisplayFromPartsWithPersistedOutput(
+        transformedParts,
+        truncated.persistedOutputFiles
+      );
+      const appDisplay = await this.loadMcpAppDisplay(
+        callToolResult,
+        fallbackText,
+        signal
+      );
       return {
         llmContent: truncated.parts,
-        returnDisplay: getDisplayFromPartsWithPersistedOutput(
-          transformedParts,
-          truncated.persistedOutputFiles
-        ),
+        returnDisplay: appDisplay ?? fallbackText,
         persistedOutputFiles: truncated.persistedOutputFiles
       };
     } catch (error) {
@@ -5633,6 +5857,57 @@ var DiscoveredMCPToolInvocation = class _DiscoveredMCPToolInvocation extends Bas
       parentAbortRace.dispose();
     }
   }
+  async loadMcpAppDisplay(toolResult, fallbackText, signal) {
+    if (!this.appResourceUri || !this.mcpClient?.readResource) return void 0;
+    try {
+      const resource = await this.mcpClient.readResource(
+        { uri: this.appResourceUri },
+        {
+          timeout: Math.min(
+            this.mcpTimeout ?? MCP_APP_RESOURCE_TIMEOUT_MS,
+            MCP_APP_RESOURCE_TIMEOUT_MS
+          ),
+          signal: AbortSignal.any([
+            signal,
+            AbortSignal.timeout(MCP_APP_RESOURCE_TIMEOUT_MS)
+          ])
+        }
+      );
+      const content = resource.contents.find(
+        (entry) => entry.uri === this.appResourceUri
+      );
+      if (!content || content.mimeType !== MCP_APP_RESOURCE_MIME_TYPE) {
+        throw new Error(
+          `resource must return ${MCP_APP_RESOURCE_MIME_TYPE} for ${this.appResourceUri}`
+        );
+      }
+      const html = typeof content.text === "string" ? content.text : typeof content.blob === "string" ? Buffer.from(content.blob, "base64").toString("utf8") : void 0;
+      if (!html) throw new Error("resource did not return HTML content");
+      if (Buffer.byteLength(html, "utf8") > MCP_APP_RESOURCE_MAX_BYTES) {
+        throw new Error("resource HTML exceeds the 1 MiB host limit");
+      }
+      const metadata = getMcpAppResourceMetadata(
+        content._meta,
+        this.appResourceUi
+      );
+      return {
+        type: "mcp_app",
+        serverName: this.serverName,
+        resourceUri: this.appResourceUri,
+        html,
+        toolResult,
+        toolArguments: this.params,
+        fallbackText,
+        ...metadata
+      };
+    } catch (error) {
+      if (signal.aborted) return void 0;
+      debugLogger5.warn(
+        `Failed to load MCP App '${this.appResourceUri}' from '${this.serverName}': ${getErrorMessage(error)}`
+      );
+      return void 0;
+    }
+  }
   /**
    * Fallback: execute using the @google/genai CallableTool wrapper.
    * This path does NOT support progress notifications.
@@ -5759,7 +6034,7 @@ var DiscoveredMCPToolInvocation = class _DiscoveredMCPToolInvocation extends Bas
   }
 };
 var DiscoveredMCPTool = class _DiscoveredMCPTool extends BaseDeclarativeTool {
-  constructor(mcpTool, serverName, serverToolName, description, parameterSchema, trust, nameOverride, cliConfig, mcpClient, mcpTimeout, mcpToolIdleTimeoutMs, annotations, alwaysLoad = false, allowInvocationContext = false) {
+  constructor(mcpTool, serverName, serverToolName, description, parameterSchema, trust, nameOverride, cliConfig, mcpClient, mcpTimeout, mcpToolIdleTimeoutMs, annotations, alwaysLoad = false, allowInvocationContext = false, appResourceUri, appResourceUi) {
     super(
       nameOverride ?? generateValidName(`mcp__${serverName}__${serverToolName}`),
       `${serverToolName} (${serverName} MCP Server)`,
@@ -5789,6 +6064,8 @@ var DiscoveredMCPTool = class _DiscoveredMCPTool extends BaseDeclarativeTool {
     this.mcpToolIdleTimeoutMs = mcpToolIdleTimeoutMs;
     this.annotations = annotations;
     this.allowInvocationContext = allowInvocationContext;
+    this.appResourceUri = appResourceUri;
+    this.appResourceUi = appResourceUi;
   }
   static {
     __name(this, "DiscoveredMCPTool");
@@ -5821,7 +6098,30 @@ var DiscoveredMCPTool = class _DiscoveredMCPTool extends BaseDeclarativeTool {
       this.mcpToolIdleTimeoutMs,
       this.annotations,
       this.alwaysLoad,
-      this.allowInvocationContext
+      this.allowInvocationContext,
+      this.appResourceUri,
+      this.appResourceUi
+    );
+  }
+  withAppResourceUi(appResourceUi) {
+    if (appResourceUi === this.appResourceUi) return this;
+    return new _DiscoveredMCPTool(
+      this.mcpTool,
+      this.serverName,
+      this.serverToolName,
+      this.description,
+      this.parameterSchema,
+      this.trust,
+      this.name,
+      this.cliConfig,
+      this.mcpClient,
+      this.mcpTimeout,
+      this.mcpToolIdleTimeoutMs,
+      this.annotations,
+      this.alwaysLoad,
+      this.allowInvocationContext,
+      this.appResourceUri,
+      appResourceUi
     );
   }
   /**
@@ -5862,7 +6162,9 @@ var DiscoveredMCPTool = class _DiscoveredMCPTool extends BaseDeclarativeTool {
       this.mcpToolIdleTimeoutMs,
       this.annotations,
       alwaysLoad,
-      this.allowInvocationContext
+      this.allowInvocationContext,
+      this.appResourceUri,
+      this.appResourceUi
     );
   }
   createInvocation(params) {
@@ -5880,10 +6182,40 @@ var DiscoveredMCPTool = class _DiscoveredMCPTool extends BaseDeclarativeTool {
       this.mcpTimeout,
       this.mcpToolIdleTimeoutMs,
       this.annotations,
-      this.allowInvocationContext
+      this.allowInvocationContext,
+      this.appResourceUri,
+      this.appResourceUi
     );
   }
 };
+function getMcpAppResourceMetadata(meta, listingUi) {
+  const ui = getRecord(meta?.["ui"]) ?? listingUi;
+  const rawCsp = getRecord(ui?.["csp"]);
+  const rawPermissions = getRecord(ui?.["permissions"]);
+  const csp = rawCsp ? {
+    ...readStringArray(rawCsp, "connectDomains"),
+    ...readStringArray(rawCsp, "resourceDomains"),
+    ...readStringArray(rawCsp, "frameDomains"),
+    ...readStringArray(rawCsp, "baseUriDomains")
+  } : void 0;
+  const permissions = rawPermissions ? Object.fromEntries(
+    ["camera", "microphone", "geolocation", "clipboardWrite"].filter((key) => getRecord(rawPermissions[key])).map((key) => [key, {}])
+  ) : void 0;
+  return {
+    ...csp && Object.keys(csp).length > 0 ? { csp } : {},
+    ...permissions && Object.keys(permissions).length > 0 ? { permissions } : {}
+  };
+}
+__name(getMcpAppResourceMetadata, "getMcpAppResourceMetadata");
+function getRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+__name(getRecord, "getRecord");
+function readStringArray(value, key) {
+  const entry = value[key];
+  return Array.isArray(entry) && entry.every((item) => typeof item === "string") ? { [key]: entry } : {};
+}
+__name(readStringArray, "readStringArray");
 function wrapMcpCallToolResultAsParts(toolName, result) {
   const response = result.isError ? { error: result, content: result.content } : result;
   return [
@@ -7876,7 +8208,7 @@ var ReadFileTool = class _ReadFileTool extends BaseDeclarativeTool {
   }
   static Name = ToolNames.READ_FILE;
   // Self-managed: ReadFile controls its own size via line-based paging
-  // (offset/limit, default 2000 lines), so it is exempt from the scheduler's
+  // (offset/limit, default truncateToolOutputLines setting), so it is exempt from the scheduler's
   // char-based truncation. Oversized reads are bounded by the per-message
   // batch budget instead.
   get maxOutputChars() {
@@ -7951,6 +8283,7 @@ export {
   runVisionBridge,
   MAIN_SOURCE,
   subagentNameContext,
+  subagentIdentityContext,
   isInternalPromptId,
   UiTelemetryService,
   uiTelemetryService,
@@ -8030,6 +8363,8 @@ export {
   isAlreadyTruncated,
   normalizeToolResultCallId,
   persistAndTruncateToolResult,
+  recordMCPServerLastError,
+  getMCPServerLastError,
   addMCPStatusChangeListener,
   removeMCPStatusChangeListener,
   updateMCPServerStatus,