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

package/chunks/{chunk-HHEFI4RP.js → chunk-YOJGIRTD.js}

@@ -16,9 +16,6 @@ import {
 import {
   normalizeCompactedReplayMaxBytes
 } from "./chunk-COH43MRJ.js";
-import {
-  MCP_RESTART_SERVER_DEADLINE_MS
-} from "./chunk-OCPBI7J5.js";
 import {
   BranchWhilePromptActiveError,
   CancelSentinelCollisionError,
@@ -28,6 +25,7 @@ import {
   InvalidRewindTargetError,
   InvalidSessionMetadataError,
   InvalidSessionScopeError,
+  MCP_RESTART_SERVER_DEADLINE_MS,
   PermissionForbiddenError,
   PromptQueueFullError,
   RestoreInProgressError,
@@ -38,10 +36,10 @@ import {
   SessionShellDisabledError,
   WorkspaceMismatchError,
   isNotCurrentlyGeneratingCancelError
-} from "./chunk-KSO42X3Z.js";
+} from "./chunk-X6YQWCIJ.js";
 import {
   defaultSpawnChannelFactory
-} from "./chunk-UFOKA4PR.js";
+} from "./chunk-VHCSIMTF.js";
 import {
   BridgeChannelClosedError,
   BridgeTimeoutError,
@@ -50,7 +48,7 @@ import {
   STATUS_SCHEMA_VERSION,
   createIdleWorkspaceExtensionsStatus,
   createIdleWorkspaceHooksStatus
-} from "./chunk-CUUXANEQ.js";
+} from "./chunk-W6J7RSCK.js";
 import {
   canonicalizeWorkspace
 } from "./chunk-W7FJ3N32.js";
@@ -70,11 +68,11 @@ import {
   metadataBudgetBytes,
   normalizeSnapshotPayload,
   stableSessionArtifactId
-} from "./chunk-K7CRWKOE.js";
+} from "./chunk-R6AO7HBQ.js";
 import {
   DAEMON_TRACEPARENT_META_KEY,
   DAEMON_TRACESTATE_META_KEY
-} from "./chunk-P6LART6G.js";
+} from "./chunk-BTSE2DUP.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -473,6 +471,30 @@ function mergeToolCallEvent(existing, incoming) {
 }
 __name(mergeToolCallEvent, "mergeToolCallEvent");
 
+// packages/acp-bridge/src/session-source.ts
+init_esbuild_shims();
+var SESSION_SOURCE_TYPE_PATTERN = /^[a-z][a-z0-9_-]{0,63}$/;
+var MAX_SESSION_SOURCE_ID_LENGTH = 256;
+function parseSessionSource(sourceType, sourceId) {
+  if (sourceType === void 0 && sourceId === void 0) return {};
+  if (typeof sourceType !== "string" || !SESSION_SOURCE_TYPE_PATTERN.test(sourceType)) {
+    return {
+      error: "`sourceType` must match [a-z][a-z0-9_-]{0,63} when provided"
+    };
+  }
+  if (sourceId === void 0) return { sourceType };
+  if (typeof sourceId !== "string" || sourceId.length === 0 || sourceId.length > MAX_SESSION_SOURCE_ID_LENGTH || [...sourceId].some((character) => {
+    const code = character.charCodeAt(0);
+    return code <= 31 || code === 127;
+  })) {
+    return {
+      error: `\`sourceId\` must be a non-empty string of at most ${MAX_SESSION_SOURCE_ID_LENGTH} characters without control characters`
+    };
+  }
+  return { sourceType, sourceId };
+}
+__name(parseSessionSource, "parseSessionSource");
+
 // packages/acp-bridge/src/internal/stderrLine.ts
 init_esbuild_shims();
 function writeStderrLine(message) {
@@ -545,8 +567,8 @@ var MultiClientPermissionMediator = class {
    * an identical line (the unanimity condition is the NORMAL
    * operating mode for M=2, not a rare edge); a busy session with
    * many tool calls would produce dozens of duplicate stderr lines
-   * within seconds. One emit per mediator (= per daemon lifetime
-   * since the bridge constructs one) is enough to make the
+   * within seconds. One emit per mediator (= per bridge/runtime lifetime
+   * since each bridge constructs one) is enough to make the
    * configuration visible without spam.
    */
   unanimityBreadcrumbEmitted = false;
@@ -1392,7 +1414,7 @@ function sliceLineRange(content, startLine, endLine) {
 }
 __name(sliceLineRange, "sliceLineRange");
 var BridgeClient = class {
-  constructor(resolveEntry, resolvePendingRestoreEvents, mediator, permissionTimeoutMs, maxPendingPerSession, fileSystem, onModelPromoted, onModePromoted, clientMcpSender, ownsSession = () => true, onTokenUsage, onCreateSubSession) {
+  constructor(resolveEntry, resolvePendingRestoreEvents, mediator, permissionTimeoutMs, maxPendingPerSession, fileSystem, onModelPromoted, onModePromoted, clientMcpSender, ownsSession = () => true, onTokenUsage, onCreateSubSession, onGenerationEvent) {
     this.resolveEntry = resolveEntry;
     this.resolvePendingRestoreEvents = resolvePendingRestoreEvents;
     this.mediator = mediator;
@@ -1405,6 +1427,7 @@ var BridgeClient = class {
     this.ownsSession = ownsSession;
     this.onTokenUsage = onTokenUsage;
     this.onCreateSubSession = onCreateSubSession;
+    this.onGenerationEvent = onGenerationEvent;
   }
   static {
     __name(this, "BridgeClient");
@@ -1816,6 +1839,51 @@ var BridgeClient = class {
    * forward-compat.
    */
   async extNotification(method, params) {
+    if (method === "qwen/notify/session/generation/event") {
+      const sessionId2 = params["sessionId"];
+      const requestId = params["requestId"];
+      const event = params["event"];
+      if (params["v"] !== 1 || typeof sessionId2 !== "string" || typeof requestId !== "string" || !event || typeof event !== "object" || Array.isArray(event)) {
+        return;
+      }
+      const record = event;
+      if (record["type"] === "started") {
+        const model = record["model"];
+        const modelSource = record["modelSource"];
+        if (typeof model !== "string" || modelSource !== "fast" && modelSource !== "main") {
+          return;
+        }
+        this.onGenerationEvent?.(sessionId2, {
+          type: "started",
+          requestId,
+          model,
+          modelSource
+        });
+        return;
+      }
+      if (record["type"] === "thinking") {
+        this.onGenerationEvent?.(sessionId2, {
+          type: "thinking",
+          requestId
+        });
+        return;
+      }
+      if (record["type"] === "delta") {
+        const seq = record["seq"];
+        const text = record["text"];
+        if (typeof seq !== "number" || !Number.isSafeInteger(seq) || seq < 0 || typeof text !== "string" || text.length === 0) {
+          return;
+        }
+        this.onGenerationEvent?.(sessionId2, {
+          type: "delta",
+          requestId,
+          seq,
+          text
+        });
+        return;
+      }
+      return;
+    }
     if (method === "qwen/notify/session/model-update") {
       this.handleInSessionModelUpdate(params);
       return;
@@ -2432,6 +2500,77 @@ function extractA2uiToolUpdate(params) {
 }
 __name(extractA2uiToolUpdate, "extractA2uiToolUpdate");
 
+// packages/acp-bridge/src/generation-stream.ts
+init_esbuild_shims();
+var GenerationStreamQueue = class {
+  constructor(capacity) {
+    this.capacity = capacity;
+  }
+  static {
+    __name(this, "GenerationStreamQueue");
+  }
+  values = [];
+  waiter;
+  closed = false;
+  failure;
+  push(value) {
+    if (this.closed) return false;
+    if (this.waiter) {
+      const waiter = this.waiter;
+      this.waiter = void 0;
+      waiter.resolve({ value, done: false });
+      return true;
+    }
+    if (this.values.length >= this.capacity) return false;
+    this.values.push(value);
+    return true;
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.settleWaiter();
+  }
+  fail(error) {
+    if (this.closed) return;
+    this.failure = error;
+    this.closed = true;
+    this.settleWaiter();
+  }
+  settleWaiter() {
+    if (!this.waiter) return;
+    const waiter = this.waiter;
+    this.waiter = void 0;
+    if (this.failure !== void 0) waiter.reject(this.failure);
+    else waiter.resolve({ value: void 0, done: true });
+  }
+  next() {
+    if (this.values.length > 0) {
+      return Promise.resolve({ value: this.values.shift(), done: false });
+    }
+    if (this.failure !== void 0) return Promise.reject(this.failure);
+    if (this.closed) {
+      return Promise.resolve({ value: void 0, done: true });
+    }
+    if (this.waiter) {
+      return Promise.reject(
+        new Error("GenerationStreamQueue supports only one pending reader")
+      );
+    }
+    return new Promise((resolve2, reject) => {
+      this.waiter = { resolve: resolve2, reject };
+    });
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: /* @__PURE__ */ __name(() => this.next(), "next"),
+      return: /* @__PURE__ */ __name(async () => {
+        this.close();
+        return { value: void 0, done: true };
+      }, "return")
+    };
+  }
+};
+
 // packages/acp-bridge/src/sessionArtifacts.ts
 init_esbuild_shims();
 import { createHash } from "node:crypto";
@@ -4660,6 +4799,14 @@ function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 __name(isRecord2, "isRecord");
+function getCanonicalModelId(response, fallback) {
+  if (!isRecord2(response) || !isRecord2(response["_meta"])) return fallback;
+  const modelSwitch = response["_meta"]["qwenModelSwitch"];
+  if (!isRecord2(modelSwitch)) return fallback;
+  const modelId = modelSwitch["modelId"];
+  return typeof modelId === "string" ? modelId : fallback;
+}
+__name(getCanonicalModelId, "getCanonicalModelId");
 function isBulkReplayUpdate(value) {
   if (!isRecord2(value)) return false;
   const updateType = value["sessionUpdate"];
@@ -5027,6 +5174,8 @@ var MCP_OAUTH_TIMEOUT_MS = 6e5;
 var DAEMON_RETRY_META_KEY = "qwen.daemon.retry";
 var DAEMON_CONTINUE_META_KEY = "qwen.daemon.continueLastTurn";
 var SESSION_RECAP_TIMEOUT_MS = 6e4;
+var SESSION_GENERATION_TIMEOUT_MS = 65e3;
+var GENERATION_STREAM_QUEUE_CAPACITY = 128;
 var SESSION_BTW_TIMEOUT_MS = 6e4;
 var SESSION_TRANSCRIPT_TIMEOUT_MS = 6e4;
 var SHELL_COMMAND_TIMEOUT_MS = 12e4;
@@ -5132,6 +5281,9 @@ function createAcpSessionBridge(opts) {
   const telemetry = opts.telemetry ?? NOOP_BRIDGE_TELEMETRY;
   let defaultEntry;
   let channelInfo;
+  let workspaceMcpStatusCache;
+  const workspaceMcpToolsCache = /* @__PURE__ */ new Map();
+  const workspaceMcpResourcesCache = /* @__PURE__ */ new Map();
   let idleTimer;
   const sessionReapIntervalMs = resolvePositiveFiniteMs(
     opts.sessionReapIntervalMs,
@@ -5196,9 +5348,41 @@ function createAcpSessionBridge(opts) {
   function hasNoChannelWork(ci, opts2) {
     const inFlightSpawnCount = ci.sessionSpawnsInFlight - (opts2?.ignoreCurrentSessionSpawn === true ? 1 : 0);
     const pendingRestoreCount = ci.pendingRestoreIds.size - (opts2?.ignoreRestoreId !== void 0 && ci.pendingRestoreIds.has(opts2.ignoreRestoreId) ? 1 : 0);
-    return ci.sessionIds.size === 0 && pendingRestoreCount === 0 && ci.workspaceControlInFlight === 0 && inFlightSpawnCount === 0;
+    return ci.sessionIds.size === 0 && pendingRestoreCount === 0 && ci.workspaceControlInFlight === 0 && !ci.workspaceMcpDiscoveryInFlight && ci.workspaceMcpAuthenticationServerNames.size === 0 && inFlightSpawnCount === 0;
   }
   __name(hasNoChannelWork, "hasNoChannelWork");
+  function beginWorkspaceMcpDiscovery(ci) {
+    workspaceMcpStatusCache = void 0;
+    workspaceMcpToolsCache.clear();
+    workspaceMcpResourcesCache.clear();
+    ci.workspaceMcpDiscoveryInFlight = true;
+    if (ci.workspaceMcpDiscoveryTimer) {
+      clearTimeout(ci.workspaceMcpDiscoveryTimer);
+    }
+    ci.workspaceMcpDiscoveryTimer = setTimeout(() => {
+      ci.workspaceMcpDiscoveryTimer = void 0;
+      ci.workspaceMcpDiscoveryInFlight = false;
+      ci.workspaceMcpDiscoveryRequested = false;
+      if (hasNoChannelWork(ci)) {
+        void startIdleTimer(ci, "workspace MCP discovery timeout");
+      }
+    }, MCP_RESTART_TIMEOUT_MS);
+    ci.workspaceMcpDiscoveryTimer.unref();
+  }
+  __name(beginWorkspaceMcpDiscovery, "beginWorkspaceMcpDiscovery");
+  function finishWorkspaceMcpDiscovery(ci) {
+    ci.workspaceMcpDiscoveryInFlight = false;
+    if (ci.workspaceMcpDiscoveryTimer) {
+      clearTimeout(ci.workspaceMcpDiscoveryTimer);
+      ci.workspaceMcpDiscoveryTimer = void 0;
+    }
+  }
+  __name(finishWorkspaceMcpDiscovery, "finishWorkspaceMcpDiscovery");
+  function invalidateWorkspaceMcpDetailCache(serverName) {
+    workspaceMcpToolsCache.delete(serverName);
+    workspaceMcpResourcesCache.delete(serverName);
+  }
+  __name(invalidateWorkspaceMcpDetailCache, "invalidateWorkspaceMcpDetailCache");
   async function reapPendingEmptyChannel(ci) {
     if (!ci.emptyReapPending || !hasNoChannelWork(ci)) return;
     ci.emptyReapPending = false;
@@ -5262,6 +5446,7 @@ function createAcpSessionBridge(opts) {
   const aliveChannels = /* @__PURE__ */ new Set();
   let inFlightChannelSpawn;
   const byId = /* @__PURE__ */ new Map();
+  const generationRequests = /* @__PURE__ */ new Map();
   const inFlightExtensionRefreshes = /* @__PURE__ */ new Map();
   const toSessionSummary = /* @__PURE__ */ __name((entry) => {
     let isWaitingForPermission = false;
@@ -5279,6 +5464,8 @@ function createAcpSessionBridge(opts) {
       createdAt: entry.createdAt,
       displayName: entry.displayName,
       ...entry.parentSessionId ? { parentSessionId: entry.parentSessionId } : {},
+      ...entry.sourceType ? { sourceType: entry.sourceType } : {},
+      ...entry.sourceId !== void 0 ? { sourceId: entry.sourceId } : {},
       clientCount: entry.clientIds.size,
       hasActivePrompt: entry.promptActive,
       isWaitingForPermission,
@@ -5376,11 +5563,13 @@ function createAcpSessionBridge(opts) {
     if (channelInfo && !channelInfo.isDying) return channelInfo;
     if (inFlightChannelSpawn) return await inFlightChannelSpawn;
     const promise = (async () => {
+      const acpChannelId = randomUUID2();
       const channel = await telemetry.withSpan(
         "channel.spawn",
         {
           "qwen-code.daemon.bridge.operation": "channel.spawn",
-          "qwen-code.daemon.channel.reused": false
+          "qwen-code.daemon.channel.reused": false,
+          "qwen-code.daemon.acp_channel.id": acpChannelId
         },
         async () => await channelFactory(boundWorkspace, childEnvOverrides)
       );
@@ -5450,10 +5639,23 @@ function createAcpSessionBridge(opts) {
         // `create_sub_session` tool: forward the request/response hook so a child
         // tool can ask the daemon to spawn a sub-session and (for 'first-turn')
         // return its result. Omitted → the method reports daemon-only.
-        opts.onCreateSubSession
+        opts.onCreateSubSession,
+        (sessionId, event) => {
+          const request = generationRequests.get(event.requestId);
+          if (!request || request.sessionId !== sessionId) return;
+          if (request.queue.push(event)) return;
+          request.settled = true;
+          generationRequests.delete(event.requestId);
+          request.queue.fail(new Error("Generation stream consumer too slow"));
+          void request.connection.extMethod(SERVE_CONTROL_EXT_METHODS.sessionGenerationCancel, {
+            sessionId,
+            requestId: event.requestId
+          }).catch(() => void 0);
+        }
       );
       const connection = new ClientSideConnection(() => client, channel.stream);
       const info = {
+        id: acpChannelId,
         channel,
         connection,
         client,
@@ -5461,6 +5663,10 @@ function createAcpSessionBridge(opts) {
         pendingRestoreIds: /* @__PURE__ */ new Set(),
         sessionSpawnsInFlight: 0,
         workspaceControlInFlight: 0,
+        workspaceMcpDiscoveryInFlight: false,
+        workspaceMcpDiscoveryRequested: false,
+        workspaceMcpAuthenticationServerNames: /* @__PURE__ */ new Set(),
+        workspaceMcpAuthenticationTimers: /* @__PURE__ */ new Map(),
         emptyReapPending: false,
         isDying: false,
         handshakeComplete: false
@@ -5473,6 +5679,15 @@ function createAcpSessionBridge(opts) {
       }
       void channel.exited.then((exitInfo) => {
         if (channelInfo === info) cancelIdleTimer();
+        if (info.workspaceMcpDiscoveryTimer) {
+          clearTimeout(info.workspaceMcpDiscoveryTimer);
+          info.workspaceMcpDiscoveryTimer = void 0;
+        }
+        for (const timer of info.workspaceMcpAuthenticationTimers.values()) {
+          clearTimeout(timer);
+        }
+        info.workspaceMcpAuthenticationTimers.clear();
+        info.workspaceMcpAuthenticationServerNames.clear();
         aliveChannels.delete(info);
         if (channelInfo === info) channelInfo = void 0;
         const sessions = Array.from(info.sessionIds);
@@ -5530,7 +5745,8 @@ function createAcpSessionBridge(opts) {
         await telemetry.withSpan(
           "channel.initialize",
           {
-            "qwen-code.daemon.bridge.operation": "channel.initialize"
+            "qwen-code.daemon.bridge.operation": "channel.initialize",
+            "qwen-code.daemon.acp_channel.id": acpChannelId
           },
           async () => await withTimeout(
             connection.initialize({
@@ -5569,8 +5785,16 @@ function createAcpSessionBridge(opts) {
     }
   }
   __name(ensureChannel, "ensureChannel");
-  async function doSpawn(modelServiceId, effectiveScope, approvalMode, requestedClientId, onSessionRegistered, parentSessionId) {
-    const ci = await ensureChannel();
+  async function doSpawn(modelServiceId, effectiveScope, approvalMode, requestedClientId, onSessionRegistered, parentSessionId, sourceType, sourceId) {
+    const channelPath = channelInfo && !channelInfo.isDying ? "reused" : inFlightChannelSpawn ? "joined" : "spawned_on_request";
+    const ci = await telemetry.withSpan(
+      "channel.wait",
+      {
+        "qwen-code.daemon.bridge.operation": "channel.wait",
+        "qwen-code.daemon.channel.path": channelPath
+      },
+      ensureChannel
+    );
     ci.sessionSpawnsInFlight++;
     let sessionRegistered = false;
     let sessionRemovedDuringInitialization = false;
@@ -5582,16 +5806,27 @@ function createAcpSessionBridge(opts) {
           "session.new",
           {
             "qwen-code.daemon.bridge.operation": "session.new",
-            "qwen-code.daemon.session_scope": effectiveScope
+            "qwen-code.daemon.session_scope": effectiveScope,
+            "qwen-code.daemon.channel.path": channelPath,
+            "qwen-code.daemon.acp_channel.id": ci.id
           },
-          async () => await withTimeout(
-            ci.connection.newSession({
-              cwd: boundWorkspace,
-              mcpServers: []
-            }),
-            initTimeoutMs,
-            "newSession"
-          )
+          async () => {
+            const response = await withTimeout(
+              ci.connection.newSession(
+                telemetry.injectPromptContext({
+                  cwd: boundWorkspace,
+                  mcpServers: []
+                })
+              ),
+              initTimeoutMs,
+              "newSession"
+            );
+            telemetry.event("session.new.completed", {
+              "session.id": response.sessionId,
+              "qwen-code.daemon.acp_channel.id": ci.id
+            });
+            return response;
+          }
         );
       } catch (err) {
         if (hasNoChannelWork(ci, { ignoreCurrentSessionSpawn: true })) {
@@ -5611,7 +5846,7 @@ function createAcpSessionBridge(opts) {
         newSessionResp.sessionId,
         boundWorkspace,
         void 0,
-        { parentSessionId }
+        { parentSessionId, sourceType, sourceId }
       );
       initializedSessionId = entry.sessionId;
       sessionRegistered = true;
@@ -5661,6 +5896,32 @@ function createAcpSessionBridge(opts) {
           );
         }
       }
+      let sourcePersisted;
+      if (entry.sourceType) {
+        try {
+          const sourceResult = await Promise.race([
+            withTimeout(
+              entry.connection.extMethod(
+                SERVE_CONTROL_EXT_METHODS.sessionSource,
+                {
+                  sessionId: entry.sessionId,
+                  sourceType: entry.sourceType,
+                  ...entry.sourceId !== void 0 ? { sourceId: entry.sourceId } : {}
+                }
+              ),
+              initTimeoutMs,
+              "sessionSource"
+            ),
+            getTransportClosedReject(entry)
+          ]);
+          sourcePersisted = sourceResult?.persisted === true;
+        } catch (err) {
+          sourcePersisted = false;
+          writeStderrLine(
+            `qwen serve: source metadata for ${entry.sessionId} was not persisted (${err instanceof Error ? err.message : String(err)}) \u2014 the source is live-only until restart (reported to the caller via sourcePersisted=false)`
+          );
+        }
+      }
       if (modelServiceId) {
         await applyModelServiceId(
           entry,
@@ -5696,6 +5957,9 @@ function createAcpSessionBridge(opts) {
         attached: false,
         clientId,
         createdAt: entry.createdAt,
+        ...entry.sourceType ? { sourceType: entry.sourceType } : {},
+        ...entry.sourceId !== void 0 ? { sourceId: entry.sourceId } : {},
+        ...entry.sourceType ? { sourcePersisted: sourcePersisted === true } : {},
         ...entry.parentSessionId ? { parentSessionPersisted: parentSessionPersisted === true } : {}
       };
     } finally {
@@ -5726,7 +5990,7 @@ function createAcpSessionBridge(opts) {
       entry.modelRoundtripInFlight = true;
       let succeeded = false;
       try {
-        await Promise.race([
+        const result = await Promise.race([
           withTimeout(
             conn.unstable_setSessionModel({
               sessionId: entry.sessionId,
@@ -5742,7 +6006,7 @@ function createAcpSessionBridge(opts) {
           type: "settings_changed",
           data: {
             key: "model.name",
-            value: modelId
+            value: getCanonicalModelId(result, modelId)
           },
           ...originatorClientId ? { originatorClientId } : {}
         });
@@ -5943,10 +6207,77 @@ function createAcpSessionBridge(opts) {
     }
     return info.statusClosedReject;
   }, "getChannelClosedReject");
-  const requestWorkspaceStatus = /* @__PURE__ */ __name(async (method, idle, params = {}) => {
+  const cacheWorkspaceMcpDetails = /* @__PURE__ */ __name(async (info, status) => {
+    if (!Array.isArray(status.servers)) return;
+    const serverNames = status.servers.flatMap(
+      (server) => isRecord2(server) && typeof server["name"] === "string" && server["mcpStatus"] === "connected" ? [server["name"]] : []
+    );
+    const cacheDetail = /* @__PURE__ */ __name(async (serverName, method, cache) => {
+      try {
+        const result = await withTimeout(
+          Promise.race([
+            info.connection.extMethod(method, {
+              serverName,
+              cwd: boundWorkspace
+            }),
+            getChannelClosedReject(info)
+          ]),
+          initTimeoutMs,
+          method
+        );
+        cache.set(serverName, result);
+      } catch {
+      }
+    }, "cacheDetail");
+    await Promise.all(
+      serverNames.flatMap((serverName) => [
+        cacheDetail(
+          serverName,
+          SERVE_STATUS_EXT_METHODS.workspaceMcpTools,
+          workspaceMcpToolsCache
+        ),
+        cacheDetail(
+          serverName,
+          SERVE_STATUS_EXT_METHODS.workspaceMcpResources,
+          workspaceMcpResourcesCache
+        )
+      ])
+    );
+  }, "cacheWorkspaceMcpDetails");
+  const mergeManagedWorkspaceMcpStatus = /* @__PURE__ */ __name((serverNames, previous, current) => {
+    if (Array.isArray(current.servers) && previous?.discoveryState === "completed" && current.discoveryState === "not_started") {
+      if (current.servers.length === 0) return previous;
+      const currentServers = new Map(
+        current.servers.map((server) => [server.name, server])
+      );
+      const previousNames = new Set(
+        previous.servers.map((server) => server.name)
+      );
+      const servers = previous.servers.map(
+        (server) => serverNames.has(server.name) ? currentServers.get(server.name) ?? server : server
+      );
+      for (const server of current.servers) {
+        if (serverNames.has(server.name) && !previousNames.has(server.name)) {
+          servers.push(server);
+        }
+      }
+      return {
+        ...previous,
+        discoveryState: "completed",
+        servers
+      };
+    }
+    return current;
+  }, "mergeManagedWorkspaceMcpStatus");
+  const requestWorkspaceStatus = /* @__PURE__ */ __name(async (method, idle, params = {}, managedServerNames) => {
     const info = liveChannelInfo();
-    if (!info) return idle();
-    const response = await withTimeout(
+    if (!info) {
+      if (method === SERVE_STATUS_EXT_METHODS.workspaceMcp && workspaceMcpStatusCache) {
+        return workspaceMcpStatusCache;
+      }
+      return idle();
+    }
+    let response = await withTimeout(
       Promise.race([
         info.connection.extMethod(method, { ...params, cwd: boundWorkspace }),
         getChannelClosedReject(info)
@@ -5954,6 +6285,67 @@ function createAcpSessionBridge(opts) {
       initTimeoutMs,
       method
     );
+    if (method === SERVE_STATUS_EXT_METHODS.workspaceMcp) {
+      const rawStatus = response;
+      if (!Array.isArray(rawStatus.servers)) {
+        return response;
+      }
+      const rawServers = rawStatus.servers;
+      const effectiveManagedServerNames = /* @__PURE__ */ new Set([
+        ...info.workspaceMcpAuthenticationServerNames,
+        ...managedServerNames ?? []
+      ]);
+      if (effectiveManagedServerNames.size > 0 || workspaceMcpStatusCache?.discoveryState === "completed" && rawStatus.discoveryState === "not_started" && rawServers.length === 0) {
+        response = mergeManagedWorkspaceMcpStatus(
+          effectiveManagedServerNames,
+          workspaceMcpStatusCache,
+          rawStatus
+        );
+      }
+      const status = response;
+      if (status.discoveryState === "completed") {
+        await cacheWorkspaceMcpDetails(
+          info,
+          effectiveManagedServerNames.size > 0 ? {
+            servers: rawServers.filter(
+              (server) => effectiveManagedServerNames.has(server.name)
+            )
+          } : status
+        );
+      }
+      if (info.workspaceMcpDiscoveryInFlight && (status.discoveryState === "completed" || Array.isArray(status.errors) && status.errors.length > 0)) {
+        finishWorkspaceMcpDiscovery(info);
+        if (hasNoChannelWork(info)) {
+          await startIdleTimer(info, "workspace MCP discovery complete");
+        }
+      }
+      if (status.discoveryState === "completed") {
+        info.workspaceMcpDiscoveryRequested = true;
+      } else if (status.discoveryState === "in_progress") {
+        info.workspaceMcpDiscoveryRequested = true;
+      } else if (Array.isArray(status.errors) && status.errors.length > 0) {
+        info.workspaceMcpDiscoveryRequested = false;
+      }
+      let authenticationCompleted = false;
+      for (const serverName of info.workspaceMcpAuthenticationServerNames) {
+        const server = rawServers.find(
+          (candidate) => candidate.name === serverName
+        );
+        if (server?.authenticationState !== "pending" && (server !== void 0 || rawStatus.discoveryState === "completed")) {
+          info.workspaceMcpAuthenticationServerNames.delete(serverName);
+          const timer = info.workspaceMcpAuthenticationTimers.get(serverName);
+          if (timer) clearTimeout(timer);
+          info.workspaceMcpAuthenticationTimers.delete(serverName);
+          authenticationCompleted = true;
+        }
+      }
+      if (authenticationCompleted) {
+        if (hasNoChannelWork(info)) {
+          await startIdleTimer(info, "workspace MCP authentication complete");
+        }
+      }
+      workspaceMcpStatusCache = response;
+    }
     return response;
   }, "requestWorkspaceStatus");
   const STALE_CHILD_RESOURCE_MS = 3e4;
@@ -6177,6 +6569,8 @@ function createAcpSessionBridge(opts) {
       workspaceCwd,
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       ...options.parentSessionId ? { parentSessionId: options.parentSessionId } : {},
+      ...options.sourceType ? { sourceType: options.sourceType } : {},
+      ...options.sourceId !== void 0 ? { sourceId: options.sourceId } : {},
       channel: ci.channel,
       connection: ci.connection,
       events,
@@ -6411,6 +6805,8 @@ function createAcpSessionBridge(opts) {
         attached: true,
         clientId,
         createdAt: existing.createdAt,
+        ...existing.sourceType ? { sourceType: existing.sourceType } : {},
+        ...existing.sourceId !== void 0 ? { sourceId: existing.sourceId } : {},
         // Late attachers get the same ACP state the original restore
         // caller saw; spawn-only sessions don't carry a state payload.
         state: existing.restoreState ?? {},
@@ -6583,6 +6979,8 @@ function createAcpSessionBridge(opts) {
           attached: true,
           clientId: clientId2,
           createdAt: racedEntry.createdAt,
+          ...racedEntry.sourceType ? { sourceType: racedEntry.sourceType } : {},
+          ...racedEntry.sourceId !== void 0 ? { sourceId: racedEntry.sourceId } : {},
           state: racedEntry.restoreState ?? {},
           hasActivePrompt: racedEntry.promptActive,
           ...replayFieldsFor(racedEntry, action)
@@ -6598,7 +6996,9 @@ function createAcpSessionBridge(opts) {
           lifecycleReason: action,
           // Re-seed the persisted parent lineage the caller recovered from the
           // transcript, so a restored sub-session's status reports its parent.
-          ...req.parentSessionId ? { parentSessionId: req.parentSessionId } : {}
+          ...req.parentSessionId ? { parentSessionId: req.parentSessionId } : {},
+          ...req.sourceType ? { sourceType: req.sourceType } : {},
+          ...req.sourceId !== void 0 ? { sourceId: req.sourceId } : {}
         }
       );
       releaseAdmissionOnce();
@@ -6643,6 +7043,8 @@ function createAcpSessionBridge(opts) {
         attached: false,
         clientId,
         createdAt: entry.createdAt,
+        ...entry.sourceType ? { sourceType: entry.sourceType } : {},
+        ...entry.sourceId !== void 0 ? { sourceId: entry.sourceId } : {},
         state: publicState,
         ...artifactRestoreWarnings.length > 0 ? { artifactWarnings: artifactRestoreWarnings } : {},
         hasActivePrompt: entry.promptActive,
@@ -6863,6 +7265,10 @@ function createAcpSessionBridge(opts) {
         throw new InvalidSessionScopeError(req.sessionScope);
       }
       const effectiveScope = req.sessionScope ?? defaultSessionScope;
+      const source = parseSessionSource(req.sourceType, req.sourceId);
+      if ("error" in source) {
+        throw new InvalidSessionMetadataError("sourceType", source.error);
+      }
       if (req.approvalMode !== void 0 && !KNOWN_APPROVAL_MODES.has(req.approvalMode)) {
         throw new Error(
           `Invalid approvalMode: ${JSON.stringify(req.approvalMode)}`
@@ -6895,6 +7301,8 @@ function createAcpSessionBridge(opts) {
             attached: true,
             clientId,
             createdAt: existing.createdAt,
+            ...existing.sourceType ? { sourceType: existing.sourceType } : {},
+            ...existing.sourceId !== void 0 ? { sourceId: existing.sourceId } : {},
             hasActivePrompt: existing.promptActive
           };
         }
@@ -6953,7 +7361,9 @@ function createAcpSessionBridge(opts) {
         req.approvalMode,
         req.clientId,
         releaseAdmissionOnce,
-        req.parentSessionId
+        req.parentSessionId,
+        source.sourceType,
+        source.sourceId
       );
       const tracker = effectiveScope === "single" ? workspaceKey : `${workspaceKey}#${randomUUID2()}`;
       inFlightSpawns.set(tracker, promise);
@@ -7728,18 +8138,39 @@ function createAcpSessionBridge(opts) {
       return requestWorkspaceStatus(method, idle);
     },
     async invokeWorkspaceCommand(method, params, invokeOpts) {
-      const info = liveChannelInfo();
+      const startsWorkspaceChannel = method === SERVE_CONTROL_EXT_METHODS.workspaceMcpRestart;
+      const info = startsWorkspaceChannel ? await ensureChannel() : liveChannelInfo();
       if (!info) throw new SessionNotFoundError(`workspace-command:${method}`);
-      const timeout = invokeOpts?.timeoutMs ?? initTimeoutMs;
-      const response = await withTimeout(
-        Promise.race([
-          info.connection.extMethod(method, params ?? {}),
-          getChannelClosedReject(info)
-        ]),
-        timeout,
-        method
-      );
-      return response;
+      try {
+        const timeout = invokeOpts?.timeoutMs ?? initTimeoutMs;
+        const invoke = /* @__PURE__ */ __name(() => withTimeout(
+          Promise.race([
+            info.connection.extMethod(method, params ?? {}),
+            getChannelClosedReject(info)
+          ]),
+          timeout,
+          method
+        ), "invoke");
+        const response = startsWorkspaceChannel ? await withWorkspaceControl(info, invoke) : await invoke();
+        if (method === SERVE_CONTROL_EXT_METHODS.workspaceMcpRestart && typeof params?.["serverName"] === "string") {
+          invalidateWorkspaceMcpDetailCache(params["serverName"]);
+          await requestWorkspaceStatus(
+            SERVE_STATUS_EXT_METHODS.workspaceMcp,
+            () => {
+              throw new BridgeChannelClosedError(
+                "workspace MCP restart status refresh"
+              );
+            },
+            {},
+            /* @__PURE__ */ new Set([params["serverName"]])
+          );
+        }
+        return response;
+      } finally {
+        if (startsWorkspaceChannel && hasNoChannelWork(info)) {
+          await startIdleTimer(info, "workspace MCP restart");
+        }
+      }
     },
     async isWorkspaceMemoryRememberAvailable() {
       const info = await ensureChannel();
@@ -7838,46 +8269,60 @@ function createAcpSessionBridge(opts) {
       }
     },
     async getWorkspaceMcpToolsStatus(serverName) {
-      return requestWorkspaceStatus(
+      const result = await requestWorkspaceStatus(
         SERVE_STATUS_EXT_METHODS.workspaceMcpTools,
-        () => ({
-          v: STATUS_SCHEMA_VERSION,
-          workspaceCwd: boundWorkspace,
-          serverName,
-          initialized: false,
-          acpChannelLive: false,
-          tools: [],
-          errors: [
-            {
-              kind: "mcp_tools",
-              status: "not_started",
-              hint: "spawn a session to populate"
-            }
-          ]
-        }),
+        () => {
+          const cached = workspaceMcpToolsCache.get(serverName);
+          return cached ? { ...cached, acpChannelLive: false } : {
+            v: STATUS_SCHEMA_VERSION,
+            workspaceCwd: boundWorkspace,
+            serverName,
+            initialized: false,
+            acpChannelLive: false,
+            tools: [],
+            errors: [
+              {
+                kind: "mcp_tools",
+                status: "not_started",
+                hint: "initialize MCP discovery to populate"
+              }
+            ]
+          };
+        },
         { serverName }
       );
+      if (result.acpChannelLive) {
+        workspaceMcpToolsCache.set(serverName, result);
+      }
+      return result;
     },
     async getWorkspaceMcpResourcesStatus(serverName) {
-      return requestWorkspaceStatus(
+      const result = await requestWorkspaceStatus(
         SERVE_STATUS_EXT_METHODS.workspaceMcpResources,
-        () => ({
-          v: STATUS_SCHEMA_VERSION,
-          workspaceCwd: boundWorkspace,
-          serverName,
-          initialized: false,
-          acpChannelLive: false,
-          resources: [],
-          errors: [
-            {
-              kind: "mcp_resources",
-              status: "not_started",
-              hint: "spawn a session to populate"
-            }
-          ]
-        }),
+        () => {
+          const cached = workspaceMcpResourcesCache.get(serverName);
+          return cached ? { ...cached, acpChannelLive: false } : {
+            v: STATUS_SCHEMA_VERSION,
+            workspaceCwd: boundWorkspace,
+            serverName,
+            initialized: false,
+            acpChannelLive: false,
+            resources: [],
+            errors: [
+              {
+                kind: "mcp_resources",
+                status: "not_started",
+                hint: "initialize MCP discovery to populate"
+              }
+            ]
+          };
+        },
         { serverName }
       );
+      if (result.acpChannelLive) {
+        workspaceMcpResourcesCache.set(serverName, result);
+      }
+      return result;
     },
     async getWorkspaceToolsStatus() {
       return requestWorkspaceStatus(
@@ -8117,7 +8562,7 @@ function createAcpSessionBridge(opts) {
             type: "settings_changed",
             data: {
               key: "model.name",
-              value: req.modelId
+              value: getCanonicalModelId(result, req.modelId)
             },
             ...originatorClientId ? { originatorClientId } : {}
           });
@@ -8245,6 +8690,75 @@ function createAcpSessionBridge(opts) {
         recap: response.recap ?? null
       };
     },
+    generateSessionContent(sessionId, prompt, signal, context) {
+      const entry = byId.get(sessionId);
+      if (!entry) throw new SessionNotFoundError(sessionId);
+      const info = channelInfoForEntry(entry);
+      if (!info || info.isDying) throw new SessionNotFoundError(sessionId);
+      resolveTrustedClientId(entry, context?.clientId);
+      const requestId = randomUUID2();
+      const queue = new GenerationStreamQueue(
+        GENERATION_STREAM_QUEUE_CAPACITY
+      );
+      const request = {
+        sessionId,
+        connection: entry.connection,
+        queue,
+        settled: false
+      };
+      generationRequests.set(requestId, request);
+      const cancel = /* @__PURE__ */ __name(() => {
+        if (request.settled) return;
+        request.settled = true;
+        generationRequests.delete(requestId);
+        queue.close();
+        void entry.connection.extMethod(SERVE_CONTROL_EXT_METHODS.sessionGenerationCancel, {
+          sessionId,
+          requestId
+        }).catch(() => void 0);
+      }, "cancel");
+      signal.addEventListener("abort", cancel, { once: true });
+      if (signal.aborted) {
+        cancel();
+        return queue;
+      }
+      void Promise.race([
+        withTimeout(
+          entry.connection.extMethod(
+            SERVE_CONTROL_EXT_METHODS.sessionGenerationStart,
+            { sessionId, requestId, prompt }
+          ),
+          SESSION_GENERATION_TIMEOUT_MS,
+          SERVE_CONTROL_EXT_METHODS.sessionGenerationStart
+        ),
+        getTransportClosedReject(entry)
+      ]).then((raw) => {
+        if (request.settled) return;
+        const response = raw;
+        const model = response["model"];
+        const modelSource = response["modelSource"];
+        if (typeof model !== "string" || modelSource !== "fast" && modelSource !== "main") {
+          throw new Error("Malformed generation completion");
+        }
+        const accepted = queue.push({
+          type: "done",
+          requestId,
+          model,
+          modelSource,
+          ...typeof response["inputTokens"] === "number" ? { inputTokens: response["inputTokens"] } : {},
+          ...typeof response["outputTokens"] === "number" ? { outputTokens: response["outputTokens"] } : {}
+        });
+        if (accepted) queue.close();
+        else queue.fail(new Error("Generation stream consumer too slow"));
+      }).catch((error) => {
+        if (!request.settled) queue.fail(error);
+      }).finally(() => {
+        request.settled = true;
+        signal.removeEventListener("abort", cancel);
+        generationRequests.delete(requestId);
+      });
+      return queue;
+    },
     getPendingPrompts(sessionId, context) {
       const entry = byId.get(sessionId);
       if (!entry) throw new SessionNotFoundError(sessionId);
@@ -8634,32 +9148,115 @@ function createAcpSessionBridge(opts) {
       };
     },
     async manageMcpServer(serverName, action, originatorClientId) {
-      const info = liveChannelInfo();
-      if (!info) {
-        throw new SessionNotFoundError(`mcp:${serverName}`);
+      const info = await ensureChannel();
+      try {
+        return await withWorkspaceControl(info, async () => {
+          const timeout = action === "authenticate" ? MCP_OAUTH_TIMEOUT_MS : MCP_RESTART_TIMEOUT_MS;
+          const response = await Promise.race([
+            withTimeout(
+              info.connection.extMethod(
+                SERVE_CONTROL_EXT_METHODS.workspaceMcpManage,
+                { serverName, action, originatorClientId }
+              ),
+              timeout,
+              SERVE_CONTROL_EXT_METHODS.workspaceMcpManage
+            ),
+            getChannelClosedReject(info)
+          ]);
+          if (action === "authenticate" && response.pending) {
+            info.workspaceMcpAuthenticationServerNames.add(serverName);
+            const previousTimer = info.workspaceMcpAuthenticationTimers.get(serverName);
+            if (previousTimer) clearTimeout(previousTimer);
+            const timer = setTimeout(() => {
+              info.workspaceMcpAuthenticationServerNames.delete(serverName);
+              info.workspaceMcpAuthenticationTimers.delete(serverName);
+              if (hasNoChannelWork(info)) {
+                void startIdleTimer(
+                  info,
+                  "workspace MCP authentication timeout"
+                );
+              }
+            }, MCP_OAUTH_TIMEOUT_MS);
+            timer.unref();
+            info.workspaceMcpAuthenticationTimers.set(serverName, timer);
+          }
+          invalidateWorkspaceMcpDetailCache(serverName);
+          await requestWorkspaceStatus(
+            SERVE_STATUS_EXT_METHODS.workspaceMcp,
+            () => {
+              throw new BridgeChannelClosedError(
+                "workspace MCP management status refresh"
+              );
+            },
+            {},
+            /* @__PURE__ */ new Set([serverName])
+          );
+          broadcastWorkspaceEvent({
+            type: "mcp_server_changed",
+            data: {
+              serverName: response.serverName,
+              action: response.action,
+              originatorClientId
+            },
+            ...originatorClientId ? { originatorClientId } : {}
+          });
+          return response;
+        });
+      } finally {
+        if (hasNoChannelWork(info)) {
+          await startIdleTimer(info, "workspace MCP management");
+        }
       }
-      const timeout = action === "authenticate" ? MCP_OAUTH_TIMEOUT_MS : MCP_RESTART_TIMEOUT_MS;
-      const response = await Promise.race([
-        withTimeout(
-          info.connection.extMethod(
-            SERVE_CONTROL_EXT_METHODS.workspaceMcpManage,
-            { serverName, action, originatorClientId }
+    },
+    async initializeWorkspaceMcp() {
+      const info = await ensureChannel();
+      info.workspaceMcpDiscoveryRequested = true;
+      try {
+        const result = await Promise.race([
+          withTimeout(
+            info.connection.extMethod(
+              SERVE_CONTROL_EXT_METHODS.workspaceMcpInitialize,
+              { cwd: boundWorkspace }
+            ),
+            initTimeoutMs,
+            SERVE_CONTROL_EXT_METHODS.workspaceMcpInitialize
           ),
-          timeout,
-          SERVE_CONTROL_EXT_METHODS.workspaceMcpManage
-        ),
-        getChannelClosedReject(info)
-      ]);
-      broadcastWorkspaceEvent({
-        type: "mcp_server_changed",
-        data: {
-          serverName: response.serverName,
-          action: response.action,
-          originatorClientId
-        },
-        ...originatorClientId ? { originatorClientId } : {}
-      });
-      return response;
+          getChannelClosedReject(info)
+        ]);
+        if (result.accepted) {
+          beginWorkspaceMcpDiscovery(info);
+        }
+        return result;
+      } finally {
+        if (hasNoChannelWork(info)) {
+          await startIdleTimer(info, "workspace MCP initialization");
+        }
+      }
+    },
+    async reloadWorkspaceMcp() {
+      const info = await ensureChannel();
+      info.workspaceMcpDiscoveryRequested = true;
+      try {
+        const result = await Promise.race([
+          withTimeout(
+            info.connection.extMethod(
+              SERVE_CONTROL_EXT_METHODS.workspaceMcpReload,
+              { cwd: boundWorkspace }
+            ),
+            initTimeoutMs,
+            SERVE_CONTROL_EXT_METHODS.workspaceMcpReload
+          ),
+          getChannelClosedReject(info)
+        ]);
+        if (result.accepted) {
+          beginWorkspaceMcpDiscovery(info);
+        }
+        return result;
+      } finally {
+        if (hasNoChannelWork(info)) {
+          await startIdleTimer(info, "workspace MCP reload");
+        }
+      }
     },
     async generateWorkspaceAgent(description, _originatorClientId) {
       const info = liveChannelInfo();
@@ -8751,10 +9348,10 @@ function createAcpSessionBridge(opts) {
     },
     async killSession(sessionId, opts2) {
       const entry = byId.get(sessionId);
-      if (!entry) return;
+      if (!entry) return false;
       if (opts2?.requireZeroAttaches && entry.attachCount > 0) {
         entry.spawnOwnerWantedKill = true;
-        return;
+        return false;
       }
       permissionMediator.forgetSession(sessionId);
       entry.pendingPermissionIds.clear();
@@ -8798,6 +9395,7 @@ function createAcpSessionBridge(opts) {
           await startIdleTimer(ci, `killSession "${sessionId}"`);
         }
       }
+      return true;
     },
     async detachClient(sessionId, clientId) {
       const entry = byId.get(sessionId);
@@ -8908,11 +9506,17 @@ function createAcpSessionBridge(opts) {
     },
     async preheat() {
       if (shuttingDown) return;
-      const ci = await ensureChannel();
-      const idleMs = resolvedChannelIdleTimeoutMs();
-      if (idleMs > 0 && hasNoChannelWork(ci)) {
-        await startIdleTimer(ci);
-      }
+      await telemetry.withSpan(
+        "channel.preheat",
+        { "qwen-code.daemon.bridge.operation": "channel.preheat" },
+        async () => {
+          const ci = await ensureChannel();
+          const idleMs = resolvedChannelIdleTimeoutMs();
+          if (idleMs > 0 && hasNoChannelWork(ci)) {
+            await startIdleTimer(ci);
+          }
+        }
+      );
     }
   };
   return bridgeApi;
@@ -8935,6 +9539,7 @@ var createHttpAcpBridge = createAcpSessionBridge;
 export {
   SessionArtifactValidationError,
   SessionArtifactAuthorizationError,
+  parseSessionSource,
   extractErrorMessage,
   extractErrorCode,
   classifyTurnErrorKind,