@qwen-code/qwen-code 0.20.0 → 0.20.1-nightly.20260724.7d17c44a3

package/chunks/{chunk-5DTTYNB7.js → chunk-PQNHRFJC.js}

@@ -12,6 +12,13 @@ init_esbuild_shims();
 var detectionComplete = false;
 var protocolSupported = false;
 var protocolEnabled = false;
+var KITTY_KEYBOARD_PUSH = "\x1B[>1u";
+var KITTY_KEYBOARD_POP = "\x1B[<u";
+function enableProtocol() {
+  process.stdout.write(KITTY_KEYBOARD_PUSH);
+  protocolEnabled = true;
+}
+__name(enableProtocol, "enableProtocol");
 async function detectAndEnableKittyProtocol() {
   if (detectionComplete) {
     return protocolSupported;
@@ -62,9 +69,8 @@ async function detectAndEnableKittyProtocol() {
           process.stdin.setRawMode(false);
         }
         if (progressiveEnhancementReceived) {
-          process.stdout.write("\x1B[>1u");
           protocolSupported = true;
-          protocolEnabled = true;
+          enableProtocol();
           process.on("exit", disableProtocol);
           process.on("SIGTERM", disableProtocol);
           process.on("SIGINT", disableProtocol);
@@ -82,11 +88,17 @@ async function detectAndEnableKittyProtocol() {
 __name(detectAndEnableKittyProtocol, "detectAndEnableKittyProtocol");
 function disableProtocol() {
   if (protocolEnabled) {
-    process.stdout.write("\x1B[<u");
+    process.stdout.write(KITTY_KEYBOARD_POP);
     protocolEnabled = false;
   }
 }
 __name(disableProtocol, "disableProtocol");
+function pushKittyProtocolFlags() {
+  if (protocolSupported) {
+    enableProtocol();
+  }
+}
+__name(pushKittyProtocolFlags, "pushKittyProtocolFlags");
 function disableKittyProtocol() {
   disableProtocol();
 }
@@ -102,6 +114,7 @@ __name(isKittyProtocolSupported, "isKittyProtocolSupported");
 
 export {
   detectAndEnableKittyProtocol,
+  pushKittyProtocolFlags,
   disableKittyProtocol,
   isKittyProtocolEnabled,
   isKittyProtocolSupported

package/chunks/{chunk-OLMETXLX.js → chunk-PXHK5ONM.js}

@@ -2,10 +2,11 @@
 "use strict";
 import {
   ChannelWorkerStartupError
-} from "./chunk-NBMIC7DR.js";
+} from "./chunk-SX4PK3FC.js";
 import {
+  ChannelDeliveryError,
   ChannelWebhookEnqueueError
-} from "./chunk-Y2ENGUD6.js";
+} from "./chunk-UPF7PTBI.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -224,7 +225,14 @@ function createChannelWorkerGroup(opts) {
     }
     return firstError ? { rolledBack: false, rollbackError: firstError } : { rolledBack: true };
   }, "restoreEntries");
-  const routeEntry = /* @__PURE__ */ __name((channelName) => {
+  const routeEntry = /* @__PURE__ */ __name((channelName, workspaceCwd) => {
+    if (workspaceCwd !== void 0) {
+      const entry = entries.get(workspaceCwd);
+      if (entry && (entry.selection.mode === "all" || entry.selection.names.includes(channelName))) {
+        return entry;
+      }
+      return void 0;
+    }
     for (const entry of entries.values()) {
       if (entry.selection.mode === "all" || entry.selection.names.includes(channelName)) {
         return entry;
@@ -298,13 +306,27 @@ function createChannelWorkerGroup(opts) {
         const targets = new Map(
           targetGroups.map((target) => [target.workspaceCwd, target])
         );
+        if (reconcileOptions?.forceWorkspaceCwd) {
+          for (const workspaceCwd of targets.keys()) {
+            if (workspaceCwd !== reconcileOptions.forceWorkspaceCwd) {
+              targets.delete(workspaceCwd);
+            }
+          }
+        }
         const unchanged = /* @__PURE__ */ new Map();
         const oldAffected = [];
         const newEntries = [];
         for (const [workspaceCwd, entry] of entries) {
           const target = targets.get(workspaceCwd);
           const healthy = entry.supervisor.snapshot().state === "running";
-          if (target && !reconcileOptions?.force && healthy && selectionsEqual(entry.selection, target.selection)) {
+          const forceWorkspace = reconcileOptions?.forceWorkspaceCwd === workspaceCwd;
+          const preserveOtherWorkspace = reconcileOptions?.forceWorkspaceCwd !== void 0 && !forceWorkspace;
+          if (preserveOtherWorkspace) {
+            unchanged.set(workspaceCwd, entry);
+            targets.delete(workspaceCwd);
+            continue;
+          }
+          if (target && !reconcileOptions?.force && !forceWorkspace && healthy && selectionsEqual(entry.selection, target.selection)) {
             unchanged.set(workspaceCwd, entry);
             targets.delete(workspaceCwd);
           } else {
@@ -392,16 +414,17 @@ function createChannelWorkerGroup(opts) {
           committed.set(entry.workspaceCwd, entry);
         }
         entries = committed;
-        const targetWorkspaceCwds = new Set(
-          targetGroups.map((target) => target.workspaceCwd)
-        );
+        const targetWorkspaceCwds = new Set(committed.keys());
         for (const workspaceCwd of groupsByWorkspace.keys()) {
           if (!targetWorkspaceCwds.has(workspaceCwd)) {
             groupsByWorkspace.delete(workspaceCwd);
           }
         }
-        for (const target of targetGroups) {
-          groupsByWorkspace.set(target.workspaceCwd, target);
+        for (const entry of committed.values()) {
+          groupsByWorkspace.set(entry.workspaceCwd, {
+            workspaceCwd: entry.workspaceCwd,
+            selection: entry.selection
+          });
         }
         return { changed: true, workers: entrySnapshots() };
       })().finally(() => {
@@ -518,6 +541,15 @@ function createChannelWorkerGroup(opts) {
         throw err;
       }
     },
+    async deliverChannelMessage(request, workspaceCwd) {
+      const entry = routeEntry(request.channelName, workspaceCwd);
+      const deliver = entry?.supervisor.deliverChannelMessage;
+      if (!entry || drainingWorkspaces.has(entry.workspaceCwd) || !deliver) {
+        const hint = workspaceCwd ? `No channel worker for the selected workspace owns channel "${request.channelName}".` : `No channel worker owns channel "${request.channelName}".`;
+        throw new ChannelDeliveryError("channel_worker_unavailable", hint);
+      }
+      return deliver.call(entry.supervisor, request);
+    },
     async enqueueWebhookTask(task) {
       const entry = routeEntry(task.channelName);
       if (!entry || drainingWorkspaces.has(entry.workspaceCwd)) {

package/chunks/{chunk-PF4CHQOJ.js → chunk-Q6GU6TKM.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   theme
-} from "./chunk-GMGDLUC7.js";
+} from "./chunk-6IL7KRLE.js";
 import {
   require_jsx_runtime
 } from "./chunk-SV5PQVQE.js";
@@ -10,17 +10,17 @@ import {
   Box_default,
   Text,
   use_is_screen_reader_enabled_default
-} from "./chunk-NEEB7UEN.js";
+} from "./chunk-6GMVPFB2.js";
 import {
   require_react
 } from "./chunk-5QWWOFGG.js";
 import {
   formatHistoryGapNotice,
   indexGapsByChild
-} from "./chunk-D22SX43D.js";
+} from "./chunk-DWNZ6PVQ.js";
 import {
   stringWidth
-} from "./chunk-H2XVO6NE.js";
+} from "./chunk-2MIN6GRR.js";
 import {
   eastAsianWidth
 } from "./chunk-QHTIBUWB.js";
@@ -29,16 +29,16 @@ import {
 } from "./chunk-E5Z2AVNV.js";
 import {
   t
-} from "./chunk-TKLLK6XQ.js";
+} from "./chunk-ZT4POVWC.js";
 import {
   getToolResponseDisplayText
-} from "./chunk-KX6UK4VJ.js";
+} from "./chunk-LI4I37W4.js";
 import {
   stripAnsi
-} from "./chunk-T4TZQJ7W.js";
+} from "./chunk-TWPJO254.js";
 import {
   ToolDisplayNames
-} from "./chunk-OP4MOGXF.js";
+} from "./chunk-P5RRUHL7.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -3023,7 +3023,7 @@ function convertToHistoryItems(conversation, config, historyGaps) {
           const payload = record.systemPayload;
           const text2 = payload?.displayText || extractTextFromParts(record.message?.parts);
           if (text2) {
-            items.push({ type: "notification", text: text2 });
+            items.push({ type: "user" /* USER */, text: text2, sentToModel: false });
           }
           break;
         }
@@ -3217,7 +3217,8 @@ function applyCollapsePolicyAndSummary(rawItems, collapseOnResume, collapsePrevi
   if (collapsePreviewCount > 0) {
     let userTurnCount = 0;
     for (let i = rawItems.length - 1; i >= 0; i--) {
-      if (rawItems[i].type === "user" /* USER */) {
+      const item = rawItems[i];
+      if (item.type === "user" /* USER */ && item.sentToModel !== false) {
         userTurnCount++;
         if (userTurnCount === collapsePreviewCount) {
           boundary = i;

package/chunks/{chunk-4ODB7WIB.js → chunk-QAFKR7WR.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   resolvePath
-} from "./chunk-NIJEXGV6.js";
+} from "./chunk-ZXYUQXY5.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-PBATSWUQ.js → chunk-QBUDF33N.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   createDebugLogger
-} from "./chunk-C27BYUX6.js";
+} from "./chunk-OQB4EXO4.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-BVLROR2T.js → chunk-QLJUC7TG.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   expandHomeDir
-} from "./chunk-C27BYUX6.js";
+} from "./chunk-OQB4EXO4.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-UEY4AYUL.js → chunk-QNLNLENL.js}

@@ -2,11 +2,11 @@
 "use strict";
 import {
   atomicWriteFileSync
-} from "./chunk-BDBMYST4.js";
+} from "./chunk-6X4GWOPW.js";
 import {
   Storage,
   createDebugLogger
-} from "./chunk-C27BYUX6.js";
+} from "./chunk-OQB4EXO4.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-333CXMNJ.js → chunk-QXZTZJLX.js}

@@ -2,21 +2,21 @@
 "use strict";
 import {
   appEvents
-} from "./chunk-4XNLIGVA.js";
+} from "./chunk-JKCALGYN.js";
 import {
   assembleMcpServers,
   getPendingGatedMcpServers,
   getPromptableMcpServers
-} from "./chunk-7SXZC7ID.js";
+} from "./chunk-2WTVWAKT.js";
 import {
   getMCPServerStatus
-} from "./chunk-ZFKNWQGQ.js";
+} from "./chunk-IFG6TYJ2.js";
 import {
   require_fast_deep_equal
-} from "./chunk-OP4MOGXF.js";
+} from "./chunk-P5RRUHL7.js";
 import {
   createDebugLogger
-} from "./chunk-C27BYUX6.js";
+} from "./chunk-OQB4EXO4.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/chunk-R6D2CTQR.js

@@ -0,0 +1,289 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  getRateLimitErrorDetails
+} from "./chunk-6QHAUJUE.js";
+import {
+  isInternalPromptId
+} from "./chunk-IFG6TYJ2.js";
+import {
+  createDebugLogger
+} from "./chunk-OQB4EXO4.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/utils/openaiLogger.ts
+init_esbuild_shims();
+import * as path from "node:path";
+import { promises as fs } from "node:fs";
+
+// node_modules/uuid/dist/esm-node/index.js
+init_esbuild_shims();
+
+// node_modules/uuid/dist/esm-node/rng.js
+init_esbuild_shims();
+import crypto from "crypto";
+var rnds8Pool = new Uint8Array(256);
+var poolPtr = rnds8Pool.length;
+function rng() {
+  if (poolPtr > rnds8Pool.length - 16) {
+    crypto.randomFillSync(rnds8Pool);
+    poolPtr = 0;
+  }
+  return rnds8Pool.slice(poolPtr, poolPtr += 16);
+}
+__name(rng, "rng");
+
+// node_modules/uuid/dist/esm-node/stringify.js
+init_esbuild_shims();
+var byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 256).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset = 0) {
+  return byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]];
+}
+__name(unsafeStringify, "unsafeStringify");
+
+// node_modules/uuid/dist/esm-node/v4.js
+init_esbuild_shims();
+
+// node_modules/uuid/dist/esm-node/native.js
+init_esbuild_shims();
+import crypto2 from "crypto";
+var native_default = {
+  randomUUID: crypto2.randomUUID
+};
+
+// node_modules/uuid/dist/esm-node/v4.js
+function v4(options, buf, offset) {
+  if (native_default.randomUUID && !buf && !options) {
+    return native_default.randomUUID();
+  }
+  options = options || {};
+  const rnds = options.random || (options.rng || rng)();
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  if (buf) {
+    offset = offset || 0;
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(rnds);
+}
+__name(v4, "v4");
+var v4_default = v4;
+
+// packages/core/src/utils/openaiLogger.ts
+import * as os from "os";
+var debugLogger = createDebugLogger("OPENAI_LOGGER");
+var MAIN_SESSION_PROMPT_ID_DELIMITER = "########";
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function resolveOpenAILogDir(customLogDir, cwd) {
+  const baseCwd = cwd || process.cwd();
+  if (!customLogDir) {
+    return path.join(baseCwd, "logs", "openai");
+  }
+  let resolvedPath = customLogDir;
+  if (customLogDir === "~" || customLogDir.startsWith("~/")) {
+    resolvedPath = path.join(os.homedir(), customLogDir.slice(1));
+  } else if (!path.isAbsolute(customLogDir)) {
+    resolvedPath = path.resolve(baseCwd, customLogDir);
+  }
+  return path.normalize(resolvedPath);
+}
+__name(resolveOpenAILogDir, "resolveOpenAILogDir");
+function sanitizeDiagnosticSuffix(suffix) {
+  if (!suffix) return void 0;
+  const sanitized = suffix.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  return sanitized || void 0;
+}
+__name(sanitizeDiagnosticSuffix, "sanitizeDiagnosticSuffix");
+function extractSubagentSuffix(promptId) {
+  const parts = promptId.split("#");
+  if (parts.length !== 3) return void 0;
+  const [, subagentId, turn] = parts;
+  if (!subagentId || !turn || !/^\d+$/.test(turn)) {
+    return void 0;
+  }
+  return `subagent-${subagentId}`;
+}
+__name(extractSubagentSuffix, "extractSubagentSuffix");
+function promptIdSuffixForFilename(promptId) {
+  if (!promptId) return void 0;
+  if (isInternalPromptId(promptId)) {
+    return sanitizeDiagnosticSuffix(promptId);
+  }
+  return sanitizeDiagnosticSuffix(extractSubagentSuffix(promptId));
+}
+__name(promptIdSuffixForFilename, "promptIdSuffixForFilename");
+function sessionIdFromPromptId(promptId) {
+  if (!promptId) return void 0;
+  const mainSessionDelimiterIndex = promptId.indexOf(
+    MAIN_SESSION_PROMPT_ID_DELIMITER
+  );
+  if (mainSessionDelimiterIndex > 0) {
+    return promptId.slice(0, mainSessionDelimiterIndex);
+  }
+  if (UUID_PATTERN.test(promptId)) {
+    return promptId;
+  }
+  const parts = promptId.split("#");
+  if (parts.length >= 3 && parts[0]) {
+    return parts[0];
+  }
+  return void 0;
+}
+__name(sessionIdFromPromptId, "sessionIdFromPromptId");
+function contextForPromptId(promptId) {
+  const trimmedPromptId = promptId?.trim();
+  const sessionId = sessionIdFromPromptId(trimmedPromptId);
+  if (!trimmedPromptId && !sessionId) {
+    return null;
+  }
+  return {
+    ...trimmedPromptId ? { promptId: trimmedPromptId } : {},
+    ...sessionId ? { sessionId } : {}
+  };
+}
+__name(contextForPromptId, "contextForPromptId");
+function getString(value) {
+  return typeof value === "string" && value ? value : void 0;
+}
+__name(getString, "getString");
+function getErrorRequestId(error) {
+  const source = error;
+  return getString(source.requestID) ?? getString(source.request_id) ?? getString(source.requestId) ?? getString(source.response_id) ?? getRateLimitErrorDetails(error).requestId;
+}
+__name(getErrorRequestId, "getErrorRequestId");
+function serializeError(error) {
+  const requestId = getErrorRequestId(error);
+  return {
+    message: error.message,
+    stack: error.stack,
+    ...requestId ? { requestId } : {}
+  };
+}
+__name(serializeError, "serializeError");
+var OpenAILogger = class {
+  static {
+    __name(this, "OpenAILogger");
+  }
+  logDir;
+  initialized = false;
+  /**
+   * Creates a new OpenAI logger
+   * @param customLogDir Optional custom log directory path (supports relative paths, absolute paths, and ~ expansion)
+   * @param cwd Optional working directory for resolving relative paths. Defaults to process.cwd().
+   *            In ACP mode, process.cwd() may be '/' (filesystem root), so callers should
+   *            pass the project working directory from Config.getWorkingDir().
+   */
+  constructor(customLogDir, cwd) {
+    this.logDir = resolveOpenAILogDir(customLogDir, cwd);
+  }
+  /**
+   * Initialize the logger by creating the log directory if it doesn't exist
+   */
+  async initialize() {
+    if (this.initialized) return;
+    try {
+      await fs.mkdir(this.logDir, { recursive: true });
+      this.initialized = true;
+    } catch (error) {
+      debugLogger.error("Failed to initialize OpenAI logger:", error);
+      throw new Error(`Failed to initialize OpenAI logger: ${error}`);
+    }
+  }
+  /**
+   * Logs an OpenAI API request and its response
+   * @param request The request sent to OpenAI
+   * @param response The response received from OpenAI
+   * @param error Optional error if the request failed
+   * @param promptId Optional prompt id; internal and subagent prompt ids are
+   *                 appended to the filename after timestamp and id.
+   * @returns The file path where the log was written
+   */
+  async logInteraction(request, response, error, promptId) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-");
+    const id = v4_default().slice(0, 8);
+    const promptIdSuffix = promptIdSuffixForFilename(promptId);
+    const filename = promptIdSuffix ? `openai-${timestamp}-${id}-${promptIdSuffix}.json` : `openai-${timestamp}-${id}.json`;
+    const filePath = path.join(this.logDir, filename);
+    const logData = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      request,
+      response: response || null,
+      error: error ? serializeError(error) : null,
+      context: contextForPromptId(promptId),
+      system: {
+        hostname: os.hostname(),
+        platform: os.platform(),
+        release: os.release(),
+        nodeVersion: process.version
+      }
+    };
+    try {
+      await fs.writeFile(filePath, JSON.stringify(logData, null, 2), "utf-8");
+      return filePath;
+    } catch (writeError) {
+      debugLogger.error("Failed to write OpenAI log file:", writeError);
+      throw new Error(`Failed to write OpenAI log file: ${writeError}`);
+    }
+  }
+  /**
+   * Get all logged interactions
+   * @param limit Optional limit on the number of log files to return (sorted by most recent first)
+   * @returns Array of log file paths
+   */
+  async getLogFiles(limit) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    try {
+      const files = await fs.readdir(this.logDir);
+      const logFiles = files.filter((file) => file.startsWith("openai-") && file.endsWith(".json")).map((file) => path.join(this.logDir, file)).sort().reverse();
+      return limit === void 0 ? logFiles : logFiles.slice(0, limit);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return [];
+      }
+      debugLogger.error("Failed to read OpenAI log directory:", error);
+      return [];
+    }
+  }
+  /**
+   * Read a specific log file
+   * @param filePath The path to the log file
+   * @returns The log file content
+   */
+  async readLogFile(filePath) {
+    try {
+      const content = await fs.readFile(filePath, "utf-8");
+      return JSON.parse(content);
+    } catch (error) {
+      debugLogger.error(`Failed to read log file ${filePath}:`, error);
+      throw new Error(`Failed to read log file: ${error}`);
+    }
+  }
+};
+var openaiLogger = new OpenAILogger();
+
+export {
+  resolveOpenAILogDir,
+  OpenAILogger,
+  openaiLogger
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */