@qwen-code/qwen-code 0.22.2 → 0.22.3-nightly.20260831.3a0c4c6108

package/chunks/send-message-WPZRCJOB.js

@@ -0,0 +1,442 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  isInProcessRecipient,
+  sendToPeer
+} from "./chunk-AYYKUUKP.js";
+import "./chunk-B2RIIK3K.js";
+import {
+  LEADER_NAME,
+  findMemberByName
+} from "./chunk-373DQUVA.js";
+import {
+  getPlanRequiredTeammatePreApprovalMessage,
+  isPlanRequiredTeammateAwaitingApproval
+} from "./chunk-VYSZUQGU.js";
+import "./chunk-JX6XHPTX.js";
+import "./chunk-26SIKQIC.js";
+import {
+  getAgentName
+} from "./chunk-S6LOFUVP.js";
+import "./chunk-KHP66DFN.js";
+import "./chunk-D7D3HSYQ.js";
+import "./chunk-YKADANK6.js";
+import "./chunk-AQ37AY7B.js";
+import "./chunk-ODZF64DM.js";
+import {
+  BaseDeclarativeTool,
+  BaseToolInvocation,
+  ToolDisplayNames,
+  ToolNames
+} from "./chunk-LYSZVCCD.js";
+import "./chunk-EAHOJF6V.js";
+import "./chunk-TBWQLLFO.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/tools/send-message.ts
+init_esbuild_shims();
+var SendMessageInvocation = class extends BaseToolInvocation {
+  constructor(config, params) {
+    super(params);
+    this.config = config;
+  }
+  static {
+    __name(this, "SendMessageInvocation");
+  }
+  getDescription() {
+    if (this.params.task_id) {
+      return `Send message to task ${this.params.task_id}`;
+    }
+    const preview = this.params.summary ?? this.params.message.slice(0, 50);
+    return `Send to ${this.params.to}: ${preview}`;
+  }
+  /**
+   * Send-message routes free-form text into a running background task or a
+   * teammate, which will then execute it as a new instruction with full
+   * tool access. Treat it as a privileged sink — the L4 default must not be
+   * 'allow', because that would let the scheduler auto-approve in
+   * AUTO mode (where 'allow' short-circuits the classifier). 'ask' lets
+   * AUTO route through the classifier so the destination and message text
+   * can be inspected.
+   */
+  async getDefaultPermission() {
+    return "ask";
+  }
+  /**
+   * Set when the peer route was consulted and found cross-session
+   * messaging off here, so the final error can say so instead of
+   * claiming a lookup that never happened.
+   */
+  peerMessagingOff = false;
+  /**
+   * Try to deliver to another Qwen Code session on this machine.
+   *
+   * Returns null when this is not a peer send at all — cross-session
+   * messaging is off here, or the name resolved to nothing and there is
+   * nothing to suggest — so the caller can fall through to its own error.
+   * Every other outcome, including failures, is a result: each one has a
+   * different next step for the model.
+   */
+  async trySendToPeer(to, teamFile) {
+    const teamActive = teamFile !== void 0;
+    let approvalMode;
+    try {
+      approvalMode = this.config.getApprovalMode();
+    } catch {
+      approvalMode = null;
+    }
+    const outcome = await sendToPeer({
+      target: to,
+      message: this.params.message,
+      approvalMode,
+      // Addresses this tool would keep in-process must never be handed
+      // back to the model as a peer address, bare.
+      isReserved: /* @__PURE__ */ __name((address) => isInProcessRecipient(address, teamFile), "isReserved")
+    });
+    switch (outcome.kind) {
+      case "disabled":
+        this.peerMessagingOff = true;
+        return null;
+      case "self": {
+        const msg = `"${outcome.name}" is this session's own name \u2014 a session cannot message itself. Use list_agents to see the other sessions you can reach.`;
+        return {
+          llmContent: msg,
+          returnDisplay: "That is this session.",
+          error: { message: msg, type: "send_message_not_found" /* SEND_MESSAGE_NOT_FOUND */ }
+        };
+      }
+      case "not-found": {
+        if (outcome.suggestions.length === 0) return null;
+        const msg = `No reachable session${teamActive ? " and no teammate" : ""} is named "${to}". Did you mean: ${outcome.suggestions.join(", ")}? Use list_agents to see who is reachable.`;
+        return {
+          llmContent: msg,
+          returnDisplay: "No such session.",
+          error: { message: msg, type: "send_message_not_found" /* SEND_MESSAGE_NOT_FOUND */ }
+        };
+      }
+      case "ambiguous": {
+        const msg = `"${to}" matches more than one live session:
+` + outcome.matches.map((line) => `  ${line}`).join("\n") + "\nRe-send with the full 'name [ref]' so it goes to the one you mean.";
+        return {
+          llmContent: msg,
+          returnDisplay: "Ambiguous recipient.",
+          error: { message: msg, type: "send_message_not_found" /* SEND_MESSAGE_NOT_FOUND */ }
+        };
+      }
+      case "failed": {
+        const msg = `Failed to send to ${outcome.address}: ${outcome.reason}`;
+        return {
+          llmContent: msg,
+          returnDisplay: "Send failed.",
+          error: { message: msg, type: "send_message_not_running" /* SEND_MESSAGE_NOT_RUNNING */ }
+        };
+      }
+      case "sent": {
+        const preview = this.params.summary ?? this.params.message.slice(0, 50);
+        return {
+          llmContent: `Sent to ${outcome.address} \u2014 another Qwen Code session on this machine, working in ${outcome.peer.cwd}. It arrives there as a marked cross-session message carrying none of your user's authority, and may be held for that session's user to review before it reaches that session's model. You will not be told whether it was delivered or held, so do not re-send; if that session replies, the reply arrives here as a <cross_session_message>.`,
+          returnDisplay: `\u201C${preview}\u201D \u2192 ${outcome.address}`
+        };
+      }
+      default: {
+        const exhaustive = outcome;
+        return exhaustive;
+      }
+    }
+  }
+  async execute(signal) {
+    if (isPlanRequiredTeammateAwaitingApproval(this.config)) {
+      const msg = getPlanRequiredTeammatePreApprovalMessage(
+        ToolNames.SEND_MESSAGE
+      );
+      return {
+        llmContent: msg,
+        returnDisplay: msg,
+        error: { message: msg }
+      };
+    }
+    if (this.params.task_id) {
+      const registry = this.config.getBackgroundTaskRegistry();
+      const entry = registry.get(this.params.task_id);
+      if (!entry) {
+        const teamManager2 = this.config.getTeamManager();
+        const teammate = teamManager2 ? findMemberByName(
+          teamManager2.getTeamFile().members,
+          this.params.task_id
+        ) : void 0;
+        const teammateHint = teammate ? ` Did you mean to message teammate "${teammate.name}"? If so, use \`to: "${teammate.name}"\` instead of \`task_id\`.` : "";
+        return {
+          llmContent: `Error: No background task found with ID "${this.params.task_id}".${teammateHint}`,
+          returnDisplay: teammate ? `Task not found; use "to" for teammate "${teammate.name}".` : "Task not found.",
+          error: {
+            message: `Task not found: ${this.params.task_id}${teammate ? `.${teammateHint}` : ""}`,
+            type: "send_message_not_found" /* SEND_MESSAGE_NOT_FOUND */
+          }
+        };
+      }
+      if (entry.resumeBlockedReason) {
+        return {
+          llmContent: `Error: Background task "${this.params.task_id}" cannot be continued: ${entry.resumeBlockedReason}`,
+          returnDisplay: "Task cannot be continued.",
+          error: {
+            message: `Task cannot be continued: ${this.params.task_id}`,
+            type: "send_message_not_running" /* SEND_MESSAGE_NOT_RUNNING */
+          }
+        };
+      }
+      if (entry.status === "paused") {
+        const resumed = await this.config.resumeBackgroundAgent(
+          this.params.task_id,
+          this.params.message
+        );
+        if (!resumed) {
+          return {
+            llmContent: `Error: Background task "${this.params.task_id}" could not be resumed.`,
+            returnDisplay: "Task could not be resumed.",
+            error: {
+              message: `Task could not be resumed: ${this.params.task_id}`,
+              type: "send_message_not_running" /* SEND_MESSAGE_NOT_RUNNING */
+            }
+          };
+        }
+        return {
+          llmContent: `Background task "${this.params.task_id}" resumed with your message as the first continuation instruction.`,
+          returnDisplay: `Resumed ${entry.description}`
+        };
+      }
+      if (entry.status === "completed") {
+        const continued = registry.continueResidentAgent(
+          this.params.task_id,
+          this.params.message
+        );
+        if (continued) {
+          return {
+            llmContent: `Background task "${this.params.task_id}" continued on its existing runtime with your message as the next instruction.`,
+            returnDisplay: `Continued ${entry.description}`
+          };
+        }
+        const revived = await this.config.reviveCompletedBackgroundAgent(
+          this.params.task_id,
+          this.params.message
+        );
+        if (!revived) {
+          return {
+            llmContent: `Error: Background task "${this.params.task_id}" could not be revived.`,
+            returnDisplay: "Task could not be revived.",
+            error: {
+              message: `Task could not be revived: ${this.params.task_id}`,
+              type: "send_message_not_running" /* SEND_MESSAGE_NOT_RUNNING */
+            }
+          };
+        }
+        return {
+          llmContent: `Background task "${this.params.task_id}" had completed; revived it with your message as the next instruction.`,
+          returnDisplay: `Revived ${entry.description}`
+        };
+      }
+      if (entry.status !== "running") {
+        return {
+          llmContent: `Error: Background task "${this.params.task_id}" is not running (status: ${entry.status}). Cannot send messages to stopped tasks.`,
+          returnDisplay: `Task not running (${entry.status}).`,
+          error: {
+            message: `Task is ${entry.status}: ${this.params.task_id}`,
+            type: "send_message_not_running" /* SEND_MESSAGE_NOT_RUNNING */
+          }
+        };
+      }
+      if (registry.isFinishing(this.params.task_id) || !registry.queueMessage(this.params.task_id, this.params.message)) {
+        const settled = await registry.waitForFinishing(
+          this.params.task_id,
+          signal
+        );
+        if (!settled) {
+          const message = `Message delivery to background task "${this.params.task_id}" was cancelled.`;
+          return {
+            llmContent: `Error: ${message}`,
+            returnDisplay: message,
+            error: {
+              message,
+              type: "send_message_not_running" /* SEND_MESSAGE_NOT_RUNNING */
+            }
+          };
+        }
+        return this.execute(signal);
+      }
+      return {
+        llmContent: `Message queued for delivery to background task "${this.params.task_id}". The task will receive it at the next tool-round boundary.`,
+        returnDisplay: `Message queued for ${entry.description}`
+      };
+    }
+    const to = this.params.to?.trim();
+    if (!to) {
+      const msg = 'Recipient "to" is required.';
+      return {
+        llmContent: msg,
+        returnDisplay: msg,
+        error: { message: msg }
+      };
+    }
+    const teamManager = this.config.getTeamManager();
+    if (to === "*") {
+      if (!teamManager) {
+        const msg = "No active team to broadcast to. Broadcasting to other Qwen Code sessions is not supported \u2014 address each session by name from list_agents.";
+        return {
+          llmContent: msg,
+          returnDisplay: "No active team for broadcast.",
+          error: { message: msg }
+        };
+      }
+      try {
+        const sender = getAgentName() ?? LEADER_NAME;
+        const { total, failedRecipients } = await teamManager.broadcast(
+          this.params.message,
+          sender
+        );
+        if (failedRecipients.length === 0) {
+          const msg2 = "Message broadcast to all teammates.";
+          return { llmContent: msg2, returnDisplay: msg2 };
+        }
+        const reached = total - failedRecipients.length;
+        if (reached === 0) {
+          const msg2 = `Broadcast failed: delivery was rejected for all ${total} recipient(s): ${failedRecipients.join(", ")}.`;
+          return {
+            llmContent: msg2,
+            returnDisplay: msg2,
+            error: { message: msg2 }
+          };
+        }
+        const msg = `Message broadcast delivered to ${reached} of ${total} recipient(s); delivery failed for: ${failedRecipients.join(", ")}. The listed recipients did not receive the message.`;
+        return { llmContent: msg, returnDisplay: msg };
+      } catch (error) {
+        const errMsg = error instanceof Error ? error.message : String(error);
+        return {
+          llmContent: `Failed to broadcast message: ${errMsg}`,
+          returnDisplay: `Failed to broadcast message: ${errMsg}`,
+          error: { message: errMsg }
+        };
+      }
+    }
+    const teamFile = teamManager?.getTeamFile();
+    const inProcessRecipient = isInProcessRecipient(to, teamFile);
+    if (!inProcessRecipient) {
+      const peerResult = await this.trySendToPeer(to, teamFile);
+      if (peerResult) return peerResult;
+    }
+    if (!teamManager) {
+      const msg = this.peerMessagingOff ? `No active team and no task_id, and cross-session messaging is not enabled in this session (agents.crossSessionMessaging), so "${to}" cannot be another session. Create a team, or pass \`task_id\` to message a background task.` : `No active team, no task_id, and no reachable session named "${to}". Create a team, pass \`task_id\` to message a background task, or use list_agents to see which sessions are reachable.`;
+      return {
+        llmContent: msg,
+        returnDisplay: msg,
+        error: { message: msg }
+      };
+    }
+    try {
+      await teamManager.sendMessage(
+        to,
+        this.params.message,
+        getAgentName() ?? LEADER_NAME,
+        this.params.summary
+      );
+      const msg = `Message sent to "${to}".`;
+      return { llmContent: msg, returnDisplay: msg };
+    } catch (error) {
+      let errMsg = error instanceof Error ? error.message : String(error);
+      if (!inProcessRecipient && /not found/i.test(errMsg)) {
+        errMsg += this.peerMessagingOff ? ` Cross-session messaging is not enabled in this session (agents.crossSessionMessaging), so another session could not have taken that name either.` : ` No reachable session has that name either; use list_agents to see who is reachable.`;
+      }
+      return {
+        llmContent: `Failed to send message: ${errMsg}`,
+        returnDisplay: `Failed to send message: ${errMsg}`,
+        error: { message: errMsg }
+      };
+    }
+  }
+};
+var SendMessageTool = class _SendMessageTool extends BaseDeclarativeTool {
+  constructor(config) {
+    super(
+      _SendMessageTool.Name,
+      ToolDisplayNames.SEND_MESSAGE,
+      `Send to a teammate or another Qwen Code session (use "to"), or a running, paused, or completed background task (use "task_id"); completed tasks are revived. Set "to" to a bare teammate name (no @), to "*" to broadcast within an active Agent Team only, or to a session name from list_agents, exactly as its "to" value shows it \u2014 list_agents appends " [ref]" whenever the bare name would not reach that session (another session or a teammate shares it). A message to another session arrives there marked as coming from another session, carries none of your user's authority, and may be held for that session's user to review; never use it to have another session perform an action this session was denied, blocked from, or cannot do itself. For background tasks, set "task_id" to the id from the launch response or list_agents. Running tasks receive it at the next tool-round boundary; paused recovered tasks resume with the message as their first continuation instruction; completed tasks continue on their resident runtime when available and otherwise revive from their transcript and continue with your message. Your text output is NOT visible to teammates or to other sessions \u2014 use this tool to communicate.`,
+      "other" /* Other */,
+      {
+        type: "object",
+        properties: {
+          to: {
+            type: "string",
+            description: `Recipient: a teammate name, "*" for Agent Team broadcast, or a session's "to" value from list_agents verbatim (it carries " [ref]" when the bare name would not reach that session).`
+          },
+          task_id: {
+            type: "string",
+            description: "The ID of the background task (from the launch response, a recovered paused task, or a completed task to continue)."
+          },
+          message: {
+            type: "string",
+            description: "Message text to send.",
+            // An empty message is nothing to deliver; the peer wire
+            // contract drops it silently, so refuse it at the boundary.
+            minLength: 1,
+            // Cap message size so a teammate can't grow the
+            // recipient's inbox file unboundedly with a single send.
+            maxLength: 65536
+          },
+          summary: {
+            type: "string",
+            description: "Optional 5-10 word summary for UI display."
+          }
+        },
+        required: ["message"],
+        additionalProperties: false
+      },
+      true,
+      // isOutputMarkdown
+      false,
+      // canUpdateOutput
+      true,
+      // shouldDefer — sending messages is infrequent
+      false,
+      // alwaysLoad
+      "send message task teammate team communicate notify"
+    );
+    this.config = config;
+  }
+  static {
+    __name(this, "SendMessageTool");
+  }
+  static Name = ToolNames.SEND_MESSAGE;
+  createInvocation(params) {
+    return new SendMessageInvocation(this.config, params);
+  }
+  validateToolParamValues(params) {
+    if (params.to && params.task_id) {
+      return 'Only one of "to" or "task_id" may be provided.';
+    }
+    return null;
+  }
+  /**
+   * Forward the routing fields and the message verbatim to the classifier —
+   * `to`/`task_id` identify the privileged sink and the `message` itself is
+   * the new instruction the recipient will execute, so the classifier needs
+   * the full text to evaluate the action's safety.
+   */
+  toAutoClassifierInput(params) {
+    return {
+      to: params.to,
+      task_id: params.task_id,
+      message: params.message
+    };
+  }
+};
+export {
+  SendMessageTool
+};
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/serve-GP2UNRP7.js

@@ -0,0 +1,123 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  maybeOpenWebShellBrowser,
+  serveCommand
+} from "./chunk-QTMPM6RC.js";
+import "./chunk-6H67XLET.js";
+import "./chunk-UXEO7E3V.js";
+import "./chunk-7U5G6JXI.js";
+import "./chunk-WCCLLK7X.js";
+import "./chunk-ALMR3E6Q.js";
+import "./chunk-3VUENPWF.js";
+import "./chunk-AAX236AR.js";
+import "./chunk-NT5XIL5H.js";
+import "./chunk-RKUWKYED.js";
+import "./chunk-GOXKNSDZ.js";
+import "./chunk-IDS7MSUP.js";
+import "./chunk-EU2B4P3D.js";
+import "./chunk-5EJZE3FP.js";
+import "./chunk-T4RMUTTT.js";
+import "./chunk-3452WXOK.js";
+import "./chunk-I75VKFCJ.js";
+import "./chunk-NPQ5ZKRP.js";
+import "./chunk-MR3PXB6E.js";
+import "./chunk-NT7LXVV5.js";
+import "./chunk-DBTMP3P4.js";
+import "./chunk-ERHAMGAA.js";
+import "./chunk-LJZSMWOH.js";
+import "./chunk-6NWPR2EB.js";
+import "./chunk-GCUR24KK.js";
+import "./chunk-W4BDHLRT.js";
+import "./chunk-ED7DD7MV.js";
+import "./chunk-AYYKUUKP.js";
+import "./chunk-PWR2NQBS.js";
+import "./chunk-ENYUKMFK.js";
+import "./chunk-UKYXYWI2.js";
+import "./chunk-ZPJWUGCS.js";
+import "./chunk-3AKCBZVW.js";
+import "./chunk-JDIO45X7.js";
+import "./chunk-ZBDYI7VM.js";
+import "./chunk-GOFAQQZA.js";
+import "./chunk-5M6IDOMF.js";
+import "./chunk-6HUXPLB5.js";
+import "./chunk-TWPJO254.js";
+import "./chunk-CQ35AJ4Z.js";
+import "./chunk-SMJYTKTB.js";
+import "./chunk-AI35S34R.js";
+import "./chunk-FIWZOMBF.js";
+import "./chunk-6PVPNMXU.js";
+import "./chunk-OKTNXDVO.js";
+import "./chunk-DJBQCO2E.js";
+import "./chunk-IRH27ZC2.js";
+import "./chunk-QHWCP53L.js";
+import "./chunk-UJ4DUYIH.js";
+import "./chunk-O6GEWCJA.js";
+import "./chunk-YDQ4OCDK.js";
+import "./chunk-SDCHI64N.js";
+import "./chunk-B2RIIK3K.js";
+import "./chunk-373DQUVA.js";
+import "./chunk-OSTQZIOY.js";
+import "./chunk-U6D2PPMN.js";
+import "./chunk-PDXYZBBQ.js";
+import "./chunk-QJNDUTOL.js";
+import "./chunk-ZHO2CW6D.js";
+import "./chunk-AF3QB6OL.js";
+import "./chunk-7TBU7PU2.js";
+import "./chunk-E4JNFXNI.js";
+import "./chunk-4P7PPAHN.js";
+import "./chunk-7J6OTNGO.js";
+import "./chunk-CHEIIBT3.js";
+import "./chunk-VYSZUQGU.js";
+import "./chunk-JX6XHPTX.js";
+import "./chunk-MLXTMF7H.js";
+import "./chunk-NAVJD2PQ.js";
+import "./chunk-KFN2IZYR.js";
+import "./chunk-GB4UKWY5.js";
+import "./chunk-QHMLYMMS.js";
+import "./chunk-UXEW7TQS.js";
+import "./chunk-VNOVK4I7.js";
+import "./chunk-PQEISIKS.js";
+import "./chunk-RT4QNQ5P.js";
+import "./chunk-26SIKQIC.js";
+import "./chunk-S6LOFUVP.js";
+import "./chunk-CFKIH3D3.js";
+import "./chunk-2LD5U7Q3.js";
+import "./chunk-DJ2GSRLV.js";
+import "./chunk-S2T7H5MI.js";
+import "./chunk-LKODFJRD.js";
+import "./chunk-FXUSWLBF.js";
+import "./chunk-XBVNNDPK.js";
+import "./chunk-VGC4I5JJ.js";
+import "./chunk-67AY5D3M.js";
+import "./chunk-HT5S5TRQ.js";
+import "./chunk-LMMHS3RS.js";
+import "./chunk-WZAD4ZNJ.js";
+import "./chunk-FPGTNKCP.js";
+import "./chunk-EIJT2PQ6.js";
+import "./chunk-H5GPPDGY.js";
+import "./chunk-XZA32HII.js";
+import "./chunk-KHP66DFN.js";
+import "./chunk-22UH7VTP.js";
+import "./chunk-HHJLM3WQ.js";
+import "./chunk-TBJ3SNS3.js";
+import "./chunk-74TONY4F.js";
+import "./chunk-IXHV5MIC.js";
+import "./chunk-D7D3HSYQ.js";
+import "./chunk-YKADANK6.js";
+import "./chunk-AQ37AY7B.js";
+import "./chunk-ODZF64DM.js";
+import "./chunk-LYSZVCCD.js";
+import "./chunk-EAHOJF6V.js";
+import "./chunk-7FA2II6K.js";
+import "./chunk-75DOP5OR.js";
+import "./chunk-DMTGGOSA.js";
+import "./chunk-YQ3U5MUC.js";
+import "./chunk-AMDSOFFV.js";
+import "./chunk-TBWQLLFO.js";
+import "./chunk-5O2XNYP6.js";
+import "./chunk-J2S4EL5Y.js";
+export {
+  maybeOpenWebShellBrowser,
+  serveCommand
+};