@qwen-code/qwen-code 0.19.10 → 0.19.11-nightly.20260717.f8e6e8931

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

@@ -3,7 +3,7 @@
 import {
   classifyApiError,
   prefixMidTurnUserMessageParts
-} from "./chunk-WIASPMLX.js";
+} from "./chunk-AH3YAJU6.js";
 import {
   EXTENSION_CONTEXT_BUDGET,
   buildExtensionMentionContext,
@@ -12,83 +12,96 @@ import {
   matchMcpServerByRef,
   parseExtensionRef,
   parseMcpServerRef
-} from "./chunk-X362TMXZ.js";
+} from "./chunk-XQDPCQ3A.js";
 import {
   getAvailableCommands,
   handleSlashCommand,
   insertAfterFunctionResponses,
   isSlashCommand,
   normalizePartList
-} from "./chunk-YX4LLZ3D.js";
+} from "./chunk-NABT4VOY.js";
+import {
+  collectContextData,
+  formatContextUsageText
+} from "./chunk-46Y6SSQ7.js";
+import {
+  recomputeMcpGating
+} from "./chunk-FXK3QMRD.js";
 import {
   appEvents,
   buildDisabledSkillNamesProvider,
   loadCliConfig,
   normalizeDisabledToolList
-} from "./chunk-CEW4HDPK.js";
+} from "./chunk-ZK4AMPKI.js";
 import {
   getCommandSubcommandNames
-} from "./chunk-XXJKGHZV.js";
-import "./chunk-422XAKCK.js";
+} from "./chunk-6VMOP2Z7.js";
+import "./chunk-G5ZKRK2E.js";
 import {
   getEffectiveSupportedModes
-} from "./chunk-DK33QJ3V.js";
-import "./chunk-K4PZ5F5T.js";
-import "./chunk-5DTTYNB7.js";
-import {
-  collectContextData,
-  formatContextUsageText
-} from "./chunk-B5I2IIWY.js";
+} from "./chunk-GCRFH57X.js";
 import "./chunk-4WGODMVR.js";
+import "./chunk-KW7NOTN6.js";
+import "./chunk-OWT2CAEQ.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-GLEJW7T2.js";
+import "./chunk-XK42MWWO.js";
 import "./chunk-YAF2MQZ6.js";
 import "./chunk-Q6TUALBE.js";
-import "./chunk-KW7NOTN6.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-SE6GSFAO.js";
 import {
   HistoryReplayer,
   MessageEmitter,
   PlanEmitter,
   ToolCallEmitter
-} from "./chunk-4FMG7EDJ.js";
-import "./chunk-SPUYQB4T.js";
-import "./chunk-WTSXKLG5.js";
+} from "./chunk-AEKHQ3E5.js";
+import "./chunk-DPXB3XRN.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-PSDTLRAV.js";
 import "./chunk-6H67XLET.js";
-import "./chunk-L62SEJWY.js";
-import "./chunk-65N2J6V2.js";
-import "./chunk-WDWJ4OQJ.js";
+import "./chunk-6RV42SFP.js";
+import "./chunk-6ANLV27M.js";
+import "./chunk-LXXMOYPL.js";
+import "./chunk-CC2UASQ4.js";
 import "./chunk-E5Z2AVNV.js";
 import {
-  formatAcpModelId,
+  ACP_ROUTE_ID_PREFIX,
+  buildAcpModelOptions,
+  getCurrentAcpModelId,
   parseAcpBaseModelId,
   parseAcpModelOption,
+  resolveAcpModelOption,
   sanitizeProviderBaseUrl
-} from "./chunk-GGJII3FM.js";
+} from "./chunk-WZJELXEU.js";
 import {
   mapSkillConfigToStatus
 } from "./chunk-2W3OOD4W.js";
@@ -98,16 +111,19 @@ import {
   buildPermissionSettings,
   normalizePermissionRules,
   readPermissionRuleSet
-} from "./chunk-N6FXRR6P.js";
+} from "./chunk-7ZFXHKKZ.js";
 import {
   MAX_AUDIO_BYTES,
   sanitizeVoiceErrorMessage,
   transcribeVoiceAudio
-} from "./chunk-FXMC7SL2.js";
+} from "./chunk-I6NOSIVF.js";
 import {
   readVoiceModel
-} from "./chunk-DPFBNG72.js";
+} from "./chunk-4UBEB74N.js";
 import "./chunk-FSA7ERJ2.js";
+import {
+  parseSessionSource
+} from "./chunk-YOJGIRTD.js";
 import {
   CLIENT_MCP_OVER_WS_CONFIG_FLAG,
   LOAD_REPLAY_BULK_MODE,
@@ -120,19 +136,19 @@ 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-UJG4VV2O.js";
+import "./chunk-4YR7FSAM.js";
 import "./chunk-57OAHC2Y.js";
-import "./chunk-OATTJGPJ.js";
-import "./chunk-ZRKBI3DP.js";
+import "./chunk-5CNYZ7TN.js";
+import "./chunk-FNX3LGAK.js";
 import "./chunk-V6WHFGST.js";
 import {
   createLoadedSettingsAdapter
-} from "./chunk-W34A5MJH.js";
+} from "./chunk-NROLDLP4.js";
 import {
   ndJsonStream
-} from "./chunk-TEGEBB2I.js";
+} from "./chunk-VHCSIMTF.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-W6J7RSCK.js";
 import "./chunk-W7FJ3N32.js";
-import "./chunk-GYTKQYDB.js";
+import "./chunk-KSZKSE23.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-3DWIFU7L.js";
+import "./chunk-ZQIYGQCG.js";
 import {
   AgentSideConnection,
   PROTOCOL_VERSION,
   RequestError
 } from "./chunk-UDXSXLER.js";
-import "./chunk-YYPXHMWO.js";
+import {
+  assembleMcpServers,
+  loadMcpApprovals
+} from "./chunk-FEYHXPZG.js";
 import {
   OUTPUT_LANGUAGE_AUTO,
   getOutputLanguageFilePath,
@@ -165,18 +183,18 @@ import {
   resolveOutputLanguage,
   updateOutputLanguageFile,
   writeOutputLanguageAndRegisterPath
-} from "./chunk-6GETGQWP.js";
+} from "./chunk-5WWYHNAH.js";
 import "./chunk-RKUWKYED.js";
 import {
   SUPPORTED_LANGUAGES,
   getCurrentLanguage,
   setLanguageAsync
-} from "./chunk-RDRVMDWV.js";
+} from "./chunk-EMJJBXS7.js";
 import {
   findEnvFiles,
   preResolveHomeEnvOverrides,
   reloadEnvironment
-} from "./chunk-5EBKKSBX.js";
+} from "./chunk-JY74T7PW.js";
 import "./chunk-GOXKNSDZ.js";
 import {
   getSystemDefaultsPath,
@@ -187,14 +205,14 @@ import {
   isFolderTrustEnabled,
   isWorkspaceTrusted,
   loadTrustedFolders
-} from "./chunk-4YWLED2A.js";
+} from "./chunk-PNCWEDF6.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-Y3TNSHKF.js";
 import "./chunk-VJNBRRZG.js";
 import {
   ALL_PROVIDERS,
@@ -238,6 +256,7 @@ import {
   clampInlineMediaPart,
   clearGoalTerminalObserver,
   computeUniqueBranchTitle,
+  convertToFunctionErrorResponse,
   convertToFunctionResponse,
   createDuplicateProviderToolCallResponse,
   dedupeToolCallsById,
@@ -269,18 +288,18 @@ import {
   getProviderToolCallId,
   getScopedEnvContents,
   getStartupContextLength,
-  hasImageParts,
   ideContextStore,
   injectPermissionRulesIfMissing,
   isApproveOutcome,
   isDenialFallbackReason,
+  isGatedMcpScope,
   isPlanModeBlocked,
   isSystemReminderContent,
   markDuplicateProviderToolCallResponseSent,
   matchesAnyServerPattern,
+  mcpServerRequiresOAuth,
   needsConfirmation,
   normalizeEventPayload,
-  normalizeParts,
   normalizeSnapshotPayload,
   parsePositiveIntegerEnv,
   persistPermissionOutcome,
@@ -295,7 +314,6 @@ import {
   runForkedAgent,
   runManagedAutoMemoryDream,
   runManagedRememberByAgent,
-  runVisionBridge,
   sessionIdContext,
   setGoalTerminalObserver,
   shouldClassifyAllShellForAutoMode,
@@ -303,24 +321,20 @@ import {
   shouldFirePermissionDeniedForAutoMode,
   shouldForceAutoModeReviewForAllow,
   shouldRunAutoModeForCall,
-  shouldRunVisionBridge,
-  splitImageParts,
   subagentGenerator,
   unregisterGoalHook,
   updateSetting
-} from "./chunk-K7CRWKOE.js";
+} from "./chunk-R6AO7HBQ.js";
+import "./chunk-T4TZQJ7W.js";
 import {
   external_exports
 } from "./chunk-H6XPXXMH.js";
 import "./chunk-5M6IDOMF.js";
-import "./chunk-E67NFMF4.js";
+import "./chunk-A2HWMJVO.js";
 import "./chunk-RCEEXIOO.js";
 import "./chunk-KKRTYONM.js";
 import "./chunk-TV6K2FB4.js";
 import "./chunk-E2UVIFI2.js";
-import {
-  runSideQuery
-} from "./chunk-6OATMEYN.js";
 import "./chunk-XU457J4V.js";
 import "./chunk-VDDGDZMA.js";
 import "./chunk-SPJQO2CE.js";
@@ -330,7 +344,7 @@ import "./chunk-CPBF7KYF.js";
 import {
   APPROVAL_MODES,
   FORK_SUBAGENT_TYPE
-} from "./chunk-TXY2C3D2.js";
+} from "./chunk-F333XEAU.js";
 import "./chunk-6AM5D4ME.js";
 import "./chunk-2Z5UX4KI.js";
 import {
@@ -349,35 +363,45 @@ import {
   endToolExecutionSpan,
   endToolSpan,
   extractDaemonTraceContext,
+  formatVisionBridgeNotice,
   getAllGeminiMdFilenames,
   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-BTSE2DUP.js";
 import "./chunk-4WKAA4KS.js";
 import "./chunk-CR3C7WXL.js";
-import "./chunk-CARU2RR2.js";
+import {
+  runSideQuery
+} from "./chunk-RTV5TUYB.js";
 import "./chunk-VGC4I5JJ.js";
 import {
   getAutoMemoryRoot,
   getUserAutoMemoryRoot
 } from "./chunk-FBU7WRZI.js";
 import "./chunk-Y66VOBRP.js";
-import "./chunk-WX6SD4IQ.js";
+import "./chunk-WTNZ6DXB.js";
 import {
   ToolConfirmationOutcome,
-  ToolNames
-} from "./chunk-2UUAIFQO.js";
+  ToolNames,
+  isShellProgressData
+} from "./chunk-JGUT3LWZ.js";
 import {
   clearCachedCredentialFile,
   qwenOAuth2Events
@@ -386,11 +410,12 @@ import "./chunk-ZPAHLFZU.js";
 import "./chunk-JESCGQM3.js";
 import "./chunk-WIEO4CWB.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-VRR65QYW.js";
 import "./chunk-A4UCTEB5.js";
 import "./chunk-XWRJCPHC.js";
 import "./chunk-4LD5APFL.js";
@@ -405,10 +430,10 @@ import {
   getErrorStatus,
   isSubpath
 } from "./chunk-7NFB7LBQ.js";
-import "./chunk-XLIRF7IK.js";
+import "./chunk-E7ECGLZW.js";
 import {
   runExitCleanup
-} from "./chunk-TISZXPAX.js";
+} from "./chunk-L263ROM6.js";
 import "./chunk-75DOP5OR.js";
 import "./chunk-DMTGGOSA.js";
 import "./chunk-YQ3U5MUC.js";
@@ -423,6 +448,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 +828,79 @@ import { Buffer as Buffer2 } from "node:buffer";
 import * as os2 from "node:os";
 import * as path3 from "node:path";
 
+// 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 +1611,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)";
@@ -2676,6 +2786,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(
@@ -2696,35 +2809,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) {
@@ -2904,6 +3038,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(
@@ -2925,33 +3062,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);
@@ -3557,6 +3715,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 +3743,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 +3764,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 +3990,9 @@ ${this.pendingWorktreeNotice}
               return;
             }
             const functionCalls = [];
+            const preparationTracker = new ToolCallPreparationTracker(
+              this.toolCallEmitter
+            );
             let usageMetadata = null;
             let responseText = "";
             const streamStartTime = Date.now();
@@ -3831,6 +4016,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 +4042,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 +4289,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 +4308,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 +4360,7 @@ ${this.pendingWorktreeNotice}
           modelId: effectiveModelId,
           baseUrl: after?.baseUrl ?? "(default)",
           apiKey: maskApiKeyForDisplay(after?.apiKey),
-          isRuntime: rawModelId.startsWith("$runtime|")
+          isRuntime: resolvedRoute?.isRuntime ?? rawModelId.startsWith("$runtime|")
         }
       }
     };
@@ -5079,27 +5315,64 @@ ${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;
           }
@@ -5110,12 +5383,16 @@ ${this.pendingWorktreeNotice}
               currentModeId: this.config.getApprovalMode()
             });
           }
-          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;
@@ -5565,7 +5842,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 +5951,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 +6159,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,
@@ -6034,6 +6348,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 +6376,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 +7455,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 +7946,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 +7985,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 +8178,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 +8261,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 +8299,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.20260717.f8e6e8931";
     return {
       protocolVersion: PROTOCOL_VERSION,
       agentInfo: {
@@ -7886,25 +8355,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);
@@ -8351,8 +8837,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 +8860,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 +8908,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 +8918,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 +8933,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 +8976,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 +9045,14 @@ var QwenAgent = class {
             ).length,
             budgetCellScope
           )
+        } : {},
+        ...this.workspaceMcpDiscoveryError ? {
+          errors: [
+            this.errorCell(
+              "mcp",
+              new Error(this.workspaceMcpDiscoveryError)
+            )
+          ]
         } : {}
       };
     } catch (error) {
@@ -8533,6 +9065,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 +9400,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 +9424,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 +9564,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 +10487,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 +10497,7 @@ var QwenAgent = class {
           );
         }
         return this.buildWorkspaceMcpToolsStatus(
-          this.config,
+          this.getWorkspaceMcpConfig(serverName),
           serverName
         );
       }
@@ -9945,7 +10510,7 @@ var QwenAgent = class {
           );
         }
         return this.buildWorkspaceMcpResourcesStatus(
-          this.config,
+          this.getWorkspaceMcpConfig(serverName),
           serverName
         );
       }
@@ -10469,6 +11034,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 +11046,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 +11054,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 +11062,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 +11105,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 +11114,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 +11127,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 +11147,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 +11172,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 +11185,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 +11201,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 +11268,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 +11280,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 +11295,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 +11318,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 +11536,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 +11811,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 +12166,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 +12197,7 @@ ${outputText}
           const result = await manager.addRuntimeMcpServer(
             name,
             safeConfig,
-            originatorClientId
+            runtimeClientId
           );
           await Promise.all(
             this.getActiveSessions().map(async (session) => {
@@ -11440,7 +12207,7 @@ ${outputText}
                 await sessionManager.addRuntimeMcpServer(
                   name,
                   safeConfig,
-                  originatorClientId
+                  runtimeClientId
                 );
               } catch (sessionErr) {
                 debugLogger7.warn(
@@ -11489,12 +12256,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 +12266,7 @@ ${outputText}
         }
         const result = await manager.removeRuntimeMcpServer(
           name,
-          originatorClientId
+          runtimeClientId
         );
         await Promise.all(
           this.getActiveSessions().map(async (session) => {
@@ -11513,7 +12275,7 @@ ${outputText}
             try {
               await sessionManager.removeRuntimeMcpServer(
                 name,
-                originatorClientId
+                runtimeClientId
               );
             } catch (sessionErr) {
               debugLogger7.warn(
@@ -11539,6 +12301,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 +13288,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 +13323,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 +13347,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 +13359,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([