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

package/chunks/{chunk-K3LPAED5.js → chunk-MQM5PJML.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-NYWWQ437.js";
 import {
   SessionNotFoundError
-} from "./chunk-624NHDGB.js";
+} from "./chunk-ERFDKH32.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -42,6 +42,7 @@ function createWorkspaceGenerationGuard() {
 __name(createWorkspaceGenerationGuard, "createWorkspaceGenerationGuard");
 function createWorkspaceSessionOwnerIndex() {
   const bySessionId = /* @__PURE__ */ new Map();
+  const unavailableWorkspaces = /* @__PURE__ */ new Set();
   const register = /* @__PURE__ */ __name((sessionId, workspaceCwd) => {
     let owners = bySessionId.get(sessionId);
     if (!owners) {
@@ -52,9 +53,15 @@ function createWorkspaceSessionOwnerIndex() {
   }, "register");
   const remove = /* @__PURE__ */ __name((sessionId, workspaceCwd) => {
     if (workspaceCwd === void 0) {
-      bySessionId.delete(sessionId);
+      const owners2 = bySessionId.get(sessionId);
+      if (!owners2) return;
+      for (const owner of owners2) {
+        if (!unavailableWorkspaces.has(owner)) owners2.delete(owner);
+      }
+      if (owners2.size === 0) bySessionId.delete(sessionId);
       return;
     }
+    if (unavailableWorkspaces.has(workspaceCwd)) return;
     const owners = bySessionId.get(sessionId);
     if (!owners) return;
     owners.delete(workspaceCwd);
@@ -66,7 +73,12 @@ function createWorkspaceSessionOwnerIndex() {
     register,
     remove,
     getWorkspaceCwds: /* @__PURE__ */ __name((sessionId) => [...bySessionId.get(sessionId) ?? []], "getWorkspaceCwds"),
+    markWorkspaceUnavailable: /* @__PURE__ */ __name((workspaceCwd) => {
+      unavailableWorkspaces.add(workspaceCwd);
+    }, "markWorkspaceUnavailable"),
+    isWorkspaceUnavailable: /* @__PURE__ */ __name((workspaceCwd) => unavailableWorkspaces.has(workspaceCwd), "isWorkspaceUnavailable"),
     removeWorkspace: /* @__PURE__ */ __name((workspaceCwd) => {
+      if (unavailableWorkspaces.has(workspaceCwd)) return;
       for (const [sessionId, owners] of bySessionId) {
         owners.delete(workspaceCwd);
         if (owners.size === 0) bySessionId.delete(sessionId);
@@ -345,7 +357,9 @@ function createWorkspaceRegistry(inputRuntimes, options = {}) {
       const entry = entryForRuntime(runtime);
       if (!entry || runtime.primary || entry.state !== "draining") return;
       entry.current?.guard.close();
-      if (!entry.internal) {
+      if (entry.internal) {
+        sessionOwnerIndex?.markWorkspaceUnavailable(runtime.workspaceCwd);
+      } else {
         sessionOwnerIndex?.removeWorkspace(runtime.workspaceCwd);
       }
     }, "commitDrain"),
@@ -358,7 +372,9 @@ function createWorkspaceRegistry(inputRuntimes, options = {}) {
       byId.delete(runtime.workspaceId);
       const index = entries.indexOf(entry);
       if (index >= 0) entries.splice(index, 1);
-      sessionOwnerIndex?.removeWorkspace(runtime.workspaceCwd);
+      if (!entry.internal) {
+        sessionOwnerIndex?.removeWorkspace(runtime.workspaceCwd);
+      }
     }, "completeDrain"),
     resolveLiveSessionOwner: /* @__PURE__ */ __name((sessionId) => {
       const indexedCwds = sessionOwnerIndex?.getWorkspaceCwds(sessionId) ?? [];
@@ -369,6 +385,10 @@ function createWorkspaceRegistry(inputRuntimes, options = {}) {
           const entry = byCwd.get(workspaceCwd);
           const runtime = entry?.current?.runtime;
           if (!entry || !runtime || entry.state === "removed") {
+            if (sessionOwnerIndex?.isWorkspaceUnavailable(workspaceCwd)) {
+              internalUnavailable = true;
+              continue;
+            }
             sessionOwnerIndex?.remove(sessionId, workspaceCwd);
             continue;
           }

package/chunks/{chunk-SM7ZVKTF.js → chunk-MTJN7FOT.js}

@@ -2,26 +2,26 @@
 "use strict";
 import {
   getExtensionManager
-} from "./chunk-A7X32SCT.js";
+} from "./chunk-6ZZBRRKQ.js";
 import {
   parseChannelConfig
-} from "./chunk-EAV3TENS.js";
+} from "./chunk-QPTRRPZU.js";
 import {
   getPlugin,
   registerPlugin
-} from "./chunk-IKN3IUJP.js";
+} from "./chunk-Y4TPOUEV.js";
 import {
   sanitizeLogText
-} from "./chunk-E55H6BZ7.js";
+} from "./chunk-ICURCKIU.js";
 import {
   loadSettings
-} from "./chunk-MDZO5V2O.js";
+} from "./chunk-HPXV655A.js";
 import {
   hashDaemonWorkspace
-} from "./chunk-ILPXSKGQ.js";
+} from "./chunk-3WK3QDNV.js";
 import {
   Storage
-} from "./chunk-2NNTE2ED.js";
+} from "./chunk-UHQFIS7N.js";
 import {
   writeStderrLine,
   writeStdoutLine

package/chunks/{chunk-BGXZBI5B.js → chunk-N4X7G4J2.js}

@@ -26,7 +26,8 @@ function mapSkillConfigToStatus(skill, disablements = /* @__PURE__ */ new Map(),
     installedPath: skill.filePath,
     ...skill.argumentHint ? { argumentHint: skill.argumentHint } : {},
     ...skill.model ? { model: skill.model } : {},
-    ...skill.extensionName ? { extensionName: skill.extensionName } : {}
+    ...skill.level === "extension" && skill.extensionName ? { extensionName: skill.extensionName } : {},
+    ...skill.level === "extension" && skill.extensionDisplayName ? { extensionDisplayName: skill.extensionDisplayName } : {}
   };
 }
 __name(mapSkillConfigToStatus, "mapSkillConfigToStatus");

package/chunks/{chunk-27ONXAFY.js → chunk-NIFYWDYN.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   createDebugLogger
-} from "./chunk-2NNTE2ED.js";
+} from "./chunk-UHQFIS7N.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-IJVDHPKD.js → chunk-NU7RKEZR.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   theme
-} from "./chunk-FPH6TXD3.js";
+} from "./chunk-WAOIHTJS.js";
 import {
   require_jsx_runtime
 } from "./chunk-SV5PQVQE.js";
@@ -21,7 +21,7 @@ import {
 } from "./chunk-2MIN6GRR.js";
 import {
   createDebugLogger
-} from "./chunk-2NNTE2ED.js";
+} from "./chunk-UHQFIS7N.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-R2ZJH3FV.js → chunk-NXMBRVMQ.js}

@@ -2,14 +2,14 @@
 "use strict";
 import {
   STATUS_SCHEMA_VERSION
-} from "./chunk-CITGRGCM.js";
+} from "./chunk-7TUBJBBJ.js";
 import {
   formatMemoryUsage
-} from "./chunk-XYX474JQ.js";
+} from "./chunk-EWIQ3NAE.js";
 import {
   detectRuntime,
   redactProxyCredentials
-} from "./chunk-GTUKW3I6.js";
+} from "./chunk-PPKZ7JOE.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-JLGFGPZJ.js → chunk-OI4NY7RA.js}

@@ -2,13 +2,13 @@
 "use strict";
 import {
   hasControlCharacter
-} from "./chunk-SKNVVYIJ.js";
+} from "./chunk-K5KXUXWC.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-KOJ6MHD5.js";
+} from "./chunk-UTLCH2FK.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

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

@@ -3,7 +3,7 @@
 import {
   createDebugLogger,
   isNodeError
-} from "./chunk-2NNTE2ED.js";
+} from "./chunk-UHQFIS7N.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

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

@@ -2,7 +2,7 @@
 "use strict";
 import {
   createDebugLogger
-} from "./chunk-2NNTE2ED.js";
+} from "./chunk-UHQFIS7N.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

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-MW5AHWOZ.js → chunk-PWIGAMA4.js}

@@ -2,19 +2,19 @@
 "use strict";
 import {
   loadSettings
-} from "./chunk-MDZO5V2O.js";
+} from "./chunk-HPXV655A.js";
 import {
   getCurrentLanguage
-} from "./chunk-W2WRNJKX.js";
+} from "./chunk-RWZB422L.js";
 import {
   isWorkspaceTrusted
-} from "./chunk-XNXWEGKB.js";
+} from "./chunk-CYAUBK46.js";
 import {
   require_strip_json_comments
 } from "./chunk-NPQ5ZKRP.js";
 import {
   hashMcpServerConfig
-} from "./chunk-VMDURMFY.js";
+} from "./chunk-W6DUQ5GA.js";
 import {
   Config,
   ExtensionManager,
@@ -25,14 +25,18 @@ import {
   isGatedMcpScope,
   normalizeClaudeMcpServer,
   runWithTimeout
-} from "./chunk-XYX474JQ.js";
+} from "./chunk-EWIQ3NAE.js";
+import {
+  getMCPServerLastError,
+  getMCPServerStatus
+} from "./chunk-SZLBBZH4.js";
 import {
   atomicWriteFile
-} from "./chunk-7QGEJI7M.js";
+} from "./chunk-23RFD54N.js";
 import {
   Storage,
   getErrorMessage
-} from "./chunk-2NNTE2ED.js";
+} from "./chunk-UHQFIS7N.js";
 import {
   writeStderrLine,
   writeStdoutLine
@@ -770,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,
@@ -780,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]) {
@@ -800,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");
@@ -830,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-WEGXPP5E.js → chunk-QFCDF5PL.js}

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

package/chunks/{chunk-EAV3TENS.js → chunk-QPTRRPZU.js}

@@ -1,15 +1,15 @@
 // Force strict mode and setup for ESM
 "use strict";
-import {
-  resolveChannelCwd
-} from "./chunk-7JPW6IYH.js";
 import {
   getPlugin,
   supportedTypes
-} from "./chunk-IKN3IUJP.js";
+} from "./chunk-Y4TPOUEV.js";
+import {
+  resolveChannelCwd
+} from "./chunk-HVC3PNVC.js";
 import {
   APPROVAL_MODES
-} from "./chunk-BVE5EMIG.js";
+} from "./chunk-V5J4J5TP.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -57,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);
@@ -359,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,
@@ -368,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"],
@@ -380,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