@mmmbuto/qwen-code-termux 0.16.1-termux → 0.18.0-termux

package/chunks/{chunk-I2V5WXHJ.js → chunk-3AUHFMSK.js}

@@ -2,16 +2,19 @@
 "use strict";
 import {
   RequestTokenizer
-} from "./chunk-SDHRQFOS.js";
-import {
-  buildRuntimeFetchOptions,
-  redactProxyError
-} from "./chunk-6PCB2DEF.js";
+} from "./chunk-ZTZ4DDQE.js";
 import {
   OpenAIContentConverter,
   TaggedThinkingParser,
   openaiRequestCaptureContext
-} from "./chunk-K6O2NBMF.js";
+} from "./chunk-OQ7NJIY7.js";
+import {
+  createChildAbortController
+} from "./chunk-64WXLC72.js";
+import {
+  buildRuntimeFetchOptions,
+  redactProxyError
+} from "./chunk-EYENRK4D.js";
 import {
   CAPPED_DEFAULT_MAX_TOKENS,
   DASHSCOPE_PROXY_BASE_URL,
@@ -22,14 +25,14 @@ import {
   runtimeDiagnostics,
   safeJsonParse,
   tokenLimit
-} from "./chunk-MAY32HXD.js";
+} from "./chunk-M6VTDSVR.js";
 import {
   GenerateContentResponse
-} from "./chunk-MYAKAFEC.js";
+} from "./chunk-55ZMG67I.js";
 import {
   createDebugLogger,
   isAbortError
-} from "./chunk-XP27SJMH.js";
+} from "./chunk-HR7SV7AY.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -7074,6 +7077,7 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
   /**
    * Determines whether to use the DashScope-compatible provider.
    * Covers dashscope.aliyuncs.com, dashscope-intl.aliyuncs.com,
+   * Token Plan endpoints under token-plan.<region>.maas.aliyuncs.com,
    * internal Alibaba domains (*.alibaba-inc.com, *.aliyun-inc.com),
    * and proxy matches.
    *
@@ -7093,12 +7097,13 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
       hostname = null;
     }
     const isDashscopeOrigin = hostname !== null && (hostname === "dashscope.aliyuncs.com" || hostname === "dashscope-intl.aliyuncs.com" || hostname.endsWith(".dashscope.aliyuncs.com") || hostname.endsWith(".dashscope-intl.aliyuncs.com"));
+    const isTokenPlanOrigin = hostname !== null && hostname.startsWith("token-plan.") && hostname.endsWith(".maas.aliyuncs.com");
     const isInternalOrigin = hostname !== null && (hostname.endsWith(".alibaba-inc.com") || hostname.endsWith(".aliyun-inc.com"));
     const normalizedProxyUrl = DASHSCOPE_PROXY_BASE_URL?.endsWith("/") ? DASHSCOPE_PROXY_BASE_URL.slice(0, -1) : DASHSCOPE_PROXY_BASE_URL;
     const isProxyMatch = Boolean(
       normalizedProxyUrl && normalizedBaseUrl.toLowerCase() === normalizedProxyUrl.toLowerCase()
     );
-    if (normalizedProxyUrl && !isDashscopeOrigin && !isInternalOrigin && !isProxyMatch) {
+    if (normalizedProxyUrl && !isDashscopeOrigin && !isTokenPlanOrigin && !isInternalOrigin && !isProxyMatch) {
       debugLogger.debug(
         `DASHSCOPE_PROXY_BASE_URL is configured but the request baseUrl does not match. DashScope headers/cache control will be skipped.`
       );
@@ -7108,7 +7113,7 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
         `DashScope provider activated via internal origin: ${hostname}`
       );
     }
-    return isDashscopeOrigin || isInternalOrigin || isProxyMatch;
+    return isDashscopeOrigin || isTokenPlanOrigin || isInternalOrigin || isProxyMatch;
   }
   buildHeaders() {
     const version = this.cliConfig.getCliVersion() || "unknown";
@@ -7285,8 +7290,12 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
     // qwen-vl-max, qwen-vl-max-latest, etc.
     "qwen3-vl-plus",
     // qwen3-vl-plus variants
-    "qwen3.5-plus"
+    "qwen3.5-plus",
     // qwen3.5-plus (has built-in vision capabilities)
+    "qwen3.6-plus",
+    // qwen3.6-plus (multimodal)
+    "qwen3.7-plus"
+    // qwen3.7-plus (multimodal)
   ];
   isVisionModel(model) {
     if (!model) {
@@ -7596,7 +7605,6 @@ var MiMoOpenAICompatibleProvider = class extends DefaultOpenAICompatibleProvider
 
 // packages/core/src/core/openaiContentGenerator/pipeline.ts
 init_esbuild_shims();
-import { setMaxListeners } from "node:events";
 
 // packages/core/src/core/openaiContentGenerator/streamingToolCallParser.ts
 init_esbuild_shims();
@@ -7913,10 +7921,6 @@ var StreamingToolCallParser = class {
 };
 
 // packages/core/src/core/openaiContentGenerator/pipeline.ts
-function raiseAbortListenerCap(signal) {
-  if (signal) setMaxListeners(0, signal);
-}
-__name(raiseAbortListenerCap, "raiseAbortListenerCap");
 var StreamContentError = class extends Error {
   static {
     __name(this, "StreamContentError");
@@ -7938,40 +7942,66 @@ var ContentGenerationPipeline = class {
   client;
   contentGeneratorConfig;
   async execute(request, userPromptId) {
-    raiseAbortListenerCap(request.config?.abortSignal);
     return this.executeWithErrorHandling(
       request,
       userPromptId,
       false,
       async (openaiRequest, context) => {
-        const openaiResponse = await this.client.chat.completions.create(
-          openaiRequest,
-          {
-            signal: request.config?.abortSignal
-          }
-        );
-        const geminiResponse = OpenAIContentConverter.convertOpenAIResponseToGemini(
-          openaiResponse,
-          context
-        );
-        return geminiResponse;
+        const parentSignal = request.config?.abortSignal;
+        const perRequestAc = parentSignal ? createChildAbortController(parentSignal) : void 0;
+        try {
+          const openaiResponse = await this.client.chat.completions.create(
+            openaiRequest,
+            {
+              signal: perRequestAc?.signal
+            }
+          );
+          const geminiResponse = OpenAIContentConverter.convertOpenAIResponseToGemini(
+            openaiResponse,
+            context
+          );
+          return geminiResponse;
+        } finally {
+          perRequestAc?.abort();
+        }
       }
     );
   }
   async executeStream(request, userPromptId) {
-    raiseAbortListenerCap(request.config?.abortSignal);
     return this.executeWithErrorHandling(
       request,
       userPromptId,
       true,
       async (openaiRequest, context) => {
-        const stream = await this.client.chat.completions.create(
-          openaiRequest,
-          {
-            signal: request.config?.abortSignal
-          }
+        const parentSignal = request.config?.abortSignal;
+        const perRequestAc = parentSignal ? createChildAbortController(parentSignal) : void 0;
+        let stream;
+        try {
+          stream = await this.client.chat.completions.create(openaiRequest, {
+            signal: perRequestAc?.signal
+          });
+        } catch (e) {
+          perRequestAc?.abort();
+          throw e;
+        }
+        if (!perRequestAc) {
+          return this.processStreamWithLogging(stream, context, request);
+        }
+        const ac = perRequestAc;
+        const innerStream = this.processStreamWithLogging(
+          stream,
+          context,
+          request
         );
-        return this.processStreamWithLogging(stream, context, request);
+        async function* drainThenCleanup() {
+          try {
+            yield* innerStream;
+          } finally {
+            ac.abort();
+          }
+        }
+        __name(drainThenCleanup, "drainThenCleanup");
+        return drainThenCleanup();
       }
     );
   }
@@ -8097,6 +8127,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(
@@ -8111,7 +8143,10 @@ var ContentGenerationPipeline = class {
     const reasoningDisabled = request.config?.thinkingConfig?.includeThoughts === false || this.contentGeneratorConfig.reasoning === false;
     if (reasoningDisabled) {
       const typed = providerRequest;
-      if ("enable_thinking" in typed) {
+      const model = (context.model ?? "").toLowerCase();
+      if (DashScopeOpenAICompatibleProvider.isDashScopeProvider(
+        this.contentGeneratorConfig
+      ) && (model.startsWith("qwen") || model === "coder-model")) {
         typed["enable_thinking"] = false;
       }
       if ("reasoning" in typed) {
@@ -8217,7 +8252,14 @@ var ContentGenerationPipeline = class {
       model: effectiveModel,
       modalities: this.contentGeneratorConfig.modalities ?? {},
       startTime: Date.now(),
-      splitToolMedia: providerOverrides.splitToolMedia ?? this.contentGeneratorConfig.splitToolMedia ?? false,
+      splitToolMedia: providerOverrides.splitToolMedia ?? this.contentGeneratorConfig.splitToolMedia ?? // Default true: the OpenAI Chat Completions spec only permits text on
+      // `role: "tool"` messages, so tool-returned media (e.g. an image read
+      // by read_file) embedded there is silently dropped or rejected by
+      // strict providers (doubao / new-api / LM Studio) and the model never
+      // sees it (QwenLM/qwen-code#4876). Splitting it into a follow-up user
+      // message is spec-compliant and safe for permissive providers too.
+      // Opt out via generationConfig.splitToolMedia = false.
+      true,
       ...toolCallParser ? { toolCallParser } : {},
       ...responseParsingOptions ? { responseParsingOptions } : {},
       ...taggedThinkingParser ? { taggedThinkingParser } : {}

package/chunks/chunk-3DHXZ6EV.js

@@ -0,0 +1,241 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  Mutex,
+  getInboxesDir,
+  require_proper_lockfile
+} from "./chunk-J5MDQKJL.js";
+import {
+  atomicWriteJSON
+} from "./chunk-B7HXHOHU.js";
+import {
+  createDebugLogger,
+  isNodeError
+} from "./chunk-HR7SV7AY.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-PR4T27R7.js → chunk-3HTIVKZE.js}

@@ -3,8 +3,9 @@
 import {
   QWEN_DIR,
   Storage,
+  resolvePath,
   sanitizeCwd
-} from "./chunk-XP27SJMH.js";
+} from "./chunk-HR7SV7AY.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -21,6 +22,7 @@ var AUTO_MEMORY_INDEX_FILENAME = "MEMORY.md";
 var AUTO_MEMORY_METADATA_FILENAME = "meta.json";
 var AUTO_MEMORY_EXTRACT_CURSOR_FILENAME = "extract-cursor.json";
 var AUTO_MEMORY_CONSOLIDATION_LOCK_FILENAME = "consolidation.lock";
+var USER_AUTO_MEMORY_DIRNAME = "memories";
 function findGitRoot(startPath) {
   let current = path.resolve(startPath);
   while (true) {
@@ -74,28 +76,31 @@ function findCanonicalGitRoot(startPath) {
 __name(findCanonicalGitRoot, "findCanonicalGitRoot");
 function getMemoryBaseDir() {
   if (process.env["QWEN_CODE_MEMORY_BASE_DIR"]) {
-    return process.env["QWEN_CODE_MEMORY_BASE_DIR"];
+    return resolvePath(void 0, process.env["QWEN_CODE_MEMORY_BASE_DIR"]);
   }
-  return Storage.getGlobalQwenDir();
+  return Storage.getRuntimeBaseDir();
 }
 __name(getMemoryBaseDir, "getMemoryBaseDir");
 var _autoMemoryRootCache = /* @__PURE__ */ new Map();
 function getAutoMemoryRoot(projectRoot) {
-  const cached = _autoMemoryRootCache.get(projectRoot);
+  const useLocalMemory = process.env["QWEN_CODE_MEMORY_LOCAL"] === "1";
+  const memoryBaseDir = useLocalMemory ? "" : getMemoryBaseDir();
+  const cacheKey = `${useLocalMemory ? "local" : memoryBaseDir}\0${projectRoot}`;
+  const cached = _autoMemoryRootCache.get(cacheKey);
   if (cached !== void 0) return cached;
   let result;
-  if (process.env["QWEN_CODE_MEMORY_LOCAL"] === "1") {
+  if (useLocalMemory) {
     result = path.join(projectRoot, QWEN_DIR, AUTO_MEMORY_DIRNAME);
   } else {
     const canonicalRoot = findCanonicalGitRoot(projectRoot) ?? path.resolve(projectRoot);
     result = path.join(
-      getMemoryBaseDir(),
+      memoryBaseDir,
       "projects",
       sanitizeCwd(canonicalRoot),
       AUTO_MEMORY_DIRNAME
     );
   }
-  _autoMemoryRootCache.set(projectRoot, result);
+  _autoMemoryRootCache.set(cacheKey, result);
   return result;
 }
 __name(getAutoMemoryRoot, "getAutoMemoryRoot");
@@ -154,6 +159,29 @@ function getAutoMemoryFilePath(projectRoot, relativePath) {
   return path.join(getAutoMemoryRoot(projectRoot), relativePath);
 }
 __name(getAutoMemoryFilePath, "getAutoMemoryFilePath");
+function getUserAutoMemoryRoot() {
+  return path.join(getMemoryBaseDir(), USER_AUTO_MEMORY_DIRNAME);
+}
+__name(getUserAutoMemoryRoot, "getUserAutoMemoryRoot");
+function getUserAutoMemoryIndexPath() {
+  return path.join(getUserAutoMemoryRoot(), AUTO_MEMORY_INDEX_FILENAME);
+}
+__name(getUserAutoMemoryIndexPath, "getUserAutoMemoryIndexPath");
+function getUserAutoMemoryTopicPath(type) {
+  return path.join(getUserAutoMemoryRoot(), getAutoMemoryTopicFilename(type));
+}
+__name(getUserAutoMemoryTopicPath, "getUserAutoMemoryTopicPath");
+function isUserAutoMemPath(absolutePath) {
+  const normalizedPath = path.normalize(absolutePath);
+  const memRoot = path.normalize(getUserAutoMemoryRoot());
+  const rel = path.relative(memRoot, normalizedPath);
+  return rel === "" || !rel.startsWith("..") && !path.isAbsolute(rel);
+}
+__name(isUserAutoMemPath, "isUserAutoMemPath");
+function isAnyAutoMemPath(absolutePath, projectRoot) {
+  return isAutoMemPath(absolutePath, projectRoot) || isUserAutoMemPath(absolutePath);
+}
+__name(isAnyAutoMemPath, "isAnyAutoMemPath");
 
 export {
   AUTO_MEMORY_DIRNAME,
@@ -161,6 +189,7 @@ export {
   AUTO_MEMORY_METADATA_FILENAME,
   AUTO_MEMORY_EXTRACT_CURSOR_FILENAME,
   AUTO_MEMORY_CONSOLIDATION_LOCK_FILENAME,
+  USER_AUTO_MEMORY_DIRNAME,
   getMemoryBaseDir,
   getAutoMemoryRoot,
   clearAutoMemoryRootCache,
@@ -172,7 +201,12 @@ export {
   getAutoMemoryConsolidationLockPath,
   getAutoMemoryTopicFilename,
   getAutoMemoryTopicPath,
-  getAutoMemoryFilePath
+  getAutoMemoryFilePath,
+  getUserAutoMemoryRoot,
+  getUserAutoMemoryIndexPath,
+  getUserAutoMemoryTopicPath,
+  isUserAutoMemPath,
+  isAnyAutoMemPath
 };
 /**
  * @license