@qwen-code/qwen-code 0.22.0 → 0.22.2-nightly.20260828.7357136dd1

package/chunks/{chunk-LURJYO2T.js → chunk-OZ6KS6KW.js}

@@ -20,6 +20,8 @@ var LOAD_REPLAY_MAX_UPDATES = 1e4;
 var REQUESTED_SESSION_ID_META_KEY = "qwen-code/sessionId";
 var CHANNEL_STARTUP_PROFILE_META_KEY = "qwen.daemon.channelStartupProfile";
 var CHANNEL_STARTUP_PROFILE_VERSION = 1;
+var CHANNEL_LIVENESS_META_KEY = "qwen.daemon.channelLiveness";
+var CHANNEL_LIVENESS_VERSION = 1;
 var ACTIVE_WORK_HEARTBEAT_META_KEY = "qwen.daemon.activeWorkHeartbeat";
 var ACTIVE_WORK_HEARTBEAT_VERSION = 1;
 var ACTIVE_WORK_HEARTBEAT_INTERVAL_MS = 15e3;
@@ -88,6 +90,8 @@ export {
   REQUESTED_SESSION_ID_META_KEY,
   CHANNEL_STARTUP_PROFILE_META_KEY,
   CHANNEL_STARTUP_PROFILE_VERSION,
+  CHANNEL_LIVENESS_META_KEY,
+  CHANNEL_LIVENESS_VERSION,
   ACTIVE_WORK_HEARTBEAT_META_KEY,
   ACTIVE_WORK_HEARTBEAT_VERSION,
   ACTIVE_WORK_HEARTBEAT_INTERVAL_MS,

package/chunks/{chunk-K52PZNU4.js → chunk-PDQGMSZK.js}

@@ -3,7 +3,7 @@
 import {
   createDebugLogger,
   isNodeError
-} from "./chunk-A5F2YNO6.js";
+} from "./chunk-UHQFIS7N.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -907,7 +907,7 @@ var QwenIgnoreParser = class {
   }
 };
 
-// packages/core/src/config/constants.ts
+// packages/core/src/utils/file-filtering-options.ts
 init_esbuild_shims();
 var DEFAULT_MEMORY_FILE_FILTERING_OPTIONS = {
   respectGitIgnore: false,

package/chunks/{chunk-PZRUV52H.js → chunk-PPKZ7JOE.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   createDebugLogger
-} from "./chunk-A5F2YNO6.js";
+} from "./chunk-UHQFIS7N.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -426,6 +426,17 @@ function buildFetchOptionsWithDispatcher(sdkType, proxyUrl) {
 }
 __name(buildFetchOptionsWithDispatcher, "buildFetchOptionsWithDispatcher");
 
+// packages/core/src/utils/auth-type.ts
+init_esbuild_shims();
+var AuthType = /* @__PURE__ */ ((AuthType2) => {
+  AuthType2["USE_OPENAI"] = "openai";
+  AuthType2["QWEN_OAUTH"] = "qwen-oauth";
+  AuthType2["USE_GEMINI"] = "gemini";
+  AuthType2["USE_VERTEX_AI"] = "vertex-ai";
+  AuthType2["USE_ANTHROPIC"] = "anthropic";
+  return AuthType2;
+})(AuthType || {});
+
 export {
   loadUndici,
   preloadRuntimeFetchModule,
@@ -436,10 +447,17 @@ export {
   setResolvedProxyUrlForRuntimeFetch,
   getOrCreateMcpDispatcher,
   redactProxyCredentials,
-  redactProxyError
+  redactProxyError,
+  AuthType
 };
 /**
  * @license
  * Copyright 2025 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-SAH4BD2J.js → chunk-PQEISIKS.js}

@@ -7,6 +7,66 @@ import {
   __name
 } from "./chunk-J2S4EL5Y.js";
 
+// packages/core/src/utils/thoughtUtils.ts
+init_esbuild_shims();
+var START_DELIMITER = "**";
+var END_DELIMITER = "**";
+var OPENAI_REASONING_THOUGHT_MARKER = Symbol("openaiReasoningThought");
+function createOpenAIReasoningThoughtPart(text) {
+  const part = { text, thought: true };
+  Object.defineProperty(part, OPENAI_REASONING_THOUGHT_MARKER, {
+    value: true
+  });
+  return part;
+}
+__name(createOpenAIReasoningThoughtPart, "createOpenAIReasoningThoughtPart");
+function isOpenAIReasoningThoughtPart(part) {
+  return Boolean(
+    part[OPENAI_REASONING_THOUGHT_MARKER]
+  );
+}
+__name(isOpenAIReasoningThoughtPart, "isOpenAIReasoningThoughtPart");
+function parseThought(rawText) {
+  const startIndex = rawText.indexOf(START_DELIMITER);
+  if (startIndex === -1) {
+    return { subject: "", description: rawText };
+  }
+  const endIndex = rawText.indexOf(
+    END_DELIMITER,
+    startIndex + START_DELIMITER.length
+  );
+  if (endIndex === -1) {
+    return { subject: "", description: rawText };
+  }
+  const subject = rawText.substring(startIndex + START_DELIMITER.length, endIndex).trim();
+  const description = (rawText.substring(0, startIndex) + rawText.substring(endIndex + END_DELIMITER.length)).trim();
+  return { subject, description };
+}
+__name(parseThought, "parseThought");
+function getThoughtSummary(response) {
+  if (response.candidates && response.candidates.length > 0) {
+    const candidate = response.candidates[0];
+    if (candidate.content && candidate.content.parts && candidate.content.parts.length > 0) {
+      const thoughtParts = candidate.content.parts.filter(
+        (part) => part.thought
+      );
+      if (thoughtParts.length === 0) {
+        return null;
+      }
+      const thoughtText = thoughtParts.map((part) => part.text ?? "").join("");
+      if (!thoughtText) {
+        return null;
+      }
+      if (thoughtParts.some(isOpenAIReasoningThoughtPart)) {
+        return { subject: "", description: thoughtText };
+      }
+      return parseThought(thoughtText);
+    }
+  }
+  return null;
+}
+__name(getThoughtSummary, "getThoughtSummary");
+
 // packages/core/src/core/openaiContentGenerator/prefix-caching.ts
 init_esbuild_shims();
 var CACHE_KEY_PREFIX = "qwen-code:";
@@ -81,10 +141,17 @@ function applyOfficialOpenAIPromptCaching(request, sessionId, cacheSharing, cach
 __name(applyOfficialOpenAIPromptCaching, "applyOfficialOpenAIPromptCaching");
 
 export {
+  createOpenAIReasoningThoughtPart,
+  getThoughtSummary,
   supportsOpenAIPrefixCaching,
   isOfficialOpenAIEndpoint,
   applyOfficialOpenAIPromptCaching
 };
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
 /**
  * @license
  * Copyright 2025 Qwen

package/chunks/{chunk-AO4M6NMD.js → chunk-PWIGAMA4.js}

@@ -2,37 +2,41 @@
 "use strict";
 import {
   loadSettings
-} from "./chunk-6UQSU7CQ.js";
+} from "./chunk-HPXV655A.js";
 import {
   getCurrentLanguage
-} from "./chunk-OE52YHCZ.js";
+} from "./chunk-RWZB422L.js";
 import {
   isWorkspaceTrusted
-} from "./chunk-L4HVF7LM.js";
+} from "./chunk-CYAUBK46.js";
 import {
   require_strip_json_comments
 } from "./chunk-NPQ5ZKRP.js";
 import {
-  hashMcpServerConfig,
-  runWithTimeout
-} from "./chunk-62JOGZL5.js";
+  hashMcpServerConfig
+} from "./chunk-W6DUQ5GA.js";
 import {
-  Client,
   Config,
   ExtensionManager,
   FileDiscoveryService,
   MCPOAuthTokenStorage,
+  createMcpClient,
   createTransport,
   isGatedMcpScope,
-  normalizeClaudeMcpServer
-} from "./chunk-T6XLJRQY.js";
+  normalizeClaudeMcpServer,
+  runWithTimeout
+} from "./chunk-EWIQ3NAE.js";
+import {
+  getMCPServerLastError,
+  getMCPServerStatus
+} from "./chunk-SZLBBZH4.js";
 import {
   atomicWriteFile
-} from "./chunk-HDKCKCYO.js";
+} from "./chunk-23RFD54N.js";
 import {
   Storage,
   getErrorMessage
-} from "./chunk-A5F2YNO6.js";
+} from "./chunk-UHQFIS7N.js";
 import {
   writeStderrLine,
   writeStdoutLine
@@ -423,6 +427,7 @@ __name(assembleMcpServers, "assembleMcpServers");
 // packages/cli/src/config/mcpApprovals.ts
 init_esbuild_shims();
 import * as fs2 from "node:fs";
+import * as os from "node:os";
 import * as path2 from "node:path";
 var import_strip_json_comments2 = __toESM(require_strip_json_comments(), 1);
 var MCP_APPROVALS_FILENAME = "mcpApprovals.json";
@@ -434,9 +439,50 @@ function getMcpApprovalsPath() {
 }
 __name(getMcpApprovalsPath, "getMcpApprovalsPath");
 function normalizeProjectRoot(projectRoot) {
-  return path2.resolve(projectRoot);
+  const resolved = path2.resolve(projectRoot);
+  return os.platform() === "win32" ? resolved.toLowerCase() : resolved;
 }
 __name(normalizeProjectRoot, "normalizeProjectRoot");
+function isApprovalRecordMap(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isApprovalRecordMap, "isApprovalRecordMap");
+function isWin32AbsolutePath(p) {
+  return /^[A-Za-z]:[\\/]/.test(p) || /^\\\\/.test(p);
+}
+__name(isWin32AbsolutePath, "isWin32AbsolutePath");
+function mergeApprovalRecords(existing, incoming) {
+  const merged = Object.assign(
+    /* @__PURE__ */ Object.create(null),
+    existing
+  );
+  for (const [name, record] of Object.entries(incoming)) {
+    if (!isApprovalRecordMap(record)) {
+      continue;
+    }
+    const current = merged[name];
+    if (!current) {
+      merged[name] = record;
+    } else if (current.status !== record.status) {
+      merged[name] = current.status === "rejected" ? current : record;
+    }
+  }
+  return merged;
+}
+__name(mergeApprovalRecords, "mergeApprovalRecords");
+function normalizeStoredProjectKeys(config) {
+  if (os.platform() !== "win32") {
+    return config;
+  }
+  const normalized = /* @__PURE__ */ Object.create(null);
+  for (const [key, value] of Object.entries(config)) {
+    const projectKey = isWin32AbsolutePath(key) ? key.toLowerCase() : key;
+    const existing = normalized[projectKey];
+    normalized[projectKey] = isApprovalRecordMap(existing) && isApprovalRecordMap(value) ? mergeApprovalRecords(existing, value) : isApprovalRecordMap(value) || !isApprovalRecordMap(existing) ? value : existing;
+  }
+  return normalized;
+}
+__name(normalizeStoredProjectKeys, "normalizeStoredProjectKeys");
 var LoadedMcpApprovals = class {
   constructor(file, errors) {
     this.file = file;
@@ -465,7 +511,9 @@ var LoadedMcpApprovals = class {
   async setState(projectRoot, serverName, config, status) {
     const root = normalizeProjectRoot(projectRoot);
     const existing = this.file.config[root];
-    const project = existing && typeof existing === "object" && !Array.isArray(existing) ? existing : /* @__PURE__ */ Object.create(null);
+    const project = isApprovalRecordMap(
+      existing
+    ) ? existing : /* @__PURE__ */ Object.create(null);
     Object.defineProperty(project, serverName, {
       value: { hash: hashMcpServerConfig(config), status },
       enumerable: true,
@@ -494,7 +542,7 @@ function loadMcpApprovals() {
           path: filePath
         });
       } else {
-        config = parsed;
+        config = normalizeStoredProjectKeys(parsed);
       }
     }
   } catch (error) {
@@ -559,7 +607,7 @@ var COLOR_GREEN = "\x1B[32m";
 var COLOR_YELLOW = "\x1B[33m";
 var COLOR_RED = "\x1B[31m";
 var RESET_COLOR = "\x1B[0m";
-var MCP_CONNECT_TIMEOUT_MS = 5e3;
+var MCP_CONNECT_TIMEOUT_MS = 1e4;
 async function getMcpServersFromConfig() {
   const settings = loadSettings();
   const extensionManager = new ExtensionManager({
@@ -592,10 +640,7 @@ async function getMcpServersFromConfig() {
 }
 __name(getMcpServersFromConfig, "getMcpServersFromConfig");
 async function testMCPConnection(serverName, config) {
-  const client = new Client({
-    name: "mcp-test-client",
-    version: "0.0.1"
-  });
+  const client = createMcpClient("mcp-test-client", config);
   let transport;
   try {
     transport = await createTransport(serverName, config, false);
@@ -609,7 +654,6 @@ async function testMCPConnection(serverName, config) {
       MCP_CONNECT_TIMEOUT_MS,
       `MCP connection for ${serverName}`
     );
-    await client.ping();
     await client.close();
     return { status: "connected" /* CONNECTED */, timedOut: false };
   } catch (error) {
@@ -730,6 +774,8 @@ async function createMinimalConfig() {
     fileFiltering?.customIgnoreFiles
   );
   const mcpServers = await getMcpServersFromConfig2();
+  const allowedMcpServers = settings.merged.mcp?.allowed ? new Set(settings.merged.mcp.allowed.filter(Boolean)) : void 0;
+  const excludedMcpServers = settings.merged.mcp?.excluded ? new Set(settings.merged.mcp.excluded.filter(Boolean)) : void 0;
   const config = new Config({
     sessionId: "mcp-reconnect",
     targetDir: cwd,
@@ -740,18 +786,74 @@ async function createMinimalConfig() {
     pendingMcpServers: getPendingGatedMcpServers(mcpServers, cwd),
     fileDiscoveryService: fileService,
     mcpServerCommand: settings.merged.mcp?.serverCommand,
+    allowedMcpServers: allowedMcpServers ? Array.from(allowedMcpServers) : void 0,
+    excludedMcpServers: excludedMcpServers ? Array.from(excludedMcpServers) : void 0,
+    // Mirror a real session's trust gate: discovery skips MCP servers in an
+    // untrusted workspace, so the throwaway Config must carry the same trust
+    // state. Without it `isTrustedFolder()` defaults to true here, the
+    // untrusted-skip reporting below becomes unreachable, and this command
+    // would attempt connections a normal session would not (issue #9944).
+    trustedFolder: isWorkspaceTrusted(settings.merged).isTrusted ?? true,
     ...fileFiltering !== void 0 ? { fileFiltering } : {}
   });
-  await config.initialize();
+  await config.initialize({ skipMcpDiscovery: true });
   return config;
 }
 __name(createMinimalConfig, "createMinimalConfig");
+var SkippedConnectionError = class extends Error {
+  static {
+    __name(this, "SkippedConnectionError");
+  }
+  skipReason;
+  constructor(skipReason) {
+    super(`no connection attempt was made: ${skipReason}`);
+    this.name = "SkippedConnectionError";
+    this.skipReason = skipReason;
+  }
+};
+var SESSION_SCOPE_NOTE = "Note: this command reconnects in a separate process; it cannot refresh the MCP tools of an already-running Qwen Code session. Restart that session if its tools remain unavailable.";
 function createReconnectError(message, exitCode = 1) {
   const error = new Error(message);
   error.exitCode = exitCode;
   return error;
 }
 __name(createReconnectError, "createReconnectError");
+function describeSkippedConnectionReason(config, serverName) {
+  const unavailableReason = config.getMcpServerUnavailableReason(serverName);
+  if (unavailableReason === "excluded") {
+    return "server is excluded in settings (mcp.excluded)";
+  }
+  if (unavailableReason === "not_allowed") {
+    return "server is not in the mcp.allowed list";
+  }
+  if (config.isMcpServerDisabled(serverName)) {
+    return "server is disabled in settings";
+  }
+  if (config.isMcpServerPendingApproval(serverName)) {
+    return "server is pending approval (.mcp.json)";
+  }
+  if (config.isTrustedFolder() === false) {
+    return "workspace folder is not trusted";
+  }
+  return void 0;
+}
+__name(describeSkippedConnectionReason, "describeSkippedConnectionReason");
+async function discoverAndVerifyConnection(config, serverName) {
+  const toolRegistry = config.getToolRegistry();
+  await toolRegistry.discoverToolsForServer(serverName);
+  const status = getMCPServerStatus(serverName);
+  if (status !== "connected" /* CONNECTED */) {
+    const skippedReason = describeSkippedConnectionReason(config, serverName);
+    if (skippedReason) {
+      throw new SkippedConnectionError(skippedReason);
+    }
+    const lastError = getMCPServerLastError(serverName);
+    throw new Error(
+      `connection attempt finished without a live connection (status: ${status})` + (lastError ? `: ${lastError}` : "")
+    );
+  }
+}
+__name(discoverAndVerifyConnection, "discoverAndVerifyConnection");
 async function reconnectMcpServer(serverName) {
   const mcpServers = await getMcpServersFromConfig2();
   if (!mcpServers[serverName]) {
@@ -760,17 +862,22 @@ async function reconnectMcpServer(serverName) {
     );
   }
   writeStdoutLine(`Reconnecting to server "${serverName}"...`);
+  let config;
   try {
-    const config = await createMinimalConfig();
-    const toolRegistry = config.getToolRegistry();
-    await toolRegistry.discoverToolsForServer(serverName);
+    config = await createMinimalConfig();
+    await discoverAndVerifyConnection(config, serverName);
     writeStdoutLine(`Successfully reconnected to server "${serverName}".`);
-    await config.shutdown();
+    writeStdoutLine(SESSION_SCOPE_NOTE);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
+    writeStdoutLine(SESSION_SCOPE_NOTE);
     throw createReconnectError(
       `Failed to reconnect to server "${serverName}": ${message}`
     );
+  } finally {
+    if (config) {
+      await config.shutdown();
+    }
   }
 }
 __name(reconnectMcpServer, "reconnectMcpServer");
@@ -790,23 +897,35 @@ async function reconnectAllMcpServers() {
   }
   writeStdoutLine("Reconnecting to all MCP servers...\n");
   let config;
+  let failedCount = 0;
   try {
     config = await createMinimalConfig();
-    const toolRegistry = config.getToolRegistry();
     for (const serverName of serverNames) {
       try {
-        await toolRegistry.discoverToolsForServer(serverName);
+        await discoverAndVerifyConnection(config, serverName);
         writeStdoutLine(`\u2713 ${serverName}: Reconnected successfully`);
       } catch (error) {
+        if (error instanceof SkippedConnectionError) {
+          writeStdoutLine(`- ${serverName}: Skipped - ${error.skipReason}`);
+          continue;
+        }
+        failedCount++;
         const message = error instanceof Error ? error.message : String(error);
         writeStdoutLine(`\u2717 ${serverName}: Failed - ${message}`);
       }
     }
+    writeStdoutLine("");
+    writeStdoutLine(SESSION_SCOPE_NOTE);
   } finally {
     if (config) {
       await config.shutdown();
     }
   }
+  if (failedCount > 0) {
+    throw createReconnectError(
+      `Failed to reconnect ${failedCount} of ${serverNames.length} configured server(s).`
+    );
+  }
 }
 __name(reconnectAllMcpServers, "reconnectAllMcpServers");
 var reconnectCommand = {

package/chunks/{chunk-S3G6YFQC.js → chunk-QFCDF5PL.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-RKUWKYED.js";
 import {
   createDebugLogger
-} from "./chunk-A5F2YNO6.js";
+} from "./chunk-UHQFIS7N.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/chunk-QHMLYMMS.js

@@ -0,0 +1,32 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/core/stream-transport-retry.ts
+init_esbuild_shims();
+var RETRYABLE_STREAM_TRANSPORT_CODES = /* @__PURE__ */ new Set([
+  "ECONNRESET",
+  "ETIMEDOUT",
+  "UND_ERR_BODY_TIMEOUT",
+  "UND_ERR_CONNECT_TIMEOUT",
+  "UND_ERR_HEADERS_TIMEOUT",
+  "UND_ERR_SOCKET"
+]);
+function isRetryableStreamTransportError(classification) {
+  return classification.kind === "transport" && classification.transportCode !== void 0 && RETRYABLE_STREAM_TRANSPORT_CODES.has(classification.transportCode);
+}
+__name(isRetryableStreamTransportError, "isRetryableStreamTransportError");
+
+export {
+  isRetryableStreamTransportError
+};
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-5XUTPXQU.js → chunk-QPTRRPZU.js}

@@ -1,12 +1,15 @@
 // Force strict mode and setup for ESM
 "use strict";
-import {
-  resolveChannelCwd
-} from "./chunk-45NQKMYB.js";
 import {
   getPlugin,
   supportedTypes
-} from "./chunk-QS4ENGVF.js";
+} from "./chunk-Y4TPOUEV.js";
+import {
+  resolveChannelCwd
+} from "./chunk-HVC3PNVC.js";
+import {
+  APPROVAL_MODES
+} from "./chunk-V5J4J5TP.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -17,13 +20,7 @@ import {
 // packages/cli/src/commands/channel/config-utils.ts
 init_esbuild_shims();
 var ENV_VAR_NAME_PATTERN = /^[A-Z_][A-Z0-9_]*$/;
-var CHANNEL_APPROVAL_MODES = /* @__PURE__ */ new Set([
-  "plan",
-  "default",
-  "auto-edit",
-  "auto",
-  "yolo"
-]);
+var CHANNEL_APPROVAL_MODES = new Set(APPROVAL_MODES);
 function resolveEnvVars(value, env = process.env) {
   if (value.startsWith("$$")) {
     return value.substring(1);
@@ -60,6 +57,26 @@ function resolveOptionalStringField(channelName, rawConfig, field, envResolution
 }
 __name(resolveOptionalStringField, "resolveOptionalStringField");
 var KNOWN_CREDENTIAL_FIELDS = /* @__PURE__ */ new Set(["token", "clientId", "clientSecret"]);
+function multiSessionCompatibilityError(name, config) {
+  if (!config.multiSession) return void 0;
+  if (config.sessionScope !== "user") {
+    return `Channel "${name}" requires sessionScope "user" when multiSession is enabled.`;
+  }
+  if (typeof config.groupHistoryLimit === "number" && config.groupHistoryLimit !== 0) {
+    return `Channel "${name}" cannot use groupHistoryLimit when multiSession is enabled.`;
+  }
+  for (const [groupId, group] of Object.entries(config.groups ?? {})) {
+    const groupHistoryLimit = group !== null && typeof group === "object" && !Array.isArray(group) ? group["groupHistoryLimit"] : void 0;
+    if (typeof groupHistoryLimit === "number" && groupHistoryLimit !== 0) {
+      return `Channel "${name}" group "${groupId}" cannot use groupHistoryLimit when multiSession is enabled.`;
+    }
+  }
+  if (config.webhooks !== void 0 && config.webhooks !== null) {
+    return `Channel "${name}" cannot use webhooks when multiSession is enabled.`;
+  }
+  return void 0;
+}
+__name(multiSessionCompatibilityError, "multiSessionCompatibilityError");
 function resolveConfigEnvVar(value, mode) {
   if (mode === false) return value;
   if (value.startsWith("$$")) return value.substring(1);
@@ -362,6 +379,21 @@ async function parseChannelConfig(name, rawConfig, defaultCwd = process.cwd(), o
     envResolution
   );
   const configuredSessionScope = rawConfig["sessionScope"] || plugin.defaultSessionScope || "user";
+  const multiSession = optionalBooleanField(
+    name,
+    "multiSession",
+    rawConfig["multiSession"]
+  );
+  const groups = rawConfig["groups"] || {};
+  const webhooks = parseWebhookConfig(name, rawConfig);
+  const multiSessionError = multiSessionCompatibilityError(name, {
+    multiSession,
+    sessionScope: configuredSessionScope,
+    groupHistoryLimit: rawConfig["groupHistoryLimit"],
+    groups,
+    webhooks
+  });
+  if (multiSessionError) throw new Error(multiSessionError);
   return {
     ...resolvedRawConfig,
     type: channelType,
@@ -371,6 +403,7 @@ async function parseChannelConfig(name, rawConfig, defaultCwd = process.cwd(), o
     senderPolicy: rawConfig["senderPolicy"] || "allowlist",
     allowedUsers: rawConfig["allowedUsers"] || [],
     sessionScope: configuredSessionScope,
+    multiSession,
     cwd: resolveChannelCwd(rawConfig["cwd"], defaultCwd),
     approvalMode: parseApprovalModeConfig(name, rawConfig),
     instructions: rawConfig["instructions"],
@@ -383,14 +416,15 @@ async function parseChannelConfig(name, rawConfig, defaultCwd = process.cwd(), o
     model: rawConfig["model"],
     groupPolicy: rawConfig["groupPolicy"] || "disabled",
     dmPolicy: rawConfig["dmPolicy"] || "open",
-    groups: rawConfig["groups"] || {},
-    webhooks: parseWebhookConfig(name, rawConfig)
+    groups,
+    webhooks
   };
 }
 __name(parseChannelConfig, "parseChannelConfig");
 
 export {
   resolveEnvVars,
+  multiSessionCompatibilityError,
   parseChannelWebhookConfig,
   parseChannelWebhookConfigLenient,
   parseChannelConfig