@qwen-code/qwen-code 0.15.12-preview.3 → 0.16.0-preview.0

package/cli.js

@@ -8,6 +8,11 @@ import {
   loadAccount,
   saveAccount
 } from "./chunks/chunk-AEJ2DKLP.js";
+import {
+  DEFAULT_RING_SIZE,
+  SERVE_STATUS_EXT_METHODS,
+  STATUS_SCHEMA_VERSION
+} from "./chunks/chunk-3MBY4GKN.js";
 import {
   SUPPORTED_LANGUAGES,
   contextCommand,
@@ -22,7 +27,7 @@ import {
   setLanguageAsync,
   t,
   ta
-} from "./chunks/chunk-AOJ3BBY7.js";
+} from "./chunks/chunk-JHMX4QTD.js";
 import {
   clearScreen,
   writeStderrLine,
@@ -93,6 +98,7 @@ import {
   checkForExtensionUpdate,
   checkHasEditorType,
   clearWelcomeBackState,
+  collectMemoryDiagnostics,
   convertToFunctionResponse,
   convertTomlToMarkdown,
   createFollowupController,
@@ -124,6 +130,7 @@ import {
   getIdeInstaller,
   getInsightPrompt,
   getLastGoalTerminal,
+  getMCPDiscoveryState,
   getMCPServerPrompts,
   getMCPServerStatus,
   getPlanModeSystemReminder,
@@ -185,7 +192,7 @@ import {
   unregisterGoalHook,
   updateSetting,
   writeRuntimeStatus
-} from "./chunks/chunk-AJSOD5IR.js";
+} from "./chunks/chunk-MNPZ2WO6.js";
 import "./chunks/chunk-5P5XGNYH.js";
 import {
   _enum,
@@ -214,24 +221,24 @@ import "./chunks/chunk-TW522KN6.js";
 import "./chunks/chunk-MLZQVCF3.js";
 import {
   runSideQuery
-} from "./chunks/chunk-JMZQICAL.js";
+} from "./chunks/chunk-PPHYLJSS.js";
 import {
   buildSkillLlmContent
-} from "./chunks/chunk-5QQ5FGTU.js";
+} from "./chunks/chunk-G7YTSRES.js";
 import {
   HOOKS_CONFIG_FIELDS,
   HookEventName,
   createHookOutput
-} from "./chunks/chunk-B7ZL7HUA.js";
+} from "./chunks/chunk-XVHR7ATJ.js";
 import "./chunks/chunk-77WXWU44.js";
-import "./chunks/chunk-OCC4MZRS.js";
+import "./chunks/chunk-F23NCRJ2.js";
 import {
   detectRuntime,
   getOrCreateSharedDispatcher,
   getUnsupportedImageFormatWarning,
   isSupportedImageMimeType,
   redactProxyCredentials
-} from "./chunks/chunk-CAWKL3UC.js";
+} from "./chunks/chunk-VTPOO6GV.js";
 import {
   ApiCancelEvent,
   AuthEvent,
@@ -270,7 +277,7 @@ import {
   setGeminiMdFilename,
   shutdownTelemetry,
   uiTelemetryService
-} from "./chunks/chunk-XLQ4E5PS.js";
+} from "./chunks/chunk-C3LHPHN2.js";
 import "./chunks/chunk-SYCJMSIJ.js";
 import "./chunks/chunk-UWCTAVOD.js";
 import {
@@ -281,12 +288,12 @@ import {
   getAutoMemoryProjectStateDir,
   getAutoMemoryRoot,
   isAutoMemPath
-} from "./chunks/chunk-CM2IESUE.js";
+} from "./chunks/chunk-PR4T27R7.js";
 import {
   DEFAULT_TOKEN_LIMIT,
   tokenLimit
-} from "./chunks/chunk-UXW7MYAW.js";
-import "./chunks/chunk-G27O2LD2.js";
+} from "./chunks/chunk-CW44BRRA.js";
+import "./chunks/chunk-D5NTAHYL.js";
 import {
   require_base64_js,
   require_ecdsa_sig_formatter,
@@ -295,7 +302,7 @@ import {
   require_jws
 } from "./chunks/chunk-T4VD6OJ4.js";
 import "./chunks/chunk-RDYWTWEM.js";
-import "./chunks/chunk-TPGOGCWM.js";
+import "./chunks/chunk-JYQUJ5DS.js";
 import {
   SchemaValidator,
   ToolConfirmationOutcome,
@@ -304,13 +311,13 @@ import {
   require_dist,
   require_fast_deep_equal,
   require_fast_uri
-} from "./chunks/chunk-FYMSCRHM.js";
+} from "./chunks/chunk-FZIUV27X.js";
 import {
   clearCachedCredentialFile,
   open_default,
   qwenOAuth2Events
-} from "./chunks/chunk-SQNQIOD5.js";
-import "./chunks/chunk-FKVKVE6N.js";
+} from "./chunks/chunk-2B7UBDY5.js";
+import "./chunks/chunk-KXZ4TJB4.js";
 import {
   FatalCancellationError,
   FatalConfigError,
@@ -332,7 +339,7 @@ import {
   tildeifyPath,
   unescapePath,
   updateSymlink
-} from "./chunks/chunk-GJXIKCKL.js";
+} from "./chunks/chunk-XP27SJMH.js";
 import "./chunks/chunk-E7E2MFYM.js";
 import "./chunks/chunk-ZERZSAZL.js";
 import "./chunks/chunk-QN5NZ3UQ.js";
@@ -93391,6 +93398,15 @@ var SETTINGS_SCHEMA = {
     showInDialog: false,
     mergeStrategy: "replace" /* REPLACE */
   },
+  plansDirectory: {
+    type: "string",
+    label: "Plans Directory",
+    category: "Advanced",
+    requiresRestart: true,
+    default: void 0,
+    description: "Custom directory for approved Plan Mode files. Relative paths are resolved from the project root, and the resolved path must stay within the project root. Defaults to ~/.qwen/plans.",
+    showInDialog: false
+  },
   // Environment variables fallback
   env: {
     type: "object",
@@ -103901,7 +103917,7 @@ __name(getPackageJson, "getPackageJson");
 // packages/cli/src/utils/version.ts
 async function getCliVersion() {
   const pkgJson = await getPackageJson();
-  return "0.15.12-preview.3";
+  return "0.16.0-preview.0";
 }
 __name(getCliVersion, "getCliVersion");
 
@@ -110258,6 +110274,18 @@ var serveCommand = {
     type: "number",
     default: 256,
     description: "Listener-level TCP connection cap (server.maxConnections). Bounds raw sockets \u2014 slow/phantom SSE clients get rejected at accept time once full. Set to 0 to disable."
+  }).option("require-auth", {
+    type: "boolean",
+    default: false,
+    description: "Refuse to start without a bearer token, even on loopback. Hardens the loopback developer default for shared dev hosts / CI runners / multi-tenant workstations where any local user can hit 127.0.0.1. Requires --token or QWEN_SERVER_TOKEN. /health also requires Authorization when enabled (no loopback exemption \u2014 k8s/Compose probes must pass the bearer too)."
+  }).option("event-ring-size", {
+    type: "number",
+    // Single source of truth — `DEFAULT_RING_SIZE` (currently 8000,
+    // #3803 §02) is also what the bridge falls back to when the
+    // option is undefined. Importing here keeps a future bump in
+    // one place rather than drifting between CLI and bus.
+    default: DEFAULT_RING_SIZE,
+    description: "Per-session SSE replay ring depth (#3803 \xA702 target). Sets the replay backlog available to `GET /session/:id/events` reconnects that send a `Last-Event-ID: N` header. Larger = more reconnect headroom at the cost of a few hundred KB extra RAM per session. Must be a positive finite integer."
   }).option("http-bridge", {
     type: "boolean",
     default: true,
@@ -110274,7 +110302,7 @@ var serveCommand = {
         "qwen serve: --token is visible in the process command line; prefer the QWEN_SERVER_TOKEN env var for any non-trivial deployment."
       );
     }
-    const { runQwenServe } = await import("./chunks/serve-VJEEEXA6.js");
+    const { runQwenServe } = await import("./chunks/serve-GAD2PEST.js");
     try {
       await runQwenServe({
         port: argv.port,
@@ -110283,7 +110311,9 @@ var serveCommand = {
         mode: "http-bridge",
         maxSessions: argv["max-sessions"],
         maxConnections: argv["max-connections"],
-        workspace: argv.workspace
+        eventRingSize: argv["event-ring-size"],
+        workspace: argv.workspace,
+        requireAuth: argv["require-auth"]
       });
     } catch (err) {
       writeStderrLine(
@@ -111231,6 +111261,7 @@ async function loadCliConfig(settings, argv, cwd5 = process.cwd(), overrideExten
     clearContextOnIdle: settings.context?.clearContextOnIdle,
     fileFiltering: settings.context?.fileFiltering,
     checkpointing: argv.checkpointing || settings.general?.checkpointing?.enabled,
+    plansDirectory: settings.plansDirectory,
     proxy: argv.proxy || settings.proxy || process.env["HTTPS_PROXY"] || process.env["https_proxy"] || process.env["HTTP_PROXY"] || process.env["http_proxy"],
     cwd: cwd5,
     fileDiscoveryService: fileService,
@@ -114621,7 +114652,7 @@ var formatDuration = /* @__PURE__ */ __name((milliseconds, options) => {
 
 // packages/cli/src/generated/git-commit.ts
 init_esbuild_shims();
-var GIT_COMMIT_INFO = "58ad5d816";
+var GIT_COMMIT_INFO = "87eb2f743";
 
 // packages/cli/src/utils/systemInfo.ts
 var debugLogger11 = createDebugLogger("STATUS");
@@ -118851,8 +118882,137 @@ ${formatHeapSnapshotErrorMessage(error)}`;
         context.ui.setPendingItem(null);
       }
     }
-  }, "action")
+  }, "action"),
+  subCommands: [
+    {
+      name: "memory",
+      get description() {
+        return t("Show current process memory diagnostics");
+      },
+      kind: "built-in" /* BUILT_IN */,
+      supportedModes: ["interactive", "non_interactive", "acp"],
+      argumentHint: "[--json] [--sample] [--snapshot]",
+      action: memoryDoctorAction
+    }
+  ]
 };
+var MEMORY_USAGE_HINT = "/doctor memory [--json] [--sample] [--snapshot]";
+async function memoryDoctorAction(context, args = "") {
+  if (context.abortSignal?.aborted) {
+    return;
+  }
+  const tokens = args.trim().split(/\s+/).filter(Boolean);
+  const unknown2 = tokens.filter(
+    (token) => token !== "--json" && token !== "--sample" && token !== "--snapshot"
+  );
+  if (unknown2.length > 0) {
+    return {
+      type: "message",
+      messageType: "error",
+      content: `${t("Unknown argument(s)")}: ${unknown2.join(", ")}. ${t("Usage")}: ${MEMORY_USAGE_HINT}`
+    };
+  }
+  const shouldSampleMemory = tokens.includes("--sample");
+  const shouldWriteHeapSnapshot = tokens.includes("--snapshot");
+  if (shouldSampleMemory || shouldWriteHeapSnapshot) {
+    return doctorCommand.action?.(
+      context,
+      [MEMORY_SUBCOMMAND, ...tokens.filter((token) => token !== "--json")].join(
+        " "
+      )
+    );
+  }
+  try {
+    const diagnostics = await collectMemoryDiagnostics({
+      sessionId: context.services.config?.getSessionId(),
+      qwenVersion: context.services.config?.getCliVersion()
+    });
+    if (context.abortSignal?.aborted) {
+      return;
+    }
+    return {
+      type: "message",
+      messageType: diagnostics.analysis.risks.length > 0 ? "warning" : "info",
+      content: tokens.includes("--json") ? JSON.stringify(diagnostics, null, 2) : formatCoreDiagnostics(diagnostics)
+    };
+  } catch (error) {
+    if (context.abortSignal?.aborted) {
+      return;
+    }
+    return {
+      type: "message",
+      messageType: "error",
+      content: `${t("Failed to collect memory diagnostics")}: ${formatErrorMessage2(error)}`
+    };
+  }
+}
+__name(memoryDoctorAction, "memoryDoctorAction");
+function formatCpuMicroseconds(micros) {
+  return `${(micros / 1e6).toFixed(2)}s`;
+}
+__name(formatCpuMicroseconds, "formatCpuMicroseconds");
+function formatHeapSpaces(spaces) {
+  if (!spaces || spaces.length === 0) {
+    return void 0;
+  }
+  const top2 = [...spaces].sort((a, b) => b.used - a.used).slice(0, 4);
+  const lines = top2.map(
+    (space) => `  - ${space.name}: used ${formatMemoryUsage(space.used)} / size ${formatMemoryUsage(space.size)}`
+  );
+  if (spaces.length > top2.length) {
+    lines.push(`  - \u2026 ${spaces.length - top2.length} more`);
+  }
+  return lines.join("\n");
+}
+__name(formatHeapSpaces, "formatHeapSpaces");
+function formatSmapsRollup(smapsRollup) {
+  if (!smapsRollup) {
+    return t("unavailable");
+  }
+  const rssLine = smapsRollup.split(/\r?\n/).map((line) => line.trim().replace(/\s+/g, " ")).find((line) => line.startsWith("Rss:"));
+  if (rssLine) {
+    return rssLine;
+  }
+  const preview = smapsRollup.slice(0, 80).trim().replace(/\s+/g, " ");
+  return `${t("parse error")}: ${preview}`;
+}
+__name(formatSmapsRollup, "formatSmapsRollup");
+function formatCoreDiagnostics(diagnostics) {
+  const risks = diagnostics.analysis.risks.length > 0 ? diagnostics.analysis.risks.map((risk) => `  - ${risk.type}: ${risk.message}`).join("\n") : `  ${t("none")}`;
+  const lines = [
+    t("Memory Diagnostics"),
+    `timestamp: ${diagnostics.timestamp}`,
+    `uptimeSeconds: ${diagnostics.uptimeSeconds.toFixed(1)}`,
+    `heapUsed: ${formatMemoryUsage(diagnostics.memoryUsage.heapUsed)}`,
+    `heapTotal: ${formatMemoryUsage(diagnostics.memoryUsage.heapTotal)}`,
+    `rss: ${formatMemoryUsage(diagnostics.memoryUsage.rss)}`,
+    `external: ${formatMemoryUsage(diagnostics.memoryUsage.external)}`,
+    `arrayBuffers: ${formatMemoryUsage(diagnostics.memoryUsage.arrayBuffers)}`,
+    `v8HeapLimit: ${formatMemoryUsage(diagnostics.v8HeapStats.heapSizeLimit)}`,
+    `v8MallocedMemory: ${formatMemoryUsage(diagnostics.v8HeapStats.mallocedMemory)}`,
+    `v8PeakMallocedMemory: ${formatMemoryUsage(diagnostics.v8HeapStats.peakMallocedMemory)}`,
+    `detachedContexts: ${diagnostics.v8HeapStats.detachedContexts}`,
+    `nativeContexts: ${diagnostics.v8HeapStats.nativeContexts}`,
+    `maxRSS: ${formatMemoryUsage(diagnostics.resourceUsage.maxRSS)}`,
+    `userCPUTime: ${formatCpuMicroseconds(diagnostics.resourceUsage.userCPUTime)}`,
+    `systemCPUTime: ${formatCpuMicroseconds(diagnostics.resourceUsage.systemCPUTime)}`,
+    `activeHandles: ${diagnostics.activeHandles}`,
+    `activeRequests: ${diagnostics.activeRequests}`,
+    `openFileDescriptors: ${diagnostics.openFileDescriptors ?? t("unavailable")}`,
+    `smapsRollup: ${formatSmapsRollup(diagnostics.smapsRollup)}`
+  ];
+  const heapSpaces = formatHeapSpaces(diagnostics.v8HeapSpaces);
+  if (heapSpaces) {
+    lines.push("v8HeapSpaces:", heapSpaces);
+  }
+  lines.push(
+    "risks:",
+    risks,
+    `recommendation: ${diagnostics.analysis.recommendation}`
+  );
+  return lines.join("\n");
+}
+__name(formatCoreDiagnostics, "formatCoreDiagnostics");
 
 // packages/cli/src/ui/commands/diffCommand.ts
 init_esbuild_shims();
@@ -119882,6 +120042,18 @@ var HistoryReplayer = class {
           }
           break;
         }
+        if (record2.subtype === "mid_turn_user_message") {
+          const displayText = record2.systemPayload?.displayText;
+          if (displayText) {
+            await this.messageEmitter.emitUserMessage(
+              displayText,
+              record2.timestamp
+            );
+          } else if (record2.message) {
+            await this.replayContent(record2.message, "user", record2.timestamp);
+          }
+          break;
+        }
         if (record2.message) {
           await this.replayContent(record2.message, "user", record2.timestamp);
         }
@@ -120221,7 +120393,7 @@ async function extractMetadata(conversation, config) {
   const gitBranch = firstRecord?.gitBranch;
   let gitRepo;
   if (cwd5) {
-    const { getGitRepoName } = await import("./chunks/src-OWV5HVQQ.js");
+    const { getGitRepoName } = await import("./chunks/src-LY4RU5AI.js");
     gitRepo = getGitRepoName(cwd5);
   }
   let model;
@@ -122733,6 +122905,16 @@ function formatAcpModelId(modelId, authType) {
   return `${modelId}(${authType})`;
 }
 __name(formatAcpModelId, "formatAcpModelId");
+function parseAcpBaseModelId(value) {
+  const trimmed = value.trim();
+  const closeIdx = trimmed.lastIndexOf(")");
+  const openIdx = trimmed.lastIndexOf("(");
+  if (openIdx >= 0 && closeIdx === trimmed.length - 1 && openIdx < closeIdx) {
+    return trimmed.slice(0, openIdx);
+  }
+  return trimmed;
+}
+__name(parseAcpBaseModelId, "parseAcpBaseModelId");
 function parseAcpModelOption(input) {
   const trimmed = input.trim();
   const closeIdx = trimmed.lastIndexOf(")");
@@ -130443,7 +130625,7 @@ var SystemController = class extends BaseController {
       throw new Error("Request aborted");
     }
     try {
-      const mod = await import("./chunks/contextCommand-SVLAZMQL.js");
+      const mod = await import("./chunks/contextCommand-IGBCEXI4.js");
       if (signal.aborted) {
         throw new Error("Request aborted");
       }
@@ -161906,6 +162088,14 @@ function convertToHistoryItems(conversation, config) {
           items.push({ type: "notification", text: text2 });
           break;
         }
+        if (record2.subtype === "mid_turn_user_message") {
+          const payload = record2.systemPayload;
+          const text2 = payload?.displayText || extractTextFromParts(record2.message?.parts);
+          if (text2) {
+            items.push({ type: "user", text: text2 });
+          }
+          break;
+        }
         if (pendingAtCommands.length > 0) {
           if (currentToolGroup.length > 0) {
             items.push({
@@ -172008,6 +172198,12 @@ var useSlashCommandProcessor = /* @__PURE__ */ __name((config, settings, addItem
                       content: result.content,
                       timestamp: /* @__PURE__ */ new Date()
                     });
+                  } else if (result.messageType === "warning") {
+                    addMessage({
+                      type: "warning" /* WARNING */,
+                      content: result.content,
+                      timestamp: /* @__PURE__ */ new Date()
+                    });
                   } else {
                     addMessage({
                       type: "error" /* ERROR */,
@@ -174381,10 +174577,12 @@ var useGeminiStream = /* @__PURE__ */ __name((geminiClient, history, addItem, co
       const drained = turnCancelledRef.current || abortControllerRef.current?.signal.aborted ? [] : midTurnDrainRef?.current?.() ?? [];
       if (drained.length > 0) {
         for (const msg of drained) {
-          responsesToSend.push({
+          const midTurnUserMessage = {
             text: `
 [User message received during tool execution]: ${msg}`
-          });
+          };
+          responsesToSend.push(midTurnUserMessage);
+          config.getChatRecordingService()?.recordMidTurnUserMessage(midTurnUserMessage, msg);
           addItem({ type: "user" /* USER */, text: msg }, Date.now());
         }
       }
@@ -185180,6 +185378,96 @@ __name(loadRewriteConfig, "loadRewriteConfig");
 
 // packages/cli/src/acp-integration/session/Session.ts
 var debugLogger72 = createDebugLogger("SESSION");
+function computeInitialTurnFromHistory(records, sessionId) {
+  let maxPromptTurn = 0;
+  let userMessageCount = 0;
+  const promptIdPrefix = `${sessionId}########`;
+  for (const record2 of records) {
+    if (record2.sessionId === sessionId && isUserPromptRecord(record2)) {
+      userMessageCount += 1;
+    }
+    for (const promptId of getRecordPromptIds(record2)) {
+      if (!promptId.startsWith(promptIdPrefix)) {
+        continue;
+      }
+      const suffix = promptId.slice(promptIdPrefix.length);
+      if (!/^\d+$/.test(suffix)) {
+        continue;
+      }
+      maxPromptTurn = Math.max(maxPromptTurn, Number(suffix));
+    }
+  }
+  return maxPromptTurn > 0 ? maxPromptTurn : userMessageCount;
+}
+__name(computeInitialTurnFromHistory, "computeInitialTurnFromHistory");
+function getRecordPromptIds(record2) {
+  const promptIds = [];
+  const recordPromptId = record2.promptId;
+  if (typeof recordPromptId === "string") {
+    promptIds.push(recordPromptId);
+  }
+  const telemetryPromptId = readTelemetryPromptId(record2.systemPayload);
+  if (telemetryPromptId) {
+    promptIds.push(telemetryPromptId);
+  }
+  return promptIds;
+}
+__name(getRecordPromptIds, "getRecordPromptIds");
+function readTelemetryPromptId(payload) {
+  if (!payload || typeof payload !== "object" || !("uiEvent" in payload)) {
+    return void 0;
+  }
+  const uiEvent = payload.uiEvent;
+  if (!uiEvent || typeof uiEvent !== "object" || !("prompt_id" in uiEvent)) {
+    return void 0;
+  }
+  const promptId = uiEvent.prompt_id;
+  return typeof promptId === "string" ? promptId : void 0;
+}
+__name(readTelemetryPromptId, "readTelemetryPromptId");
+function isUserPromptRecord(record2) {
+  if (record2.type !== "user") {
+    return false;
+  }
+  return record2.message?.parts?.some(
+    (part) => typeof part.text === "string" && part.text.trim().length > 0
+  ) ?? false;
+}
+__name(isUserPromptRecord, "isUserPromptRecord");
+async function buildAvailableCommandsSnapshot(config, abortSignal = AbortSignal.timeout(1e4)) {
+  const slashCommands = await getAvailableCommands(config, abortSignal, "acp");
+  const availableCommands = slashCommands.map((cmd) => {
+    const acceptsInput = cmd.acceptsInput ?? (cmd.kind !== "built-in" /* BUILT_IN */ || cmd.completion != null || cmd.argumentHint != null || cmd.subCommands != null && cmd.subCommands.length > 0);
+    return {
+      name: cmd.name,
+      description: cmd.description,
+      input: acceptsInput ? { hint: cmd.argumentHint ?? "" } : null,
+      _meta: {
+        argumentHint: cmd.argumentHint,
+        source: cmd.source,
+        sourceLabel: cmd.sourceLabel,
+        supportedModes: getEffectiveSupportedModes(cmd),
+        subcommands: getCommandSubcommandNames(cmd),
+        modelInvocable: cmd.modelInvocable === true
+      }
+    };
+  });
+  let availableSkills;
+  try {
+    const skillManager = config.getSkillManager();
+    if (skillManager) {
+      const skills = await skillManager.listSkills();
+      availableSkills = skills.map((skill) => skill.name);
+    }
+  } catch (error) {
+    debugLogger72.error("Error loading available skills:", error);
+  }
+  return {
+    availableCommands,
+    ...availableSkills !== void 0 ? { availableSkills } : {}
+  };
+}
+__name(buildAvailableCommandsSnapshot, "buildAvailableCommandsSnapshot");
 var Session2 = class {
   constructor(id, config, client, settings) {
     this.config = config;
@@ -185249,6 +185537,10 @@ var Session2 = class {
    * Delegates to HistoryReplayer for consistent event emission.
    */
   async replayHistory(records) {
+    this.turn = Math.max(
+      this.turn,
+      computeInitialTurnFromHistory(records, this.config.getSessionId())
+    );
     await this.historyReplayer.replay(records);
   }
   rewindToTurn(targetTurnIndex) {
@@ -186075,43 +186367,12 @@ var Session2 = class {
     );
   }
   async sendAvailableCommandsUpdate() {
-    const abortController = new AbortController();
     try {
-      const slashCommands = await getAvailableCommands(
-        this.config,
-        abortController.signal,
-        "acp"
-      );
-      const availableCommands = slashCommands.map((cmd) => {
-        const acceptsInput = cmd.kind !== "built-in" /* BUILT_IN */ || cmd.completion != null || cmd.argumentHint != null || cmd.subCommands != null && cmd.subCommands.length > 0;
-        return {
-          name: cmd.name,
-          description: cmd.description,
-          input: acceptsInput ? { hint: cmd.argumentHint ?? "" } : null,
-          _meta: {
-            argumentHint: cmd.argumentHint,
-            source: cmd.source,
-            sourceLabel: cmd.sourceLabel,
-            supportedModes: getEffectiveSupportedModes(cmd),
-            subcommands: getCommandSubcommandNames(cmd),
-            modelInvocable: cmd.modelInvocable === true
-          }
-        };
-      });
-      let availableSkills;
-      try {
-        const skillManager = this.config.getSkillManager();
-        if (skillManager) {
-          const skills = await skillManager.listSkills();
-          availableSkills = skills.map((skill) => skill.name);
-        }
-      } catch (error) {
-        debugLogger72.error("Error loading available skills:", error);
-      }
+      const { availableCommands, availableSkills } = await buildAvailableCommandsSnapshot(this.config);
       const update = {
         sessionUpdate: "available_commands_update",
         availableCommands,
-        ...availableSkills ? {
+        ...availableSkills !== void 0 ? {
           _meta: {
             availableSkills
           }
@@ -186990,7 +187251,7 @@ var QwenAgent = class {
   async initialize(args) {
     this.clientCapabilities = args.clientCapabilities;
     const authMethods = buildAuthMethods();
-    const version = "0.15.12-preview.3";
+    const version = "0.16.0-preview.0";
     return {
       protocolVersion: PROTOCOL_VERSION,
       agentInfo: {
@@ -187220,10 +187481,288 @@ var QwenAgent = class {
     }
     await session.cancelPendingPrompt();
   }
+  workspaceCwd(config) {
+    return config.getTargetDir();
+  }
+  safeWorkspaceCwd(config) {
+    try {
+      return this.workspaceCwd(config);
+    } catch {
+      return "";
+    }
+  }
+  mcpTransport(server) {
+    if (server && typeof server === "object" && "type" in server && server.type === "sdk") {
+      return "sdk";
+    }
+    if (server && typeof server === "object" && typeof server.httpUrl === "string") {
+      return "http";
+    }
+    if (server && typeof server === "object" && typeof server.url === "string") {
+      return "sse";
+    }
+    if (server && typeof server === "object" && typeof server.tcp === "string") {
+      return "websocket";
+    }
+    if (server && typeof server === "object" && typeof server.command === "string") {
+      return "stdio";
+    }
+    return "unknown";
+  }
+  mcpStatus(status) {
+    switch (status) {
+      case "connected" /* CONNECTED */:
+        return "connected";
+      case "connecting" /* CONNECTING */:
+        return "connecting";
+      case "disconnected" /* DISCONNECTED */:
+      default:
+        return "disconnected";
+    }
+  }
+  mcpCellStatus(status, disabled) {
+    if (disabled) return "disabled";
+    switch (status) {
+      case "connected" /* CONNECTED */:
+        return "ok";
+      case "connecting" /* CONNECTING */:
+        return "warning";
+      case "disconnected" /* DISCONNECTED */:
+      default:
+        return "error";
+    }
+  }
+  discoveryState() {
+    const state = getMCPDiscoveryState();
+    switch (state) {
+      case "in_progress" /* IN_PROGRESS */:
+        return "in_progress";
+      case "completed" /* COMPLETED */:
+        return "completed";
+      case "not_started" /* NOT_STARTED */:
+      default:
+        return "not_started";
+    }
+  }
+  buildWorkspaceMcpStatus(config) {
+    try {
+      const workspaceCwd = this.workspaceCwd(config);
+      const servers = config.getMcpServers() ?? {};
+      return {
+        v: STATUS_SCHEMA_VERSION,
+        workspaceCwd,
+        initialized: true,
+        discoveryState: this.discoveryState(),
+        servers: Object.entries(servers).map(([name, server]) => {
+          const disabled = config.isMcpServerDisabled(name);
+          const rawStatus = getMCPServerStatus(name);
+          const out = {
+            kind: "mcp_server",
+            status: this.mcpCellStatus(rawStatus, disabled),
+            name,
+            mcpStatus: this.mcpStatus(rawStatus),
+            transport: this.mcpTransport(server),
+            disabled
+          };
+          const description = server && typeof server === "object" ? server.description : void 0;
+          const extensionName = server && typeof server === "object" ? server.extensionName : void 0;
+          if (typeof description === "string") {
+            out.description = description;
+          }
+          if (typeof extensionName === "string") {
+            out.extensionName = extensionName;
+          }
+          return out;
+        })
+      };
+    } catch (error) {
+      return {
+        v: STATUS_SCHEMA_VERSION,
+        workspaceCwd: this.safeWorkspaceCwd(config),
+        initialized: true,
+        servers: [],
+        errors: [this.errorCell("mcp", error)]
+      };
+    }
+  }
+  errorCell(kind, error) {
+    return {
+      kind,
+      status: "error",
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+  async buildWorkspaceSkillsStatus(config) {
+    const skillManager = config.getSkillManager();
+    if (!skillManager) {
+      return {
+        v: STATUS_SCHEMA_VERSION,
+        workspaceCwd: this.workspaceCwd(config),
+        initialized: true,
+        skills: []
+      };
+    }
+    try {
+      const skills = await skillManager.listSkills();
+      return {
+        v: STATUS_SCHEMA_VERSION,
+        workspaceCwd: this.workspaceCwd(config),
+        initialized: true,
+        skills: skills.map((skill) => {
+          const modelInvocable = skill.disableModelInvocation !== true;
+          return {
+            kind: "skill",
+            status: modelInvocable ? "ok" : "disabled",
+            name: skill.name,
+            description: skill.description,
+            level: skill.level,
+            modelInvocable,
+            ...skill.argumentHint ? { argumentHint: skill.argumentHint } : {},
+            ...skill.model ? { model: skill.model } : {},
+            ...skill.extensionName ? { extensionName: skill.extensionName } : {}
+          };
+        })
+      };
+    } catch (error) {
+      return {
+        v: STATUS_SCHEMA_VERSION,
+        workspaceCwd: this.workspaceCwd(config),
+        initialized: true,
+        skills: [],
+        errors: [this.errorCell("skills", error)]
+      };
+    }
+  }
+  buildWorkspaceProvidersStatus(config) {
+    try {
+      const workspaceCwd = this.workspaceCwd(config);
+      const currentAuthType = config.getAuthType?.();
+      const activeRuntimeSnapshot = config.getActiveRuntimeModelSnapshot?.();
+      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 providers = /* @__PURE__ */ new Map();
+      for (const model of config.getAllConfiguredModels()) {
+        const authType = String(model.authType);
+        let provider = providers.get(authType);
+        if (!provider) {
+          provider = {
+            kind: "model_provider",
+            status: "ok",
+            authType,
+            current: false,
+            models: []
+          };
+          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 providerModel = {
+          modelId,
+          baseModelId: parseAcpBaseModelId(effectiveModelId),
+          name: model.label,
+          ...model.description !== void 0 ? { description: model.description } : {},
+          contextLimit: model.contextWindowSize ?? tokenLimit(effectiveModelId),
+          isCurrent,
+          isRuntime: model.isRuntimeModel === true
+        };
+        provider.models.push(providerModel);
+        if (isCurrent) provider.current = true;
+      }
+      return {
+        v: STATUS_SCHEMA_VERSION,
+        workspaceCwd,
+        initialized: true,
+        ...currentAuth || currentAcpModelId ? {
+          current: {
+            ...currentAuth ? { authType: String(currentAuth) } : {},
+            ...currentAcpModelId ? { modelId: currentAcpModelId } : {}
+          }
+        } : {},
+        providers: [...providers.values()]
+      };
+    } catch (error) {
+      return {
+        v: STATUS_SCHEMA_VERSION,
+        workspaceCwd: this.safeWorkspaceCwd(config),
+        initialized: true,
+        providers: [],
+        errors: [this.errorCell("providers", error)]
+      };
+    }
+  }
+  sessionOrThrow(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      throw RequestError.invalidParams(
+        void 0,
+        `Session not found for id: ${sessionId}`
+      );
+    }
+    return session;
+  }
+  buildSessionContextStatus(sessionId) {
+    const session = this.sessionOrThrow(sessionId);
+    const config = session.getConfig();
+    return {
+      v: STATUS_SCHEMA_VERSION,
+      sessionId,
+      workspaceCwd: this.workspaceCwd(config),
+      state: {
+        models: this.buildAvailableModels(config),
+        modes: this.buildModesData(config),
+        configOptions: this.buildConfigOptions(config)
+      }
+    };
+  }
+  async buildSessionSupportedCommandsStatus(sessionId) {
+    const session = this.sessionOrThrow(sessionId);
+    const { availableCommands, availableSkills } = await buildAvailableCommandsSnapshot(session.getConfig());
+    return {
+      v: STATUS_SCHEMA_VERSION,
+      sessionId,
+      availableCommands,
+      availableSkills: availableSkills ?? []
+    };
+  }
   async extMethod(method, params) {
     const cwd5 = params["cwd"] || process.cwd();
     const SESSION_ID_RE = /^[0-9a-fA-F-]{32,36}$/;
     switch (method) {
+      case SERVE_STATUS_EXT_METHODS.workspaceMcp:
+        return this.buildWorkspaceMcpStatus(this.config);
+      case SERVE_STATUS_EXT_METHODS.workspaceSkills:
+        return await this.buildWorkspaceSkillsStatus(
+          this.config
+        );
+      case SERVE_STATUS_EXT_METHODS.workspaceProviders:
+        return this.buildWorkspaceProvidersStatus(
+          this.config
+        );
+      case SERVE_STATUS_EXT_METHODS.sessionContext: {
+        const sessionId = params["sessionId"];
+        if (typeof sessionId !== "string" || sessionId.length === 0) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Invalid or missing sessionId"
+          );
+        }
+        return this.buildSessionContextStatus(sessionId);
+      }
+      case SERVE_STATUS_EXT_METHODS.sessionSupportedCommands: {
+        const sessionId = params["sessionId"];
+        if (typeof sessionId !== "string" || sessionId.length === 0) {
+          throw RequestError.invalidParams(
+            void 0,
+            "Invalid or missing sessionId"
+          );
+        }
+        return await this.buildSessionSupportedCommandsStatus(
+          sessionId
+        );
+      }
       case "deleteSession": {
         const sessionId = params["sessionId"];
         if (!sessionId || !SESSION_ID_RE.test(sessionId)) {