@qwen-code/qwen-code 0.19.5 → 0.19.6-nightly.20260704.5dc2e1501

package/chunks/{chunk-LHMZCIKL.js → chunk-SZFYG244.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   SkillError
-} from "./chunk-6QTCOQX7.js";
+} from "./chunk-B5ZACOMA.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -86,6 +86,8 @@ var SERVE_CONTROL_EXT_METHODS = {
   workspaceAgentGenerate: "qwen/control/workspace/agents/generate",
   workspaceMemoryRememberAvailability: "qwen/control/workspace/memory/remember/availability",
   workspaceMemoryRemember: "qwen/control/workspace/memory/remember",
+  workspaceMemoryForget: "qwen/control/workspace/memory/forget",
+  workspaceMemoryDream: "qwen/control/workspace/memory/dream",
   // Runtime MCP server mutation ext-methods
   sessionTaskCancel: "qwen/control/session/task/cancel",
   sessionGoalClear: "qwen/control/session/goal/clear",

package/chunks/{chunk-CHY5C5T4.js → chunk-TDMIHT6B.js}

@@ -29,13 +29,13 @@ import {
 } from "./chunk-BZHLWC6T.js";
 import {
   STRUCTURED_OUTPUT_REDACTED_ARGS
-} from "./chunk-DG573EOO.js";
+} from "./chunk-RZORUN6X.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-MTNTVOJR.js";
+} from "./chunk-MJKMIQMK.js";
 import {
   atomicWriteFile,
   atomicWriteFileSync
@@ -64131,21 +64131,22 @@ function convertOpenAITextToParts(text, requestContext, final = true) {
   return parseTaggedThinkingText(text);
 }
 __name(convertOpenAITextToParts, "convertOpenAITextToParts");
-function hasThoughtPart(parts) {
-  return parts.some((part) => part.thought === true);
-}
-__name(hasThoughtPart, "hasThoughtPart");
 function convertOpenAIResponseToGemini(openaiResponse, requestContext) {
   const choice = openaiResponse.choices?.[0];
   const response = new GenerateContentResponse();
   if (choice) {
     const parts = [];
-    const textParts = choice.message.content ? convertOpenAITextToParts(choice.message.content, requestContext) : [];
-    const reasoningText = choice.message.reasoning_content ?? choice.message.reasoning;
-    if (reasoningText && !hasThoughtPart(textParts)) {
-      parts.push({ text: reasoningText, thought: true });
+    if (!requestContext.responseParsingOptions?.taggedThinkingTags) {
+      const reasoningText = choice.message.reasoning_content ?? choice.message.reasoning;
+      if (reasoningText) {
+        parts.push({ text: reasoningText, thought: true });
+      }
+    }
+    if (choice.message.content) {
+      parts.push(
+        ...convertOpenAITextToParts(choice.message.content, requestContext)
+      );
     }
-    parts.push(...textParts);
     if (choice.message.tool_calls) {
       for (const toolCall of choice.message.tool_calls) {
         if (toolCall.function) {
@@ -64219,8 +64220,22 @@ function convertOpenAIChunkToGemini(chunk, requestContext) {
   }
   if (choice) {
     const parts = [];
-    let contentParts = [];
-    const reasoningText = choice.delta?.reasoning_content ?? choice.delta?.reasoning;
+    if (!requestContext.responseParsingOptions?.taggedThinkingTags) {
+      const reasoningText = choice.delta?.reasoning_content ?? choice.delta?.reasoning;
+      if (reasoningText) {
+        const normalizedReasoningText = normalizeStreamingTextDelta(
+          reasoningText,
+          requestContext.reasoningDeltaState ??= {
+            emittedText: "",
+            emittedLength: 0,
+            cumulativeMode: false
+          }
+        );
+        if (normalizedReasoningText) {
+          parts.push({ text: normalizedReasoningText, thought: true });
+        }
+      }
+    }
     if (typeof choice.delta?.content === "string") {
       const normalizedContent = normalizeStreamingTextDelta(
         choice.delta.content,
@@ -64231,72 +64246,17 @@ function convertOpenAIChunkToGemini(chunk, requestContext) {
         }
       );
       if (normalizedContent || choice.finish_reason) {
-        contentParts = convertOpenAITextToParts(
-          normalizedContent,
-          requestContext,
-          Boolean(choice.finish_reason)
+        parts.push(
+          ...convertOpenAITextToParts(
+            normalizedContent,
+            requestContext,
+            Boolean(choice.finish_reason)
+          )
         );
       }
     } else if (choice.finish_reason) {
-      contentParts = convertOpenAITextToParts("", requestContext, true);
-    }
-    if (hasThoughtPart(contentParts)) {
-      requestContext.hasTaggedThinkingThought = true;
-      requestContext.pendingReasoningText = void 0;
-      debugLogger6.debug(
-        "convertOpenAIChunkToGemini: tagged thinking content emitted a thought; dropping buffered reasoning"
-      );
-      if (requestContext.pendingContentParts?.length) {
-        debugLogger6.debug(
-          `convertOpenAIChunkToGemini: flushing ${requestContext.pendingContentParts.length} buffered content part(s) before tagged content`
-        );
-        parts.push(...requestContext.pendingContentParts);
-        requestContext.pendingContentParts = void 0;
-      }
-    }
-    if (reasoningText && (!requestContext.responseParsingOptions?.taggedThinkingTags || !requestContext.hasTaggedThinkingThought)) {
-      const normalizedReasoningText = normalizeStreamingTextDelta(
-        reasoningText,
-        requestContext.reasoningDeltaState ??= {
-          emittedText: "",
-          emittedLength: 0,
-          cumulativeMode: false
-        }
-      );
-      if (normalizedReasoningText && !requestContext.responseParsingOptions?.taggedThinkingTags) {
-        parts.push({ text: normalizedReasoningText, thought: true });
-      } else if (normalizedReasoningText && !requestContext.hasTaggedThinkingThought) {
-        requestContext.pendingReasoningText = (requestContext.pendingReasoningText ?? "") + normalizedReasoningText;
-        debugLogger6.debug(
-          `convertOpenAIChunkToGemini: buffered reasoning text (${requestContext.pendingReasoningText.length} chars) for tagged stream`
-        );
-      }
-    }
-    if (requestContext.responseParsingOptions?.taggedThinkingTags && !requestContext.hasTaggedThinkingThought && requestContext.pendingReasoningText && contentParts.length) {
-      requestContext.pendingContentParts = [
-        ...requestContext.pendingContentParts ?? [],
-        ...contentParts
-      ];
-      debugLogger6.debug(
-        `convertOpenAIChunkToGemini: buffered ${contentParts.length} content part(s) behind pending reasoning`
-      );
-      contentParts = [];
+      parts.push(...convertOpenAITextToParts("", requestContext, true));
     }
-    if (choice.finish_reason && requestContext.responseParsingOptions?.taggedThinkingTags && !requestContext.hasTaggedThinkingThought && requestContext.pendingReasoningText) {
-      debugLogger6.debug(
-        "convertOpenAIChunkToGemini: flushing buffered reasoning for tagged stream with no tagged thought"
-      );
-      parts.push({ text: requestContext.pendingReasoningText, thought: true });
-      requestContext.pendingReasoningText = void 0;
-    }
-    if (choice.finish_reason && requestContext.pendingContentParts?.length) {
-      debugLogger6.debug(
-        `convertOpenAIChunkToGemini: flushing ${requestContext.pendingContentParts.length} buffered content part(s) on stream finish`
-      );
-      parts.push(...requestContext.pendingContentParts);
-      requestContext.pendingContentParts = void 0;
-    }
-    parts.push(...contentParts);
     if (choice.delta?.tool_calls) {
       for (const toolCall of choice.delta.tool_calls) {
         const index = toolCall.index ?? 0;
@@ -67637,6 +67597,7 @@ var DAEMON_PROMPT_QUEUE_WAIT = `${SERVICE_NAME}.daemon.prompt.queue_wait`;
 var DAEMON_PROMPT_DURATION = `${SERVICE_NAME}.daemon.prompt.duration`;
 var DAEMON_BRIDGE_ERROR_COUNT = `${SERVICE_NAME}.daemon.bridge.error.count`;
 var DAEMON_CANCEL_COUNT = `${SERVICE_NAME}.daemon.cancel.count`;
+var DAEMON_PIPE_MESSAGE_BYTES = `${SERVICE_NAME}.daemon.pipe.message_bytes`;
 var DAEMON_SSE_ACTIVE = `${SERVICE_NAME}.daemon.sse.active`;
 var DAEMON_PROCESS_HEAP_USED = `${SERVICE_NAME}.daemon.process.heap_used`;
 var KNOWN_ERROR_TYPES = /* @__PURE__ */ new Set([
@@ -67669,6 +67630,7 @@ var promptQueueWaitHistogram;
 var promptDurationHistogram;
 var bridgeErrorCounter;
 var cancelCounter;
+var pipeMessageBytesHistogram;
 function normalizeErrorType(err) {
   const name = err instanceof Error ? err.name : typeof err;
   return KNOWN_ERROR_TYPES.has(name) ? name : "unknown";
@@ -67764,6 +67726,24 @@ function initializeDaemonMetrics() {
     description: "Daemon cancel request count.",
     valueType: ValueType.INT
   });
+  pipeMessageBytesHistogram = meter.createHistogram(DAEMON_PIPE_MESSAGE_BYTES, {
+    description: "Daemon ACP child pipe message payload size in bytes.",
+    unit: "By",
+    valueType: ValueType.INT,
+    advice: {
+      explicitBucketBoundaries: [
+        256,
+        1024,
+        4096,
+        16384,
+        65536,
+        262144,
+        1048576,
+        4194304,
+        16777216
+      ]
+    }
+  });
   initialized = true;
 }
 __name(initializeDaemonMetrics, "initializeDaemonMetrics");
@@ -67843,6 +67823,114 @@ function recordDaemonCancel() {
   cancelCounter?.add(1);
 }
 __name(recordDaemonCancel, "recordDaemonCancel");
+function recordDaemonPipeMessage(direction, bytes) {
+  if (!initialized) return;
+  pipeMessageBytesHistogram?.record(bytes, { direction });
+}
+__name(recordDaemonPipeMessage, "recordDaemonPipeMessage");
+
+// packages/core/src/telemetry/event-loop-lag.ts
+init_esbuild_shims();
+import { monitorEventLoopDelay } from "node:perf_hooks";
+var DEFAULT_RESOLUTION_MS = 20;
+var DEFAULT_STALL_THRESHOLD_MS = 1e3;
+var NS_PER_MS = 1e6;
+function startEventLoopLagMonitor(options = {}) {
+  const resolutionMs = positiveFiniteOrDefault(
+    options.resolutionMs,
+    DEFAULT_RESOLUTION_MS
+  );
+  const stallThresholdMs = positiveFiniteOrDefault(
+    options.stallThresholdMs,
+    DEFAULT_STALL_THRESHOLD_MS
+  );
+  const histogram = monitorEventLoopDelay({ resolution: resolutionMs });
+  histogram.enable();
+  let disposed = false;
+  let lastReportedMaxMs = 0;
+  const readMaxMs = /* @__PURE__ */ __name(() => nsToMs(histogram.max), "readMaxMs");
+  const checkForNewMaxStall = /* @__PURE__ */ __name(() => {
+    if (disposed || !options.onNewMaxStall) return;
+    const maxMs = readMaxMs();
+    if (maxMs >= stallThresholdMs && maxMs > lastReportedMaxMs) {
+      lastReportedMaxMs = maxMs;
+      try {
+        options.onNewMaxStall(maxMs);
+      } catch {
+      }
+    }
+  }, "checkForNewMaxStall");
+  const interval = options.onNewMaxStall !== void 0 ? setInterval(checkForNewMaxStall, resolutionMs) : void 0;
+  interval?.unref();
+  return {
+    snapshot() {
+      return {
+        meanMs: nsToMs(histogram.mean),
+        p50Ms: nsToMs(histogram.percentile(50)),
+        p99Ms: nsToMs(histogram.percentile(99)),
+        maxMs: readMaxMs()
+      };
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      if (interval) {
+        clearInterval(interval);
+      }
+      histogram.disable();
+    }
+  };
+}
+__name(startEventLoopLagMonitor, "startEventLoopLagMonitor");
+function nsToMs(value) {
+  return Number.isFinite(value) ? value / NS_PER_MS : 0;
+}
+__name(nsToMs, "nsToMs");
+function positiveFiniteOrDefault(value, fallback) {
+  return value !== void 0 && Number.isFinite(value) && value > 0 ? value : fallback;
+}
+__name(positiveFiniteOrDefault, "positiveFiniteOrDefault");
+
+// packages/core/src/telemetry/event-loop-lag-metrics.ts
+init_esbuild_shims();
+init_esm();
+var DAEMON_EVENT_LOOP_LAG = `${SERVICE_NAME}.daemon.event_loop.lag`;
+var ACP_EVENT_LOOP_LAG = `${SERVICE_NAME}.acp.event_loop.lag`;
+var daemonGaugeRegistered = false;
+var acpGaugeRegistered = false;
+function registerDaemonEventLoopLagGauge(read2) {
+  if (daemonGaugeRegistered) return;
+  daemonGaugeRegistered = registerEventLoopLagGauge(
+    DAEMON_EVENT_LOOP_LAG,
+    read2
+  );
+}
+__name(registerDaemonEventLoopLagGauge, "registerDaemonEventLoopLagGauge");
+function registerAcpEventLoopLagGauge(read2) {
+  if (acpGaugeRegistered) return;
+  acpGaugeRegistered = registerEventLoopLagGauge(ACP_EVENT_LOOP_LAG, read2);
+}
+__name(registerAcpEventLoopLagGauge, "registerAcpEventLoopLagGauge");
+function registerEventLoopLagGauge(name, read2) {
+  const meter = getMeter();
+  if (!meter) return false;
+  meter.createObservableGauge(name, {
+    description: "Event loop lag in milliseconds.",
+    unit: "ms",
+    valueType: ValueType.DOUBLE
+  }).addCallback((result) => {
+    try {
+      const snapshot = read2();
+      result.observe(snapshot.meanMs, { stat: "mean" });
+      result.observe(snapshot.p50Ms, { stat: "p50" });
+      result.observe(snapshot.p99Ms, { stat: "p99" });
+      result.observe(snapshot.maxMs, { stat: "max" });
+    } catch {
+    }
+  });
+  return true;
+}
+__name(registerEventLoopLagGauge, "registerEventLoopLagGauge");
 
 // packages/core/src/telemetry/index.ts
 var TelemetryTarget = /* @__PURE__ */ ((TelemetryTarget2) => {
@@ -68959,11 +69047,11 @@ async function createContentGenerator(generatorConfig, config, isInitialAuth) {
   let baseGenerator;
   try {
     if (authType === "openai" /* USE_OPENAI */) {
-      const { createOpenAIContentGenerator } = await import("./openaiContentGenerator-EXR3ZL3Z.js");
+      const { createOpenAIContentGenerator } = await import("./openaiContentGenerator-GMMEY5PG.js");
       baseGenerator = createOpenAIContentGenerator(generatorConfig, config);
     } else if (authType === "qwen-oauth" /* QWEN_OAUTH */) {
       const { getQwenOAuthClient: getQwenOauthClient } = await import("./qwenOAuth2-LWLA6MQG.js");
-      const { QwenContentGenerator } = await import("./qwenContentGenerator-A7B6J4U7.js");
+      const { QwenContentGenerator } = await import("./qwenContentGenerator-7XCBMQBM.js");
       try {
         const qwenClient = await getQwenOauthClient(
           config,
@@ -68981,10 +69069,10 @@ async function createContentGenerator(generatorConfig, config, isInitialAuth) {
         throw new Error(error instanceof Error ? error.message : String(error));
       }
     } else if (authType === "anthropic" /* USE_ANTHROPIC */) {
-      const { createAnthropicContentGenerator } = await import("./anthropicContentGenerator-WL3LJOUB.js");
+      const { createAnthropicContentGenerator } = await import("./anthropicContentGenerator-H5ZOEENQ.js");
       baseGenerator = createAnthropicContentGenerator(generatorConfig, config);
     } else if (authType === "gemini" /* USE_GEMINI */ || authType === "vertex-ai" /* USE_VERTEX_AI */) {
-      const { createGeminiContentGenerator } = await import("./geminiContentGenerator-MZDVHVZH.js");
+      const { createGeminiContentGenerator } = await import("./geminiContentGenerator-JEG2PANG.js");
       baseGenerator = createGeminiContentGenerator(generatorConfig, config);
     } else {
       throw new Error(
@@ -72045,6 +72133,10 @@ export {
   recordDaemonPromptDuration,
   recordDaemonBridgeError,
   recordDaemonCancel,
+  recordDaemonPipeMessage,
+  startEventLoopLagMonitor,
+  registerDaemonEventLoopLagGauge,
+  registerAcpEventLoopLagGauge,
   TelemetryTarget,
   DEFAULT_TELEMETRY_TARGET,
   DEFAULT_OTLP_ENDPOINT,

package/chunks/{chunk-DRS2HTNT.js → chunk-TE6JTKY5.js}

@@ -5,19 +5,19 @@ import {
 } from "./chunk-3GONHQOA.js";
 import {
   getErrorMessage
-} from "./chunk-JJ6B3ZD3.js";
+} from "./chunk-3ZSJDRNO.js";
 import {
   loadSettings
-} from "./chunk-BC4R5C5R.js";
+} from "./chunk-5WYLPENX.js";
 import {
   getCurrentLanguage,
   initializeI18n,
   resolveLanguageSetting,
   t
-} from "./chunk-DM4E337C.js";
+} from "./chunk-X3UQVEBR.js";
 import {
   isWorkspaceTrusted
-} from "./chunk-Z7XNVNPM.js";
+} from "./chunk-EMSRFDBD.js";
 import {
   writeStderrLine,
   writeStdoutLine
@@ -29,7 +29,7 @@ import {
   redactUrlCredentials,
   require_prompts,
   stripAnsi
-} from "./chunk-6QTCOQX7.js";
+} from "./chunk-B5ZACOMA.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";