@qwen-code/qwen-code 0.21.0 → 0.21.1-simplify-system-prompt.0

package/chunks/{chunk-JXJFVC6E.js → chunk-DN6ZX5AY.js}

@@ -17,7 +17,7 @@ import {
 import {
   formatHistoryGapNotice,
   indexGapsByChild
-} from "./chunk-WCXCRJYB.js";
+} from "./chunk-BRRAJXPA.js";
 import {
   stringWidth
 } from "./chunk-2MIN6GRR.js";
@@ -29,10 +29,10 @@ import {
 } from "./chunk-E5Z2AVNV.js";
 import {
   t
-} from "./chunk-LKEJ26GS.js";
+} from "./chunk-VV6XU5L7.js";
 import {
   getToolResponseDisplayText
-} from "./chunk-PHOF65IG.js";
+} from "./chunk-DM4Q4JJH.js";
 import {
   stripAnsi
 } from "./chunk-TWPJO254.js";

package/chunks/{chunk-J24WCGIN.js → chunk-E5WH5O3C.js}

@@ -3,17 +3,17 @@
 import {
   getGitVersion,
   getNpmVersion
-} from "./chunk-MVSUYZDT.js";
+} from "./chunk-SASBXAQL.js";
 import {
   buildEnvStatusFromEnv,
   snapshotProcessEnv
-} from "./chunk-ETSW4KLJ.js";
+} from "./chunk-WDSWXQU3.js";
 import {
   mapDomainErrorToErrorKind
-} from "./chunk-VIA5XA4U.js";
+} from "./chunk-KU5XMLDK.js";
 import {
   canUseRipgrep
-} from "./chunk-PHOF65IG.js";
+} from "./chunk-DM4Q4JJH.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-4WIZGAH3.js → chunk-ER5LWJR6.js}

@@ -2,7 +2,11 @@
 "use strict";
 import {
   resolveChannelCwd
-} from "./chunk-7ZCNENPP.js";
+} from "./chunk-W4CQXHT6.js";
+import {
+  getPlugin,
+  supportedTypes
+} from "./chunk-MK7VQDN3.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -12,60 +16,6 @@ import {
 
 // packages/cli/src/commands/channel/config-utils.ts
 init_esbuild_shims();
-
-// packages/cli/src/commands/channel/channel-registry.ts
-init_esbuild_shims();
-var registry = /* @__PURE__ */ new Map();
-var builtinsPromise = null;
-function ensureBuiltins() {
-  if (!builtinsPromise) {
-    builtinsPromise = (async () => {
-      const labelled = [
-        { name: "telegram", promise: import("./dist-BBLXMS3N.js") },
-        { name: "weixin", promise: import("./dist-46NQKLTW.js") },
-        { name: "dingtalk", promise: import("./dist-AIKFMUKK.js") },
-        { name: "wecom", promise: import("./dist-YFNEUWSE.js") },
-        { name: "feishu", promise: import("./dist-F6IBUDR4.js") },
-        { name: "qqbot", promise: import("./dist-WEAHOXDM.js") }
-      ];
-      const results = await Promise.allSettled(labelled.map((l) => l.promise));
-      for (let i = 0; i < results.length; i++) {
-        const result = results[i];
-        if (result.status === "fulfilled") {
-          registry.set(result.value.plugin.channelType, result.value.plugin);
-        } else {
-          process.stderr.write(
-            `[channel-registry] Failed to load "${labelled[i].name}" channel: ${result.reason}
-`
-          );
-        }
-      }
-    })();
-  }
-  return builtinsPromise;
-}
-__name(ensureBuiltins, "ensureBuiltins");
-function registerPlugin(plugin) {
-  if (registry.has(plugin.channelType)) {
-    throw new Error(
-      `Channel type "${plugin.channelType}" is already registered.`
-    );
-  }
-  registry.set(plugin.channelType, plugin);
-}
-__name(registerPlugin, "registerPlugin");
-async function getPlugin(channelType) {
-  await ensureBuiltins();
-  return registry.get(channelType);
-}
-__name(getPlugin, "getPlugin");
-async function supportedTypes() {
-  await ensureBuiltins();
-  return [...registry.keys()];
-}
-__name(supportedTypes, "supportedTypes");
-
-// packages/cli/src/commands/channel/config-utils.ts
 var ENV_VAR_NAME_PATTERN = /^[A-Z_][A-Z0-9_]*$/;
 var CHANNEL_APPROVAL_MODES = /* @__PURE__ */ new Set([
   "plan",
@@ -439,8 +389,6 @@ async function parseChannelConfig(name, rawConfig, defaultCwd = process.cwd(), o
 __name(parseChannelConfig, "parseChannelConfig");
 
 export {
-  registerPlugin,
-  getPlugin,
   resolveEnvVars,
   parseChannelWebhookConfig,
   parseChannelWebhookConfigLenient,

package/chunks/chunk-FY3M44RD.js

@@ -0,0 +1,463 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  GenAiOutputAccumulator,
+  extractAnthropicContent,
+  extractGeminiContent,
+  extractOpenAiContent,
+  stringifyGenAiJson
+} from "./chunk-SQBYH7PX.js";
+import {
+  createDebugLogger
+} from "./chunk-NL7LTRLR.js";
+import {
+  ROOT_CONTEXT,
+  context,
+  createContextKey,
+  init_esm
+} from "./chunk-TARRHLLG.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/telemetry/gen-ai-request.ts
+init_esbuild_shims();
+init_esm();
+var debugLogger = createDebugLogger("GEN_AI_EXCHANGE");
+var requestObserverKey = createContextKey(
+  "qwen-code.gen-ai-request-observer"
+);
+var DISABLED_OBSERVER = Symbol("disabled-gen-ai-exchange");
+function ownValue(record, key) {
+  return Object.hasOwn(record, key) ? record[key] : void 0;
+}
+__name(ownValue, "ownValue");
+function finiteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+__name(finiteNumber, "finiteNumber");
+function safeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) ? value : void 0;
+}
+__name(safeInteger, "safeInteger");
+function stopSequences(value, allowSingleString) {
+  if (allowSingleString && typeof value === "string") return [value];
+  if (!Array.isArray(value) || !value.every((item) => typeof item === "string"))
+    return void 0;
+  return [...value];
+}
+__name(stopSequences, "stopSequences");
+function outputBudget(record) {
+  const values = ["max_tokens", "max_completion_tokens", "max_new_tokens"].map((key) => ownValue(record, key)).filter((value) => value !== void 0 && value !== null);
+  if (values.length === 0) return void 0;
+  const integers = values.map(safeInteger);
+  if (integers.some((value) => value === void 0)) return void 0;
+  const first = integers[0];
+  return integers.every((value) => value === first) ? first : void 0;
+}
+__name(outputBudget, "outputBudget");
+function assignNumber(attributes, key, value) {
+  const number = finiteNumber(value);
+  if (number !== void 0) attributes[key] = number;
+}
+__name(assignNumber, "assignNumber");
+function assignInteger(attributes, key, value) {
+  const integer = safeInteger(value);
+  if (integer !== void 0) attributes[key] = integer;
+}
+__name(assignInteger, "assignInteger");
+function assignStopSequences(attributes, value, allowSingleString) {
+  const sequences = stopSequences(value, allowSingleString);
+  if (sequences !== void 0)
+    attributes["gen_ai.request.stop_sequences"] = sequences;
+}
+__name(assignStopSequences, "assignStopSequences");
+function extractOpenAiRequestAttributes(request) {
+  const record = request;
+  const attributes = {};
+  const choiceCount = safeInteger(ownValue(record, "n"));
+  if (choiceCount !== void 0 && choiceCount !== 1) {
+    attributes["gen_ai.request.choice.count"] = choiceCount;
+  }
+  const maxTokens = outputBudget(record);
+  if (maxTokens !== void 0) {
+    attributes["gen_ai.request.max_tokens"] = maxTokens;
+  }
+  assignNumber(
+    attributes,
+    "gen_ai.request.temperature",
+    ownValue(record, "temperature")
+  );
+  assignNumber(attributes, "gen_ai.request.top_p", ownValue(record, "top_p"));
+  assignNumber(
+    attributes,
+    "gen_ai.request.frequency_penalty",
+    ownValue(record, "frequency_penalty")
+  );
+  assignNumber(
+    attributes,
+    "gen_ai.request.presence_penalty",
+    ownValue(record, "presence_penalty")
+  );
+  assignStopSequences(attributes, ownValue(record, "stop"), true);
+  return attributes;
+}
+__name(extractOpenAiRequestAttributes, "extractOpenAiRequestAttributes");
+function extractAnthropicRequestAttributes(request) {
+  const record = request;
+  const attributes = {};
+  assignInteger(
+    attributes,
+    "gen_ai.request.max_tokens",
+    ownValue(record, "max_tokens")
+  );
+  assignNumber(
+    attributes,
+    "gen_ai.request.temperature",
+    ownValue(record, "temperature")
+  );
+  assignNumber(attributes, "gen_ai.request.top_p", ownValue(record, "top_p"));
+  assignStopSequences(attributes, ownValue(record, "stop_sequences"), false);
+  return attributes;
+}
+__name(extractAnthropicRequestAttributes, "extractAnthropicRequestAttributes");
+function extractGeminiRequestAttributes(request) {
+  const record = request;
+  const config = ownValue(record, "config");
+  if (typeof config !== "object" || config === null) return {};
+  const configRecord = config;
+  const attributes = {};
+  const choiceCount = safeInteger(ownValue(configRecord, "candidateCount"));
+  if (choiceCount !== void 0 && choiceCount !== 1) {
+    attributes["gen_ai.request.choice.count"] = choiceCount;
+  }
+  assignInteger(
+    attributes,
+    "gen_ai.request.max_tokens",
+    ownValue(configRecord, "maxOutputTokens")
+  );
+  assignNumber(
+    attributes,
+    "gen_ai.request.temperature",
+    ownValue(configRecord, "temperature")
+  );
+  assignNumber(
+    attributes,
+    "gen_ai.request.top_p",
+    ownValue(configRecord, "topP")
+  );
+  assignNumber(
+    attributes,
+    "gen_ai.request.frequency_penalty",
+    ownValue(configRecord, "frequencyPenalty")
+  );
+  assignNumber(
+    attributes,
+    "gen_ai.request.presence_penalty",
+    ownValue(configRecord, "presencePenalty")
+  );
+  assignStopSequences(
+    attributes,
+    ownValue(configRecord, "stopSequences"),
+    false
+  );
+  return attributes;
+}
+__name(extractGeminiRequestAttributes, "extractGeminiRequestAttributes");
+var GenAiExchangeController = class {
+  constructor(span, options, enabled) {
+    this.span = span;
+    this.options = options;
+    this.enabled = enabled;
+    this.output = this.newOutput();
+  }
+  static {
+    __name(this, "GenAiExchangeController");
+  }
+  requestConsumed = false;
+  generation = 0;
+  finalized = false;
+  output;
+  responseConversionFailed = false;
+  beginRequest(request, extractRequest, extractContent) {
+    if (!this.enabled || this.finalized) return void 0;
+    const generation = ++this.generation;
+    this.output = this.newOutput();
+    this.responseConversionFailed = false;
+    if (!this.requestConsumed) {
+      this.requestConsumed = true;
+      const attributes = {};
+      try {
+        Object.assign(attributes, extractRequest(request));
+        if (this.options.captureContent) {
+          const content = extractContent(request);
+          this.assignJsonAttribute(
+            attributes,
+            "gen_ai.input.messages",
+            content.inputMessages
+          );
+          this.assignJsonAttribute(
+            attributes,
+            "gen_ai.system_instructions",
+            content.systemInstructions
+          );
+          this.assignJsonAttribute(
+            attributes,
+            "gen_ai.tool.definitions",
+            content.toolDefinitions
+          );
+        }
+      } catch {
+        debugLogger.debug("Failed to convert GenAI request attributes");
+      }
+      try {
+        this.span.setAttributes(attributes);
+      } catch {
+        debugLogger.debug("Failed to set GenAI request span attributes");
+      }
+    }
+    return { controller: this, generation };
+  }
+  beginFollowingRequest(handle, request, extractRequest, extractContent) {
+    if (handle.controller !== this || handle.generation !== this.generation || this.finalized) {
+      return void 0;
+    }
+    return this.beginRequest(request, extractRequest, extractContent);
+  }
+  record(handle, update) {
+    if (!handle || handle.controller !== this || handle.generation !== this.generation || this.finalized) {
+      return;
+    }
+    try {
+      update(this.output);
+    } catch {
+      this.output.discardContent();
+      this.responseConversionFailed = true;
+      debugLogger.debug("Failed to convert GenAI response content");
+    }
+  }
+  finalize(success) {
+    if (this.finalized) return void 0;
+    this.finalized = true;
+    let finishReasons;
+    try {
+      const outputMessages = this.output.finalize(success);
+      finishReasons = this.responseConversionFailed ? void 0 : this.output.finishReasons;
+      if (outputMessages !== void 0) {
+        this.span.setAttribute("gen_ai.output.messages", outputMessages);
+      }
+    } catch {
+      debugLogger.debug("Failed to finalize GenAI response attributes");
+    } finally {
+      this.output = this.newOutput();
+    }
+    return finishReasons;
+  }
+  assignJsonAttribute(attributes, key, value) {
+    if (value === void 0) return;
+    let serialized;
+    try {
+      serialized = stringifyGenAiJson(
+        value,
+        this.options.sensitiveAttributeMaxLength
+      );
+    } catch {
+      debugLogger.debug(`Failed to serialize ${key} span attribute`);
+      return;
+    }
+    if (serialized !== void 0) attributes[key] = serialized;
+  }
+  newOutput() {
+    return new GenAiOutputAccumulator(
+      this.options.captureContent,
+      this.options.sensitiveAttributeMaxLength
+    );
+  }
+};
+function disabledFallbackContext(parent) {
+  const fallback = Object.create(parent);
+  fallback.getValue = (key) => {
+    if (key === requestObserverKey) return DISABLED_OBSERVER;
+    try {
+      return parent.getValue(key);
+    } catch {
+      return void 0;
+    }
+  };
+  fallback.setValue = (key, value) => {
+    if (key === requestObserverKey) return fallback;
+    try {
+      return disabledFallbackContext(parent.setValue(key, value));
+    } catch {
+      return fallback;
+    }
+  };
+  fallback.deleteValue = (key) => {
+    if (key === requestObserverKey) return fallback;
+    try {
+      return disabledFallbackContext(parent.deleteValue(key));
+    } catch {
+      return fallback;
+    }
+  };
+  return fallback;
+}
+__name(disabledFallbackContext, "disabledFallbackContext");
+function createGenAiExchange(parent, span, options) {
+  let enabled = false;
+  try {
+    enabled = span.isRecording();
+  } catch {
+    enabled = false;
+  }
+  const controller = new GenAiExchangeController(span, options, enabled);
+  try {
+    return {
+      context: parent.setValue(
+        requestObserverKey,
+        enabled ? controller : DISABLED_OBSERVER
+      ),
+      controller
+    };
+  } catch {
+    return {
+      context: parent === ROOT_CONTEXT ? ROOT_CONTEXT : disabledFallbackContext(parent),
+      controller
+    };
+  }
+}
+__name(createGenAiExchange, "createGenAiExchange");
+function activeController(requestContext) {
+  let observer;
+  try {
+    observer = (requestContext ?? context.active()).getValue(
+      requestObserverKey
+    );
+  } catch {
+    return void 0;
+  }
+  return observer instanceof GenAiExchangeController ? observer : void 0;
+}
+__name(activeController, "activeController");
+function reportRequest(request, extractRequest, extractContent, requestContext, previousAttempt) {
+  try {
+    if (previousAttempt) {
+      return previousAttempt.controller.beginFollowingRequest(
+        previousAttempt,
+        request,
+        extractRequest,
+        extractContent
+      );
+    }
+    return activeController(requestContext)?.beginRequest(
+      request,
+      extractRequest,
+      extractContent
+    );
+  } catch {
+    return void 0;
+  }
+}
+__name(reportRequest, "reportRequest");
+function reportOpenAiRequest(request, requestContext) {
+  return reportRequest(
+    request,
+    extractOpenAiRequestAttributes,
+    extractOpenAiContent,
+    requestContext
+  );
+}
+__name(reportOpenAiRequest, "reportOpenAiRequest");
+function reportAnthropicRequest(request, requestContext) {
+  return reportRequest(
+    request,
+    extractAnthropicRequestAttributes,
+    extractAnthropicContent,
+    requestContext
+  );
+}
+__name(reportAnthropicRequest, "reportAnthropicRequest");
+function reportAnthropicFollowingRequest(request, previousAttempt) {
+  if (!previousAttempt) return void 0;
+  return reportRequest(
+    request,
+    extractAnthropicRequestAttributes,
+    extractAnthropicContent,
+    void 0,
+    previousAttempt
+  );
+}
+__name(reportAnthropicFollowingRequest, "reportAnthropicFollowingRequest");
+function reportGeminiRequest(request, requestContext) {
+  return reportRequest(
+    request,
+    extractGeminiRequestAttributes,
+    extractGeminiContent,
+    requestContext
+  );
+}
+__name(reportGeminiRequest, "reportGeminiRequest");
+function reportOpenAiResponse(handle, response) {
+  handle?.controller.record(
+    handle,
+    (output) => output.recordOpenAiResponse(response)
+  );
+}
+__name(reportOpenAiResponse, "reportOpenAiResponse");
+function reportOpenAiChunk(handle, chunk) {
+  handle?.controller.record(
+    handle,
+    (output) => output.recordOpenAiChunk(chunk)
+  );
+}
+__name(reportOpenAiChunk, "reportOpenAiChunk");
+function reportAnthropicResponse(handle, response) {
+  handle?.controller.record(
+    handle,
+    (output) => output.recordAnthropicResponse(response)
+  );
+}
+__name(reportAnthropicResponse, "reportAnthropicResponse");
+function reportAnthropicEvent(handle, event) {
+  handle?.controller.record(
+    handle,
+    (output) => output.recordAnthropicEvent(event)
+  );
+}
+__name(reportAnthropicEvent, "reportAnthropicEvent");
+function reportGeminiResponse(handle, response) {
+  handle?.controller.record(
+    handle,
+    (output) => output.recordGeminiResponse(response)
+  );
+}
+__name(reportGeminiResponse, "reportGeminiResponse");
+function reportGeminiChunk(handle, chunk) {
+  handle?.controller.record(
+    handle,
+    (output) => output.recordGeminiChunk(chunk)
+  );
+}
+__name(reportGeminiChunk, "reportGeminiChunk");
+
+export {
+  createGenAiExchange,
+  reportOpenAiRequest,
+  reportAnthropicRequest,
+  reportAnthropicFollowingRequest,
+  reportGeminiRequest,
+  reportOpenAiResponse,
+  reportOpenAiChunk,
+  reportAnthropicResponse,
+  reportAnthropicEvent,
+  reportGeminiResponse,
+  reportGeminiChunk
+};
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-IO3IX5Q4.js → chunk-G4WFQUYQ.js}

@@ -6,7 +6,7 @@ import {
   getNestedProperty,
   getPersistScopeForModelSelection,
   restoreSettingsFromBackup
-} from "./chunk-TEHGS6UP.js";
+} from "./chunk-JALU3ZDU.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-VULLI6WQ.js → chunk-GDIPH4JY.js}

@@ -2,13 +2,13 @@
 "use strict";
 import {
   t
-} from "./chunk-LKEJ26GS.js";
+} from "./chunk-VV6XU5L7.js";
 import {
   SessionReferenceService,
   SessionService,
   readManyFiles,
   stripTerminalControlSequences
-} from "./chunk-PHOF65IG.js";
+} from "./chunk-DM4Q4JJH.js";
 import {
   emptyMcpResourceText,
   formatMcpResourceContents,
@@ -16,7 +16,7 @@ import {
 } from "./chunk-HTO4JFDZ.js";
 import {
   shouldRunVisionBridge
-} from "./chunk-CIKQ7KKO.js";
+} from "./chunk-RWS5VYWC.js";
 import {
   Storage,
   getErrorMessage,

package/chunks/chunk-HV3G62R6.js

@@ -0,0 +1,76 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  redactLogCredentials
+} from "./chunk-M5GB774H.js";
+import {
+  sanitizeLogText
+} from "./chunk-ML52PL6O.js";
+import {
+  stripAnsi
+} from "./chunk-TWPJO254.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/serve/channel-worker-diagnostics.ts
+init_esbuild_shims();
+var WORKER_LOG_INVISIBLE_RE = new RegExp("[\\p{Cf}\\u2028\\u2029]|\\p{Variation_Selector}", "gu");
+var WORKER_LOG_CONTROL_RE = /[\x00-\x1f\x7f-\x9f]/g;
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+__name(escapeRegExp, "escapeRegExp");
+function sensitiveEnvValues(env) {
+  const sensitiveKey = /(^|_)(TOKEN|SECRET|API_KEY|ACCESS_KEY|PRIVATE_KEY|CREDENTIAL|PASSWORD|PASSWD|PASSPHRASE|BASIC_AUTH|AUTH_TOKEN|AUTHORIZATION|SESSION_SECRET|SESSION_TOKEN|SESSION_KEY|SESSION_COOKIE|DSN|CONNECTION_STRING)($|_)/i;
+  return Object.entries(env).filter(([key, value]) => sensitiveKey.test(key) && value !== void 0).flatMap(([, value]) => {
+    const lines = value.split("\n").filter((line) => line.length >= 4);
+    return lines.length > 0 ? [value, ...lines] : [value];
+  }).filter((value) => value.length >= 4);
+}
+__name(sensitiveEnvValues, "sensitiveEnvValues");
+function normalizeWorkerDiagnostic(value) {
+  return stripAnsi(value).replace(WORKER_LOG_INVISIBLE_RE, "").replace(WORKER_LOG_CONTROL_RE, "");
+}
+__name(normalizeWorkerDiagnostic, "normalizeWorkerDiagnostic");
+function createWorkerDiagnosticRedactor(opts) {
+  const secretPatterns = [
+    ...new Set(
+      [
+        ...opts.daemonToken ? [opts.daemonToken] : [],
+        ...sensitiveEnvValues(opts.workerEnv)
+      ].flatMap((secret) => [
+        normalizeWorkerDiagnostic(secret),
+        normalizeWorkerDiagnostic(secret.replace(/\t/gu, " "))
+      ]).filter((secret) => secret.length >= 4)
+    )
+  ].sort((left, right) => right.length - left.length).map((secret) => new RegExp(escapeRegExp(secret), "g"));
+  return (value) => {
+    let redacted = value;
+    for (const secretPattern of secretPatterns) {
+      redacted = redacted.replace(secretPattern, "<redacted>");
+    }
+    return redactLogCredentials(redacted);
+  };
+}
+__name(createWorkerDiagnosticRedactor, "createWorkerDiagnosticRedactor");
+function sanitizeWorkerDiagnostic(value, maxLength, opts) {
+  const normalized = normalizeWorkerDiagnostic(value);
+  const redacted = createWorkerDiagnosticRedactor(opts)(normalized);
+  return sanitizeLogText(redacted, maxLength);
+}
+__name(sanitizeWorkerDiagnostic, "sanitizeWorkerDiagnostic");
+
+export {
+  normalizeWorkerDiagnostic,
+  createWorkerDiagnosticRedactor,
+  sanitizeWorkerDiagnostic
+};
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */