@qwen-code/qwen-code 0.19.10 → 0.19.11-nightly.20260718.767a32484

package/chunks/{acpAgent-VPZJXLFX.js → acpAgent-U2P2IESZ.js}

@@ -1,9 +1,8 @@
 // Force strict mode and setup for ESM
 "use strict";
 import {
-  classifyApiError,
-  prefixMidTurnUserMessageParts
-} from "./chunk-WIASPMLX.js";
+  classifyApiError
+} from "./chunk-3X2CFOUM.js";
 import {
   EXTENSION_CONTEXT_BUDGET,
   buildExtensionMentionContext,
@@ -12,83 +11,96 @@ import {
   matchMcpServerByRef,
   parseExtensionRef,
   parseMcpServerRef
-} from "./chunk-X362TMXZ.js";
+} from "./chunk-GAQOQMHY.js";
 import {
   getAvailableCommands,
   handleSlashCommand,
   insertAfterFunctionResponses,
   isSlashCommand,
   normalizePartList
-} from "./chunk-YX4LLZ3D.js";
+} from "./chunk-QPRDXJIC.js";
+import {
+  collectContextData,
+  formatContextUsageText
+} from "./chunk-OBYAX5QZ.js";
+import {
+  recomputeMcpGating
+} from "./chunk-4JBTZBCW.js";
 import {
   appEvents,
   buildDisabledSkillNamesProvider,
   loadCliConfig,
   normalizeDisabledToolList
-} from "./chunk-CEW4HDPK.js";
+} from "./chunk-GUNTLALV.js";
 import {
   getCommandSubcommandNames
-} from "./chunk-XXJKGHZV.js";
-import "./chunk-422XAKCK.js";
+} from "./chunk-ZTSDZQZO.js";
+import "./chunk-U2XBPBO3.js";
 import {
   getEffectiveSupportedModes
-} from "./chunk-DK33QJ3V.js";
-import "./chunk-K4PZ5F5T.js";
-import "./chunk-5DTTYNB7.js";
-import {
-  collectContextData,
-  formatContextUsageText
-} from "./chunk-B5I2IIWY.js";
+} from "./chunk-CZSAIBUB.js";
 import "./chunk-4WGODMVR.js";
+import "./chunk-KW7NOTN6.js";
+import "./chunk-TVYM3Q3J.js";
+import "./chunk-5DTTYNB7.js";
 import "./chunk-NHDKSOEY.js";
 import {
   isTerminalGoalStatusKind
 } from "./chunk-7X7TEQNX.js";
 import "./chunk-HTHUX2T5.js";
-import "./chunk-EQY6POVO.js";
-import "./chunk-7L4XBYVW.js";
+import "./chunk-F5XYN5VF.js";
+import "./chunk-632KROVU.js";
 import "./chunk-YAF2MQZ6.js";
-import "./chunk-Q6TUALBE.js";
-import "./chunk-KW7NOTN6.js";
+import "./chunk-XAAEDML2.js";
 import {
+  GENERATION_MAX_PROMPT_BYTES,
+  GENERATION_TIMEOUT_MS,
   MAX_REMEMBER_CONTENT_BYTES,
+  REDACTED_MCP_SECRET,
   collectHistoryReplayUpdates,
   copyCumulativeUsage,
   createReplayCumulativeUsage,
   createWorkspaceMemoryExtractionErrorLogger,
+  executeGeneration,
   formatWorkspaceMemoryForgetSummary,
   isValidServerName,
+  redactMcpServerSecrets,
   replayTranscriptRecordPage,
+  restoreRedactedMcpSecrets,
   shouldSuppressRememberErrorDetails,
   workspaceMemoryFailureCode,
   workspaceMemoryFailureDiagnostics
-} from "./chunk-6W6DI34P.js";
+} from "./chunk-IX7O5WI3.js";
 import {
   HistoryReplayer,
   MessageEmitter,
   PlanEmitter,
   ToolCallEmitter
-} from "./chunk-4FMG7EDJ.js";
-import "./chunk-SPUYQB4T.js";
-import "./chunk-WTSXKLG5.js";
+} from "./chunk-PWYLF7SS.js";
+import "./chunk-JBAQ5BYX.js";
+import "./chunk-SUARMD4Q.js";
 import "./chunk-QHTIBUWB.js";
 import "./chunk-L573Z2QZ.js";
 import {
   computeCpuPercent
 } from "./chunk-HGT6JR3U.js";
 import "./chunk-RXFQM6FQ.js";
-import "./chunk-WDW64OW3.js";
+import "./chunk-LGY7PG7Q.js";
 import "./chunk-6H67XLET.js";
-import "./chunk-L62SEJWY.js";
-import "./chunk-65N2J6V2.js";
-import "./chunk-WDWJ4OQJ.js";
+import "./chunk-FHUXCRAF.js";
+import "./chunk-64XGKNSI.js";
+import "./chunk-LXXMOYPL.js";
+import "./chunk-K2GBHL73.js";
 import "./chunk-E5Z2AVNV.js";
 import {
-  formatAcpModelId,
+  ACP_ROUTE_ID_PREFIX,
+  buildAcpModelOptions,
+  getCurrentAcpModelId,
   parseAcpBaseModelId,
   parseAcpModelOption,
+  resolveAcpModelOption,
   sanitizeProviderBaseUrl
-} from "./chunk-GGJII3FM.js";
+} from "./chunk-6Z5NRZVU.js";
 import {
   mapSkillConfigToStatus
 } from "./chunk-2W3OOD4W.js";
@@ -98,41 +110,45 @@ import {
   buildPermissionSettings,
   normalizePermissionRules,
   readPermissionRuleSet
-} from "./chunk-N6FXRR6P.js";
+} from "./chunk-57RWF6R7.js";
 import {
   MAX_AUDIO_BYTES,
   sanitizeVoiceErrorMessage,
   transcribeVoiceAudio
-} from "./chunk-FXMC7SL2.js";
+} from "./chunk-6ITLKEOZ.js";
 import {
   readVoiceModel
-} from "./chunk-DPFBNG72.js";
-import "./chunk-FSA7ERJ2.js";
+} from "./chunk-AEKYFMYE.js";
+import "./chunk-F2RR4HO2.js";
+import {
+  parseSessionSource
+} from "./chunk-KEVDWH3U.js";
 import {
   CLIENT_MCP_OVER_WS_CONFIG_FLAG,
   LOAD_REPLAY_BULK_MODE,
   LOAD_REPLAY_META_KEY,
   LOAD_REPLAY_MODE_META_KEY,
+  LOAD_REPLAY_PAGE_SIZE_META_KEY,
   LOAD_REPLAY_VERSION,
   MID_TURN_QUEUE_DRAIN_METHOD
-} from "./chunk-PZL23GTM.js";
+} from "./chunk-T3W4SDRB.js";
 import "./chunk-6RLROE6G.js";
 import "./chunk-COH43MRJ.js";
 import {
   NOT_CURRENTLY_GENERATING_CANCEL_MESSAGE
-} from "./chunk-KSO42X3Z.js";
-import "./chunk-Q5GLXH5Q.js";
-import "./chunk-AAR5SGMD.js";
+} from "./chunk-X6YQWCIJ.js";
+import "./chunk-3CL5SEDT.js";
+import "./chunk-IVKLDHU6.js";
 import "./chunk-57OAHC2Y.js";
-import "./chunk-OATTJGPJ.js";
-import "./chunk-ZRKBI3DP.js";
+import "./chunk-Y72B36CP.js";
+import "./chunk-FZRES4GK.js";
 import "./chunk-V6WHFGST.js";
 import {
   createLoadedSettingsAdapter
-} from "./chunk-W34A5MJH.js";
+} from "./chunk-LTD3CHGS.js";
 import {
   ndJsonStream
-} from "./chunk-TEGEBB2I.js";
+} from "./chunk-O2K6BLPZ.js";
 import {
   ACP_PREFLIGHT_KINDS,
   IDLE_HOOK_EVENTS,
@@ -140,21 +156,23 @@ import {
   SERVE_STATUS_EXT_METHODS,
   STATUS_SCHEMA_VERSION,
   mapDomainErrorToErrorKind
-} from "./chunk-CUUXANEQ.js";
+} from "./chunk-URP6O2PP.js";
 import "./chunk-W7FJ3N32.js";
-import "./chunk-GYTKQYDB.js";
+import "./chunk-JDIUK2Y3.js";
 import "./chunk-TJTKSVIV.js";
 import "./chunk-M5GB774H.js";
-import "./chunk-OJAMDVF5.js";
-import "./chunk-LXLTBIDP.js";
-import "./chunk-BBNVFRGD.js";
-import "./chunk-SXU3KKNI.js";
+import "./chunk-HCCR43AY.js";
+import "./chunk-MI2V6IWU.js";
+import "./chunk-ATJ7H5AS.js";
 import {
   AgentSideConnection,
   PROTOCOL_VERSION,
   RequestError
 } from "./chunk-UDXSXLER.js";
-import "./chunk-YYPXHMWO.js";
+import {
+  assembleMcpServers,
+  loadMcpApprovals
+} from "./chunk-2XRGFF5K.js";
 import {
   OUTPUT_LANGUAGE_AUTO,
   getOutputLanguageFilePath,
@@ -165,18 +183,18 @@ import {
   resolveOutputLanguage,
   updateOutputLanguageFile,
   writeOutputLanguageAndRegisterPath
-} from "./chunk-6GETGQWP.js";
+} from "./chunk-C5NSOSF4.js";
 import "./chunk-RKUWKYED.js";
 import {
   SUPPORTED_LANGUAGES,
   getCurrentLanguage,
   setLanguageAsync
-} from "./chunk-RDRVMDWV.js";
+} from "./chunk-HIMIG6PI.js";
 import {
   findEnvFiles,
   preResolveHomeEnvOverrides,
   reloadEnvironment
-} from "./chunk-5EBKKSBX.js";
+} from "./chunk-336KPNNV.js";
 import "./chunk-GOXKNSDZ.js";
 import {
   getSystemDefaultsPath,
@@ -187,14 +205,14 @@ import {
   isFolderTrustEnabled,
   isWorkspaceTrusted,
   loadTrustedFolders
-} from "./chunk-4YWLED2A.js";
+} from "./chunk-LSFVUGXT.js";
 import "./chunk-ALGGS7UH.js";
 import "./chunk-MR3PXB6E.js";
 import {
   writeStderrLine
 } from "./chunk-YUZI3WAC.js";
 import "./chunk-XFSFZCM5.js";
-import "./chunk-YU56QGXX.js";
+import "./chunk-KTKETHMY.js";
 import "./chunk-VJNBRRZG.js";
 import {
   ALL_PROVIDERS,
@@ -218,7 +236,9 @@ import {
   SESSION_ARTIFACT_PERSISTENCE_VERSION,
   SESSION_TITLE_MAX_LENGTH,
   SESSION_TRANSCRIPT_MAX_LIMIT,
+  SESSION_TRANSCRIPT_MAX_PAGE_BYTES,
   SessionService,
+  SessionTranscriptPageTooLargeError,
   SessionTranscriptReader,
   SessionTranscriptSnapshotUnavailableError,
   SessionTranscriptTooLargeError,
@@ -238,6 +258,7 @@ import {
   clampInlineMediaPart,
   clearGoalTerminalObserver,
   computeUniqueBranchTitle,
+  convertToFunctionErrorResponse,
   convertToFunctionResponse,
   createDuplicateProviderToolCallResponse,
   dedupeToolCallsById,
@@ -269,18 +290,18 @@ import {
   getProviderToolCallId,
   getScopedEnvContents,
   getStartupContextLength,
-  hasImageParts,
   ideContextStore,
   injectPermissionRulesIfMissing,
   isApproveOutcome,
   isDenialFallbackReason,
+  isGatedMcpScope,
   isPlanModeBlocked,
   isSystemReminderContent,
   markDuplicateProviderToolCallResponseSent,
   matchesAnyServerPattern,
+  mcpServerRequiresOAuth,
   needsConfirmation,
   normalizeEventPayload,
-  normalizeParts,
   normalizeSnapshotPayload,
   parsePositiveIntegerEnv,
   persistPermissionOutcome,
@@ -295,7 +316,6 @@ import {
   runForkedAgent,
   runManagedAutoMemoryDream,
   runManagedRememberByAgent,
-  runVisionBridge,
   sessionIdContext,
   setGoalTerminalObserver,
   shouldClassifyAllShellForAutoMode,
@@ -303,42 +323,39 @@ import {
   shouldFirePermissionDeniedForAutoMode,
   shouldForceAutoModeReviewForAllow,
   shouldRunAutoModeForCall,
-  shouldRunVisionBridge,
-  splitImageParts,
   subagentGenerator,
   unregisterGoalHook,
   updateSetting
-} from "./chunk-K7CRWKOE.js";
+} from "./chunk-3YJZ6WNY.js";
+import "./chunk-T4TZQJ7W.js";
 import {
   external_exports
 } from "./chunk-H6XPXXMH.js";
 import "./chunk-5M6IDOMF.js";
-import "./chunk-E67NFMF4.js";
-import "./chunk-RCEEXIOO.js";
-import "./chunk-KKRTYONM.js";
-import "./chunk-TV6K2FB4.js";
+import "./chunk-LKR7QQ63.js";
+import "./chunk-4XCVGEEX.js";
+import "./chunk-XSPFQQRE.js";
+import "./chunk-4RPARQ5D.js";
 import "./chunk-E2UVIFI2.js";
-import {
-  runSideQuery
-} from "./chunk-6OATMEYN.js";
 import "./chunk-XU457J4V.js";
 import "./chunk-VDDGDZMA.js";
-import "./chunk-SPJQO2CE.js";
+import "./chunk-J2MKYJKZ.js";
 import "./chunk-SZRN75WQ.js";
 import "./chunk-HTO4JFDZ.js";
 import "./chunk-CPBF7KYF.js";
 import {
   APPROVAL_MODES,
-  FORK_SUBAGENT_TYPE
-} from "./chunk-TXY2C3D2.js";
+  FORK_SUBAGENT_TYPE,
+  runWithRuntimeContentGenerator
+} from "./chunk-VNN3JNYT.js";
 import "./chunk-6AM5D4ME.js";
-import "./chunk-2Z5UX4KI.js";
+import "./chunk-OSSDHJDU.js";
 import {
   HookEventName,
   createHookOutput
-} from "./chunk-ARKANCNX.js";
-import "./chunk-L5U3ELZX.js";
-import "./chunk-TYLOFD2U.js";
+} from "./chunk-SGPFJMRP.js";
+import "./chunk-335ECZTA.js";
+import "./chunk-JCJPZMJV.js";
 import {
   AuthType,
   ConversationFinishedEvent,
@@ -349,66 +366,79 @@ import {
   endToolExecutionSpan,
   endToolSpan,
   extractDaemonTraceContext,
+  formatFullTurnVisionNotice,
+  formatVisionBridgeNotice,
   getAllGeminiMdFilenames,
+  getFullTurnVisionModelSelector,
   getMCPServerStatus,
+  hasImageParts,
   logConversationFinishedEvent,
   logLoopDetected,
   logPromptSuggestion,
   logToolCall,
   logUserPrompt,
+  normalizeParts,
   registerAcpEventLoopLagGauge,
   runInToolSpanContext,
+  runVisionBridge,
+  shouldRunVisionBridge,
+  splitImageParts,
   startEventLoopLagMonitor,
   startToolExecutionSpan,
   startToolSpan,
   uiTelemetryService,
+  withDaemonSpan,
   withInteractionSpan
-} from "./chunk-P6LART6G.js";
+} from "./chunk-66IT3EY2.js";
 import "./chunk-4WKAA4KS.js";
 import "./chunk-CR3C7WXL.js";
-import "./chunk-CARU2RR2.js";
+import {
+  runSideQuery
+} from "./chunk-U2LNTX56.js";
 import "./chunk-VGC4I5JJ.js";
 import {
   getAutoMemoryRoot,
   getUserAutoMemoryRoot
-} from "./chunk-FBU7WRZI.js";
-import "./chunk-Y66VOBRP.js";
-import "./chunk-WX6SD4IQ.js";
+} from "./chunk-FUTHTZVV.js";
+import "./chunk-4CA4WUMS.js";
+import "./chunk-WEPXQKGP.js";
 import {
   ToolConfirmationOutcome,
-  ToolNames
-} from "./chunk-2UUAIFQO.js";
+  ToolNames,
+  isShellProgressData
+} from "./chunk-ANRANWVE.js";
 import {
   clearCachedCredentialFile,
   qwenOAuth2Events
-} from "./chunk-OKAIGAYW.js";
-import "./chunk-ZPAHLFZU.js";
+} from "./chunk-G274ETR6.js";
+import "./chunk-Z2LBNX3R.js";
 import "./chunk-JESCGQM3.js";
-import "./chunk-WIEO4CWB.js";
+import "./chunk-VAJS2E2D.js";
 import "./chunk-XVNQMZ2I.js";
+import "./chunk-FEOZBUMT.js";
 import {
   DEFAULT_TOKEN_LIMIT,
+  getToolCallPreparations,
   tokenLimit
-} from "./chunk-B7NUUEXC.js";
-import "./chunk-TQBODCFD.js";
+} from "./chunk-CMVFTMRD.js";
 import "./chunk-A4UCTEB5.js";
 import "./chunk-XWRJCPHC.js";
-import "./chunk-4LD5APFL.js";
+import "./chunk-TYQMGACW.js";
 import "./chunk-TYAMGABM.js";
 import "./chunk-FCMNKVXT.js";
 import "./chunk-DJ2GSRLV.js";
-import "./chunk-LQIDP6K5.js";
+import "./chunk-4CHDYDG3.js";
 import {
   Storage,
   createDebugLogger,
   getErrorMessage,
   getErrorStatus,
   isSubpath
-} from "./chunk-7NFB7LBQ.js";
-import "./chunk-XLIRF7IK.js";
+} from "./chunk-UE5TZ55T.js";
+import "./chunk-S4N3G4BB.js";
 import {
   runExitCleanup
-} from "./chunk-TISZXPAX.js";
+} from "./chunk-4HCYNDMG.js";
 import "./chunk-75DOP5OR.js";
 import "./chunk-DMTGGOSA.js";
 import "./chunk-YQ3U5MUC.js";
@@ -423,6 +453,7 @@ import {
 // packages/cli/src/acp-integration/acpAgent.ts
 init_esbuild_shims();
 import { randomUUID } from "node:crypto";
+import { performance } from "node:perf_hooks";
 
 // packages/cli/src/acp-integration/authMethods.ts
 init_esbuild_shims();
@@ -802,6 +833,104 @@ import { Buffer as Buffer2 } from "node:buffer";
 import * as os2 from "node:os";
 import * as path3 from "node:path";
 
+// packages/cli/src/utils/midTurnUserMessage.ts
+init_esbuild_shims();
+var MID_TURN_USER_MESSAGE_PREFIX = "\n[User message received during tool execution]: ";
+function prefixMidTurnUserMessageParts(parts, displayText) {
+  const partArray = normalizePartList(parts);
+  if (partArray.length === 0) {
+    return [{ text: `${MID_TURN_USER_MESSAGE_PREFIX}${displayText}` }];
+  }
+  const [firstPart, ...rest] = partArray;
+  if ("text" in firstPart && typeof firstPart.text === "string") {
+    return [
+      {
+        ...firstPart,
+        text: `${MID_TURN_USER_MESSAGE_PREFIX}${firstPart.text}`
+      },
+      ...rest
+    ];
+  }
+  return [
+    { text: `${MID_TURN_USER_MESSAGE_PREFIX}${displayText}` },
+    ...partArray
+  ];
+}
+__name(prefixMidTurnUserMessageParts, "prefixMidTurnUserMessageParts");
+
+// packages/cli/src/acp-integration/session/tool-call-preparation-tracker.ts
+init_esbuild_shims();
+var ToolCallPreparationTracker = class {
+  constructor(emitter) {
+    this.emitter = emitter;
+  }
+  static {
+    __name(this, "ToolCallPreparationTracker");
+  }
+  /** Contains only calls whose start frame was emitted successfully. */
+  pending = /* @__PURE__ */ new Map();
+  /** Contains calls whose start frame was intentionally suppressed. */
+  suppressed = /* @__PURE__ */ new Set();
+  /** Calls parsed completely but not yet handed to tool execution. */
+  resolved = /* @__PURE__ */ new Set();
+  /**
+   * Emits at most one preparing frame per call ID before the full call arrives.
+   */
+  async observe(response) {
+    for (const preparation of getToolCallPreparations(response)) {
+      if (this.pending.has(preparation.callId) || this.suppressed.has(preparation.callId)) {
+        continue;
+      }
+      const emitted = await this.emitter.emitStart({
+        callId: preparation.callId,
+        toolName: preparation.toolName,
+        args: {},
+        status: "pending",
+        phase: "preparing"
+      });
+      if (emitted) {
+        this.pending.set(preparation.callId, preparation.toolName);
+      } else {
+        this.suppressed.add(preparation.callId);
+      }
+    }
+  }
+  /** Resolves preparations once their complete function calls arrive. */
+  resolve(functionCalls) {
+    for (const functionCall of functionCalls) {
+      if (functionCall.id && this.pending.has(functionCall.id)) {
+        this.resolved.add(functionCall.id);
+      }
+    }
+  }
+  /**
+   * Terminates unresolved preparations. The map is cleared first so repeated
+   * cleanup, including re-entry after an emission failure, cannot emit twice.
+   */
+  async discard(includeResolved = false) {
+    const pending = [...this.pending.entries()];
+    this.pending.clear();
+    const resolved = new Set(this.resolved);
+    this.resolved.clear();
+    let firstError;
+    let hasError = false;
+    for (const [callId, toolName] of pending) {
+      if (!includeResolved && resolved.has(callId)) continue;
+      try {
+        await this.emitter.emitPreparationDiscarded(callId, toolName);
+      } catch (error) {
+        if (!hasError) {
+          firstError = error;
+          hasError = true;
+        }
+      }
+    }
+    if (hasError) {
+      throw firstError;
+    }
+  }
+};
+
 // packages/cli/src/acp-integration/session/SubAgentTracker.ts
 init_esbuild_shims();
 
@@ -1512,6 +1641,17 @@ var debugLogger6 = createDebugLogger("SESSION");
 var USER_CANCEL_ABORT_REASON = "qwen:user-cancel";
 var DAEMON_RETRY_META_KEY = "qwen.daemon.retry";
 var DAEMON_CONTINUE_META_KEY = "qwen.daemon.continueLastTurn";
+async function finalizeToolCallPreparations(tracker, includeResolved, streamName) {
+  try {
+    await tracker.discard(includeResolved);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    debugLogger6.warn(
+      `Failed to discard tool preparations for ${streamName}; continuing stream: ${message}`
+    );
+  }
+}
+__name(finalizeToolCallPreparations, "finalizeToolCallPreparations");
 function maskApiKeyForDisplay(apiKey) {
   const trimmed = apiKey?.trim() ?? "";
   if (trimmed.length === 0) return "(not set)";
@@ -2581,6 +2721,14 @@ var Session = class {
             );
             const inputText = firstTextBlock?.text || "";
             let parts;
+            let fullTurnModelOverride;
+            const onFullTurnModel = /* @__PURE__ */ __name((model) => {
+              if (fullTurnModelOverride) {
+                return false;
+              }
+              fullTurnModelOverride = model;
+              return true;
+            }, "onFullTurnModel");
             if (isContinue) {
               parts = continuationParts;
             } else if (isSlashCommand(inputText)) {
@@ -2592,7 +2740,9 @@ var Session = class {
               );
               parts = await this.#processSlashCommandResult(
                 slashCommandResult,
-                params.prompt
+                params.prompt,
+                pendingSend.signal,
+                onFullTurnModel
               );
               if (parts === null) {
                 return { stopReason: "end_turn" };
@@ -2601,7 +2751,7 @@ var Session = class {
               parts = await this.#resolvePrompt(
                 params.prompt,
                 pendingSend.signal,
-                { promptLast: true }
+                { promptLast: true, onFullTurnModel }
               );
             }
             const hooksEnabled = !this.config.getDisableAllHooks?.();
@@ -2676,6 +2826,9 @@ ${this.pendingWorktreeNotice}
                   return { stopReason: "cancelled" };
                 }
                 const functionCalls = [];
+                const preparationTracker = new ToolCallPreparationTracker(
+                  this.toolCallEmitter
+                );
                 let usageMetadata = null;
                 const streamStartTime = Date.now();
                 const messageDisplay = this.#createMessageDisplayDispatcher(
@@ -2685,7 +2838,8 @@ ${this.pendingWorktreeNotice}
                   const sendResult = await this.#sendMessageStreamWithAutoCompression(
                     promptId,
                     nextMessage?.parts ?? [],
-                    pendingSend.signal
+                    pendingSend.signal,
+                    { modelOverride: fullTurnModelOverride }
                   );
                   if (!sendResult.responseStream) {
                     this.#preserveUnsentMessageHistory(
@@ -2696,35 +2850,56 @@ ${this.pendingWorktreeNotice}
                   }
                   const responseStream = sendResult.responseStream;
                   nextMessage = null;
-                  for await (const resp of responseStream) {
-                    if (pendingSend.signal.aborted) {
-                      return { stopReason: "cancelled" };
-                    }
-                    if (resp.type === "chunk" /* CHUNK */ && resp.value.candidates && resp.value.candidates.length > 0) {
-                      const candidate = resp.value.candidates[0];
-                      for (const part of candidate.content?.parts ?? []) {
-                        if (!part.text) {
-                          continue;
+                  let streamFailed = false;
+                  try {
+                    for await (const resp of responseStream) {
+                      if (pendingSend.signal.aborted) {
+                        return { stopReason: "cancelled" };
+                      }
+                      if (resp.type === "chunk" /* CHUNK */ && resp.value.candidates && resp.value.candidates.length > 0) {
+                        const candidate = resp.value.candidates[0];
+                        for (const part of candidate.content?.parts ?? []) {
+                          if (!part.text) {
+                            continue;
+                          }
+                          this.messageEmitter.emitMessage(
+                            part.text,
+                            "assistant",
+                            part.thought
+                          );
+                          if (!part.thought) {
+                            messageDisplay?.addChunk(part.text);
+                          }
                         }
-                        this.messageEmitter.emitMessage(
-                          part.text,
-                          "assistant",
-                          part.thought
-                        );
-                        if (!part.thought) {
-                          messageDisplay?.addChunk(part.text);
+                      }
+                      if (resp.type === "chunk" /* CHUNK */ && resp.value.usageMetadata) {
+                        usageMetadata = resp.value.usageMetadata;
+                      }
+                      if (resp.type === "chunk" /* CHUNK */) {
+                        await preparationTracker.observe(resp.value);
+                        if (resp.value.functionCalls) {
+                          preparationTracker.resolve(resp.value.functionCalls);
+                          functionCalls.push(...resp.value.functionCalls);
                         }
                       }
+                      if (resp.type === "retry" /* RETRY */ || resp.type === "model_fallback" /* MODEL_FALLBACK */) {
+                        await finalizeToolCallPreparations(
+                          preparationTracker,
+                          true,
+                          `main prompt ${resp.type}`
+                        );
+                        functionCalls.length = 0;
+                      }
                     }
-                    if (resp.type === "chunk" /* CHUNK */ && resp.value.usageMetadata) {
-                      usageMetadata = resp.value.usageMetadata;
-                    }
-                    if (resp.type === "chunk" /* CHUNK */ && resp.value.functionCalls) {
-                      functionCalls.push(...resp.value.functionCalls);
-                    }
-                    if (resp.type === "model_fallback" /* MODEL_FALLBACK */) {
-                      functionCalls.length = 0;
-                    }
+                  } catch (error) {
+                    streamFailed = true;
+                    throw error;
+                  } finally {
+                    await finalizeToolCallPreparations(
+                      preparationTracker,
+                      streamFailed || pendingSend.signal.aborted,
+                      "main prompt"
+                    );
                   }
                 } catch (error) {
                   if (strippedOrphanEntries && (this.#getCurrentChat().getUserContentPushCount?.() ?? 0) <= orphanPushCountSnapshot) {
@@ -2772,11 +2947,14 @@ ${this.pendingWorktreeNotice}
                   );
                 }
                 if (functionCalls.length > 0) {
-                  const toolRun = await this.runToolCalls(
-                    pendingSend.signal,
-                    promptId,
-                    functionCalls,
-                    toolLoopState
+                  const toolRun = await this.#runWithFullTurnModel(
+                    fullTurnModelOverride,
+                    () => this.runToolCalls(
+                      pendingSend.signal,
+                      promptId,
+                      functionCalls,
+                      toolLoopState
+                    )
                   );
                   if (toolRun.stopAfterPermissionCancel) {
                     await this.#preserveStoppedToolRun(
@@ -2787,7 +2965,8 @@ ${this.pendingWorktreeNotice}
                   }
                   nextMessage = await this.#buildNextMessageAfterToolRun(
                     toolRun,
-                    pendingSend.signal
+                    pendingSend.signal,
+                    onFullTurnModel
                   );
                   if (toolRun.loopDetected) {
                     await this.#preserveStoppedToolRun(
@@ -2805,7 +2984,8 @@ ${this.pendingWorktreeNotice}
                 pendingSend,
                 promptId,
                 hooksEnabled,
-                messageBus
+                messageBus,
+                fullTurnModelOverride
               );
             } finally {
               logConversationFinishedEvent(
@@ -2834,10 +3014,17 @@ ${this.pendingWorktreeNotice}
    * @param messageBus - The MessageBus for hook communication (may be undefined)
    * @returns The ACP stop reason for the prompt.
    */
-  async #handleStopHookLoop(pendingSend, promptId, hooksEnabled, messageBus) {
+  async #handleStopHookLoop(pendingSend, promptId, hooksEnabled, messageBus, modelOverride) {
     const stopHookBlockingCap = this.config.getStopHookBlockingCap();
     let stopHookIterationCount = 0;
     let stopHookReasons = [];
+    const onFullTurnModel = /* @__PURE__ */ __name((model) => {
+      if (modelOverride) {
+        return false;
+      }
+      modelOverride = model;
+      return true;
+    }, "onFullTurnModel");
     while (stopHookIterationCount < stopHookBlockingCap) {
       if (!hooksEnabled || !messageBus || pendingSend.signal.aborted || !this.config.hasHooksForEvent?.("Stop")) {
         return { stopReason: "end_turn" };
@@ -2904,6 +3091,9 @@ ${this.pendingWorktreeNotice}
             return { stopReason: "cancelled" };
           }
           const functionCalls = [];
+          const preparationTracker = new ToolCallPreparationTracker(
+            this.toolCallEmitter
+          );
           let usageMetadata = null;
           const streamStartTime = Date.now();
           const messageDisplay = this.#createMessageDisplayDispatcher(
@@ -2914,7 +3104,10 @@ ${this.pendingWorktreeNotice}
               promptId + "_stop_hook_" + stopHookIterationCount,
               nextMessage?.parts ?? [],
               pendingSend.signal,
-              { skipCompression: stopHookIterationCount > 1 }
+              {
+                skipCompression: stopHookIterationCount > 1,
+                modelOverride
+              }
             );
             if (!continueSendResult.responseStream) {
               this.#preserveUnsentMessageHistory(
@@ -2925,33 +3118,54 @@ ${this.pendingWorktreeNotice}
             }
             const continueResponseStream = continueSendResult.responseStream;
             nextMessage = null;
-            for await (const resp of continueResponseStream) {
-              if (pendingSend.signal.aborted) {
-                return { stopReason: "cancelled" };
-              }
-              if (resp.type === "chunk" /* CHUNK */ && resp.value.candidates && resp.value.candidates.length > 0) {
-                const candidate = resp.value.candidates[0];
-                for (const part of candidate.content?.parts ?? []) {
-                  if (!part.text) continue;
-                  this.messageEmitter.emitMessage(
-                    part.text,
-                    "assistant",
-                    part.thought
-                  );
-                  if (!part.thought) {
-                    messageDisplay?.addChunk(part.text);
+            let streamFailed = false;
+            try {
+              for await (const resp of continueResponseStream) {
+                if (pendingSend.signal.aborted) {
+                  return { stopReason: "cancelled" };
+                }
+                if (resp.type === "chunk" /* CHUNK */ && resp.value.candidates && resp.value.candidates.length > 0) {
+                  const candidate = resp.value.candidates[0];
+                  for (const part of candidate.content?.parts ?? []) {
+                    if (!part.text) continue;
+                    this.messageEmitter.emitMessage(
+                      part.text,
+                      "assistant",
+                      part.thought
+                    );
+                    if (!part.thought) {
+                      messageDisplay?.addChunk(part.text);
+                    }
                   }
                 }
+                if (resp.type === "chunk" /* CHUNK */ && resp.value.usageMetadata) {
+                  usageMetadata = resp.value.usageMetadata;
+                }
+                if (resp.type === "chunk" /* CHUNK */) {
+                  await preparationTracker.observe(resp.value);
+                  if (resp.value.functionCalls) {
+                    preparationTracker.resolve(resp.value.functionCalls);
+                    functionCalls.push(...resp.value.functionCalls);
+                  }
+                }
+                if (resp.type === "retry" /* RETRY */ || resp.type === "model_fallback" /* MODEL_FALLBACK */) {
+                  await finalizeToolCallPreparations(
+                    preparationTracker,
+                    true,
+                    `Stop Hook continuation ${resp.type}`
+                  );
+                  functionCalls.length = 0;
+                }
               }
-              if (resp.type === "chunk" /* CHUNK */ && resp.value.usageMetadata) {
-                usageMetadata = resp.value.usageMetadata;
-              }
-              if (resp.type === "chunk" /* CHUNK */ && resp.value.functionCalls) {
-                functionCalls.push(...resp.value.functionCalls);
-              }
-              if (resp.type === "model_fallback" /* MODEL_FALLBACK */) {
-                functionCalls.length = 0;
-              }
+            } catch (error) {
+              streamFailed = true;
+              throw error;
+            } finally {
+              await finalizeToolCallPreparations(
+                preparationTracker,
+                streamFailed || pendingSend.signal.aborted,
+                "Stop Hook continuation"
+              );
             }
           } catch (error) {
             const errorStatus = getErrorStatus(error);
@@ -2987,11 +3201,14 @@ ${this.pendingWorktreeNotice}
             );
           }
           if (functionCalls.length > 0) {
-            const toolRun = await this.runToolCalls(
-              pendingSend.signal,
-              promptId,
-              functionCalls,
-              toolLoopState
+            const toolRun = await this.#runWithFullTurnModel(
+              modelOverride,
+              () => this.runToolCalls(
+                pendingSend.signal,
+                promptId,
+                functionCalls,
+                toolLoopState
+              )
             );
             if (toolRun.stopAfterPermissionCancel) {
               await this.#preserveStoppedToolRun(toolRun, pendingSend.signal);
@@ -2999,7 +3216,8 @@ ${this.pendingWorktreeNotice}
             }
             nextMessage = await this.#buildNextMessageAfterToolRun(
               toolRun,
-              pendingSend.signal
+              pendingSend.signal,
+              onFullTurnModel
             );
             if (toolRun.loopDetected) {
               await this.#preserveStoppedToolRun(toolRun, pendingSend.signal);
@@ -3023,6 +3241,13 @@ ${this.pendingWorktreeNotice}
   #getCurrentChat() {
     return this.config.getGeminiClient().getChat();
   }
+  async #runWithFullTurnModel(modelOverride, fn) {
+    if (!modelOverride?.endsWith("\0")) {
+      return fn();
+    }
+    const runtimeView = await this.config.getBaseLlmClient().resolveForModel(modelOverride.slice(0, -1), { failClosed: true });
+    return runWithRuntimeContentGenerator(runtimeView, fn);
+  }
   /**
    * Mirrors the core send path for ACP model sends.
    *
@@ -3057,7 +3282,7 @@ ${this.pendingWorktreeNotice}
     const geminiClient = this.config.getGeminiClient();
     let compressionDiagnostic = null;
     let compressionInfo = null;
-    if (!options.skipCompression) {
+    if (!options.skipCompression && !options.modelOverride) {
       try {
         const compressed = await geminiClient.tryCompressChat(
           promptId,
@@ -3115,7 +3340,7 @@ ${this.pendingWorktreeNotice}
       return { responseStream: null, stopReason: "cancelled" };
     }
     const responseStream = await this.#getCurrentChat().sendMessageStream(
-      this.config.getModel(),
+      options.modelOverride ?? this.config.getModel(),
       {
         message,
         config: {
@@ -3162,7 +3387,7 @@ ${this.pendingWorktreeNotice}
     );
     await this.messageRewriter?.waitForPendingRewrites();
   }
-  async #buildNextMessageAfterToolRun(toolRun, abortSignal) {
+  async #buildNextMessageAfterToolRun(toolRun, abortSignal, onFullTurnModel) {
     if (toolRun.loopDetected) {
       debugLogger6.debug("Stopping ACP turn after daemon loop detection.");
       return null;
@@ -3175,7 +3400,7 @@ ${this.pendingWorktreeNotice}
     }
     const parts = [
       ...toolRun.parts,
-      ...await this.#drainMidTurnUserMessages(abortSignal)
+      ...await this.#drainMidTurnUserMessages(abortSignal, onFullTurnModel)
     ];
     return { role: "user", parts };
   }
@@ -3255,10 +3480,10 @@ ${this.pendingWorktreeNotice}
       content: { type: "text", text }
     });
   }
-  async #drainMidTurnUserMessages(abortSignal) {
+  async #drainMidTurnUserMessages(abortSignal, onFullTurnModel) {
     const recovered = this.#takeRecoveredMidTurnMessages();
     if (this.midTurnDrainUnavailable) {
-      return this.#buildMidTurnParts(recovered, abortSignal);
+      return this.#buildMidTurnParts(recovered, abortSignal, onFullTurnModel);
     }
     let drainPromise;
     try {
@@ -3281,7 +3506,8 @@ ${this.pendingWorktreeNotice}
       this.midTurnDrainTimeoutStrikes = 0;
       return this.#buildMidTurnParts(
         [...recovered, ...parseMidTurnDrainResponse(response)],
-        abortSignal
+        abortSignal,
+        onFullTurnModel
       );
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : error && typeof error === "object" && "message" in error ? String(error.message) : String(error);
@@ -3298,7 +3524,7 @@ ${this.pendingWorktreeNotice}
       debugLogger6.warn(
         `Mid-turn queue drain ${isPermanentError ? "permanently " : ""}unavailable [session ${this.sessionId}]: ${errorMessage}`
       );
-      return this.#buildMidTurnParts(recovered, abortSignal);
+      return this.#buildMidTurnParts(recovered, abortSignal, onFullTurnModel);
     }
   }
   /** Read and clear the buffer of messages recovered from a timed-out drain. */
@@ -3356,7 +3582,7 @@ ${this.pendingWorktreeNotice}
    * happens on injection (here), so a message recovered from an earlier
    * timed-out drain is still recorded exactly once.
    */
-  async #buildMidTurnParts(messages, abortSignal) {
+  async #buildMidTurnParts(messages, abortSignal, onFullTurnModel) {
     const parts = [];
     for (const message of messages) {
       const displayText = message.kind === "text" ? message.message : message.displayText;
@@ -3365,7 +3591,9 @@ ${this.pendingWorktreeNotice}
         rawParts = message.kind === "text" ? [{ text: message.message }] : await withTimeoutSignal(
           abortSignal,
           MID_TURN_QUEUE_RESOLVE_TIMEOUT_MS,
-          (signal) => this.#resolvePrompt(message.content, signal)
+          (signal) => this.#resolvePrompt(message.content, signal, {
+            onFullTurnModel
+          })
         );
       } catch (messageError) {
         if (abortSignal.aborted) return parts;
@@ -3557,6 +3785,9 @@ ${this.pendingWorktreeNotice}
                 turnCount++;
                 if (ac.signal.aborted) return;
                 const functionCalls = [];
+                const preparationTracker = new ToolCallPreparationTracker(
+                  this.toolCallEmitter
+                );
                 let usageMetadata = null;
                 const streamStartTime = Date.now();
                 const sendResult = await this.#sendMessageStreamWithAutoCompression(
@@ -3582,6 +3813,7 @@ ${this.pendingWorktreeNotice}
                 const messageDisplay = this.#createMessageDisplayDispatcher(
                   ac.signal
                 );
+                let streamFailed = false;
                 try {
                   for await (const resp of responseStream) {
                     if (ac.signal.aborted) return;
@@ -3602,15 +3834,35 @@ ${this.pendingWorktreeNotice}
                     if (resp.type === "chunk" /* CHUNK */ && resp.value.usageMetadata) {
                       usageMetadata = resp.value.usageMetadata;
                     }
-                    if (resp.type === "chunk" /* CHUNK */ && resp.value.functionCalls) {
-                      functionCalls.push(...resp.value.functionCalls);
+                    if (resp.type === "chunk" /* CHUNK */) {
+                      await preparationTracker.observe(resp.value);
+                      if (resp.value.functionCalls) {
+                        preparationTracker.resolve(resp.value.functionCalls);
+                        functionCalls.push(...resp.value.functionCalls);
+                      }
                     }
-                    if (resp.type === "model_fallback" /* MODEL_FALLBACK */) {
+                    if (resp.type === "retry" /* RETRY */ || resp.type === "model_fallback" /* MODEL_FALLBACK */) {
+                      await finalizeToolCallPreparations(
+                        preparationTracker,
+                        true,
+                        `cron/loop tick ${resp.type}`
+                      );
                       functionCalls.length = 0;
                     }
                   }
+                } catch (error) {
+                  streamFailed = true;
+                  throw error;
                 } finally {
-                  await messageDisplay?.finish();
+                  try {
+                    await finalizeToolCallPreparations(
+                      preparationTracker,
+                      streamFailed || ac.signal.aborted,
+                      "cron/loop tick"
+                    );
+                  } finally {
+                    await messageDisplay?.finish();
+                  }
                 }
                 if (usageMetadata) {
                   this.#recordPromptTokenCount(usageMetadata);
@@ -3808,6 +4060,9 @@ ${this.pendingWorktreeNotice}
               return;
             }
             const functionCalls = [];
+            const preparationTracker = new ToolCallPreparationTracker(
+              this.toolCallEmitter
+            );
             let usageMetadata = null;
             let responseText = "";
             const streamStartTime = Date.now();
@@ -3831,6 +4086,7 @@ ${this.pendingWorktreeNotice}
             const messageDisplay = this.#createMessageDisplayDispatcher(
               ac.signal
             );
+            let streamFailed = false;
             try {
               for await (const resp of responseStream) {
                 if (ac.signal.aborted) {
@@ -3856,15 +4112,35 @@ ${this.pendingWorktreeNotice}
                 if (resp.type === "chunk" /* CHUNK */ && resp.value.usageMetadata) {
                   usageMetadata = resp.value.usageMetadata;
                 }
-                if (resp.type === "chunk" /* CHUNK */ && resp.value.functionCalls) {
-                  functionCalls.push(...resp.value.functionCalls);
+                if (resp.type === "chunk" /* CHUNK */) {
+                  await preparationTracker.observe(resp.value);
+                  if (resp.value.functionCalls) {
+                    preparationTracker.resolve(resp.value.functionCalls);
+                    functionCalls.push(...resp.value.functionCalls);
+                  }
                 }
-                if (resp.type === "model_fallback" /* MODEL_FALLBACK */) {
+                if (resp.type === "retry" /* RETRY */ || resp.type === "model_fallback" /* MODEL_FALLBACK */) {
+                  await finalizeToolCallPreparations(
+                    preparationTracker,
+                    true,
+                    `background notification ${resp.type}`
+                  );
                   functionCalls.length = 0;
                 }
               }
+            } catch (error) {
+              streamFailed = true;
+              throw error;
             } finally {
-              await messageDisplay?.finish();
+              try {
+                await finalizeToolCallPreparations(
+                  preparationTracker,
+                  streamFailed || ac.signal.aborted,
+                  "background notification"
+                );
+              } finally {
+                await messageDisplay?.finish();
+              }
             }
             if (responseText.length > 0) {
               await this.#emitBackgroundNotificationResponse(
@@ -4083,7 +4359,17 @@ ${this.pendingWorktreeNotice}
     if (!rawModelId) {
       throw RequestError.invalidParams(void 0, "modelId cannot be empty");
     }
-    const parsed = parseAcpModelOption(rawModelId);
+    const resolvedRoute = resolveAcpModelOption(
+      rawModelId,
+      this.config.getAllConfiguredModels()
+    );
+    if (!resolvedRoute && rawModelId.startsWith(ACP_ROUTE_ID_PREFIX)) {
+      throw RequestError.invalidParams(
+        void 0,
+        `Unknown or stale model route: "${rawModelId}"`
+      );
+    }
+    const parsed = resolvedRoute ?? parseAcpModelOption(rawModelId);
     const previousAuthType = this.config.getAuthType?.();
     const selectedAuthType = parsed.authType ?? previousAuthType;
     if (!selectedAuthType) {
@@ -4092,29 +4378,49 @@ ${this.pendingWorktreeNotice}
         `authType cannot be determined for modelId "${parsed.modelId}"`
       );
     }
+    const requireCachedCredentials = selectedAuthType !== previousAuthType && selectedAuthType === "qwen-oauth" /* QWEN_OAUTH */;
+    const switchOptions = resolvedRoute?.baseUrl !== void 0 || requireCachedCredentials ? {
+      ...resolvedRoute?.baseUrl !== void 0 ? { baseUrl: resolvedRoute.baseUrl } : {},
+      ...requireCachedCredentials ? { requireCachedCredentials: true } : {}
+    } : void 0;
     await this.config.switchModel(
       selectedAuthType,
       parsed.modelId,
-      selectedAuthType !== previousAuthType && selectedAuthType === "qwen-oauth" /* QWEN_OAUTH */ ? { requireCachedCredentials: true } : void 0
+      switchOptions
     );
     const after = this.config.getContentGeneratorConfig?.();
     const effectiveAuthType = after?.authType ?? selectedAuthType;
     const effectiveModelId = after?.model ?? parsed.modelId;
+    const activeRuntimeSnapshot = this.config.getActiveRuntimeModelSnapshot?.();
+    const currentAcpModelId = getCurrentAcpModelId(
+      buildAcpModelOptions(this.config.getAllConfiguredModels()),
+      activeRuntimeSnapshot?.id ?? effectiveModelId,
+      activeRuntimeSnapshot?.authType ?? effectiveAuthType,
+      activeRuntimeSnapshot ? void 0 : resolvedRoute ? resolvedRoute.registryBaseUrl : this.config.getCurrentModelRegistryBaseUrl?.()
+    );
     void this.client.extNotification("qwen/notify/session/model-update", {
       v: 1,
       sessionId: this.sessionId,
-      currentModelId: effectiveModelId
+      currentModelId: currentAcpModelId
     }).catch((error) => {
       debugLogger6.debug("model-update extNotification failed", error);
     });
     if (options.persistDefault ?? true) {
       const persistScope = getPersistScopeForModelSelection(this.settings);
-      this.settings.setValue(persistScope, "model.name", parsed.modelId);
-      this.settings.setValue(persistScope, "model.baseUrl", "");
+      this.settings.setValue(
+        persistScope,
+        "model.name",
+        resolvedRoute?.isRuntime ? resolvedRoute.modelId : effectiveModelId
+      );
+      this.settings.setValue(
+        persistScope,
+        "model.baseUrl",
+        resolvedRoute && !resolvedRoute.isRuntime ? resolvedRoute.baseUrl ?? "" : ""
+      );
       this.settings.setValue(
         persistScope,
         "security.auth.selectedType",
-        selectedAuthType
+        effectiveAuthType
       );
     }
     return {
@@ -4124,7 +4430,7 @@ ${this.pendingWorktreeNotice}
           modelId: effectiveModelId,
           baseUrl: after?.baseUrl ?? "(default)",
           apiKey: maskApiKeyForDisplay(after?.apiKey),
-          isRuntime: rawModelId.startsWith("$runtime|")
+          isRuntime: resolvedRoute?.isRuntime ?? rawModelId.startsWith("$runtime|")
         }
       }
     };
@@ -4133,33 +4439,29 @@ ${this.pendingWorktreeNotice}
    * Sends a current_mode_update notification to the client.
    * Called after the agent switches modes (e.g., from exit_plan_mode tool).
    */
-  async sendCurrentModeUpdateNotification(outcome) {
-    let newModeId;
-    switch (outcome) {
-      case "proceed_always" /* ProceedAlways */:
-        newModeId = "auto-edit";
-        break;
-      case "restore_previous" /* RestorePrevious */:
-        newModeId = this.config.getApprovalMode();
-        break;
-      case "proceed_once" /* ProceedOnce */:
-      default:
-        newModeId = "default";
-        break;
-    }
+  async sendCurrentModeUpdateNotification() {
+    const newModeId = this.config.getApprovalMode();
     const update = {
       sessionUpdate: "current_mode_update",
       currentModeId: newModeId
     };
-    await this.sendUpdate(update);
-    void this.client.extNotification("qwen/notify/session/mode-update", {
-      v: 1,
-      sessionId: this.sessionId,
-      currentModeId: newModeId,
-      legacyFrameSent: true
-    }).catch((error) => {
+    let legacyFrameSent = false;
+    try {
+      await this.sendUpdate(update);
+      legacyFrameSent = true;
+    } catch (error) {
+      debugLogger6.debug("current_mode_update notification failed", error);
+    }
+    try {
+      await this.client.extNotification("qwen/notify/session/mode-update", {
+        v: 1,
+        sessionId: this.sessionId,
+        currentModeId: newModeId,
+        legacyFrameSent
+      });
+    } catch (error) {
       debugLogger6.debug("mode-update extNotification failed", error);
-    });
+    }
   }
   /**
    * Execute a batch of model-returned tool calls, running Agent calls
@@ -4767,7 +5069,13 @@ ${this.pendingWorktreeNotice}
             toolName,
             toolParams
           );
-          const { finalPermission, pmForcedAsk, pmCtx, denyMessage } = flowResult;
+          const {
+            finalPermission,
+            pmForcedAsk,
+            pmCtx,
+            denyMessage,
+            requiresUserInteraction
+          } = flowResult;
           const isPlanMode = approvalMode === "plan" /* PLAN */;
           if (finalPermission === "deny") {
             return earlyErrorResponse(
@@ -4792,7 +5100,7 @@ ${this.pendingWorktreeNotice}
             );
           }
           let wasAutoModeDenialFallback = false;
-          if (!autoModeAllowed && shouldRunAutoModeForCall(approvalMode, toolName)) {
+          if (!autoModeAllowed && !requiresUserInteraction && shouldRunAutoModeForCall(approvalMode, toolName)) {
             const denialState = this.config.getAutoModeDenialState();
             const fallback = shouldFallback(denialState);
             const messages = this.config.getGeminiClient?.()?.getHistoryTail(MAX_TRANSCRIPT_MESSAGES, false) ?? [];
@@ -4865,7 +5173,12 @@ ${this.pendingWorktreeNotice}
               this.config.setAutoModeDenialState(after);
             }
           }, "recordAutoModeFallbackResolution");
-          if (!autoModeAllowed && needsConfirmation(confirmationPermission, approvalMode, toolName)) {
+          if (!autoModeAllowed && needsConfirmation(
+            confirmationPermission,
+            approvalMode,
+            toolName,
+            requiresUserInteraction
+          )) {
             confirmationDetails = await invocation.getConfirmationDetails(abortSignal);
             injectPermissionRulesIfMissing(confirmationDetails, pmCtx);
             if (isPlanModeBlocked(
@@ -4892,7 +5205,7 @@ ${this.pendingWorktreeNotice}
                 args,
                 String(approvalMode)
               );
-              if (hookResult.hasDecision) {
+              if (hookResult.hasDecision && (!hookResult.shouldAllow || !requiresUserInteraction)) {
                 hookHandled = true;
                 if (hookResult.shouldAllow) {
                   if (hookResult.updatedInput) {
@@ -4915,7 +5228,7 @@ ${this.pendingWorktreeNotice}
                 }
               }
             }
-            if (approvalMode === "auto-edit" /* AUTO_EDIT */ && (confirmationDetails.type === "edit" || confirmationDetails.type === "info")) {
+            if (!requiresUserInteraction && approvalMode === "auto-edit" /* AUTO_EDIT */ && (confirmationDetails.type === "edit" || confirmationDetails.type === "info")) {
             } else if (!hookHandled) {
               didRequestPermission = true;
               const content = buildPermissionRequestContent(confirmationDetails);
@@ -4983,12 +5296,11 @@ ${this.pendingWorktreeNotice}
                   );
                 }
                 onStopAfterPermissionCancel?.();
+                const permissionFailureMessage = isExitPlanModeTool ? "The host could not present plan-exit approval. Plan mode remains active; use the host mode selector or /plan exit to leave plan mode." : `Permission request failed for "${toolName}": ${this.#formatError(
+                  error
+                )}`;
                 return earlyErrorResponse(
-                  new Error(
-                    `Permission request failed for "${toolName}": ${this.#formatError(
-                      error
-                    )}`
-                  ),
+                  new Error(permissionFailureMessage),
                   toolName,
                   { stopAfterPermissionCancel: true }
                 );
@@ -5017,11 +5329,8 @@ ${this.pendingWorktreeNotice}
                   { answers: output.answers }
                 );
               }
-              if (isExitPlanModeTool && outcome !== "cancel" /* Cancel */) {
-                await this.sendCurrentModeUpdateNotification(outcome);
-              }
               if (confirmationDetails.type === "edit" && outcome === "proceed_always" /* ProceedAlways */) {
-                await this.sendCurrentModeUpdateNotification(outcome);
+                await this.sendCurrentModeUpdateNotification();
               }
               switch (outcome) {
                 case "cancel" /* Cancel */:
@@ -5079,43 +5388,81 @@ ${this.pendingWorktreeNotice}
           }
           const execSpan = startToolExecutionSpan();
           let toolResult;
+          let isExecutionTimeout = false;
+          let aborted = false;
+          let toolSettled = false;
+          let heartbeatCount = 0;
+          let lastHeartbeat;
+          const onToolProgress = /* @__PURE__ */ __name((chunk) => {
+            if (toolSettled || !isShellProgressData(chunk)) {
+              return;
+            }
+            heartbeatCount++;
+            lastHeartbeat = chunk;
+            void this.sendUpdate({
+              sessionUpdate: "tool_call_update",
+              toolCallId: callId,
+              status: "in_progress",
+              _meta: { toolName, shellProgress: chunk }
+            }).catch((err) => {
+              debugLogger6.debug(
+                `[Session.runTool] heartbeat update failed for ${callId}: ${err}`
+              );
+            });
+          }, "onToolProgress");
+          const heartbeatSpanAttributes = /* @__PURE__ */ __name(() => heartbeatCount > 0 ? {
+            attributes: {
+              "shell.heartbeat_count": heartbeatCount,
+              ...lastHeartbeat?.lastOutputAgeMs !== void 0 && {
+                "shell.last_output_age_ms": lastHeartbeat.lastOutputAgeMs
+              }
+            }
+          } : void 0, "heartbeatSpanAttributes");
           try {
             const sleepInhibitorHandle = acquireSleepInhibitor(
               this.config,
               `Qwen Code is executing tool ${toolName}`
             );
             try {
-              toolResult = await invocation.execute(activeToolAbortSignal);
+              toolResult = await invocation.execute(
+                activeToolAbortSignal,
+                onToolProgress
+              );
             } finally {
+              toolSettled = true;
               sleepInhibitorHandle.release();
             }
-            const aborted2 = activeToolAbortSignal.aborted;
+            isExecutionTimeout = toolResult.error?.type === "execution_timeout" /* EXECUTION_TIMEOUT */;
+            aborted = activeToolAbortSignal.aborted && !isExecutionTimeout;
             endToolExecutionSpan(execSpan, {
-              success: !toolResult.error && !aborted2,
-              error: aborted2 ? "tool_cancelled" : toolResult.error ? "tool_error" : void 0,
-              cancelled: aborted2
+              success: !toolResult.error && !aborted,
+              error: aborted ? "tool_cancelled" : isExecutionTimeout ? "tool_timeout" : toolResult.error ? "tool_error" : void 0,
+              cancelled: aborted,
+              ...heartbeatSpanAttributes()
             });
           } catch (execError) {
             endToolExecutionSpan(execSpan, {
               success: false,
               error: activeToolAbortSignal.aborted ? "tool_cancelled" : "tool_exception",
-              cancelled: activeToolAbortSignal.aborted
+              cancelled: activeToolAbortSignal.aborted,
+              ...heartbeatSpanAttributes()
             });
             throw execError;
           }
           cleanupAgentToolResources();
-          if ((isEnterPlanModeTool || isExitPlanModeTool) && !didRequestPermission && !toolResult.error && this.config.getApprovalMode() !== approvalMode) {
-            await this.sendUpdate({
-              sessionUpdate: "current_mode_update",
-              currentModeId: this.config.getApprovalMode()
-            });
+          if ((isEnterPlanModeTool || isExitPlanModeTool) && !toolResult.error && this.config.getApprovalMode() !== approvalMode) {
+            await this.sendCurrentModeUpdateNotification();
           }
-          const responseParts = convertToFunctionResponse(
+          const responseParts = toolResult.error ? convertToFunctionErrorResponse(
+            toolName,
+            callId,
+            toolResult.llmContent,
+            toolResult.error.message
+          ) : convertToFunctionResponse(
             toolName,
             callId,
             toolResult.llmContent
           );
-          const aborted = activeToolAbortSignal.aborted;
           const status = aborted ? "cancelled" : toolResult.error ? "error" : "success";
           const succeeded = status === "success";
           const responseError = toolResult.error ? new Error(toolResult.error.message) : aborted ? new Error("Tool execution was cancelled") : void 0;
@@ -5343,11 +5690,15 @@ ${this.pendingWorktreeNotice}
    * @param originalPrompt The original prompt blocks
    * @returns Parts to use for the prompt, or null if command was handled without needing model interaction
    */
-  async #processSlashCommandResult(result, originalPrompt) {
+  async #processSlashCommandResult(result, originalPrompt, abortSignal, onFullTurnModel) {
     this.#emitGoalStatusItems(result);
     switch (result.type) {
       case "submit_prompt":
-        return normalizePartList(result.content);
+        return this.#applyBridgeConversionsIfNeeded(
+          normalizePartList(result.content),
+          abortSignal,
+          onFullTurnModel
+        );
       case "message": {
         if (result.messageType === "error") {
           throw new Error(result.content || "Slash command failed.");
@@ -5390,11 +5741,10 @@ ${this.pendingWorktreeNotice}
         throw new Error(unsupportedError);
       }
       case "no_command":
-        return this.#resolvePrompt(
-          originalPrompt,
-          new AbortController().signal,
-          { promptLast: true }
-        );
+        return this.#resolvePrompt(originalPrompt, abortSignal, {
+          promptLast: true,
+          onFullTurnModel
+        });
       default: {
         const _exhaustive = result;
         const unknownError = `Unknown slash command result type: ${_exhaustive.type}`;
@@ -5468,12 +5818,17 @@ ${this.pendingWorktreeNotice}
     );
     const mcpServerParts = this.#resolveMcpServerMentionParts(mcpServerMentions);
     if (atPathCommandParts.length === 0 && embeddedContext.length === 0 && extensionParts.length === 0 && mcpServerParts.length === 0) {
-      return this.#applyBridgeConversionsIfNeeded(parts, abortSignal);
+      return this.#applyBridgeConversionsIfNeeded(
+        parts,
+        abortSignal,
+        options.onFullTurnModel
+      );
     }
     if (atPathCommandParts.length === 0 && embeddedContext.length === 0) {
       return this.#applyBridgeConversionsIfNeeded(
         [...parts, ...extensionParts, ...mcpServerParts],
-        abortSignal
+        abortSignal,
+        options.onFullTurnModel
       );
     }
     const pathSpecsToRead = atPathCommandParts.map(
@@ -5534,10 +5889,11 @@ ${contextPart.text}`
     const processedQueryParts = options.promptLast ? [...referenceParts, promptPart] : [promptPart, ...referenceParts];
     return this.#applyBridgeConversionsIfNeeded(
       processedQueryParts,
-      abortSignal
+      abortSignal,
+      options.onFullTurnModel
     );
   }
-  async #applyBridgeConversionsIfNeeded(originalParts, abortSignal) {
+  async #applyBridgeConversionsIfNeeded(originalParts, abortSignal, onFullTurnModel) {
     const parts = await this.#applyVoiceBridgeIfNeeded(
       originalParts,
       abortSignal
@@ -5545,6 +5901,28 @@ ${contextPart.text}`
     if (!hasImageParts(parts) || !shouldRunVisionBridge(this.config)) {
       return parts;
     }
+    const fullTurnModel = this.config.getDefaultVisionBridgeModel();
+    if (onFullTurnModel && fullTurnModel?.agentCapable) {
+      const fullTurnParts = parts.map((part) => clampInlineMediaPart(part));
+      if (!hasImageParts(fullTurnParts)) {
+        return fullTurnParts;
+      }
+      const selected = onFullTurnModel(
+        getFullTurnVisionModelSelector(fullTurnModel)
+      );
+      if (selected) {
+        try {
+          await this.messageEmitter.emitAgentMessage(
+            formatFullTurnVisionNotice(fullTurnModel)
+          );
+        } catch (error) {
+          debugLogger6.debug(
+            `full-turn vision: failed to emit notice; continuing error=${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      return fullTurnParts;
+    }
     let bridgeResult;
     try {
       debugLogger6.debug("vision bridge: gate matched, running conversion");
@@ -5565,7 +5943,7 @@ ${contextPart.text}`
     if (bridgeResult.status !== "skipped" || bridgeResult.egressOccurred) {
       try {
         await this.messageEmitter.emitAgentMessage(
-          this.#formatVisionBridgeNotice(bridgeResult)
+          formatVisionBridgeNotice(bridgeResult)
         );
       } catch (error) {
         debugLogger6.debug(
@@ -5674,20 +6052,6 @@ ${contextPart.text}`
   #formatVoiceBridgeEgressNotice(modelId, audioCount) {
     return `Sent ${audioCount} audio file(s) to ${modelId} for transcription, but no transcript was produced.`;
   }
-  #formatVisionBridgeNotice(result) {
-    const modelName = result.modelId ?? "vision model";
-    const target = result.modelEndpoint ? `${modelName} (${result.modelEndpoint})` : modelName;
-    const egressNote = result.egressOccurred ? ` Your image and prompt/context were sent to ${target}.` : "";
-    if (result.status === "failed") {
-      const reason = result.egressOccurred ? "the vision model request failed" : "the vision bridge could not run";
-      return `Vision bridge (${modelName}) failed: ${reason}.${egressNote} The image was not interpreted.`;
-    }
-    if (result.status === "skipped") {
-      return `Vision bridge cancelled.${egressNote}`;
-    }
-    const omitted = result.omittedCount > 0 ? ` (${result.omittedCount} image(s) omitted)` : "";
-    return `Converted ${result.convertedCount} image(s)${omitted} to text via ${target}. Your image and prompt/context were sent to that model.`;
-  }
   async #resolveExtensionMentionParts(extensionMentions, abortSignal) {
     if (extensionMentions.size === 0) return [];
     const activeExtensions = this.config.getActiveExtensions?.() ?? [];
@@ -5896,7 +6260,58 @@ var debugLogger7 = createDebugLogger("ACP_AGENT");
 var QWEN_ACP_LOCAL_READ_ROOTS_ENV = "QWEN_ACP_LOCAL_READ_ROOTS";
 var POSIX_TMP_LOCAL_READ_ROOT = "/tmp";
 var BTW_CHILD_TIMEOUT_MS = 55e3;
+var MCP_OAUTH_START_TIMEOUT_MS = 3e4;
 var WORKSPACE_MEMORY_REMEMBER_CHILD_TIMEOUT_MS = 295e3;
+function createAcpSessionStartProfiler(span) {
+  let failedStage;
+  const setAttribute = /* @__PURE__ */ __name((name, value) => {
+    try {
+      span?.setAttribute(name, value);
+    } catch {
+    }
+  }, "setAttribute");
+  const recordStage = /* @__PURE__ */ __name((stage, start) => {
+    const durationMs = Math.round((performance.now() - start) * 100) / 100;
+    if (Number.isFinite(durationMs) && durationMs >= 0) {
+      setAttribute(`qwen-code.daemon.session_start.${stage}_ms`, durationMs);
+    }
+  }, "recordStage");
+  const recordFailure = /* @__PURE__ */ __name((stage) => {
+    if (failedStage !== void 0) return;
+    failedStage = stage;
+    setAttribute("qwen-code.daemon.session_start.failed_stage", stage);
+  }, "recordFailure");
+  return {
+    async time(stage, fn) {
+      if (!span) return await fn();
+      const start = performance.now();
+      try {
+        return await fn();
+      } catch (error) {
+        recordFailure(stage);
+        throw error;
+      } finally {
+        recordStage(stage, start);
+      }
+    },
+    timeSync(stage, fn) {
+      if (!span) return fn();
+      const start = performance.now();
+      try {
+        return fn();
+      } catch (error) {
+        recordFailure(stage);
+        throw error;
+      } finally {
+        recordStage(stage, start);
+      }
+    },
+    setSessionId(sessionId) {
+      setAttribute("session.id", sessionId);
+    }
+  };
+}
+__name(createAcpSessionStartProfiler, "createAcpSessionStartProfiler");
 function workspaceMemoryErrorData(code, diagnostics) {
   return {
     errorKind: code,
@@ -5977,14 +6392,48 @@ function isBulkLoadReplayRequest(params) {
   return meta?.[LOAD_REPLAY_MODE_META_KEY] === LOAD_REPLAY_BULK_MODE;
 }
 __name(isBulkLoadReplayRequest, "isBulkLoadReplayRequest");
-function createHiddenWorkspaceMemoryConfig(config) {
-  return new Proxy(config, {
-    get(target, prop) {
-      if (prop === "getChatRecordingService") {
-        return () => void 0;
-      }
-      if (prop === "getTranscriptPath") {
-        return () => "";
+function getLoadReplayPageSize(params) {
+  const meta = isObjectRecord(params._meta) ? params._meta : void 0;
+  const value = meta?.[LOAD_REPLAY_PAGE_SIZE_META_KEY];
+  if (value === void 0) return void 0;
+  if (!Number.isSafeInteger(value) || value < 1 || value > SESSION_TRANSCRIPT_MAX_LIMIT) {
+    throw RequestError.invalidParams(
+      void 0,
+      `Invalid load replay page size; expected 1..${SESSION_TRANSCRIPT_MAX_LIMIT}`
+    );
+  }
+  return value;
+}
+__name(getLoadReplayPageSize, "getLoadReplayPageSize");
+function isHistoryTurnStart(record) {
+  return record.type === "user" && record.subtype !== "mid_turn_user_message";
+}
+__name(isHistoryTurnStart, "isHistoryTurnStart");
+function selectRecentHistoryRecords(records, pageSize) {
+  if (pageSize === void 0 || records.length <= pageSize) {
+    return { records, hasMore: false };
+  }
+  let start = records.length - pageSize;
+  for (let i = start; i < records.length; i++) {
+    if (isHistoryTurnStart(records[i])) {
+      start = i;
+      break;
+    }
+  }
+  while (start > 0 && !isHistoryTurnStart(records[start])) {
+    start--;
+  }
+  return { records: records.slice(start), hasMore: start > 0 };
+}
+__name(selectRecentHistoryRecords, "selectRecentHistoryRecords");
+function createHiddenWorkspaceMemoryConfig(config) {
+  return new Proxy(config, {
+    get(target, prop) {
+      if (prop === "getChatRecordingService") {
+        return () => void 0;
+      }
+      if (prop === "getTranscriptPath") {
+        return () => "";
       }
       const value = Reflect.get(target, prop, target);
       return typeof value === "function" ? value.bind(target) : value;
@@ -6034,6 +6483,10 @@ var QWEN_CORE_SETTING_DEFINITIONS = {
   "general.showSessionRecap": { type: "boolean" },
   "general.sessionRecapAwayThresholdMinutes": { type: "number", min: 1 },
   "general.terminalBell": { type: "boolean" },
+  "general.notificationMode": {
+    type: "enum",
+    values: ["all", "task-complete"]
+  },
   "general.gitCoAuthor.commit": { type: "boolean" },
   "general.gitCoAuthor.pr": { type: "boolean" },
   "general.defaultFileEncoding": {
@@ -6058,7 +6511,7 @@ var QWEN_HOOK_EVENTS = Object.values(HookEventName);
 var DEFAULT_QWEN_MEMORY_SETTINGS = {
   enableManagedAutoMemory: true,
   enableManagedAutoDream: true,
-  enableAutoSkill: true,
+  enableAutoSkill: false,
   autoSkillConfirm: true,
   enableTeamMemory: false,
   enableTeamMemorySync: false
@@ -7137,42 +7590,6 @@ function toMcpServerConfig(value) {
   return void 0;
 }
 __name(toMcpServerConfig, "toMcpServerConfig");
-var REDACTED_MCP_SECRET = "__redacted__";
-function redactMcpServerSecrets(server) {
-  const redactValues = /* @__PURE__ */ __name((record) => record ? Object.fromEntries(
-    Object.keys(record).map((key) => [key, REDACTED_MCP_SECRET])
-  ) : record, "redactValues");
-  return {
-    ...server,
-    env: redactValues(server.env),
-    headers: redactValues(server.headers)
-  };
-}
-__name(redactMcpServerSecrets, "redactMcpServerSecrets");
-function restoreRedactedMcpSecrets(server, existing) {
-  const restore = /* @__PURE__ */ __name((incoming, prior) => {
-    if (!incoming) return incoming;
-    const priorRecord = toRecord(prior);
-    const result = {};
-    for (const [key, value] of Object.entries(incoming)) {
-      if (value !== REDACTED_MCP_SECRET) {
-        result[key] = value;
-        continue;
-      }
-      const priorValue = priorRecord[key];
-      if (typeof priorValue === "string") {
-        result[key] = priorValue;
-      }
-    }
-    return result;
-  }, "restore");
-  return {
-    ...server,
-    env: restore(server.env, existing["env"]),
-    headers: restore(server.headers, existing["headers"])
-  };
-}
-__name(restoreRedactedMcpSecrets, "restoreRedactedMcpSecrets");
 function redactSecretRecord(record) {
   return record ? Object.fromEntries(
     Object.keys(record).map((key) => [key, REDACTED_MCP_SECRET])
@@ -7664,6 +8081,12 @@ var QwenAgent = class {
     __name(this, "QwenAgent");
   }
   sessions = /* @__PURE__ */ new Map();
+  workspaceMcpDiscoveryConfig;
+  workspaceMcpDiscoveryPromise;
+  workspaceMcpDiscoveryError;
+  pendingMcpAuthentications = /* @__PURE__ */ new Map();
+  mcpAuthenticationResults = /* @__PURE__ */ new Map();
+  generationControllers = /* @__PURE__ */ new Map();
   transcriptReplayConfigCache = /* @__PURE__ */ new Map();
   clientCapabilities;
   // CPU-usage delta baseline for the daemon's `workspaceResource` extMethod
@@ -7697,6 +8120,178 @@ var QwenAgent = class {
   getActiveSessions() {
     return [...this.sessions.values()];
   }
+  getWorkspaceMcpConfig(serverName) {
+    if (serverName && this.config.getRuntimeMcpServers?.()[serverName] !== void 0) {
+      return this.config;
+    }
+    return this.workspaceMcpDiscoveryConfig ?? this.config;
+  }
+  getLiveMcpConfigs(serverName) {
+    return [
+      .../* @__PURE__ */ new Set([
+        this.getWorkspaceMcpConfig(serverName),
+        this.config,
+        ...this.getActiveSessions().map((session) => session.getConfig())
+      ])
+    ].filter((config) => Boolean(config.getMcpServers()?.[serverName]));
+  }
+  async reconcileMcpServerAcrossLiveConfigs(serverName, operation) {
+    const errors = [];
+    for (const config of this.getLiveMcpConfigs(serverName)) {
+      try {
+        const registry = config.getToolRegistry();
+        if (operation === "discover") {
+          await registry?.discoverToolsForServer(serverName);
+          const geminiClient = config.getGeminiClient?.();
+          if (geminiClient?.isInitialized?.()) {
+            await geminiClient.setTools?.();
+          }
+        } else if (operation === "disable") {
+          await registry?.disableMcpServer(serverName);
+        } else {
+          await registry?.disconnectServer(serverName);
+        }
+      } catch (error) {
+        errors.push(error);
+      }
+    }
+    if (errors.length > 0) {
+      const details = errors.map(
+        (error) => error instanceof Error ? error.message : String(error)
+      ).join("; ");
+      throw new AggregateError(
+        errors,
+        `Failed to synchronize MCP server ${JSON.stringify(serverName)}: ${details}`
+      );
+    }
+  }
+  getMcpServerStatus(config, serverName) {
+    const manager = config.getToolRegistry()?.getMcpClientManager();
+    return manager?.getServerStatus?.(serverName) ?? getMCPServerStatus(serverName);
+  }
+  enqueueWorkspaceMcpDiscovery(label, run) {
+    const previous = this.workspaceMcpDiscoveryPromise ?? Promise.resolve();
+    const tracked = previous.then(async () => {
+      this.workspaceMcpDiscoveryError = void 0;
+      await run();
+    }).catch((err) => {
+      this.workspaceMcpDiscoveryError = err instanceof Error ? err.message : String(err);
+      debugLogger7.error(
+        `Workspace MCP ${label} failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }).finally(() => {
+      if (this.workspaceMcpDiscoveryPromise === tracked) {
+        this.workspaceMcpDiscoveryPromise = void 0;
+      }
+    });
+    this.workspaceMcpDiscoveryPromise = tracked;
+    return { accepted: true };
+  }
+  async createWorkspaceMcpDiscoveryConfig(settings) {
+    if (this.workspaceMcpDiscoveryConfig) return;
+    const cwd = this.config.getTargetDir();
+    const config = await loadCliConfig(
+      settings.merged,
+      {
+        ...this.argv,
+        sessionId: "workspace-mcp-discovery",
+        resume: void 0,
+        continue: false
+      },
+      cwd,
+      void 0,
+      {
+        userHooks: settings.getUserHooks(),
+        projectHooks: settings.getProjectHooks()
+      },
+      buildDisabledSkillNamesProvider(settings)
+    );
+    config.setMcpTransportPool(this.mcpPool);
+    try {
+      await config.initialize({
+        skipGeminiInitialization: true,
+        skipFileCheckpointing: true,
+        skipHooks: true,
+        skipSkillManager: true,
+        skipMcpDiscovery: true,
+        lenientToolWarmup: true
+      });
+      const manager = config.getToolRegistry()?.getMcpClientManager();
+      if (!manager) {
+        throw new Error("MCP client manager is unavailable");
+      }
+      await manager.discoverAllMcpToolsIncremental(config);
+      if (manager.getDiscoveryState() === "not_started" /* NOT_STARTED */) {
+        throw new Error(
+          "MCP discovery did not start. The workspace may not be trusted."
+        );
+      }
+      this.workspaceMcpDiscoveryConfig = config;
+    } catch (error) {
+      try {
+        await config.getToolRegistry()?.stop();
+      } catch {
+      }
+      throw error;
+    }
+  }
+  initializeWorkspaceMcpDiscovery() {
+    if (this.workspaceMcpDiscoveryConfig || this.workspaceMcpDiscoveryPromise) {
+      return { accepted: false };
+    }
+    return this.enqueueWorkspaceMcpDiscovery("initialization", async () => {
+      const settings = loadSettings(this.config.getTargetDir());
+      await this.createWorkspaceMcpDiscoveryConfig(settings);
+    });
+  }
+  reloadWorkspaceMcpDiscovery() {
+    return this.enqueueWorkspaceMcpDiscovery("reload", async () => {
+      const settings = loadSettings(this.config.getTargetDir());
+      const discoveryConfig = this.workspaceMcpDiscoveryConfig;
+      const liveConfigs = /* @__PURE__ */ new Set([
+        this.config,
+        ...this.getActiveSessions().map((session) => session.getConfig()),
+        ...discoveryConfig ? [discoveryConfig] : []
+      ]);
+      const syncErrors = [];
+      for (const config of liveConfigs) {
+        try {
+          const cwd = config.getTargetDir();
+          const mcpServers = assembleMcpServers(
+            settings.merged.mcpServers,
+            cwd,
+            config.getTopTierMcpServers()
+          );
+          const gating = recomputeMcpGating(
+            settings,
+            mcpServers,
+            cwd,
+            config.getCliAllowedMcpServerNames(),
+            config.getApprovalMode() === "yolo" /* YOLO */
+          );
+          config.setExcludedMcpServers(gating.excluded ?? []);
+          config.setAllowedMcpServers(gating.allowed);
+          config.setPendingMcpServers(gating.pending);
+          await config.reinitializeMcpServers(mcpServers);
+        } catch (error) {
+          syncErrors.push(error);
+        }
+      }
+      if (!discoveryConfig) {
+        try {
+          await this.createWorkspaceMcpDiscoveryConfig(settings);
+        } catch (error) {
+          syncErrors.push(error);
+        }
+      }
+      if (syncErrors.length > 0) {
+        throw new AggregateError(
+          syncErrors,
+          "Failed to synchronize MCP settings with live sessions"
+        );
+      }
+    });
+  }
   /**
    * Drain the workspace MCP transport pool. Called on shutdown so all
    * pool entries get a coordinated SIGTERM before process.exit. No-op
@@ -7718,6 +8313,11 @@ var QwenAgent = class {
     }
   }
   async closeStoredSession(sessionId, opts) {
+    for (const [requestId, generation] of this.generationControllers) {
+      if (generation.sessionId !== sessionId) continue;
+      generation.controller.abort();
+      this.generationControllers.delete(requestId);
+    }
     const session = this.sessions.get(sessionId);
     if (!session) {
       this.mcpPool?.releaseSession(sessionId);
@@ -7796,6 +8396,10 @@ var QwenAgent = class {
     this.sessions.delete(sessionId);
   }
   disposeSessions() {
+    for (const generation of this.generationControllers.values()) {
+      generation.controller.abort();
+    }
+    this.generationControllers.clear();
     for (const session of this.sessions.values()) {
       session.dispose();
     }
@@ -7830,7 +8434,7 @@ var QwenAgent = class {
   async initialize(args) {
     this.clientCapabilities = args.clientCapabilities;
     const authMethods = buildAuthMethods();
-    const version = "0.19.10";
+    const version = "0.19.11-nightly.20260718.767a32484";
     return {
       protocolVersion: PROTOCOL_VERSION,
       agentInfo: {
@@ -7886,25 +8490,42 @@ var QwenAgent = class {
       }
     }
   }
-  async newSession({
-    cwd,
-    mcpServers
-  }) {
-    const settings = loadSettingsCached(cwd);
-    this.settings = settings;
-    const config = await this.newSessionConfig(cwd, mcpServers, settings);
-    await this.ensureAuthenticated(config);
-    this.setupFileSystem(config);
-    const session = await this.createAndStoreSession(config, settings);
-    const availableModels = this.buildAvailableModels(config);
-    const modesData = this.buildModesData(config);
-    const configOptions = this.buildConfigOptions(config);
-    return {
-      sessionId: session.getId(),
-      models: availableModels,
-      modes: modesData,
-      configOptions
-    };
+  async newSession(params) {
+    const { cwd, mcpServers } = params;
+    const parentContext = extractDaemonTraceContext(params);
+    return await withDaemonSpan(
+      "qwen-code.daemon.session_start",
+      { "qwen-code.daemon.operation": "acp_session_new" },
+      async (span) => {
+        const profiler = createAcpSessionStartProfiler(span);
+        const settings = profiler.timeSync(
+          "settings_load",
+          () => loadSettingsCached(cwd)
+        );
+        this.settings = settings;
+        const config = await profiler.time(
+          "config_setup",
+          () => this.newSessionConfig(cwd, mcpServers, settings)
+        );
+        await profiler.time("auth", () => this.ensureAuthenticated(config));
+        profiler.timeSync(
+          "file_system_setup",
+          () => this.setupFileSystem(config)
+        );
+        const session = await profiler.time(
+          "session_register",
+          () => this.createAndStoreSession(config, settings)
+        );
+        profiler.setSessionId(session.getId());
+        return profiler.timeSync("response_build", () => ({
+          sessionId: session.getId(),
+          models: this.buildAvailableModels(config),
+          modes: this.buildModesData(config),
+          configOptions: this.buildConfigOptions(config)
+        }));
+      },
+      parentContext ? { parentContext } : {}
+    );
   }
   async loadSession(params) {
     const settings = loadSettingsCached(params.cwd);
@@ -7935,6 +8556,7 @@ var QwenAgent = class {
     this.setupFileSystem(config);
     const sessionData = config.getResumedSessionData();
     const bulkReplay = isBulkLoadReplayRequest(params);
+    const replayPageSize = bulkReplay ? getLoadReplayPageSize(params) : void 0;
     const session = await this.createAndStoreSession(
       config,
       settings,
@@ -7948,11 +8570,15 @@ var QwenAgent = class {
         let replayUpdates = [];
         if (records) {
           session.primeTurnFromHistory(records);
+          const replayPage = selectRecentHistoryRecords(
+            records,
+            replayPageSize
+          );
           const replayUsage = createReplayCumulativeUsage();
           const replay = await collectHistoryReplayUpdates({
             sessionId: params.sessionId,
             config,
-            records,
+            records: replayPage.records,
             gaps: sessionData?.historyGaps,
             cumulativeUsage: replayUsage,
             logger: debugLogger7
@@ -7964,9 +8590,15 @@ var QwenAgent = class {
               v: LOAD_REPLAY_VERSION,
               updates: replayUpdates,
               partial: true,
-              replayError: replay.replayError
+              replayError: replay.replayError,
+              ...replayPage.hasMore ? { hasMore: true } : {}
             };
           }
+          replayEnvelope ??= {
+            v: LOAD_REPLAY_VERSION,
+            updates: replayUpdates,
+            ...replayPage.hasMore ? { hasMore: true } : {}
+          };
         }
         replayEnvelope ??= {
           v: LOAD_REPLAY_VERSION,
@@ -8351,8 +8983,15 @@ var QwenAgent = class {
         return "error";
     }
   }
-  discoveryState() {
-    const state = getMCPDiscoveryState();
+  discoveryState(config) {
+    if (this.workspaceMcpDiscoveryPromise && (config === this.config || config === this.workspaceMcpDiscoveryConfig)) {
+      return "in_progress";
+    }
+    let state = getMCPDiscoveryState();
+    try {
+      state = config?.getToolRegistry()?.getMcpClientManager().getDiscoveryState() ?? state;
+    } catch {
+    }
     switch (state) {
       case "in_progress" /* IN_PROGRESS */:
         return "in_progress";
@@ -8367,10 +9006,10 @@ var QwenAgent = class {
     try {
       const workspaceCwd = this.workspaceCwd(config);
       const settings = loadSettings(config.getTargetDir());
-      const workspaceSettings = settings.forScope(
-        "Workspace" /* Workspace */
-      ).settings;
+      const userServers = settings.user?.settings.mcpServers ?? {};
+      const systemDefaultServers = settings.systemDefaults?.settings.mcpServers ?? {};
       const servers = config.getMcpServers() ?? {};
+      const approvals = loadMcpApprovals();
       let poolByName = {};
       try {
         const snap = this.mcpPool?.getSnapshot();
@@ -8415,7 +9054,7 @@ var QwenAgent = class {
         v: STATUS_SCHEMA_VERSION,
         workspaceCwd,
         initialized: true,
-        discoveryState: this.discoveryState(),
+        discoveryState: this.discoveryState(config),
         servers: await Promise.all(
           Object.entries(servers).map(async ([name, server]) => {
             const disabled = config.isMcpServerDisabled(name);
@@ -8425,7 +9064,8 @@ var QwenAgent = class {
               hasOAuthTokens = credentials !== null;
             } catch {
             }
-            const rawStatus = getMCPServerStatus(name);
+            const rawStatus = this.getMcpServerStatus(config, name);
+            const requiresAuth = rawStatus !== "connected" /* CONNECTED */ && (mcpServerRequiresOAuth.get(name) === true || server.oauth?.enabled === true && !hasOAuthTokens);
             const refusedByBudget = refusedSet.has(name);
             const effectivelyRefused = refusedByBudget && !disabled;
             const out = {
@@ -8439,8 +9079,34 @@ var QwenAgent = class {
               mcpStatus: this.mcpStatus(rawStatus),
               transport: this.mcpTransport(server),
               disabled,
-              hasOAuthTokens
+              hasOAuthTokens,
+              ...requiresAuth ? { requiresAuth: true } : {}
             };
+            if (isGatedMcpScope(server.scope)) {
+              const approvalState = approvals.getState(
+                config.getWorkingDir(),
+                name,
+                server
+              );
+              if (approvalState !== "approved") {
+                out.approvalState = approvalState;
+                if (!disabled) {
+                  out.status = "warning";
+                  out.mcpStatus = "disconnected";
+                }
+              }
+            }
+            if (this.pendingMcpAuthentications.has(name)) {
+              out.authenticationState = "pending";
+            } else {
+              const authentication = this.mcpAuthenticationResults.get(name);
+              if (authentication) {
+                out.authenticationState = authentication.state;
+                if (authentication.error) {
+                  out.authenticationError = authentication.error;
+                }
+              }
+            }
             if (effectivelyRefused) {
               out.errorKind = "budget_exhausted";
               out.disabledReason = "budget";
@@ -8456,7 +9122,11 @@ var QwenAgent = class {
             if (typeof extensionName === "string") {
               out.extensionName = extensionName;
             }
-            out.source = out.extensionName ? "extension" : workspaceSettings.mcpServers?.[name] ? "project" : "user";
+            const transient = config.getTopTierMcpServers?.()?.[name] !== void 0 || config.getRuntimeMcpServers?.()[name] !== void 0;
+            const configOrigin = out.extensionName ? "extension" : transient ? "runtime" : server.scope === "workspace" ? "workspace_settings" : server.scope === "project" ? "project_mcp_json" : server.scope === "system" ? "system_settings" : userServers[name] !== void 0 ? "user_settings" : systemDefaultServers[name] !== void 0 ? "system_settings" : "user_settings";
+            out.configOrigin = configOrigin;
+            out.source = out.extensionName ? "extension" : configOrigin === "workspace_settings" ? "project" : "user";
+            out.removable = configOrigin === "user_settings" || configOrigin === "workspace_settings";
             if (server && typeof server === "object") {
               const candidate = server;
               const serverConfig = {};
@@ -8521,6 +9191,14 @@ var QwenAgent = class {
             ).length,
             budgetCellScope
           )
+        } : {},
+        ...this.workspaceMcpDiscoveryError ? {
+          errors: [
+            this.errorCell(
+              "mcp",
+              new Error(this.workspaceMcpDiscoveryError)
+            )
+          ]
         } : {}
       };
     } catch (error) {
@@ -8533,6 +9211,34 @@ var QwenAgent = class {
       };
     }
   }
+  async buildManagedWorkspaceMcpStatus() {
+    const config = this.getWorkspaceMcpConfig();
+    const status = await this.buildWorkspaceMcpStatus(config);
+    if (config === this.config) return status;
+    const runtimeNames = new Set(
+      Object.keys(this.config.getRuntimeMcpServers?.() ?? {})
+    );
+    if (runtimeNames.size === 0) return status;
+    const runtimeStatus = await this.buildWorkspaceMcpStatus(this.config);
+    const errors = [
+      ...status.errors ?? [],
+      ...(runtimeStatus.errors ?? []).filter(
+        (candidate) => !status.errors?.some(
+          (existing) => existing.kind === candidate.kind && existing.status === candidate.status && existing.error === candidate.error
+        )
+      )
+    ];
+    return {
+      ...status,
+      servers: [
+        ...status.servers.filter((server) => !runtimeNames.has(server.name)),
+        ...runtimeStatus.servers.filter(
+          (server) => runtimeNames.has(server.name)
+        )
+      ],
+      ...errors.length > 0 ? { errors } : {}
+    };
+  }
   buildWorkspaceMcpToolsStatus(config, serverName) {
     const workspaceCwd = this.safeWorkspaceCwd(config);
     try {
@@ -8840,9 +9546,18 @@ var QwenAgent = class {
       const currentModelId = activeRuntimeSnapshot ? activeRuntimeSnapshot.id : (config.getModel() || "").trim();
       const hasCurrentModel = currentModelId.length > 0;
       const currentAuth = activeRuntimeSnapshot?.authType ?? currentAuthType;
-      const currentAcpModelId = hasCurrentModel && currentAuth ? formatAcpModelId(currentModelId, currentAuth) : currentModelId || void 0;
+      const modelOptions = buildAcpModelOptions(
+        config.getAllConfiguredModels()
+      );
+      const currentAcpModelId = hasCurrentModel ? getCurrentAcpModelId(
+        modelOptions,
+        currentModelId,
+        currentAuth,
+        activeRuntimeSnapshot ? void 0 : config.getCurrentModelRegistryBaseUrl?.()
+      ) : void 0;
       const providers = /* @__PURE__ */ new Map();
-      for (const model of config.getAllConfiguredModels().filter(isMainSelectableModel)) {
+      for (const option of modelOptions) {
+        const { model, effectiveModelId, modelId } = option;
         const authType = String(model.authType);
         let provider = providers.get(authType);
         if (!provider) {
@@ -8855,9 +9570,7 @@ var QwenAgent = class {
           };
           providers.set(authType, provider);
         }
-        const effectiveModelId = model.isRuntimeModel && model.runtimeSnapshotId ? model.runtimeSnapshotId : model.id;
-        const modelId = formatAcpModelId(effectiveModelId, model.authType);
-        const isCurrent = currentAuth === model.authType && hasCurrentModel && (currentModelId === effectiveModelId || currentModelId === model.id || currentAcpModelId === modelId);
+        const isCurrent = currentAuth === model.authType && currentAcpModelId === modelId;
         const providerModel = {
           modelId,
           baseModelId: parseAcpBaseModelId(effectiveModelId),
@@ -8997,7 +9710,7 @@ var QwenAgent = class {
   }
   buildMcpDiscoveryPreflightCell(config) {
     try {
-      const discovery = this.discoveryState();
+      const discovery = this.discoveryState(config);
       const servers = config.getMcpServers() ?? {};
       const total = Object.keys(servers).length;
       const counts = {
@@ -9920,9 +10633,7 @@ var QwenAgent = class {
         };
       }
       case SERVE_STATUS_EXT_METHODS.workspaceMcp:
-        return await this.buildWorkspaceMcpStatus(
-          this.config
-        );
+        return await this.buildManagedWorkspaceMcpStatus();
       case SERVE_STATUS_EXT_METHODS.workspaceMcpTools: {
         const serverName = params["serverName"];
         if (typeof serverName !== "string" || serverName.length === 0) {
@@ -9932,7 +10643,7 @@ var QwenAgent = class {
           );
         }
         return this.buildWorkspaceMcpToolsStatus(
-          this.config,
+          this.getWorkspaceMcpConfig(serverName),
           serverName
         );
       }
@@ -9945,7 +10656,7 @@ var QwenAgent = class {
           );
         }
         return this.buildWorkspaceMcpResourcesStatus(
-          this.config,
+          this.getWorkspaceMcpConfig(serverName),
           serverName
         );
       }
@@ -10060,6 +10771,19 @@ var QwenAgent = class {
             "Invalid transcript cursor"
           );
         }
+        const rawBeforeRecordId = params["beforeRecordId"];
+        if (rawBeforeRecordId !== void 0 && (typeof rawBeforeRecordId !== "string" || rawBeforeRecordId.length === 0)) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Invalid transcript record boundary"
+          );
+        }
+        if (rawCursor !== void 0 && rawBeforeRecordId !== void 0) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Transcript cursor and record boundary are mutually exclusive"
+          );
+        }
         const rawLimit = params["limit"];
         if (rawLimit !== void 0 && (!Number.isSafeInteger(rawLimit) || rawLimit < 1 || rawLimit > SESSION_TRANSCRIPT_MAX_LIMIT)) {
           throw RequestError.invalidParams(
@@ -10073,7 +10797,9 @@ var QwenAgent = class {
             const reader = new SessionTranscriptReader(cwd);
             const page = await reader.readPage(sessionId, {
               ...typeof rawCursor === "string" ? { cursor: rawCursor } : {},
-              ...typeof rawLimit === "number" ? { limit: rawLimit } : {}
+              ...typeof rawBeforeRecordId === "string" ? { beforeRecordId: rawBeforeRecordId } : {},
+              ...typeof rawLimit === "number" ? { limit: rawLimit } : {},
+              maxBytes: SESSION_TRANSCRIPT_MAX_PAGE_BYTES
             });
             const config = await this.getTranscriptReplayConfig(cwd, settings);
             const replay = await replayTranscriptRecordPage({
@@ -10122,6 +10848,14 @@ var QwenAgent = class {
               maxBytes: error.maxBytes
             });
           }
+          if (error instanceof SessionTranscriptPageTooLargeError) {
+            throw new RequestError(-32012, error.message, {
+              errorKind: "transcript_page_too_large",
+              sessionId,
+              pageBytes: error.pageBytes,
+              maxBytes: error.maxBytes
+            });
+          }
           if (error.code === "ENOENT") {
             if (typeof rawCursor === "string") {
               throw new RequestError(
@@ -10469,6 +11203,7 @@ var QwenAgent = class {
             "Invalid or missing serverName"
           );
         }
+        const config = this.getWorkspaceMcpConfig(serverName);
         let entryIndex;
         const rawEntryIndex = params["entryIndex"];
         if (rawEntryIndex !== void 0 && rawEntryIndex !== "*") {
@@ -10480,7 +11215,7 @@ var QwenAgent = class {
           }
           entryIndex = rawEntryIndex;
         }
-        const servers = this.config.getMcpServers() ?? {};
+        const servers = config.getMcpServers() ?? {};
         if (!Object.prototype.hasOwnProperty.call(servers, serverName)) {
           throw new RequestError(
             -32004,
@@ -10488,7 +11223,7 @@ var QwenAgent = class {
             { errorKind: "mcp_server_not_found", serverName }
           );
         }
-        if (this.config.isMcpServerDisabled(serverName)) {
+        if (config.isMcpServerDisabled(serverName)) {
           return {
             serverName,
             restarted: false,
@@ -10496,7 +11231,23 @@ var QwenAgent = class {
             reason: "disabled"
           };
         }
-        const manager = this.config.getToolRegistry()?.getMcpClientManager();
+        const server = servers[serverName];
+        let requiresAuth = mcpServerRequiresOAuth.get(serverName) === true;
+        if (!requiresAuth && server.oauth?.enabled === true) {
+          try {
+            requiresAuth = await new MCPOAuthTokenStorage().getCredentials(serverName) === null;
+          } catch {
+          }
+        }
+        if (requiresAuth && this.getMcpServerStatus(config, serverName) !== "connected" /* CONNECTED */) {
+          return {
+            serverName,
+            restarted: false,
+            skipped: true,
+            reason: "authentication_required"
+          };
+        }
+        const manager = config.getToolRegistry()?.getMcpClientManager();
         if (!manager) {
           throw RequestError.internalError(
             void 0,
@@ -10523,7 +11274,7 @@ var QwenAgent = class {
           };
         }
         try {
-          const fresh = loadSettings(this.config.getTargetDir());
+          const fresh = loadSettings(config.getTargetDir());
           const mergedDisabled = fresh.merged.tools?.disabled;
           if (mergedDisabled !== void 0 && !Array.isArray(mergedDisabled)) {
             process.stderr.write(
@@ -10532,7 +11283,7 @@ var QwenAgent = class {
             );
           }
           const disabledList = normalizeDisabledToolList(mergedDisabled);
-          this.config.setDisabledTools(new Set(disabledList));
+          config.setDisabledTools(new Set(disabledList));
         } catch (err) {
           process.stderr.write(
             `qwen serve: MCP restart for ${JSON.stringify(serverName)} could not refresh disabledTools from merged settings (${err instanceof Error ? err.message : String(err)}); proceeding with the bootstrap snapshot \u2014 recently toggled tools may not take effect until daemon restart.
@@ -10545,6 +11296,14 @@ var QwenAgent = class {
           const restartResults = await this.mcpPool.restartByName(serverName, {
             ...entryIndex !== void 0 ? { entryIndex } : {}
           });
+          await Promise.all(
+            this.getLiveMcpConfigs(serverName).map(async (liveConfig) => {
+              const geminiClient = liveConfig.getGeminiClient?.();
+              if (geminiClient?.isInitialized?.()) {
+                await geminiClient.setTools?.();
+              }
+            })
+          );
           return {
             serverName,
             entries: restartResults
@@ -10557,19 +11316,18 @@ var QwenAgent = class {
           );
         }
         const start = Date.now();
-        const toolRegistry = this.config.getToolRegistry();
-        if (!toolRegistry) {
-          throw RequestError.internalError(
-            void 0,
-            "ToolRegistry unavailable on this Config"
+        await this.reconcileMcpServerAcrossLiveConfigs(serverName, "discover");
+        const disconnectedRuntime = this.getLiveMcpConfigs(serverName).find(
+          (liveConfig) => this.getMcpServerStatus(liveConfig, serverName) !== "connected" /* CONNECTED */
+        );
+        if (disconnectedRuntime) {
+          const postStatus = this.getMcpServerStatus(
+            disconnectedRuntime,
+            serverName
           );
-        }
-        await toolRegistry.discoverToolsForServer(serverName);
-        const postStatus = getMCPServerStatus(serverName);
-        if (postStatus !== "connected" /* CONNECTED */) {
           throw new RequestError(
             -32099,
-            `MCP server ${JSON.stringify(serverName)} did not reach a connected state after restart (status: ${postStatus}).`,
+            `MCP server ${JSON.stringify(serverName)} did not reach a connected state in every live runtime after restart (status: ${postStatus}).`,
             {
               errorKind: "mcp_restart_failed",
               serverName,
@@ -10583,6 +11341,10 @@ var QwenAgent = class {
           durationMs: Date.now() - start
         };
       }
+      case SERVE_CONTROL_EXT_METHODS.workspaceMcpInitialize:
+        return this.initializeWorkspaceMcpDiscovery();
+      case SERVE_CONTROL_EXT_METHODS.workspaceMcpReload:
+        return this.reloadWorkspaceMcpDiscovery();
       case SERVE_CONTROL_EXT_METHODS.workspaceMcpManage: {
         const serverName = params["serverName"];
         const action = params["action"];
@@ -10592,13 +11354,14 @@ var QwenAgent = class {
             "Invalid or missing serverName"
           );
         }
-        if (action !== "enable" && action !== "disable" && action !== "authenticate" && action !== "clear-auth") {
+        if (action !== "approve" && action !== "enable" && action !== "disable" && action !== "authenticate" && action !== "clear-auth") {
           throw RequestError.invalidParams(
             void 0,
             "Invalid or missing MCP manage action"
           );
         }
-        const servers = this.config.getMcpServers() ?? {};
+        const config = this.getWorkspaceMcpConfig(serverName);
+        const servers = config.getMcpServers() ?? {};
         const server = servers[serverName];
         if (!server) {
           throw new RequestError(
@@ -10607,37 +11370,65 @@ var QwenAgent = class {
             { errorKind: "mcp_server_not_found", serverName }
           );
         }
-        const toolRegistry = this.config.getToolRegistry();
+        const toolRegistry = config.getToolRegistry();
         if (!toolRegistry) {
           throw RequestError.internalError(
             void 0,
             "ToolRegistry unavailable on this Config"
           );
         }
+        if (action === "approve") {
+          if (!isGatedMcpScope(server.scope)) {
+            throw RequestError.invalidParams(
+              void 0,
+              `MCP server is not approval-gated: ${serverName}`
+            );
+          }
+          const approvals = loadMcpApprovals();
+          await approvals.setState(
+            config.getWorkingDir(),
+            serverName,
+            server,
+            "approved"
+          );
+          for (const liveConfig of this.getLiveMcpConfigs(serverName)) {
+            liveConfig.approveMcpServerForSession(serverName);
+          }
+          await this.reconcileMcpServerAcrossLiveConfigs(
+            serverName,
+            "discover"
+          );
+          return { serverName, action, ok: true, changed: true };
+        }
         if (action === "enable") {
-          const settings = loadSettings(this.config.getTargetDir());
+          const settings = loadSettings(config.getTargetDir());
           let settingsChanged = false;
           for (const scope of ["User" /* User */, "Workspace" /* Workspace */]) {
             const scopeSettings = settings.forScope(scope).settings;
-            const currentExcluded2 = scopeSettings.mcp?.excluded || [];
-            const filtered = currentExcluded2.filter(
+            const currentExcluded = scopeSettings.mcp?.excluded || [];
+            const filtered = currentExcluded.filter(
               (pattern) => pattern !== serverName
             );
-            if (filtered.length !== currentExcluded2.length) {
+            if (filtered.length !== currentExcluded.length) {
               settings.setValue(scope, "mcp.excluded", filtered);
               settingsChanged = true;
             }
           }
-          const currentExcluded = this.config.getExcludedMcpServers() || [];
-          const runtimeFiltered = currentExcluded.filter(
-            (pattern) => pattern !== serverName
-          );
           let runtimeChanged = false;
-          if (runtimeFiltered.length !== currentExcluded.length) {
-            this.config.setExcludedMcpServers(runtimeFiltered);
-            runtimeChanged = true;
+          for (const liveConfig of this.getLiveMcpConfigs(serverName)) {
+            const currentExcluded = liveConfig.getExcludedMcpServers() || [];
+            const runtimeFiltered = currentExcluded.filter(
+              (pattern) => pattern !== serverName
+            );
+            if (runtimeFiltered.length !== currentExcluded.length) {
+              liveConfig.setExcludedMcpServers(runtimeFiltered);
+              runtimeChanged = true;
+            }
           }
-          await toolRegistry.discoverToolsForServer(serverName);
+          await this.reconcileMcpServerAcrossLiveConfigs(
+            serverName,
+            "discover"
+          );
           return {
             serverName,
             action,
@@ -10646,7 +11437,7 @@ var QwenAgent = class {
           };
         }
         if (action === "disable") {
-          const settings = loadSettings(this.config.getTargetDir());
+          const settings = loadSettings(config.getTargetDir());
           const userSettings = settings.forScope("User" /* User */).settings;
           const workspaceSettings = settings.forScope(
             "Workspace" /* Workspace */
@@ -10658,7 +11449,7 @@ var QwenAgent = class {
               `Cannot disable extension MCP server: ${serverName}`
             );
           }
-          if (workspaceSettings.mcpServers?.[serverName]) {
+          if (server.scope === "project" || server.scope === "workspace" || workspaceSettings.mcpServers?.[serverName]) {
             targetScope = "Workspace" /* Workspace */;
           } else if (userSettings.mcpServers?.[serverName]) {
             targetScope = "User" /* User */;
@@ -10673,13 +11464,19 @@ var QwenAgent = class {
             ]);
             settingsChanged = true;
           }
-          const runtimeExcluded = this.config.getExcludedMcpServers() || [];
           let runtimeChanged = false;
-          if (!matchesAnyServerPattern(serverName, runtimeExcluded)) {
-            this.config.setExcludedMcpServers([...runtimeExcluded, serverName]);
-            runtimeChanged = true;
+          const liveConfigs = this.getLiveMcpConfigs(serverName);
+          for (const liveConfig of liveConfigs) {
+            const runtimeExcluded = liveConfig.getExcludedMcpServers() || [];
+            if (!matchesAnyServerPattern(serverName, runtimeExcluded)) {
+              liveConfig.setExcludedMcpServers([
+                ...runtimeExcluded,
+                serverName
+              ]);
+              runtimeChanged = true;
+            }
           }
-          await toolRegistry.disableMcpServer(serverName);
+          await this.reconcileMcpServerAcrossLiveConfigs(serverName, "disable");
           return {
             serverName,
             action,
@@ -10690,61 +11487,114 @@ var QwenAgent = class {
         if (action === "clear-auth") {
           const tokenStorage = new MCPOAuthTokenStorage();
           await tokenStorage.deleteCredentials(serverName);
-          await toolRegistry.disconnectServer(serverName);
+          await this.reconcileMcpServerAcrossLiveConfigs(
+            serverName,
+            "disconnect"
+          );
           return { serverName, action, ok: true, changed: true };
         }
-        const messages = [];
-        let authUrl;
-        const displayListener = /* @__PURE__ */ __name((message) => {
-          if (typeof message === "string") {
-            messages.push(message);
-          } else if (message && typeof message === "object") {
-            const key = message.key;
-            if (typeof key === "string") {
-              messages.push(key);
+        let pending = this.pendingMcpAuthentications.get(serverName);
+        if (!pending) {
+          this.mcpAuthenticationResults.delete(serverName);
+          const messages2 = [];
+          let resolveStarted;
+          let rejectStarted;
+          let startedTimer;
+          const started = new Promise((resolve4, reject) => {
+            resolveStarted = /* @__PURE__ */ __name((value) => {
+              clearTimeout(startedTimer);
+              resolve4(value);
+            }, "resolveStarted");
+            rejectStarted = /* @__PURE__ */ __name((reason) => {
+              clearTimeout(startedTimer);
+              reject(reason);
+            }, "rejectStarted");
+            startedTimer = setTimeout(
+              () => rejectStarted(
+                new Error(
+                  `MCP OAuth authentication did not provide a URL within ${MCP_OAUTH_START_TIMEOUT_MS / 1e3} seconds`
+                )
+              ),
+              MCP_OAUTH_START_TIMEOUT_MS
+            );
+            startedTimer.unref();
+          });
+          pending = { started };
+          this.pendingMcpAuthentications.set(serverName, pending);
+          const displayListener = /* @__PURE__ */ __name((message) => {
+            if (typeof message === "string") {
+              messages2.push(message);
+            } else if (message && typeof message === "object") {
+              const key = message.key;
+              if (typeof key === "string") messages2.push(key);
             }
-          }
-        }, "displayListener");
-        const authUrlListener = /* @__PURE__ */ __name((url) => {
-          if (typeof url === "string") {
-            authUrl = url;
-          }
-        }, "authUrlListener");
-        appEvents.on("oauth-display-message" /* OauthDisplayMessage */, displayListener);
-        appEvents.on("oauth-auth-url" /* OauthAuthUrl */, authUrlListener);
-        try {
-          const oauthConfig = server.oauth ?? { enabled: false };
-          const mcpServerUrl = server.httpUrl || server.url;
-          const authProvider = new MCPOAuthProvider(new MCPOAuthTokenStorage());
-          await authProvider.authenticate(
-            serverName,
-            oauthConfig,
-            mcpServerUrl,
-            appEvents
-          );
-          messages.push(
-            `Successfully authenticated and refreshed tools for '${serverName}'.`
-          );
-          await toolRegistry.discoverToolsForServer(serverName);
-          const geminiClient = this.config.getGeminiClient();
-          if (geminiClient) {
-            await geminiClient.setTools();
-          }
-          return {
-            serverName,
-            action,
-            ok: true,
-            changed: true,
-            messages,
-            ...authUrl ? { authUrl } : {}
-          };
-        } finally {
-          appEvents.removeListener(
-            "oauth-display-message" /* OauthDisplayMessage */,
-            displayListener
-          );
-          appEvents.removeListener("oauth-auth-url" /* OauthAuthUrl */, authUrlListener);
+          }, "displayListener");
+          const authUrlListener = /* @__PURE__ */ __name((url) => {
+            if (typeof url === "string") {
+              resolveStarted({ authUrl: url, messages: [...messages2] });
+            }
+          }, "authUrlListener");
+          appEvents.on("oauth-display-message" /* OauthDisplayMessage */, displayListener);
+          appEvents.on("oauth-auth-url" /* OauthAuthUrl */, authUrlListener);
+          void (async () => {
+            try {
+              try {
+                const oauthConfig = server.oauth ?? { enabled: false };
+                const mcpServerUrl = server.httpUrl || server.url;
+                const authProvider = new MCPOAuthProvider(
+                  new MCPOAuthTokenStorage()
+                );
+                await authProvider.authenticate(
+                  serverName,
+                  oauthConfig,
+                  mcpServerUrl,
+                  appEvents
+                );
+                this.mcpAuthenticationResults.set(serverName, {
+                  state: "succeeded"
+                });
+              } catch (error) {
+                this.mcpAuthenticationResults.set(serverName, {
+                  state: "failed",
+                  error: error instanceof Error ? error.message : String(error)
+                });
+                rejectStarted(error);
+                debugLogger7.warn(
+                  `MCP OAuth authentication failed for ${serverName}:`,
+                  error
+                );
+                return;
+              }
+              try {
+                await this.reconcileMcpServerAcrossLiveConfigs(
+                  serverName,
+                  "discover"
+                );
+              } catch (error) {
+                debugLogger7.warn(
+                  `MCP OAuth authenticated for ${serverName}, but tool synchronization failed:`,
+                  error
+                );
+              }
+            } finally {
+              appEvents.removeListener(
+                "oauth-display-message" /* OauthDisplayMessage */,
+                displayListener
+              );
+              appEvents.removeListener("oauth-auth-url" /* OauthAuthUrl */, authUrlListener);
+              this.pendingMcpAuthentications.delete(serverName);
+            }
+          })();
         }
+        const { authUrl, messages } = await pending.started;
+        return {
+          serverName,
+          action,
+          ok: true,
+          pending: true,
+          messages,
+          authUrl
+        };
       }
       case SERVE_CONTROL_EXT_METHODS.workspaceAgentGenerate: {
         const description = params["description"];
@@ -10855,6 +11705,39 @@ var QwenAgent = class {
         }
         return { sessionId, parentSessionId, persisted: ok };
       }
+      case SERVE_CONTROL_EXT_METHODS.sessionSource: {
+        const sessionId = params["sessionId"];
+        const sourceType = params["sourceType"];
+        const sourceId = params["sourceId"];
+        if (typeof sessionId !== "string" || sessionId.length === 0) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Invalid or missing sessionId"
+          );
+        }
+        const source = parseSessionSource(sourceType, sourceId);
+        if ("error" in source || source.sourceType === void 0) {
+          throw RequestError.invalidParams(
+            void 0,
+            "error" in source ? source.error : "Invalid or missing sourceType"
+          );
+        }
+        const session = this.sessionOrThrow(sessionId);
+        const recording = session.getConfig().getChatRecordingService();
+        let ok = false;
+        if (recording) {
+          ok = await recording.recordSessionSource(
+            source.sourceType,
+            source.sourceId
+          );
+        }
+        return {
+          sessionId,
+          sourceType: source.sourceType,
+          ...source.sourceId !== void 0 ? { sourceId: source.sourceId } : {},
+          persisted: ok
+        };
+      }
       case SERVE_CONTROL_EXT_METHODS.sessionClose: {
         const sessionId = params["sessionId"];
         if (typeof sessionId !== "string" || sessionId.length === 0) {
@@ -11097,6 +11980,64 @@ var QwenAgent = class {
         );
         return { sessionId, recap };
       }
+      case SERVE_CONTROL_EXT_METHODS.sessionGenerationStart: {
+        const sessionId = params["sessionId"];
+        const requestId = params["requestId"];
+        const prompt = params["prompt"];
+        if (typeof sessionId !== "string" || typeof requestId !== "string" || typeof prompt !== "string" || prompt.trim().length === 0 || Buffer.byteLength(prompt, "utf8") > GENERATION_MAX_PROMPT_BYTES) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Invalid generation request"
+          );
+        }
+        if (this.generationControllers.has(requestId)) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Duplicate generation requestId"
+          );
+        }
+        const session = this.sessionOrThrow(sessionId);
+        const controller = new AbortController();
+        this.generationControllers.set(requestId, { sessionId, controller });
+        const signal = AbortSignal.any([
+          controller.signal,
+          AbortSignal.timeout(GENERATION_TIMEOUT_MS)
+        ]);
+        try {
+          const result = await executeGeneration(
+            session.getConfig(),
+            requestId,
+            prompt,
+            signal,
+            async (event) => {
+              await this.connection.extNotification(
+                "qwen/notify/session/generation/event",
+                { v: 1, sessionId, requestId, event }
+              );
+            }
+          );
+          return { sessionId, requestId, ...result };
+        } finally {
+          this.generationControllers.delete(requestId);
+        }
+      }
+      case SERVE_CONTROL_EXT_METHODS.sessionGenerationCancel: {
+        const sessionId = params["sessionId"];
+        const requestId = params["requestId"];
+        if (typeof sessionId !== "string" || typeof requestId !== "string") {
+          throw RequestError.invalidParams(
+            void 0,
+            "Invalid generation cancellation request"
+          );
+        }
+        const generation = this.generationControllers.get(requestId);
+        const cancelled = generation?.sessionId === sessionId;
+        if (cancelled) {
+          generation.controller.abort();
+          this.generationControllers.delete(requestId);
+        }
+        return { sessionId, requestId, cancelled };
+      }
       case SERVE_CONTROL_EXT_METHODS.sessionBtw: {
         const sessionId = params["sessionId"];
         if (typeof sessionId !== "string" || sessionId.length === 0) {
@@ -11394,12 +12335,7 @@ ${outputText}
             "Invalid or missing config"
           );
         }
-        if (typeof originatorClientId !== "string" || originatorClientId.length === 0) {
-          throw RequestError.invalidParams(
-            void 0,
-            "Invalid or missing originatorClientId"
-          );
-        }
+        const runtimeClientId = typeof originatorClientId === "string" && originatorClientId.length > 0 ? originatorClientId : "daemon";
         const manager = this.config.getToolRegistry()?.getMcpClientManager();
         if (!manager) {
           throw RequestError.internalError(
@@ -11430,7 +12366,7 @@ ${outputText}
           const result = await manager.addRuntimeMcpServer(
             name,
             safeConfig,
-            originatorClientId
+            runtimeClientId
           );
           await Promise.all(
             this.getActiveSessions().map(async (session) => {
@@ -11440,7 +12376,7 @@ ${outputText}
                 await sessionManager.addRuntimeMcpServer(
                   name,
                   safeConfig,
-                  originatorClientId
+                  runtimeClientId
                 );
               } catch (sessionErr) {
                 debugLogger7.warn(
@@ -11489,12 +12425,7 @@ ${outputText}
             "Server name must be \u2264256 chars, alphanumeric + underscore/hyphen, and not a reserved JS property name"
           );
         }
-        if (typeof originatorClientId !== "string" || originatorClientId.length === 0) {
-          throw RequestError.invalidParams(
-            void 0,
-            "Invalid or missing originatorClientId"
-          );
-        }
+        const runtimeClientId = typeof originatorClientId === "string" && originatorClientId.length > 0 ? originatorClientId : "daemon";
         const manager = this.config.getToolRegistry()?.getMcpClientManager();
         if (!manager) {
           throw RequestError.internalError(
@@ -11504,7 +12435,7 @@ ${outputText}
         }
         const result = await manager.removeRuntimeMcpServer(
           name,
-          originatorClientId
+          runtimeClientId
         );
         await Promise.all(
           this.getActiveSessions().map(async (session) => {
@@ -11513,7 +12444,7 @@ ${outputText}
             try {
               await sessionManager.removeRuntimeMcpServer(
                 name,
-                originatorClientId
+                runtimeClientId
               );
             } catch (sessionErr) {
               debugLogger7.warn(
@@ -11539,6 +12470,16 @@ ${outputText}
         }, "runRefresh");
         await runRefresh(async () => await extensionManager.refreshCache());
         await runRefresh(async () => await extensionManager.refreshTools());
+        const discoveryConfig = this.workspaceMcpDiscoveryConfig;
+        if (discoveryConfig && discoveryConfig !== config) {
+          const discoveryExtensionManager = discoveryConfig.getExtensionManager();
+          await runRefresh(
+            async () => await discoveryExtensionManager.refreshCache()
+          );
+          await runRefresh(
+            async () => await discoveryExtensionManager.refreshTools()
+          );
+        }
         await runRefresh(
           async () => await config.getGeminiClient()?.refreshSystemInstruction()
         );
@@ -12516,23 +13457,22 @@ ${outputText}
   buildAvailableModels(config) {
     const rawCurrentModelId = (config.getModel() || this.config.getModel() || "").trim();
     const currentAuthType = config.getAuthType();
-    const allConfiguredModels = config.getAllConfiguredModels().filter(isMainSelectableModel);
+    const modelOptions = buildAcpModelOptions(config.getAllConfiguredModels());
     const activeRuntimeSnapshot = config.getActiveRuntimeModelSnapshot?.();
-    const currentModelId = activeRuntimeSnapshot ? formatAcpModelId(
-      activeRuntimeSnapshot.id,
-      activeRuntimeSnapshot.authType
-    ) : this.formatCurrentModelId(rawCurrentModelId, currentAuthType);
-    const mappedAvailableModels = allConfiguredModels.map((model) => {
-      const effectiveModelId = model.isRuntimeModel && model.runtimeSnapshotId ? model.runtimeSnapshotId : model.id;
-      return {
-        modelId: formatAcpModelId(effectiveModelId, model.authType),
-        name: model.label,
-        description: model.description ?? null,
-        _meta: {
-          contextLimit: model.contextWindowSize ?? tokenLimit(model.id)
-        }
-      };
-    });
+    const currentModelId = getCurrentAcpModelId(
+      modelOptions,
+      activeRuntimeSnapshot?.id ?? rawCurrentModelId,
+      activeRuntimeSnapshot?.authType ?? currentAuthType,
+      activeRuntimeSnapshot ? void 0 : config.getCurrentModelRegistryBaseUrl?.()
+    );
+    const mappedAvailableModels = modelOptions.map(({ model, modelId }) => ({
+      modelId,
+      name: model.label,
+      description: model.description ?? null,
+      _meta: {
+        contextLimit: model.contextWindowSize ?? tokenLimit(model.id)
+      }
+    }));
     return {
       currentModelId,
       availableModels: mappedAvailableModels
@@ -12552,14 +13492,16 @@ ${outputText}
   }
   buildConfigOptions(config) {
     const currentApprovalMode = config.getApprovalMode();
-    const allConfiguredModels = config.getAllConfiguredModels().filter(isMainSelectableModel);
+    const modelOptions = buildAcpModelOptions(config.getAllConfiguredModels());
     const rawCurrentModelId = (config.getModel() || "").trim();
     const currentAuthType = config.getAuthType?.();
     const activeRuntimeSnapshot = config.getActiveRuntimeModelSnapshot?.();
-    const currentModelId = activeRuntimeSnapshot ? formatAcpModelId(
-      activeRuntimeSnapshot.id,
-      activeRuntimeSnapshot.authType
-    ) : this.formatCurrentModelId(rawCurrentModelId, currentAuthType);
+    const currentModelId = getCurrentAcpModelId(
+      modelOptions,
+      activeRuntimeSnapshot?.id ?? rawCurrentModelId,
+      activeRuntimeSnapshot?.authType ?? currentAuthType,
+      activeRuntimeSnapshot ? void 0 : config.getCurrentModelRegistryBaseUrl?.()
+    );
     const modeOptions = APPROVAL_MODES.map((mode) => ({
       value: mode,
       name: APPROVAL_MODE_INFO[mode].name,
@@ -12574,14 +13516,11 @@ ${outputText}
       currentValue: currentApprovalMode,
       options: modeOptions
     };
-    const modelOptions = allConfiguredModels.map((model) => {
-      const effectiveModelId = model.isRuntimeModel && model.runtimeSnapshotId ? model.runtimeSnapshotId : model.id;
-      return {
-        value: formatAcpModelId(effectiveModelId, model.authType),
-        name: model.label,
-        description: model.description ?? ""
-      };
-    });
+    const configModelOptions = modelOptions.map(({ model, modelId }) => ({
+      value: modelId,
+      name: model.label,
+      description: model.description ?? ""
+    }));
     const modelConfigOption = {
       id: "model",
       name: "Model",
@@ -12589,19 +13528,11 @@ ${outputText}
       category: "model",
       type: "select",
       currentValue: currentModelId,
-      options: modelOptions
+      options: configModelOptions
     };
     return [modeConfigOption, modelConfigOption];
   }
-  formatCurrentModelId(baseModelId, authType) {
-    if (!baseModelId) return baseModelId;
-    return authType ? formatAcpModelId(baseModelId, authType) : baseModelId;
-  }
 };
-function isMainSelectableModel(model) {
-  return model.fastOnly !== true && model.voiceOnly !== true;
-}
-__name(isMainSelectableModel, "isMainSelectableModel");
 function diffSettingsKeys(oldMerged, newMerged) {
   const changed = /* @__PURE__ */ new Set();
   const allKeys = /* @__PURE__ */ new Set([
@@ -12634,6 +13565,11 @@ export {
  * Copyright 2025 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */
+/**
+ * @license
+ * Copyright 2026 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
 /**
  * @license
  * Copyright 2025 Qwen