@qwen-code/qwen-code 0.19.2 → 0.19.3

package/chunks/{acpAgent-4MCETHF2.js → acpAgent-7RZUOWOM.js}

@@ -3,8 +3,8 @@
 import {
   classifyApiError,
   prefixMidTurnUserMessageParts
-} from "./chunk-LLFFKXZZ.js";
-import "./chunk-B6HQGTYR.js";
+} from "./chunk-QE6KJYLT.js";
+import "./chunk-UFLGERMB.js";
 import {
   HistoryReplayer,
   MessageEmitter,
@@ -14,88 +14,90 @@ import {
   handleSlashCommand,
   isSlashCommand,
   normalizePartList
-} from "./chunk-2TJ3YN6Q.js";
+} from "./chunk-RRFZXMYP.js";
 import {
   appEvents,
   buildDisabledSkillNamesProvider,
   loadCliConfig,
   normalizeDisabledToolList
-} from "./chunk-ZUAXI2OA.js";
+} from "./chunk-EDMZZFDU.js";
+import {
+  collectContextData,
+  formatContextUsageText
+} from "./chunk-FNJ7BDPH.js";
 import {
   getCommandSubcommandNames
-} from "./chunk-4W4T77MO.js";
+} from "./chunk-J7FA27RO.js";
+import "./chunk-5GOVVXEV.js";
 import {
   getEffectiveSupportedModes
-} from "./chunk-JTYRZODB.js";
-import "./chunk-MRO43B25.js";
-import "./chunk-UAARJR2G.js";
-import "./chunk-JZSY4WP3.js";
-import {
-  collectContextData,
-  formatContextUsageText
-} from "./chunk-TZM5JIAX.js";
+} from "./chunk-3TV3HUWZ.js";
 import {
   isTerminalGoalStatusKind
 } from "./chunk-KSPVDFE4.js";
+import "./chunk-MRO43B25.js";
+import "./chunk-SMXULRAN.js";
+import "./chunk-T4T2FNV4.js";
 import "./chunk-KYMBIKIW.js";
-import "./chunk-I2RFAW6Q.js";
+import "./chunk-I4H7PRWQ.js";
+import "./chunk-JZSY4WP3.js";
+import "./chunk-JVHEVCAU.js";
+import "./chunk-CNLEDYE3.js";
 import "./chunk-3GONHQOA.js";
-import "./chunk-5R4SBCX6.js";
-import "./chunk-Z7XXFPGP.js";
-import "./chunk-JXQ23SNT.js";
-import "./chunk-TMBPDHXD.js";
+import "./chunk-PR32FRT6.js";
+import "./chunk-CKQA6AWF.js";
+import "./chunk-BW4KCQFD.js";
 import {
-  PERMISSION_RULE_TYPES,
-  PermissionRulesValidationError,
-  buildPermissionSettings,
-  normalizePermissionRules,
-  readPermissionRuleSet
-} from "./chunk-WGAEWQTF.js";
-import "./chunk-NYOHZYHM.js";
-import "./chunk-CGOMICBE.js";
+  createLoadedSettingsAdapter
+} from "./chunk-BXSHL2SF.js";
+import "./chunk-NDOC6M5S.js";
+import "./chunk-M2U5NM24.js";
+import "./chunk-JJXWTVSK.js";
+import "./chunk-R2BXK7SX.js";
 import "./chunk-RKIZXJMB.js";
-import "./chunk-CI5O6SQL.js";
+import "./chunk-MNF6S5PR.js";
 import "./chunk-KHDZHZMH.js";
-import {
-  MID_TURN_QUEUE_DRAIN_METHOD
-} from "./chunk-QBZ22PQX.js";
 import {
   formatAcpModelId,
   parseAcpBaseModelId,
   parseAcpModelOption,
   sanitizeProviderBaseUrl
-} from "./chunk-RS4HRC75.js";
+} from "./chunk-UYT3MWEB.js";
 import {
-  NOT_CURRENTLY_GENERATING_CANCEL_MESSAGE
-} from "./chunk-S566HKUS.js";
-import "./chunk-BS64PXY3.js";
-import "./chunk-SEZC2725.js";
-import "./chunk-DBZUXSSV.js";
-import "./chunk-R2BXK7SX.js";
+  PERMISSION_RULE_TYPES,
+  PermissionRulesValidationError,
+  buildPermissionSettings,
+  normalizePermissionRules,
+  readPermissionRuleSet
+} from "./chunk-ODLIHNOY.js";
+import "./chunk-4LUZAKMK.js";
+import "./chunk-BC3C4F3Q.js";
+import "./chunk-GT2FGICD.js";
+import {
+  MID_TURN_QUEUE_DRAIN_METHOD
+} from "./chunk-QBZ22PQX.js";
 import "./chunk-ALX6BUYW.js";
-import "./chunk-5DWXLGOM.js";
 import {
-  createLoadedSettingsAdapter
-} from "./chunk-5RVSM6NW.js";
+  NOT_CURRENTLY_GENERATING_CANCEL_MESSAGE
+} from "./chunk-JE5FVRPC.js";
 import {
   OUTPUT_LANGUAGE_AUTO,
   getOutputLanguageFilePath,
   getPersistScopeForModelSelection,
   isAutoLanguage,
-  isWorkspaceTrusted,
   loadSettings,
   reloadEnvironment,
   resolveOutputLanguage,
   updateOutputLanguageFile,
   writeOutputLanguageAndRegisterPath
-} from "./chunk-OQHQHJRK.js";
+} from "./chunk-FKAVULLM.js";
 import {
   SUPPORTED_LANGUAGES,
   getCurrentLanguage,
   setLanguageAsync
-} from "./chunk-5JZLXFPD.js";
+} from "./chunk-R5OP2ATH.js";
 import "./chunk-TLRYABYP.js";
-import "./chunk-Y6Z2O3WR.js";
+import "./chunk-5DWXLGOM.js";
 import {
   AgentSideConnection,
   PROTOCOL_VERSION,
@@ -109,8 +111,15 @@ import {
   SERVE_STATUS_EXT_METHODS,
   STATUS_SCHEMA_VERSION,
   mapDomainErrorToErrorKind
-} from "./chunk-D5E5TMYH.js";
-import "./chunk-UN3C6GOR.js";
+} from "./chunk-L7OKCI7T.js";
+import "./chunk-CF6BB3LT.js";
+import {
+  isFolderTrustEnabled,
+  isWorkspaceTrusted,
+  loadTrustedFolders
+} from "./chunk-F3ZYSEY6.js";
+import "./chunk-Y6Z2O3WR.js";
+import "./chunk-QYUE6W3T.js";
 import {
   ALL_PROVIDERS,
   APPROVAL_MODES,
@@ -149,6 +158,7 @@ import {
   evaluatePermissionFlow,
   findExistingProviderModels,
   findProviderById,
+  findRepeatedDuplicateProviderToolCall,
   fireNotificationHook,
   firePermissionRequestHook,
   firePostToolUseFailureHook,
@@ -174,6 +184,7 @@ import {
   isDenialFallbackReason,
   isPlanModeBlocked,
   isSystemReminderContent,
+  markDuplicateProviderToolCallResponseSent,
   needsConfirmation,
   parsePositiveIntegerEnv,
   persistPermissionOutcome,
@@ -193,32 +204,31 @@ import {
   subagentGenerator,
   unregisterGoalHook,
   updateSetting
-} from "./chunk-PXFFKNCO.js";
+} from "./chunk-YAINVQ3Q.js";
 import {
   external_exports
 } from "./chunk-K5PGHDBN.js";
-import "./chunk-5P5XGNYH.js";
 import "./chunk-SKAZWEV5.js";
-import "./chunk-TXVGVZYR.js";
-import "./chunk-XU5P23GN.js";
-import "./chunk-2BIF2NVV.js";
+import "./chunk-XJYUPHRC.js";
+import "./chunk-QLDPRILK.js";
+import "./chunk-BVSVIN45.js";
 import {
   runSideQuery
-} from "./chunk-BG4BIP7F.js";
-import "./chunk-ZD3NW5KL.js";
+} from "./chunk-SBBN4BWR.js";
+import "./chunk-S7AKE7HL.js";
 import "./chunk-2MPVVENX.js";
 import "./chunk-ZTQ26VBE.js";
-import "./chunk-GZCJS5WH.js";
+import "./chunk-O2VBQ3Y2.js";
 import "./chunk-MLZQVCF3.js";
 import "./chunk-LQ7TMOCE.js";
 import "./chunk-LD2XBG6Z.js";
-import "./chunk-OTBK43JR.js";
+import "./chunk-HYCC3XM3.js";
 import {
   HookEventName,
   createHookOutput
-} from "./chunk-HGNSRCRB.js";
-import "./chunk-EEEZIVFJ.js";
-import "./chunk-PRYMDRBV.js";
+} from "./chunk-NL4C3H6C.js";
+import "./chunk-JOLIREYR.js";
+import "./chunk-DDMOU62Q.js";
 import {
   AuthType,
   ConversationFinishedEvent,
@@ -239,46 +249,45 @@ import {
   startToolSpan,
   uiTelemetryService,
   withInteractionSpan
-} from "./chunk-WA5OJGFL.js";
+} from "./chunk-QNKBEJO2.js";
 import "./chunk-3PJXIDKI.js";
 import "./chunk-UWCTAVOD.js";
 import "./chunk-OFEVLU4C.js";
 import "./chunk-OMX7CUOE.js";
 import {
   getAutoMemoryRoot
-} from "./chunk-BNXANYLH.js";
-import "./chunk-T2VDEFUU.js";
-import "./chunk-OIC6S73E.js";
+} from "./chunk-RD6YJJJ6.js";
+import "./chunk-SKQZZVAV.js";
+import "./chunk-BUUQ5HPX.js";
 import {
   ToolConfirmationOutcome,
   ToolNames
-} from "./chunk-TOEGRAVX.js";
+} from "./chunk-BX5YO7UW.js";
 import {
   clearCachedCredentialFile,
   qwenOAuth2Events
-} from "./chunk-BGUDAULQ.js";
-import "./chunk-EW6C27XX.js";
+} from "./chunk-UO5GVXQE.js";
+import "./chunk-KMGMKW5Q.js";
 import "./chunk-22IFUCVR.js";
-import "./chunk-64WXLC72.js";
-import "./chunk-3UALQ56H.js";
+import "./chunk-3227DZO4.js";
 import {
   tokenLimit
-} from "./chunk-F6XNTYNE.js";
-import "./chunk-CGEGHF2C.js";
-import "./chunk-IRJWHZWU.js";
-import "./chunk-SYCJMSIJ.js";
+} from "./chunk-U3KSMM7G.js";
+import "./chunk-BKXBARJZ.js";
+import "./chunk-EJYJYJZ2.js";
 import "./chunk-55ZMG67I.js";
 import "./chunk-H6BD2ELD.js";
 import "./chunk-5IFG2VC4.js";
+import "./chunk-64WXLC72.js";
 import {
   Storage,
   createDebugLogger,
   getErrorStatus
-} from "./chunk-C4K3FEQ2.js";
-import "./chunk-PF523XJX.js";
+} from "./chunk-UX4SGCGN.js";
+import "./chunk-SMYQZVZ3.js";
 import {
   runExitCleanup
-} from "./chunk-GYZQA2FO.js";
+} from "./chunk-I2LYBGNI.js";
 import "./chunk-ZERZSAZL.js";
 import "./chunk-QN5NZ3UQ.js";
 import "./chunk-BR4QREVK.js";
@@ -1448,6 +1457,10 @@ var Session = class {
   lastPromptTokenCountChat = null;
   midTurnDrainUnavailable = false;
   midTurnDrainTimeoutStrikes = 0;
+  // ACP can continue one logical conversation through prompt, cron, and
+  // background loops, so keep this with the session instead of a single
+  // runToolCalls invocation.
+  duplicateProviderToolCallResponseIds = /* @__PURE__ */ new Set();
   // Messages from a drain that the daemon answered but we timed out waiting for
   // (the daemon already spliced + SSE-published them). Re-injected on the next
   // batch so a transient stall can't silently lose them. See
@@ -1751,6 +1764,7 @@ var Session = class {
     if (pendingSend.signal.aborted) {
       return { stopReason: "cancelled" };
     }
+    this.duplicateProviderToolCallResponseIds.clear();
     let resolveCompletion;
     this.pendingPromptCompletion = new Promise((resolve3) => {
       resolveCompletion = resolve3;
@@ -2075,15 +2089,10 @@ ${this.pendingWorktreeNotice}
                     );
                     return { stopReason: "end_turn" };
                   }
-                  nextMessage = {
-                    role: "user",
-                    parts: [
-                      ...toolRun.parts,
-                      ...await this.#drainMidTurnUserMessages(
-                        pendingSend.signal
-                      )
-                    ]
-                  };
+                  nextMessage = await this.#buildNextMessageAfterToolRun(
+                    toolRun,
+                    pendingSend.signal
+                  );
                 }
               }
               if (this.messageRewriter) {
@@ -2270,13 +2279,10 @@ ${this.pendingWorktreeNotice}
               );
               return { stopReason: "end_turn" };
             }
-            nextMessage = {
-              role: "user",
-              parts: [
-                ...toolRun.parts,
-                ...await this.#drainMidTurnUserMessages(pendingSend.signal)
-              ]
-            };
+            nextMessage = await this.#buildNextMessageAfterToolRun(
+              toolRun,
+              pendingSend.signal
+            );
           }
         }
         continue;
@@ -2410,6 +2416,19 @@ ${this.pendingWorktreeNotice}
     );
     await this.messageRewriter?.waitForPendingRewrites();
   }
+  async #buildNextMessageAfterToolRun(toolRun, abortSignal) {
+    if (toolRun.repeatedDuplicateProviderToolCall) {
+      debugLogger4.debug(
+        "Stopping ACP turn after dropping repeated duplicate provider tool-call response."
+      );
+      return null;
+    }
+    const parts = [
+      ...toolRun.parts,
+      ...await this.#drainMidTurnUserMessages(abortSignal)
+    ];
+    return { role: "user", parts };
+  }
   #recordCompressionTokenCount(info) {
     this.#syncPromptTokenCountWithCurrentChat();
     const tokenCount = this.#extractCompressionTokenCount(info);
@@ -2781,13 +2800,10 @@ ${this.pendingWorktreeNotice}
                     );
                     return;
                   }
-                  nextMessage = {
-                    role: "user",
-                    parts: [
-                      ...toolRun.parts,
-                      ...await this.#drainMidTurnUserMessages(ac.signal)
-                    ]
-                  };
+                  nextMessage = await this.#buildNextMessageAfterToolRun(
+                    toolRun,
+                    ac.signal
+                  );
                 }
               }
             } catch (error) {
@@ -3020,13 +3036,10 @@ ${this.pendingWorktreeNotice}
                 await this.#emitBackgroundNotificationEndTurn("end_turn");
                 return;
               }
-              nextMessage = {
-                role: "user",
-                parts: [
-                  ...toolRun.parts,
-                  ...await this.#drainMidTurnUserMessages(ac.signal)
-                ]
-              };
+              nextMessage = await this.#buildNextMessageAfterToolRun(
+                toolRun,
+                ac.signal
+              );
             }
           }
           if (this.messageRewriter) {
@@ -3270,10 +3283,32 @@ ${this.pendingWorktreeNotice}
     const handledProviderToolCallIds = new Set(
       this.#getCurrentChat().getHistoryFunctionResponseIds()
     );
+    const repeatedDuplicateCall = findRepeatedDuplicateProviderToolCall(
+      dedupedFunctionCalls,
+      (fc) => getProviderToolCallId(fc) ?? fc.id,
+      handledProviderToolCallIds,
+      this.duplicateProviderToolCallResponseIds
+    );
+    if (repeatedDuplicateCall) {
+      const providerCallId = getProviderToolCallId(repeatedDuplicateCall) ?? repeatedDuplicateCall.id;
+      debugLogger4.debug(
+        `[Session.runToolCalls] Dropping batch after repeated duplicate provider tool-call id: ${providerCallId} (tool: ${repeatedDuplicateCall.name ?? "unknown_tool"})`
+      );
+      return {
+        parts: [],
+        stopAfterPermissionCancel: false,
+        repeatedDuplicateProviderToolCall: true
+      };
+    }
     const pushDuplicateBatch = /* @__PURE__ */ __name((request) => {
+      const providerCallId = request.providerCallId ?? request.callId;
+      markDuplicateProviderToolCallResponseSent(
+        providerCallId,
+        this.duplicateProviderToolCallResponseIds
+      );
       const response = createDuplicateProviderToolCallResponse(request);
       debugLogger4.debug(
-        `[Session.runToolCalls] Suppressing duplicate provider tool-call id: ${request.providerCallId} (tool: ${request.name})`
+        `[Session.runToolCalls] Suppressing duplicate provider tool-call id: ${providerCallId} (tool: ${request.name})`
       );
       batches.push({ kind: "duplicate", request, response });
     }, "pushDuplicateBatch");
@@ -3459,7 +3494,11 @@ ${this.pendingWorktreeNotice}
         }
         if (shouldStop) {
           await appendSkippedAfter(parts, batch.calls[batch.calls.length - 1]);
-          return { parts, stopAfterPermissionCancel: true };
+          return {
+            parts,
+            stopAfterPermissionCancel: true,
+            repeatedDuplicateProviderToolCall: false
+          };
         }
       } else {
         for (const fc of batch.calls) {
@@ -3467,12 +3506,20 @@ ${this.pendingWorktreeNotice}
           parts.push(...r.parts);
           if (r.stopAfterPermissionCancel) {
             await appendSkippedAfter(parts, fc);
-            return { parts, stopAfterPermissionCancel: true };
+            return {
+              parts,
+              stopAfterPermissionCancel: true,
+              repeatedDuplicateProviderToolCall: false
+            };
           }
         }
       }
     }
-    return { parts, stopAfterPermissionCancel: false };
+    return {
+      parts,
+      stopAfterPermissionCancel: false,
+      repeatedDuplicateProviderToolCall: false
+    };
   }
   /**
    * Assemble the per-turn system reminders the model needs to see at the
@@ -4527,6 +4574,9 @@ var QWEN_CORE_SETTING_DEFINITIONS = {
   "memory.enableManagedAutoMemory": { type: "boolean" },
   "memory.enableManagedAutoDream": { type: "boolean" },
   "memory.enableAutoSkill": { type: "boolean" },
+  "memory.autoSkillConfirm": { type: "boolean" },
+  "memory.enableTeamMemory": { type: "boolean" },
+  "memory.enableTeamMemorySync": { type: "boolean" },
   disableAllHooks: { type: "boolean" }
 };
 var QWEN_CORE_SETTING_KEYS = Object.keys(
@@ -4536,12 +4586,18 @@ var QWEN_HOOK_EVENTS = Object.values(HookEventName);
 var DEFAULT_QWEN_MEMORY_SETTINGS = {
   enableManagedAutoMemory: true,
   enableManagedAutoDream: true,
-  enableAutoSkill: true
+  enableAutoSkill: true,
+  autoSkillConfirm: true,
+  enableTeamMemory: false,
+  enableTeamMemorySync: false
 };
 var QWEN_MEMORY_SETTING_KEYS = [
   "enableManagedAutoMemory",
   "enableManagedAutoDream",
-  "enableAutoSkill"
+  "enableAutoSkill",
+  "autoSkillConfirm",
+  "enableTeamMemory",
+  "enableTeamMemorySync"
 ];
 function normalizeQwenMemorySettings(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -4551,7 +4607,10 @@ function normalizeQwenMemorySettings(value) {
   return {
     enableManagedAutoMemory: typeof record["enableManagedAutoMemory"] === "boolean" ? record["enableManagedAutoMemory"] : DEFAULT_QWEN_MEMORY_SETTINGS.enableManagedAutoMemory,
     enableManagedAutoDream: typeof record["enableManagedAutoDream"] === "boolean" ? record["enableManagedAutoDream"] : DEFAULT_QWEN_MEMORY_SETTINGS.enableManagedAutoDream,
-    enableAutoSkill: typeof record["enableAutoSkill"] === "boolean" ? record["enableAutoSkill"] : DEFAULT_QWEN_MEMORY_SETTINGS.enableAutoSkill
+    enableAutoSkill: typeof record["enableAutoSkill"] === "boolean" ? record["enableAutoSkill"] : DEFAULT_QWEN_MEMORY_SETTINGS.enableAutoSkill,
+    autoSkillConfirm: typeof record["autoSkillConfirm"] === "boolean" ? record["autoSkillConfirm"] : DEFAULT_QWEN_MEMORY_SETTINGS.autoSkillConfirm,
+    enableTeamMemory: typeof record["enableTeamMemory"] === "boolean" ? record["enableTeamMemory"] : DEFAULT_QWEN_MEMORY_SETTINGS.enableTeamMemory,
+    enableTeamMemorySync: typeof record["enableTeamMemorySync"] === "boolean" ? record["enableTeamMemorySync"] : DEFAULT_QWEN_MEMORY_SETTINGS.enableTeamMemorySync
   };
 }
 __name(normalizeQwenMemorySettings, "normalizeQwenMemorySettings");
@@ -6179,7 +6238,7 @@ var QwenAgent = class {
   async initialize(args) {
     this.clientCapabilities = args.clientCapabilities;
     const authMethods = buildAuthMethods();
-    const version = "0.19.2";
+    const version = "0.19.3";
     return {
       protocolVersion: PROTOCOL_VERSION,
       agentInfo: {
@@ -6774,6 +6833,16 @@ var QwenAgent = class {
                 status: this.mcpStatus(e.status)
               }));
             }
+            if (!disabled) {
+              out.resourceCount = this.resolveServerMcpResources(
+                config,
+                name
+              ).length;
+              out.promptCount = this.resolveServerMcpPrompts(
+                config,
+                name
+              ).length;
+            }
             return out;
           })
         ),
@@ -6880,6 +6949,102 @@ var QwenAgent = class {
       };
     }
   }
+  /**
+   * Resolve the resources discovered for one server, with the same
+   * pool-mode fallback `buildWorkspaceMcpToolsStatus` uses for tools: the
+   * workspace `Config`'s `ResourceRegistry` is authoritative in
+   * single-session mode, but in pool mode resources are registered into
+   * per-session registries (`SessionMcpView.applyResources`), leaving the
+   * workspace registry empty. Fall back to the first active session that
+   * has this server's resources.
+   */
+  resolveServerMcpResources(config, serverName) {
+    const resources = config.getResourceRegistry?.()?.getResourcesByServer(serverName) ?? [];
+    if (resources.length > 0) {
+      return resources;
+    }
+    for (const session of this.getActiveSessions()) {
+      try {
+        const sessionResources = session.getConfig().getResourceRegistry?.()?.getResourcesByServer(serverName) ?? [];
+        if (sessionResources.length > 0) {
+          return sessionResources;
+        }
+      } catch {
+      }
+    }
+    return resources;
+  }
+  /**
+   * Resolve the prompts discovered for one server, mirroring
+   * {@link resolveServerMcpResources}. Used only for the per-server
+   * `promptCount` on the base status — prompts have no drill-down
+   * endpoint (they surface as slash commands).
+   */
+  resolveServerMcpPrompts(config, serverName) {
+    const prompts = config.getPromptRegistry?.()?.getPromptsByServer(serverName) ?? [];
+    if (prompts.length > 0) {
+      return prompts;
+    }
+    for (const session of this.getActiveSessions()) {
+      try {
+        const sessionPrompts = session.getConfig().getPromptRegistry?.()?.getPromptsByServer(serverName) ?? [];
+        if (sessionPrompts.length > 0) {
+          return sessionPrompts;
+        }
+      } catch {
+      }
+    }
+    return prompts;
+  }
+  buildWorkspaceMcpResourcesStatus(config, serverName) {
+    const workspaceCwd = this.safeWorkspaceCwd(config);
+    try {
+      const servers = config.getMcpServers() ?? {};
+      if (!Object.prototype.hasOwnProperty.call(servers, serverName)) {
+        return {
+          v: STATUS_SCHEMA_VERSION,
+          workspaceCwd,
+          serverName,
+          initialized: true,
+          acpChannelLive: true,
+          resources: [],
+          errors: [
+            {
+              kind: "mcp_resources",
+              status: "error",
+              error: `MCP server not configured: ${serverName}`
+            }
+          ]
+        };
+      }
+      const resources = this.resolveServerMcpResources(config, serverName).map((resource) => ({
+        uri: resource.uri,
+        ...typeof resource.name === "string" ? { name: resource.name } : {},
+        ...typeof resource.title === "string" ? { title: resource.title } : {},
+        ...typeof resource.description === "string" ? { description: resource.description } : {},
+        ...typeof resource.mimeType === "string" ? { mimeType: resource.mimeType } : {},
+        ...typeof resource.size === "number" ? { size: resource.size } : {}
+      }));
+      return {
+        v: STATUS_SCHEMA_VERSION,
+        workspaceCwd,
+        serverName,
+        initialized: true,
+        acpChannelLive: true,
+        resources
+      };
+    } catch (error) {
+      return {
+        v: STATUS_SCHEMA_VERSION,
+        workspaceCwd,
+        serverName,
+        initialized: true,
+        acpChannelLive: true,
+        resources: [],
+        errors: [this.errorCell("mcp_resources", error)]
+      };
+    }
+  }
   /**
    * Build the MCP budget status cells exposed on `GET /workspace/mcp`.
    *
@@ -7480,6 +7645,25 @@ var QwenAgent = class {
         }
       };
     }
+    const skillMetrics = metrics.skills ?? {
+      totalCalls: 0,
+      totalSuccess: 0,
+      totalFail: 0,
+      byName: {}
+    };
+    const skillsByName = {};
+    for (const [name, skill] of Object.entries(skillMetrics.byName)) {
+      Object.defineProperty(skillsByName, name, {
+        value: {
+          count: skill.count,
+          success: skill.success,
+          fail: skill.fail
+        },
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    }
     return {
       v: STATUS_SCHEMA_VERSION,
       sessionId,
@@ -7498,6 +7682,12 @@ var QwenAgent = class {
       files: {
         totalLinesAdded: metrics.files.totalLinesAdded,
         totalLinesRemoved: metrics.files.totalLinesRemoved
+      },
+      skills: {
+        totalCalls: skillMetrics.totalCalls,
+        totalSuccess: skillMetrics.totalSuccess,
+        totalFail: skillMetrics.totalFail,
+        byName: skillsByName
       }
     };
   }
@@ -7948,19 +8138,25 @@ var QwenAgent = class {
         );
         const persistScope = readProviderConnectScope(params["scope"]);
         const plan = buildInstallPlan(providerConfig, inputs);
+        const adapter = createLoadedSettingsAdapter(
+          this.settings,
+          persistScope
+        );
         await applyProviderInstallPlan(plan, {
-          settings: createLoadedSettingsAdapter(this.settings, persistScope),
+          settings: adapter,
           reloadModelProviders: /* @__PURE__ */ __name((modelProviders) => this.config.reloadModelProvidersConfig(modelProviders), "reloadModelProviders"),
           syncAuthState: /* @__PURE__ */ __name((authType, modelId, baseUrl) => this.config.getModelsConfig().syncAfterAuthRefresh(authType, modelId, baseUrl), "syncAuthState"),
           refreshAuth: /* @__PURE__ */ __name((authType) => this.config.refreshAuth(authType), "refreshAuth")
         });
+        const effectiveModelId = adapter.getValue("model.name") ?? plan.modelSelection?.modelId;
+        const effectiveBaseUrl = adapter.getValue("model.baseUrl") ?? plan.modelSelection?.baseUrl;
         return {
           success: true,
           providerId: providerConfig.id,
           providerLabel: providerConfig.label,
           authType: plan.authType,
-          modelId: plan.modelSelection?.modelId,
-          ...plan.modelSelection?.baseUrl ? { baseUrl: plan.modelSelection.baseUrl } : {}
+          ...effectiveModelId ? { modelId: effectiveModelId } : {},
+          ...effectiveBaseUrl ? { baseUrl: effectiveBaseUrl } : {}
         };
       }
       case "qwen/skills/install": {
@@ -8026,6 +8222,19 @@ var QwenAgent = class {
           serverName
         );
       }
+      case SERVE_STATUS_EXT_METHODS.workspaceMcpResources: {
+        const serverName = params["serverName"];
+        if (typeof serverName !== "string" || serverName.length === 0) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Invalid or missing serverName"
+          );
+        }
+        return this.buildWorkspaceMcpResourcesStatus(
+          this.config,
+          serverName
+        );
+      }
       case SERVE_STATUS_EXT_METHODS.workspaceSkills:
         return await this.buildWorkspaceSkillsStatus(
           this.config
@@ -8481,6 +8690,78 @@ var QwenAgent = class {
         await this.closeStoredSession(sessionId);
         return { sessionId, closed: true };
       }
+      case SERVE_CONTROL_EXT_METHODS.sessionCd: {
+        const sessionId = params["sessionId"];
+        const targetPath = params["path"];
+        if (typeof sessionId !== "string" || sessionId.length === 0) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Invalid or missing sessionId"
+          );
+        }
+        if (typeof targetPath !== "string" || targetPath.length === 0 || !path.isAbsolute(targetPath) || targetPath.includes("\0")) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Invalid or missing path (must be an absolute path)"
+          );
+        }
+        const session = this.sessionOrThrow(sessionId);
+        const config = session.getConfig();
+        if (config.isRestrictiveSandbox()) {
+          throw new RequestError(-32003, "Restrictive sandbox mode active", {
+            errorKind: "restrictive_sandbox"
+          });
+        }
+        let stats;
+        try {
+          stats = await fs.stat(targetPath);
+        } catch {
+          throw new RequestError(-32002, `Directory not found: ${targetPath}`, {
+            errorKind: "directory_not_found",
+            path: targetPath
+          });
+        }
+        if (!stats.isDirectory()) {
+          throw new RequestError(-32002, `Not a directory: ${targetPath}`, {
+            errorKind: "directory_not_found",
+            path: targetPath
+          });
+        }
+        const canonicalPath = await fs.realpath(targetPath);
+        const previousCwd = config.getTargetDir();
+        if (canonicalPath === previousCwd) {
+          return { previousCwd, newCwd: canonicalPath, warnings: [] };
+        }
+        if (isFolderTrustEnabled(this.settings.merged)) {
+          const trustedFolders = loadTrustedFolders();
+          if (trustedFolders.isPathTrusted(canonicalPath) !== true) {
+            throw new RequestError(
+              -32001,
+              `Directory not trusted: ${canonicalPath}`,
+              { errorKind: "directory_not_trusted", path: canonicalPath }
+            );
+          }
+        }
+        const warnings = [];
+        const relocation = await config.relocateWorkingDirectory(
+          canonicalPath,
+          canonicalPath,
+          { skipProcessChdir: true, skipArtifactMigration: true }
+        );
+        if (relocation.memoryRefreshError) {
+          warnings.push(
+            `Memory refresh failed: ${relocation.memoryRefreshError instanceof Error ? relocation.memoryRefreshError.message : String(relocation.memoryRefreshError)}`
+          );
+        }
+        try {
+          await config.getGeminiClient()?.addWorkingDirectoryChangedContext(previousCwd, canonicalPath);
+        } catch (error) {
+          warnings.push(
+            `Model context refresh failed: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+        return { previousCwd, newCwd: canonicalPath, warnings };
+      }
       case SERVE_CONTROL_EXT_METHODS.sessionApprovalMode: {
         const sessionId = params["sessionId"];
         const mode = params["mode"];
@@ -9576,9 +9857,13 @@ ${outputText}
             }
             const config = session.getConfig();
             const authType = config.getAuthType();
-            if (changed.has("modelProviders")) {
+            const providersChanged = changed.has("modelProviders") || changed.has("providerProtocol");
+            if (providersChanged) {
               try {
-                config.reloadModelProvidersConfig(newMerged.modelProviders);
+                config.reloadModelProvidersConfig(
+                  newMerged.modelProviders,
+                  newMerged.providerProtocol ?? {}
+                );
               } catch (err) {
                 debugLogger5.warn(
                   `reload: reloadModelProvidersConfig failed for session ${id}: ${err}`
@@ -9594,7 +9879,7 @@ ${outputText}
                   `reload: switchModel failed for session ${id}: ${err}`
                 );
               }
-            } else if ((changed.has("modelProviders") || envChanged) && authType) {
+            } else if ((providersChanged || envChanged) && authType) {
               try {
                 await config.refreshAuth(authType);
               } catch (err) {
@@ -9822,6 +10107,9 @@ ${outputText}
     if (sessionData?.fileHistorySnapshots?.length) {
       config.getFileHistoryService().restoreFromSnapshots(sessionData.fileHistorySnapshots);
     }
+    if (sessionData?.conversation.messages) {
+      config.getChatRecordingService()?.rebuildTurnBoundaries(sessionData.conversation.messages);
+    }
     if (options.replayHistory !== false && sessionData?.conversation.messages) {
       await session.replayHistory(sessionData.conversation.messages);
     }