@qwen-code/qwen-code 0.18.0-preview.2 → 0.18.1

package/chunks/chunk-SFRV6BGY.js

@@ -0,0 +1,243 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  getInboxesDir,
+  require_proper_lockfile
+} from "./chunk-WPTCDQN6.js";
+import {
+  Mutex
+} from "./chunk-OMX7CUOE.js";
+import {
+  atomicWriteJSON
+} from "./chunk-LXYWINWF.js";
+import {
+  createDebugLogger,
+  isNodeError
+} from "./chunk-HA2UEYZP.js";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+import {
+  __name,
+  __toESM
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/agents/team/leaderPermissionBridge.ts
+init_esbuild_shims();
+var leaderCallbacks = null;
+function registerLeader(callbacks) {
+  leaderCallbacks = callbacks;
+}
+__name(registerLeader, "registerLeader");
+function getLeader() {
+  return leaderCallbacks;
+}
+__name(getLeader, "getLeader");
+function unregisterLeader() {
+  leaderCallbacks = null;
+}
+__name(unregisterLeader, "unregisterLeader");
+function forwardApproval(teammateName, teammateColor, details) {
+  if (!leaderCallbacks) {
+    return false;
+  }
+  leaderCallbacks.enqueueApproval({
+    teammateName,
+    teammateColor,
+    details
+  });
+  return true;
+}
+__name(forwardApproval, "forwardApproval");
+function wrapConfirmWithBadge(original, teammateName, respond, _teammateColor) {
+  return {
+    ...original,
+    title: `[${teammateName}] ${original.title}`,
+    onConfirm: /* @__PURE__ */ __name(async (outcome, payload) => {
+      await respond(outcome, payload);
+    }, "onConfirm")
+  };
+}
+__name(wrapConfirmWithBadge, "wrapConfirmWithBadge");
+
+// packages/core/src/agents/team/mailbox.ts
+init_esbuild_shims();
+var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+var debug = createDebugLogger("AGENTS_TEAM_MAILBOX");
+var LOCK_OPTIONS = {
+  retries: {
+    retries: 10,
+    minTimeout: 5,
+    maxTimeout: 100,
+    factor: 2,
+    // Jitter the backoff so cross-process contenders don't retry in
+    // lockstep (thundering herd) and starve each other out of the
+    // retry budget.
+    randomize: true
+  },
+  stale: 5e3,
+  // Stale locks from crashed processes are expected in multi-agent
+  // scenarios; log at debug level for traceability without noise.
+  onCompromised: /* @__PURE__ */ __name((err) => {
+    debug.debug("mailbox lock compromised:", err?.message ?? err);
+  }, "onCompromised")
+};
+var inboxLocks = /* @__PURE__ */ new Map();
+function getInboxLock(inboxPath) {
+  let lock = inboxLocks.get(inboxPath);
+  if (!lock) {
+    lock = new Mutex();
+    inboxLocks.set(inboxPath, lock);
+  }
+  return lock;
+}
+__name(getInboxLock, "getInboxLock");
+function disposeInboxLocks(teamName) {
+  const dir = getInboxesDir(teamName);
+  let evicted = 0;
+  for (const key of inboxLocks.keys()) {
+    if (path.dirname(key) === dir) {
+      inboxLocks.delete(key);
+      evicted++;
+    }
+  }
+  return evicted;
+}
+__name(disposeInboxLocks, "disposeInboxLocks");
+async function withInboxLock(inboxPath, fn) {
+  return getInboxLock(inboxPath).runExclusive(async () => {
+    const release = await import_proper_lockfile.default.lock(inboxPath, LOCK_OPTIONS);
+    try {
+      return await fn();
+    } finally {
+      await release();
+    }
+  });
+}
+__name(withInboxLock, "withInboxLock");
+function getInboxPath(teamName, agentName) {
+  return path.join(getInboxesDir(teamName), `${agentName}.json`);
+}
+__name(getInboxPath, "getInboxPath");
+async function readInbox(teamName, agentName) {
+  const inboxPath = getInboxPath(teamName, agentName);
+  try {
+    const raw = await fs.readFile(inboxPath, "utf-8");
+    return JSON.parse(raw);
+  } catch (err) {
+    if (isNodeError(err) && err.code === "ENOENT") return [];
+    throw err;
+  }
+}
+__name(readInbox, "readInbox");
+var READ_RETENTION_MS = 5 * 60 * 1e3;
+async function writeMessage(teamName, toAgentName, message) {
+  const inboxPath = getInboxPath(teamName, toAgentName);
+  await ensureInboxFile(inboxPath);
+  await withInboxLock(inboxPath, async () => {
+    const messages = await readInboxRaw(inboxPath);
+    const cutoff = Date.now() - READ_RETENTION_MS;
+    const compacted = messages.filter((m) => {
+      if (!m.read) return true;
+      const ts = Date.parse(m.timestamp);
+      return Number.isNaN(ts) || ts >= cutoff;
+    });
+    compacted.push(message);
+    await atomicWriteJSON(inboxPath, compacted);
+  });
+}
+__name(writeMessage, "writeMessage");
+async function consumeUnread(teamName, agentName, type) {
+  const inboxPath = getInboxPath(teamName, agentName);
+  await ensureInboxFile(inboxPath);
+  return withInboxLock(inboxPath, async () => {
+    const messages = await readInboxRaw(inboxPath);
+    const predicate = /* @__PURE__ */ __name((m) => !m.read && (type === void 0 || m.type === type), "predicate");
+    const matching = messages.filter(predicate);
+    if (matching.length === 0) return [];
+    const updated = messages.map(
+      (m) => predicate(m) ? { ...m, read: true } : m
+    );
+    await atomicWriteJSON(inboxPath, updated);
+    return matching;
+  });
+}
+__name(consumeUnread, "consumeUnread");
+async function clearInbox(teamName, agentName) {
+  const inboxPath = getInboxPath(teamName, agentName);
+  try {
+    await fs.unlink(inboxPath);
+  } catch (err) {
+    if (!isNodeError(err) || err.code !== "ENOENT") throw err;
+  }
+}
+__name(clearInbox, "clearInbox");
+async function clearAllInboxes(teamName) {
+  const dir = getInboxesDir(teamName);
+  await fs.rm(dir, { recursive: true, force: true });
+  disposeInboxLocks(teamName);
+}
+__name(clearAllInboxes, "clearAllInboxes");
+async function sendStructuredMessage(teamName, toAgentName, opts) {
+  await writeMessage(teamName, toAgentName, {
+    from: opts.from,
+    text: opts.text,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    read: false,
+    type: opts.type,
+    color: opts.color,
+    summary: opts.summary
+  });
+}
+__name(sendStructuredMessage, "sendStructuredMessage");
+async function ensureInboxFile(inboxPath) {
+  await fs.mkdir(path.dirname(inboxPath), { recursive: true });
+  try {
+    await fs.writeFile(inboxPath, "[]\n", { flag: "wx" });
+  } catch (err) {
+    if (!isNodeError(err) || err.code !== "EEXIST") throw err;
+  }
+}
+__name(ensureInboxFile, "ensureInboxFile");
+async function readInboxRaw(inboxPath) {
+  try {
+    const raw = await fs.readFile(inboxPath, "utf-8");
+    return JSON.parse(raw);
+  } catch (err) {
+    if (isNodeError(err) && err.code === "ENOENT") return [];
+    const errMsg = err instanceof Error ? err.message : String(err);
+    debug.warn(`Quarantining corrupt inbox at ${inboxPath}: ${errMsg}`);
+    try {
+      await fs.rename(inboxPath, `${inboxPath}.corrupt-${Date.now()}`);
+    } catch (renameErr) {
+      const renameMsg = renameErr instanceof Error ? renameErr.message : String(renameErr);
+      debug.warn(`Failed to quarantine ${inboxPath}: ${renameMsg}`);
+      throw err instanceof Error ? err : new Error(`Failed to read inbox at ${inboxPath}: ${errMsg}`);
+    }
+    return [];
+  }
+}
+__name(readInboxRaw, "readInboxRaw");
+
+export {
+  registerLeader,
+  getLeader,
+  unregisterLeader,
+  forwardApproval,
+  wrapConfirmWithBadge,
+  disposeInboxLocks,
+  getInboxPath,
+  readInbox,
+  writeMessage,
+  consumeUnread,
+  clearInbox,
+  clearAllInboxes,
+  sendStructuredMessage
+};
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-AVW55ZCO.js → chunk-WJ3SND6W.js}

@@ -2,19 +2,19 @@
 "use strict";
 import {
   RequestTokenizer
-} from "./chunk-CWV3SJZS.js";
-import {
-  createChildAbortController
-} from "./chunk-64WXLC72.js";
+} from "./chunk-3NRO6NHX.js";
 import {
   OpenAIContentConverter,
   TaggedThinkingParser,
   openaiRequestCaptureContext
-} from "./chunk-ZK4AMNIU.js";
+} from "./chunk-RON7LFNH.js";
+import {
+  createChildAbortController
+} from "./chunk-64WXLC72.js";
 import {
   buildRuntimeFetchOptions,
   redactProxyError
-} from "./chunk-LR62TEET.js";
+} from "./chunk-NNIYWQIS.js";
 import {
   CAPPED_DEFAULT_MAX_TOKENS,
   DASHSCOPE_PROXY_BASE_URL,
@@ -25,14 +25,14 @@ import {
   runtimeDiagnostics,
   safeJsonParse,
   tokenLimit
-} from "./chunk-Y7R6H6FT.js";
+} from "./chunk-LYSND7KR.js";
 import {
   GenerateContentResponse
-} from "./chunk-BNESGOSJ.js";
+} from "./chunk-55ZMG67I.js";
 import {
   createDebugLogger,
   isAbortError
-} from "./chunk-JXAZUMDW.js";
+} from "./chunk-HA2UEYZP.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -7608,6 +7608,7 @@ init_esbuild_shims();
 
 // packages/core/src/core/openaiContentGenerator/streamingToolCallParser.ts
 init_esbuild_shims();
+var debugLogger2 = createDebugLogger("STREAMING_TOOL_CALL_PARSER");
 var StreamingToolCallParser = class {
   static {
     __name(this, "StreamingToolCallParser");
@@ -7644,6 +7645,7 @@ var StreamingToolCallParser = class {
    */
   addChunk(index, chunk, id, name) {
     let actualIndex = index;
+    const isKnownId = Boolean(id && this.idToIndexMap.has(id));
     if (id) {
       if (this.idToIndexMap.has(id)) {
         actualIndex = this.idToIndexMap.get(id);
@@ -7685,11 +7687,21 @@ var StreamingToolCallParser = class {
       this.escapes.set(actualIndex, false);
       this.toolCallMeta.set(actualIndex, {});
     }
+    const currentBuffer = this.buffers.get(actualIndex);
+    const currentDepth = this.depths.get(actualIndex);
+    if (isKnownId && currentBuffer.trim() && currentDepth === 0) {
+      try {
+        JSON.parse(currentBuffer);
+        debugLogger2.debug(
+          `Ignoring replay chunk for completed toolCall id=${id}`
+        );
+        return { complete: false };
+      } catch {
+      }
+    }
     const meta = this.toolCallMeta.get(actualIndex);
     if (id) meta.id = id;
     if (name) meta.name = name;
-    const currentBuffer = this.buffers.get(actualIndex);
-    const currentDepth = this.depths.get(actualIndex);
     const currentInString = this.inStrings.get(actualIndex);
     const currentEscape = this.escapes.get(actualIndex);
     const newBuffer = currentBuffer + chunk;
@@ -7758,9 +7770,16 @@ var StreamingToolCallParser = class {
    */
   getCompletedToolCalls() {
     const completed = [];
+    const emittedIds = /* @__PURE__ */ new Set();
     for (const [index, buffer] of this.buffers.entries()) {
       const meta = this.toolCallMeta.get(index);
       if (meta?.name && buffer.trim()) {
+        if (meta.id) {
+          if (emittedIds.has(meta.id)) {
+            continue;
+          }
+          emittedIds.add(meta.id);
+        }
         let args = {};
         try {
           args = JSON.parse(buffer);
@@ -8127,6 +8146,8 @@ var ContentGenerationPipeline = class {
     if (isStreaming) {
       baseRequest.stream = true;
       baseRequest.stream_options = { include_usage: true };
+    } else {
+      baseRequest.stream = false;
     }
     if (request.config?.tools && request.config.tools.length > 0) {
       baseRequest.tools = await OpenAIContentConverter.convertGeminiToolsToOpenAI(
@@ -8267,7 +8288,7 @@ var ContentGenerationPipeline = class {
 
 // packages/core/src/core/openaiContentGenerator/errorHandler.ts
 init_esbuild_shims();
-var debugLogger2 = createDebugLogger("OPENAI_ERROR");
+var debugLogger3 = createDebugLogger("OPENAI_ERROR");
 var EnhancedErrorHandler = class {
   constructor(shouldSuppressLogging = () => false) {
     this.shouldSuppressLogging = shouldSuppressLogging;
@@ -8284,7 +8305,7 @@ var EnhancedErrorHandler = class {
       isTimeoutError
     );
     if (!this.shouldSuppressErrorLogging(redactedError, request)) {
-      debugLogger2.error("OpenAI API Error:", errorMessage);
+      debugLogger3.error("OpenAI API Error:", errorMessage);
     }
     if (isTimeoutError) {
       throw new Error(
@@ -8324,7 +8345,7 @@ ${tips.join("\n")}`;
 };
 
 // packages/core/src/core/openaiContentGenerator/openaiContentGenerator.ts
-var debugLogger3 = createDebugLogger("OPENAI");
+var debugLogger4 = createDebugLogger("OPENAI");
 var OpenAIContentGenerator = class {
   static {
     __name(this, "OpenAIContentGenerator");
@@ -8367,7 +8388,7 @@ var OpenAIContentGenerator = class {
         totalTokens: result.totalTokens
       };
     } catch (error) {
-      debugLogger3.warn(
+      debugLogger4.warn(
         "Failed to calculate tokens with new tokenizer, falling back to simple method:",
         error
       );
@@ -8414,7 +8435,7 @@ var OpenAIContentGenerator = class {
       };
     } catch (error) {
       const redactedError = redactProxyError(error);
-      debugLogger3.error("OpenAI API Embedding Error:", redactedError);
+      debugLogger4.error("OpenAI API Embedding Error:", redactedError);
       throw new Error(
         `OpenAI API error: ${redactedError instanceof Error ? redactedError.message : String(redactedError)}`
       );