@qwen-code/qwen-code 0.19.7 → 0.19.8-nightly.20260710.205430235

package/chunks/create-sub-session-EVYZYAE3.js

@@ -0,0 +1,364 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  writeStderrLine
+} from "./chunk-JM7BYJO5.js";
+import {
+  stripTerminalControlSequences
+} from "./chunk-ZDAZSR2O.js";
+import "./chunk-5P5XGNYH.js";
+import "./chunk-SKAZWEV5.js";
+import "./chunk-K5PGHDBN.js";
+import "./chunk-2GUVUHJY.js";
+import "./chunk-W7EEOR7D.js";
+import "./chunk-42XGFRJS.js";
+import "./chunk-X2XNQQJI.js";
+import "./chunk-IAMRWMFU.js";
+import "./chunk-2MPVVENX.js";
+import "./chunk-ZTQ26VBE.js";
+import "./chunk-2SZOMGOR.js";
+import "./chunk-MLZQVCF3.js";
+import "./chunk-LQ7TMOCE.js";
+import "./chunk-E5A7LHNN.js";
+import "./chunk-ZJQBTFJ6.js";
+import "./chunk-GO6LNQXT.js";
+import "./chunk-NQKLOAVJ.js";
+import "./chunk-WMPVYQ4P.js";
+import "./chunk-TLWA7TPR.js";
+import "./chunk-QYNNN7BK.js";
+import "./chunk-5ZVIYNLN.js";
+import "./chunk-E6US47KI.js";
+import "./chunk-UWCTAVOD.js";
+import "./chunk-OFEVLU4C.js";
+import "./chunk-OMX7CUOE.js";
+import "./chunk-OACJLMLD.js";
+import "./chunk-SUAKHHK7.js";
+import "./chunk-NY2ZOFMM.js";
+import "./chunk-KS2FRTYI.js";
+import "./chunk-IJRL2S3D.js";
+import "./chunk-AHNJGLFV.js";
+import "./chunk-22IFUCVR.js";
+import "./chunk-7LTB54MK.js";
+import "./chunk-SIUQ3YYX.js";
+import "./chunk-HW4N45EE.js";
+import "./chunk-SS5P6JM6.js";
+import "./chunk-IRJWHZWU.js";
+import "./chunk-SYCJMSIJ.js";
+import "./chunk-55ZMG67I.js";
+import "./chunk-H6BD2ELD.js";
+import "./chunk-5IFG2VC4.js";
+import "./chunk-64WXLC72.js";
+import "./chunk-H6EMK6QK.js";
+import {
+  createDebugLogger
+} from "./chunk-22MNNNXE.js";
+import "./chunk-ZERZSAZL.js";
+import "./chunk-QN5NZ3UQ.js";
+import "./chunk-BR4QREVK.js";
+import "./chunk-Z2Z3GUXZ.js";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/serve/create-sub-session.ts
+init_esbuild_shims();
+import { randomUUID } from "node:crypto";
+var log = createDebugLogger("SUB_SESSION");
+var MAX_CONCURRENT_SUB_SESSIONS_PER_CALLER = 5;
+var MAX_CONCURRENT_SUB_SESSIONS_TOTAL = 20;
+var FIRST_TURN_TIMEOUT_MS = 5 * 6e4;
+var SENT_MODE_DRAIN_TIMEOUT_MS = 30 * 6e4;
+var MAX_RESULT_CHARS = 32e3;
+var MAX_NAME_LENGTH = 60;
+var MAX_TRACKED_SPAWNED_SESSIONS = 1024;
+var BIDI_CONTROL_MARKS = new RegExp(
+  "[\\u061C\\u200E\\u200F\\u202A-\\u202E\\u2066-\\u2069]",
+  "g"
+);
+function subSessionName(label) {
+  const cleaned = stripTerminalControlSequences(label).replace(BIDI_CONTROL_MARKS, "").trim().replace(/\s+/g, " ");
+  let short = cleaned;
+  if (cleaned.length > MAX_NAME_LENGTH) {
+    let cut = MAX_NAME_LENGTH - 1;
+    const boundary = cleaned.charCodeAt(cut - 1);
+    if (boundary >= 55296 && boundary <= 56319) cut -= 1;
+    short = `${cleaned.slice(0, cut)}\u2026`;
+  }
+  return `\u{1F9F5} ${short}`;
+}
+__name(subSessionName, "subSessionName");
+async function awaitFirstTurn(bridge, sessionId, promptId, lastEventId, timeoutMs, stopSignal) {
+  const ac = new AbortController();
+  let timedOut = false;
+  const timer = setTimeout(() => {
+    timedOut = true;
+    ac.abort();
+  }, timeoutMs);
+  if (typeof timer.unref === "function") timer.unref();
+  const composed = stopSignal ? AbortSignal.any([ac.signal, stopSignal]) : ac.signal;
+  let acc = "";
+  let truncated = false;
+  let stopReason;
+  const appendChunk = /* @__PURE__ */ __name((text) => {
+    if (truncated) return;
+    if (acc.length + text.length > MAX_RESULT_CHARS) {
+      let cut = Math.max(0, MAX_RESULT_CHARS - acc.length);
+      if (cut > 0) {
+        const code = text.charCodeAt(cut - 1);
+        if (code >= 55296 && code <= 56319) cut -= 1;
+      }
+      acc += text.slice(0, cut);
+      truncated = true;
+    } else {
+      acc += text;
+    }
+  }, "appendChunk");
+  try {
+    for await (const e of bridge.subscribeEvents(sessionId, {
+      lastEventId,
+      signal: composed
+    })) {
+      if (e.type === "session_update") {
+        const d = e.data;
+        if (d?.update?.sessionUpdate === "agent_message_chunk" && typeof d.update.content?.text === "string") {
+          appendChunk(d.update.content.text);
+        }
+      } else if (e.type === "turn_complete") {
+        const d = e.data;
+        if (d?.promptId === promptId) {
+          stopReason = d.stopReason ?? "end_turn";
+          break;
+        }
+      } else if (e.type === "turn_error") {
+        const d = e.data;
+        if (d?.promptId === promptId) {
+          stopReason = "error";
+          if (d.message && !truncated) {
+            const suffix = `${acc ? "\n" : ""}[turn error] ${d.message}`;
+            if (acc.length + suffix.length <= MAX_RESULT_CHARS) {
+              acc += suffix;
+            } else {
+              truncated = true;
+            }
+          }
+          break;
+        }
+      }
+    }
+  } finally {
+    clearTimeout(timer);
+    ac.abort();
+  }
+  if (stopReason === void 0) {
+    stopReason = stopSignal?.aborted ? "shutdown" : timedOut ? "timeout" : "incomplete";
+  }
+  if (truncated) acc += "\n[\u2026output truncated]";
+  return { result: acc, stopReason };
+}
+__name(awaitFirstTurn, "awaitFirstTurn");
+function createSubSessionLauncher(opts) {
+  const { getBridge, boundWorkspace } = opts;
+  const firstTurnTimeoutMs = opts.firstTurnTimeoutMs ?? FIRST_TURN_TIMEOUT_MS;
+  const sentModeDrainTimeoutMs = opts.sentModeDrainTimeoutMs ?? SENT_MODE_DRAIN_TIMEOUT_MS;
+  const inflight = /* @__PURE__ */ new Map();
+  const spawnedSessionIds = /* @__PURE__ */ new Set();
+  const stopAc = new AbortController();
+  let inflightTotal = 0;
+  const release = /* @__PURE__ */ __name((key) => {
+    const n = (inflight.get(key) ?? 1) - 1;
+    if (n <= 0) inflight.delete(key);
+    else inflight.set(key, n);
+    inflightTotal = Math.max(0, inflightTotal - 1);
+  }, "release");
+  const rememberSpawned = /* @__PURE__ */ __name((sessionId) => {
+    spawnedSessionIds.add(sessionId);
+    while (spawnedSessionIds.size > MAX_TRACKED_SPAWNED_SESSIONS) {
+      const oldest = spawnedSessionIds.values().next().value;
+      if (oldest === void 0) break;
+      spawnedSessionIds.delete(oldest);
+    }
+  }, "rememberSpawned");
+  const launch = /* @__PURE__ */ __name(async (info) => {
+    if (stopAc.signal.aborted) {
+      throw new Error(
+        "The daemon is shutting down; cannot create a sub-session."
+      );
+    }
+    const bridge = getBridge();
+    if (!bridge) {
+      throw new Error("Session bridge is not available.");
+    }
+    if (spawnedSessionIds.has(info.callerSessionId)) {
+      throw new Error(
+        "A sub-session cannot create further sub-sessions (nesting is capped at one level)."
+      );
+    }
+    const key = info.callerSessionId;
+    const current = inflight.get(key) ?? 0;
+    if (current >= MAX_CONCURRENT_SUB_SESSIONS_PER_CALLER) {
+      throw new Error(
+        `Too many concurrent sub-sessions for this session (cap ${MAX_CONCURRENT_SUB_SESSIONS_PER_CALLER}); wait for one to finish.`
+      );
+    }
+    if (inflightTotal >= MAX_CONCURRENT_SUB_SESSIONS_TOTAL) {
+      throw new Error(
+        `Too many concurrent sub-sessions in this workspace (cap ${MAX_CONCURRENT_SUB_SESSIONS_TOTAL}); wait for one to finish.`
+      );
+    }
+    inflight.set(key, current + 1);
+    inflightTotal += 1;
+    let released = false;
+    const releaseOnce = /* @__PURE__ */ __name(() => {
+      if (released) return;
+      released = true;
+      release(key);
+    }, "releaseOnce");
+    let spawnedSessionId;
+    try {
+      const sub = await bridge.spawnOrAttach({
+        workspaceCwd: boundWorkspace,
+        sessionScope: "thread",
+        // force a fresh top-level session, never attach
+        ...info.model ? { modelServiceId: info.model } : {}
+      });
+      spawnedSessionId = sub.sessionId;
+      const sessionId = sub.sessionId;
+      rememberSpawned(sessionId);
+      try {
+        bridge.updateSessionMetadata(sessionId, {
+          displayName: subSessionName(info.name ?? info.prompt)
+        });
+      } catch (err) {
+        log.debug("sub-session: updateSessionMetadata failed", sessionId, err);
+      }
+      const lastEventId = bridge.getSessionLastEventId(sessionId);
+      const promptId = randomUUID();
+      const turn = bridge.sendPrompt(
+        sessionId,
+        {
+          sessionId,
+          prompt: [{ type: "text", text: info.prompt }]
+        },
+        void 0,
+        { promptId }
+      );
+      void turn.catch((err) => {
+        log.debug("sub-session: sendPrompt rejected", sessionId, String(err));
+      });
+      if (info.completion === "sent") {
+        const drainAc = new AbortController();
+        let drainTimedOut = false;
+        const drainTimer = setTimeout(() => {
+          drainTimedOut = true;
+          drainAc.abort();
+        }, sentModeDrainTimeoutMs);
+        if (typeof drainTimer.unref === "function") drainTimer.unref();
+        const drainSignal = AbortSignal.any([stopAc.signal, drainAc.signal]);
+        void (async () => {
+          try {
+            const turnSettled = turn.then(
+              () => "ok",
+              () => "rejected"
+            );
+            const drainDone = (async () => {
+              for await (const e of bridge.subscribeEvents(sessionId, {
+                lastEventId,
+                signal: drainSignal
+              })) {
+                if (e.type === "turn_complete" || e.type === "turn_error") {
+                  const d = e.data;
+                  if (d?.promptId === promptId) break;
+                }
+              }
+              return "drained";
+            })();
+            await Promise.race([turnSettled, drainDone]);
+          } catch (err) {
+            if (!(err instanceof Error && err.name === "AbortError") && !(stopAc.signal.aborted || drainAc.signal.aborted)) {
+              log.debug(
+                "sub-session: sent-mode drain error",
+                sessionId,
+                String(err)
+              );
+            }
+          } finally {
+            clearTimeout(drainTimer);
+            if (drainTimedOut) {
+              writeStderrLine(
+                `qwen serve: sub-session ${sessionId} drain timed out after ${Math.round(sentModeDrainTimeoutMs / 6e4)}min; releasing its concurrency slot (the sub-session may still be running)`
+              );
+            }
+            drainAc.abort();
+            releaseOnce();
+          }
+        })();
+        return { sessionId };
+      }
+      try {
+        const turnError = turn.then(
+          () => new Promise(() => {
+          }),
+          // never resolves on success
+          (err) => Promise.reject(
+            new Error(
+              `sub-session dispatch failed: ${err instanceof Error ? err.message : String(err)}`
+            )
+          )
+        );
+        const firstTurn = awaitFirstTurn(
+          bridge,
+          sessionId,
+          promptId,
+          lastEventId,
+          firstTurnTimeoutMs,
+          stopAc.signal
+        );
+        const { result, stopReason } = await Promise.race([
+          firstTurn,
+          turnError
+        ]);
+        return { sessionId, result, stopReason };
+      } finally {
+        releaseOnce();
+      }
+    } catch (err) {
+      releaseOnce();
+      if (spawnedSessionId !== void 0) {
+        try {
+          void bridge.closeSession(spawnedSessionId).catch(() => {
+          });
+        } catch (closeErr) {
+          log.debug(
+            "sub-session: closeSession threw",
+            spawnedSessionId,
+            closeErr
+          );
+        }
+      }
+      writeStderrLine(
+        `qwen serve: create_sub_session failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+      throw err instanceof Error ? err : new Error(String(err));
+    }
+  }, "launch");
+  return {
+    launch,
+    stop: /* @__PURE__ */ __name(() => {
+      stopAc.abort();
+    }, "stop")
+  };
+}
+__name(createSubSessionLauncher, "createSubSessionLauncher");
+export {
+  MAX_CONCURRENT_SUB_SESSIONS_PER_CALLER,
+  MAX_CONCURRENT_SUB_SESSIONS_TOTAL,
+  createSubSessionLauncher
+};
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{cron-create-JSXEIPVS.js → cron-create-2CCO2PW6.js}

@@ -9,14 +9,14 @@ import {
 } from "./chunk-ZTQ26VBE.js";
 import {
   CRON_TASKS_DISPLAY_PATH
-} from "./chunk-FV7425LN.js";
+} from "./chunk-2SZOMGOR.js";
 import "./chunk-OMX7CUOE.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-X3YGAX7V.js";
+} from "./chunk-KS2FRTYI.js";
 import "./chunk-7LTB54MK.js";
 import "./chunk-22MNNNXE.js";
 import "./chunk-Z2Z3GUXZ.js";

package/chunks/{cron-delete-OIFVEPGU.js → cron-delete-ETVTP5IV.js}

@@ -3,14 +3,14 @@
 import {
   CRON_TASKS_DISPLAY_PATH,
   removeCronTasks
-} from "./chunk-FV7425LN.js";
+} from "./chunk-2SZOMGOR.js";
 import "./chunk-OMX7CUOE.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-X3YGAX7V.js";
+} from "./chunk-KS2FRTYI.js";
 import "./chunk-7LTB54MK.js";
 import {
   getErrorMessage

package/chunks/{cron-list-D4ZX4IOE.js → cron-list-FS3KWOY5.js}

@@ -6,14 +6,14 @@ import {
 import {
   CRON_TASKS_DISPLAY_PATH,
   readCronTasks
-} from "./chunk-FV7425LN.js";
+} from "./chunk-2SZOMGOR.js";
 import "./chunk-OMX7CUOE.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-X3YGAX7V.js";
+} from "./chunk-KS2FRTYI.js";
 import "./chunk-7LTB54MK.js";
 import "./chunk-22MNNNXE.js";
 import "./chunk-Z2Z3GUXZ.js";