@qwen-code/qwen-code 0.23.2-preview.0 → 0.23.2

package/chunks/chunk-NFXXBWSE.js

@@ -0,0 +1,463 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  isSameProcess,
+  readLocalBootId,
+  readPidNamespaceId,
+  readProcStartToken
+} from "./chunk-CH2YDT6X.js";
+import {
+  require_proper_lockfile
+} from "./chunk-MLXTMF7H.js";
+import {
+  Storage
+} from "./chunk-ZAFYHRVY.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name,
+  __toESM
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/commands/channel/pidfile.ts
+init_esbuild_shims();
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  unlinkSync,
+  openSync,
+  closeSync,
+  constants,
+  ftruncateSync,
+  writeSync
+} from "node:fs";
+import * as path2 from "node:path";
+
+// packages/cli/src/commands/channel/pidfile-lock.ts
+init_esbuild_shims();
+var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
+import fs from "node:fs";
+import path from "node:path";
+var RETRY_DELAYS_MS = [10, 20, 30, 40, 50];
+var STALE_LOCK_MS = 1e4;
+var sleepState = new Int32Array(new SharedArrayBuffer(4));
+function sleepSync(ms) {
+  Atomics.wait(sleepState, 0, 0, ms);
+}
+__name(sleepSync, "sleepSync");
+function withChannelPidfileLock(filePath, operation) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  let release;
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      release = import_proper_lockfile.default.lockSync(filePath, {
+        realpath: false,
+        stale: STALE_LOCK_MS
+      });
+      break;
+    } catch (error) {
+      const lockError = error;
+      if (lockError.code !== "ELOCKED") {
+        throw error;
+      }
+      if (attempt >= RETRY_DELAYS_MS.length) {
+        throw Object.assign(
+          new Error(
+            `Channel pidfile lock ${filePath}.lock is held; an abandoned lock recovers automatically after ${STALE_LOCK_MS / 1e3} seconds.`,
+            { cause: error }
+          ),
+          { code: "ELOCKED" }
+        );
+      }
+      sleepSync(RETRY_DELAYS_MS[attempt]);
+    }
+  }
+  try {
+    return operation();
+  } finally {
+    release();
+  }
+}
+__name(withChannelPidfileLock, "withChannelPidfileLock");
+
+// packages/cli/src/commands/channel/pidfile.ts
+function pidFilePath() {
+  return path2.join(Storage.getGlobalQwenDir(), "channels", "service.pid");
+}
+__name(pidFilePath, "pidFilePath");
+function isValidPid(pid) {
+  return typeof pid === "number" && Number.isSafeInteger(pid) && pid > 0;
+}
+__name(isValidPid, "isValidPid");
+function parseServiceInfo(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return null;
+  }
+  const info = value;
+  const owner = info.owner ?? "channel";
+  if (owner !== "channel" && owner !== "serve") return null;
+  if (!isValidPid(info.pid) || typeof info.startedAt !== "string" || Number.isNaN(Date.parse(info.startedAt)) || !Array.isArray(info.channels) || !info.channels.every((channel) => typeof channel === "string")) {
+    return null;
+  }
+  if (info.servePid !== void 0 && !isValidPid(info.servePid)) return null;
+  if (info.workerPid !== void 0 && !isValidPid(info.workerPid)) return null;
+  if (info.procStart !== void 0 && info.procStart !== null && typeof info.procStart !== "string") {
+    return null;
+  }
+  if (info.pidNs !== void 0 && info.pidNs !== null && typeof info.pidNs !== "number") {
+    return null;
+  }
+  const workers = parseServiceInfoWorkers(info.workers);
+  if (workers === null) return null;
+  return {
+    owner,
+    pid: info.pid,
+    ...info.procStart !== void 0 ? { procStart: info.procStart } : {},
+    ...info.pidNs !== void 0 ? { pidNs: info.pidNs } : {},
+    startedAt: info.startedAt,
+    channels: info.channels,
+    ...info.servePid !== void 0 ? { servePid: info.servePid } : {},
+    ...info.workerPid !== void 0 ? { workerPid: info.workerPid } : {},
+    ...workers !== void 0 ? { workers } : {}
+  };
+}
+__name(parseServiceInfo, "parseServiceInfo");
+function parseServiceInfoWorkers(value) {
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value)) return null;
+  const workers = [];
+  for (const raw of value) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+      return null;
+    }
+    const worker = raw;
+    if (!Array.isArray(worker.channels) || !worker.channels.every((channel) => typeof channel === "string")) {
+      return null;
+    }
+    if (worker.workspaceId !== void 0 && typeof worker.workspaceId !== "string") {
+      return null;
+    }
+    if (worker.workspaceCwd !== void 0 && typeof worker.workspaceCwd !== "string") {
+      return null;
+    }
+    if (worker.workerPid !== void 0 && !isValidPid(worker.workerPid)) {
+      return null;
+    }
+    workers.push({
+      channels: worker.channels,
+      ...worker.workspaceId !== void 0 ? { workspaceId: worker.workspaceId } : {},
+      ...worker.workspaceCwd !== void 0 ? { workspaceCwd: worker.workspaceCwd } : {},
+      ...worker.workerPid !== void 0 ? { workerPid: worker.workerPid } : {}
+    });
+  }
+  return workers;
+}
+__name(parseServiceInfoWorkers, "parseServiceInfoWorkers");
+function unlinkPidFile(filePath) {
+  try {
+    unlinkSync(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(unlinkPidFile, "unlinkPidFile");
+function bootIdOf(procStart) {
+  if (procStart == null) return null;
+  const separator = procStart.indexOf(":");
+  return separator === -1 ? null : procStart.slice(0, separator);
+}
+__name(bootIdOf, "bootIdOf");
+function isLocalIdentity(info) {
+  if (info.pidNs !== void 0 && info.pidNs !== readPidNamespaceId()) {
+    return false;
+  }
+  const recordBootId = bootIdOf(info.procStart);
+  return recordBootId === null || recordBootId === readLocalBootId();
+}
+__name(isLocalIdentity, "isLocalIdentity");
+function isOwnServeReservation(info, servePid) {
+  return info !== null && info.owner === "serve" && info.pid === servePid && info.servePid === servePid && isLocalIdentity(info);
+}
+__name(isOwnServeReservation, "isOwnServeReservation");
+function withPidFileLock(operation) {
+  const filePath = pidFilePath();
+  return withChannelPidfileLock(filePath, () => operation(filePath));
+}
+__name(withPidFileLock, "withPidFileLock");
+function readServiceInfo() {
+  const filePath = pidFilePath();
+  if (!existsSync(filePath)) return null;
+  try {
+    return withChannelPidfileLock(
+      filePath,
+      () => readServiceInfoRecord(filePath, true)
+    );
+  } catch {
+    return readServiceInfoRecord(filePath, false);
+  }
+}
+__name(readServiceInfo, "readServiceInfo");
+function readServiceInfoRecord(filePath, sweep) {
+  if (!existsSync(filePath)) return null;
+  let raw;
+  try {
+    raw = readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    if (sweep) unlinkPidFile(filePath);
+    return null;
+  }
+  const info = parseServiceInfo(parsed);
+  if (!info) {
+    if (sweep) unlinkPidFile(filePath);
+    return null;
+  }
+  if (!isLocalIdentity(info)) {
+    return null;
+  }
+  if (!isSameProcess(info.pid, info.procStart)) {
+    if (sweep) unlinkPidFile(filePath);
+    return null;
+  }
+  return info;
+}
+__name(readServiceInfoRecord, "readServiceInfoRecord");
+function writeInfo(info, flag = "w") {
+  const filePath = pidFilePath();
+  const dir = path2.dirname(filePath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(filePath, JSON.stringify(info, null, 2), {
+    encoding: "utf-8",
+    flag
+  });
+}
+__name(writeInfo, "writeInfo");
+function fileExistsError(message) {
+  const err = new Error(message);
+  err.code = "EEXIST";
+  return err;
+}
+__name(fileExistsError, "fileExistsError");
+function writeInfoExclusive(info) {
+  const filePath = pidFilePath();
+  try {
+    writeInfo(info, "wx");
+  } catch (err) {
+    if (err.code !== "EEXIST") throw err;
+    let existing = null;
+    try {
+      existing = parseServiceInfo(JSON.parse(readFileSync(filePath, "utf-8")));
+    } catch {
+      throw err;
+    }
+    if (existing && !isLocalIdentity(existing)) {
+      const conflict = new Error(
+        `Channel service pidfile ${filePath} holds a record this machine cannot verify, written before a reboot or by another machine or PID namespace sharing this home. Confirm no channel service is running, then delete that file to start again.`
+      );
+      conflict.code = "channel_service_conflict";
+      throw conflict;
+    }
+    if (existing && isSameProcess(existing.pid, existing.procStart)) {
+      throw err;
+    }
+    unlinkPidFile(filePath);
+    writeInfo(info, "wx");
+  }
+}
+__name(writeInfoExclusive, "writeInfoExclusive");
+function readPidfileProcessToken(pid) {
+  let procStart = readProcStartToken(pid);
+  if (process.platform !== "linux" || procStart !== null) return procStart;
+  procStart = readProcStartToken(pid);
+  if (procStart !== null) return procStart;
+  throw new Error(
+    `Unable to read the process start token for PID ${pid}; refusing to write an impersonable Channel pidfile.`
+  );
+}
+__name(readPidfileProcessToken, "readPidfileProcessToken");
+function readPidfileNamespaceId() {
+  let pidNs = readPidNamespaceId();
+  if (process.platform !== "linux" || pidNs !== null) return pidNs;
+  pidNs = readPidNamespaceId();
+  if (pidNs !== null) return pidNs;
+  throw new Error(
+    "Unable to read the PID namespace id; refusing to write an unreclaimable Channel pidfile."
+  );
+}
+__name(readPidfileNamespaceId, "readPidfileNamespaceId");
+function writeServiceInfo(channels) {
+  const info = {
+    owner: "channel",
+    pid: process.pid,
+    procStart: readPidfileProcessToken(process.pid),
+    pidNs: readPidfileNamespaceId(),
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    channels
+  };
+  withPidFileLock(() => writeInfoExclusive(info));
+}
+__name(writeServiceInfo, "writeServiceInfo");
+function writeServeServiceInfo({
+  channels,
+  servePid = process.pid,
+  workerPid,
+  workers
+}) {
+  const buildInfo = /* @__PURE__ */ __name((startedAt, procStart) => ({
+    owner: "serve",
+    pid: servePid,
+    procStart,
+    pidNs: readPidfileNamespaceId(),
+    startedAt,
+    channels,
+    servePid,
+    ...workerPid !== void 0 ? { workerPid } : {},
+    ...workers !== void 0 ? { workers } : {}
+  }), "buildInfo");
+  withPidFileLock((filePath) => {
+    let fd;
+    try {
+      fd = openSync(filePath, constants.O_RDWR | constants.O_NOFOLLOW);
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        writeInfo(
+          buildInfo(
+            (/* @__PURE__ */ new Date()).toISOString(),
+            readPidfileProcessToken(servePid)
+          ),
+          "wx"
+        );
+        return;
+      }
+      throw err;
+    }
+    try {
+      let existing = null;
+      try {
+        existing = parseServiceInfo(JSON.parse(readFileSync(fd, "utf-8")));
+      } catch {
+      }
+      if (!isOwnServeReservation(existing, servePid)) {
+        throw fileExistsError(
+          "Channel service pidfile is owned by another process."
+        );
+      }
+      const info = buildInfo(
+        existing.startedAt,
+        existing.procStart ?? readPidfileProcessToken(servePid)
+      );
+      ftruncateSync(fd, 0);
+      writeSync(fd, JSON.stringify(info, null, 2), 0, "utf-8");
+    } finally {
+      closeSync(fd);
+    }
+  });
+}
+__name(writeServeServiceInfo, "writeServeServiceInfo");
+function reserveServeServiceInfo({
+  channels,
+  servePid = process.pid
+}) {
+  const info = {
+    owner: "serve",
+    pid: servePid,
+    procStart: readPidfileProcessToken(servePid),
+    pidNs: readPidfileNamespaceId(),
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    channels,
+    servePid
+  };
+  withPidFileLock(() => writeInfoExclusive(info));
+}
+__name(reserveServeServiceInfo, "reserveServeServiceInfo");
+function removeServiceInfo(expected) {
+  try {
+    withPidFileLock((filePath) => {
+      if (!expected) {
+        if (existsSync(filePath)) unlinkPidFile(filePath);
+        return;
+      }
+      try {
+        const current = parseServiceInfo(
+          JSON.parse(readFileSync(filePath, "utf-8"))
+        );
+        if (current?.owner === expected.owner && current.pid === expected.pid && current.procStart === expected.procStart && current.startedAt === expected.startedAt) {
+          unlinkPidFile(filePath);
+        }
+      } catch {
+      }
+    });
+  } catch {
+  }
+}
+__name(removeServiceInfo, "removeServiceInfo");
+function removeServeServiceInfo(servePid = process.pid) {
+  try {
+    return withPidFileLock((filePath) => {
+      if (!existsSync(filePath)) return false;
+      let parsed;
+      try {
+        parsed = JSON.parse(readFileSync(filePath, "utf-8"));
+      } catch {
+        return false;
+      }
+      if (!isOwnServeReservation(parseServiceInfo(parsed), servePid)) {
+        return false;
+      }
+      return unlinkPidFile(filePath);
+    });
+  } catch {
+    return false;
+  }
+}
+__name(removeServeServiceInfo, "removeServeServiceInfo");
+function signalService(pid, signal = "SIGTERM", procStart) {
+  if (!isValidPid(pid)) {
+    return "refused";
+  }
+  if (procStart != null) {
+    const current = readProcStartToken(pid) ?? readProcStartToken(pid);
+    if (current !== procStart) return "refused";
+  }
+  try {
+    process.kill(pid, signal);
+    return "sent";
+  } catch (err) {
+    return err.code === "EPERM" ? "not-permitted" : "refused";
+  }
+}
+__name(signalService, "signalService");
+async function waitForExit(pid, timeoutMs = 5e3, pollMs = 200, procStart) {
+  const isOriginalProcessAlive = /* @__PURE__ */ __name(() => isSameProcess(pid, procStart), "isOriginalProcessAlive");
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (!isOriginalProcessAlive()) return true;
+    await new Promise((r) => setTimeout(r, pollMs));
+  }
+  return !isOriginalProcessAlive();
+}
+__name(waitForExit, "waitForExit");
+
+export {
+  pidFilePath,
+  readServiceInfo,
+  writeServiceInfo,
+  writeServeServiceInfo,
+  reserveServeServiceInfo,
+  removeServiceInfo,
+  removeServeServiceInfo,
+  signalService,
+  waitForExit
+};

package/chunks/{chunk-PQSCGZT2.js → chunk-NPKCVSXX.js}

@@ -244,6 +244,19 @@ function convertLlmToolParametersToOpenAI(parameters) {
 }
 __name(convertLlmToolParametersToOpenAI, "convertLlmToolParametersToOpenAI");
 var grammarSchemaValidationCache = /* @__PURE__ */ new WeakMap();
+var PARAMETERLESS_SCHEMA_KEYS = /* @__PURE__ */ new Set([
+  "$comment",
+  "$schema",
+  "additionalProperties",
+  "deprecated",
+  "description",
+  "examples",
+  "properties",
+  "readOnly",
+  "title",
+  "type",
+  "writeOnly"
+]);
 function isStrictlyValidSchema(schema) {
   const cached = grammarSchemaValidationCache.get(schema);
   if (cached !== void 0) {
@@ -278,13 +291,24 @@ async function convertLlmToolsToOpenAI(llmTools, schemaCompliance = "auto") {
             );
           }
           if (parameters) {
-            const sourceSchema = func.parametersJsonSchema;
-            const canValidateLocally = typeof sourceSchema === "object" && sourceSchema !== null && !Array.isArray(sourceSchema) && !("$id" in sourceSchema) && isStrictlyValidSchema(sourceSchema);
+            const sourceSchema = typeof func.parametersJsonSchema === "object" && func.parametersJsonSchema !== null && !Array.isArray(func.parametersJsonSchema) ? func.parametersJsonSchema : void 0;
+            const canValidateLocally = sourceSchema !== void 0 && !("$id" in sourceSchema) && isStrictlyValidSchema(sourceSchema);
+            const sourceProperties = sourceSchema?.["properties"];
+            const sourceAdditionalProperties = sourceSchema?.["additionalProperties"];
+            const hasEmptyProperties = typeof sourceProperties === "object" && sourceProperties !== null && !Array.isArray(sourceProperties) && Object.keys(sourceProperties).length === 0;
+            const declaresEmptyArgumentList = sourceSchema !== void 0 && (hasEmptyProperties && (sourceAdditionalProperties === false || sourceAdditionalProperties === void 0) || sourceProperties === void 0 && sourceAdditionalProperties === false) && Object.keys(sourceSchema).every(
+              (key) => PARAMETERLESS_SCHEMA_KEYS.has(key)
+            );
             parameters = convertSchema(parameters, schemaCompliance);
             parameters = relaxSchemaForFunctionCalling(
               parameters,
               canValidateLocally
             );
+            if (canValidateLocally && declaresEmptyArgumentList && parameters["type"] === "object" && Object.keys(parameters).every(
+              (key) => PARAMETERLESS_SCHEMA_KEYS.has(key)
+            )) {
+              parameters = void 0;
+            }
           }
           openAITools.push({
             type: "function",

package/chunks/{chunk-7RXOEUFF.js → chunk-NX7ZTXFF.js}

@@ -12,7 +12,7 @@ import {
 } from "./chunk-MR3PXB6E.js";
 import {
   ideContextStore
-} from "./chunk-43CI6YWJ.js";
+} from "./chunk-HJ5UJQQL.js";
 import {
   require_proper_lockfile
 } from "./chunk-MLXTMF7H.js";

package/chunks/{chunk-G5QLLD53.js → chunk-OXR34GCD.js}

@@ -4,7 +4,7 @@ import {
   isActiveWorkflowStatus,
   isTerminalWorkflowStatus,
   isWorkflowRunPersistenceActive
-} from "./chunk-43CI6YWJ.js";
+} from "./chunk-HJ5UJQQL.js";
 import {
   atomicWriteFile
 } from "./chunk-XFFRI3WM.js";
@@ -881,6 +881,17 @@ function createWorkflowSandbox(opts) {
           isAbort = false;
         }
         if (isAbort || __b.isRunAborted()) vmErr.__wfAbort = true;
+        var isRunFailure = false;
+        try {
+          isRunFailure = !!(hostErr && (
+            hostErr.__wfRunFailure === true ||
+            hostErr.name === 'WorkflowBudgetExceededError' ||
+            hostErr.name === 'WorkflowAgentCapExceededError'
+          ));
+        } catch (e) {
+          isRunFailure = false;
+        }
+        if (isRunFailure) vmErr.__wfRunFailure = true;
         vmErr.__wfDispatchFailed = true;
         return vmErr;
       }
@@ -1873,6 +1884,7 @@ function toSnapshot(task) {
     })),
     agentsDispatched: task.agentsDispatched,
     agentsCompleted: task.agentsCompleted,
+    agentsRespawned: task.agentsRespawned ?? 0,
     tokensSpent: task.tokensSpent,
     tokenBudgetTotal: task.tokenBudgetTotal,
     perPhaseTokens: Array.from(task.perPhaseTokens.entries()),
@@ -2050,7 +2062,7 @@ function isWorkflowSnapshot(value) {
   const dispatches = value["dispatches"];
   const events = value["events"];
   const perPhaseTokens = value["perPhaseTokens"];
-  return typeof value["runId"] === "string" && value["runId"].length > 0 && isOptionalString(value["toolUseId"]) && isOptionalString(value["description"]) && isOptionalString(value["workflowName"]) && isOptionalString(value["sourceRunId"]) && (value["startMode"] === void 0 || value["startMode"] === "retry" || value["startMode"] === "rerun") && isWorkflowMeta(value["meta"]) && (status === "completed" || status === "failed" || status === "cancelled") && typeof value["script"] === "string" && isOptionalString(value["scriptPath"]) && isStringArray(value["phases"]) && (phaseVisits === void 0 || Array.isArray(phaseVisits) && phaseVisits.every(isWorkflowPhaseVisit)) && (dispatches === void 0 || Array.isArray(dispatches) && dispatches.every(isWorkflowDispatch)) && (events === void 0 || Array.isArray(events) && events.every(isWorkflowEvent)) && isFiniteNumber(value["agentsDispatched"]) && isFiniteNumber(value["agentsCompleted"]) && isFiniteNumber(value["tokensSpent"]) && (value["tokenBudgetTotal"] === null || isFiniteNumber(value["tokenBudgetTotal"])) && Array.isArray(perPhaseTokens) && perPhaseTokens.every(
+  return typeof value["runId"] === "string" && value["runId"].length > 0 && isOptionalString(value["toolUseId"]) && isOptionalString(value["description"]) && isOptionalString(value["workflowName"]) && isOptionalString(value["sourceRunId"]) && (value["startMode"] === void 0 || value["startMode"] === "retry" || value["startMode"] === "rerun") && isWorkflowMeta(value["meta"]) && (status === "completed" || status === "failed" || status === "cancelled") && typeof value["script"] === "string" && isOptionalString(value["scriptPath"]) && isStringArray(value["phases"]) && (phaseVisits === void 0 || Array.isArray(phaseVisits) && phaseVisits.every(isWorkflowPhaseVisit)) && (dispatches === void 0 || Array.isArray(dispatches) && dispatches.every(isWorkflowDispatch)) && (events === void 0 || Array.isArray(events) && events.every(isWorkflowEvent)) && isFiniteNumber(value["agentsDispatched"]) && isFiniteNumber(value["agentsCompleted"]) && (value["agentsRespawned"] === void 0 || isFiniteNumber(value["agentsRespawned"])) && isFiniteNumber(value["tokensSpent"]) && (value["tokenBudgetTotal"] === null || isFiniteNumber(value["tokenBudgetTotal"])) && Array.isArray(perPhaseTokens) && perPhaseTokens.every(
     (entry) => Array.isArray(entry) && entry.length === 2 && (entry[0] === null || typeof entry[0] === "string") && isFiniteNumber(entry[1])
   ) && isStringArray(value["recentLogs"]) && isFiniteNumber(value["startTime"]) && (value["endTime"] === void 0 || isFiniteNumber(value["endTime"])) && isOptionalString(value["error"]);
 }

package/chunks/{chunk-VHPG7BH6.js → chunk-PDN7FJZV.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   performStandaloneUpdate
-} from "./chunk-LUVXLLMS.js";
+} from "./chunk-IR6JKBAP.js";
 import {
   updateEventEmitter
 } from "./chunk-YAF2MQZ6.js";

package/chunks/{chunk-UHUT4IDM.js → chunk-PFKGV6PO.js}

@@ -255,15 +255,15 @@ function ensureBuiltins() {
   if (!builtinsPromise) {
     builtinsPromise = (async () => {
       const labelled = [
-        { name: "telegram", promise: import("./dist-OR2ZQTXZ.js") },
-        { name: "weixin", promise: import("./dist-WZTUKIDR.js") },
-        { name: "dingtalk", promise: import("./dist-STAGIFNB.js") },
-        { name: "dws", promise: import("./dist-24TCWK5H.js") },
-        { name: "wecom", promise: import("./dist-NQ2636VT.js") },
-        { name: "feishu", promise: import("./dist-FDISN4AK.js") },
-        { name: "qqbot", promise: import("./dist-XJ25G6OH.js") },
-        { name: "github", promise: import("./dist-5I4HLUTO.js") },
-        { name: "gitlab", promise: import("./dist-M4CBX53H.js") }
+        { name: "telegram", promise: import("./dist-F6JLAJLE.js") },
+        { name: "weixin", promise: import("./dist-NP7QKLVG.js") },
+        { name: "dingtalk", promise: import("./dist-6YDUH3BB.js") },
+        { name: "dws", promise: import("./dist-Y5KC3IHW.js") },
+        { name: "wecom", promise: import("./dist-F34J4FZX.js") },
+        { name: "feishu", promise: import("./dist-ZDNJK74R.js") },
+        { name: "qqbot", promise: import("./dist-BNQVF565.js") },
+        { name: "github", promise: import("./dist-XLV33CLY.js") },
+        { name: "gitlab", promise: import("./dist-UFTFGI6I.js") }
       ];
       const results = await Promise.allSettled(labelled.map((l) => l.promise));
       for (let i = 0; i < results.length; i++) {

package/chunks/{chunk-NFIDVZND.js → chunk-QB3KS3N3.js}

@@ -1,8 +1,9 @@
 // Force strict mode and setup for ESM
 "use strict";
 import {
+  isDocumentNavigation,
   require_express
-} from "./chunk-IRKQ4YYX.js";
+} from "./chunk-SVWWF5TZ.js";
 import {
   isLoopbackAddress
 } from "./chunk-DMEUXLSS.js";
@@ -92,24 +93,6 @@ function buildWebShellCsp(frameAncestors = [], frameSrcOrigins = loopbackSandbox
 }
 __name(buildWebShellCsp, "buildWebShellCsp");
 var WEB_SHELL_CSP = buildWebShellCsp();
-function isDocumentNavigation(req) {
-  const fetchMode = req.headers["sec-fetch-mode"];
-  const fetchDest = req.headers["sec-fetch-dest"];
-  const accept = req.headers.accept ?? "";
-  return fetchMode === "navigate" || fetchDest === "document" || accept.trim().toLowerCase().startsWith("text/html");
-}
-__name(isDocumentNavigation, "isDocumentNavigation");
-var SESSION_DEEP_LINK_PATH = /^\/session\/[^/]+\/?$/u;
-function isPreAuthWebShellRequest(req) {
-  if (req.method !== "GET" && req.method !== "HEAD") return false;
-  const reqPath = req.path.toLowerCase();
-  if (reqPath === "/" || // Express non-strict routing compiles `/` to `/^(?:\/)(?:\/$)?$/i`, so
-  // a raw `//` also matches `app.get('/')` pre-auth (but `///` does not).
-  reqPath === "//" || reqPath === "/assets" || reqPath.startsWith("/assets/") || reqPath === "/mcp-app-sandbox")
-    return true;
-  return SESSION_DEEP_LINK_PATH.test(reqPath) && isDocumentNavigation(req);
-}
-__name(isPreAuthWebShellRequest, "isPreAuthWebShellRequest");
 function createSendIndex(webShellDir, frameAncestors = []) {
   const indexPath = path.join(webShellDir, "index.html");
   return (req, res) => {
@@ -193,8 +176,6 @@ export {
   buildWebShellPermissionsPolicy,
   buildWebShellCsp,
   WEB_SHELL_CSP,
-  isDocumentNavigation,
-  isPreAuthWebShellRequest,
   mountWebShellAssets,
   mountWebShellSpaFallback
 };