@qwen-code/qwen-code 0.21.0 → 0.21.1

package/chunks/{chunk-NIBLUX3Y.js → chunk-75MIQ3LV.js}

@@ -1,27 +1,28 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  stringifyGenAiJson
+} from "./chunk-DZLYR4U3.js";
 import {
   getMeter,
   isTelemetrySdkInitialized,
   truncateSpanError
-} from "./chunk-MB4MZHMJ.js";
+} from "./chunk-BGTQCTQW.js";
 import {
   require_src
-} from "./chunk-HTR4WV6U.js";
+} from "./chunk-W4RQUHY3.js";
 import {
   DEFAULT_SENSITIVE_SPAN_ATTRIBUTE_MAX_LENGTH,
   SENSITIVE_SPAN_ATTRIBUTE_MAX_LENGTH_LIMIT,
   SERVICE_NAME,
   isValidSensitiveSpanAttributeMaxLength
-} from "./chunk-BULDBTYC.js";
-import {
-  init_esm as init_esm2
-} from "./chunk-U7ZFW55U.js";
+} from "./chunk-S7W2GKIO.js";
 import {
   FatalConfigError,
+  createDebugLogger,
   formatTraceparent,
   getActiveSpanTraceContext
-} from "./chunk-NL7LTRLR.js";
+} from "./chunk-UHUSJ6X7.js";
 import {
   ROOT_CONTEXT,
   SpanKind,
@@ -32,7 +33,7 @@ import {
   init_esm,
   propagation,
   trace
-} from "./chunk-TARRHLLG.js";
+} from "./chunk-QUGAUQGJ.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -46,8 +47,6 @@ init_esbuild_shims();
 
 // packages/core/src/telemetry/index.ts
 init_esbuild_shims();
-init_esm();
-init_esm2();
 
 // packages/core/src/telemetry/daemon-tracing.ts
 init_esbuild_shims();
@@ -653,12 +652,127 @@ function registerEventLoopLagGauge(name, read) {
 }
 __name(registerEventLoopLagGauge, "registerEventLoopLagGauge");
 
+// packages/core/src/telemetry/detailed-span-attributes.ts
+init_esbuild_shims();
+var SHORT_TRUNCATION_SUFFIX = "...[TRUNCATED]";
+var debugLogger = createDebugLogger("GEN_AI_CONTENT");
+function areSensitiveSpanAttributesEnabled(config) {
+  return isTelemetrySdkInitialized() && config.getTelemetryIncludeSensitiveSpanAttributes();
+}
+__name(areSensitiveSpanAttributesEnabled, "areSensitiveSpanAttributesEnabled");
+function truncateContent(content, maxSize = DEFAULT_SENSITIVE_SPAN_ATTRIBUTE_MAX_LENGTH, originalLength = content.length) {
+  if (!Number.isSafeInteger(maxSize) || maxSize < 1) {
+    throw new TypeError(
+      `maxSize must be a positive safe integer, got ${String(maxSize)}`
+    );
+  }
+  if (!Number.isSafeInteger(originalLength) || originalLength < 0) {
+    throw new TypeError(
+      `originalLength must be a non-negative safe integer, got ${String(
+        originalLength
+      )}`
+    );
+  }
+  if (originalLength < content.length) {
+    throw new TypeError(
+      `originalLength must be greater than or equal to content length, got ${originalLength} for content length ${content.length}`
+    );
+  }
+  if (originalLength <= maxSize && content.length <= maxSize) {
+    return { content, truncated: false };
+  }
+  if (originalLength > content.length && content.length <= maxSize) {
+    return { content, truncated: true };
+  }
+  const suffix = `
+
+[TRUNCATED - Content exceeds configured limit of ${maxSize} characters]`;
+  if (suffix.length >= maxSize) {
+    if (SHORT_TRUNCATION_SUFFIX.length >= maxSize) {
+      return {
+        content: SHORT_TRUNCATION_SUFFIX.slice(0, maxSize),
+        truncated: true
+      };
+    }
+    return {
+      content: content.slice(0, maxSize - SHORT_TRUNCATION_SUFFIX.length) + SHORT_TRUNCATION_SUFFIX,
+      truncated: true
+    };
+  }
+  return {
+    content: content.slice(0, maxSize - suffix.length) + suffix,
+    truncated: true
+  };
+}
+__name(truncateContent, "truncateContent");
+function getMaxContentSize(config) {
+  return config.getTelemetrySensitiveSpanAttributeMaxLength();
+}
+__name(getMaxContentSize, "getMaxContentSize");
+function truncatePrefixedContent(prefix, content, maxSize) {
+  const prefixedContent = `${prefix}${content}`;
+  const result = truncateContent(prefixedContent, maxSize);
+  return {
+    ...result,
+    originalLength: content.length
+  };
+}
+__name(truncatePrefixedContent, "truncatePrefixedContent");
+function addUserPromptAttributes(config, span, promptText) {
+  if (!areSensitiveSpanAttributesEnabled(config) || !promptText) return;
+  const { content, truncated, originalLength } = truncatePrefixedContent(
+    `[USER PROMPT]
+`,
+    promptText,
+    getMaxContentSize(config)
+  );
+  span.setAttributes({
+    new_context: content,
+    ...truncated && {
+      new_context_truncated: true,
+      new_context_original_length: originalLength
+    }
+  });
+}
+__name(addUserPromptAttributes, "addUserPromptAttributes");
+function addToolArgumentsAttributes(config, span, argumentsValue) {
+  if (!areSensitiveSpanAttributesEnabled(config)) return;
+  writeJsonAttribute(
+    config,
+    span,
+    "gen_ai.tool.call.arguments",
+    argumentsValue,
+    true
+  );
+}
+__name(addToolArgumentsAttributes, "addToolArgumentsAttributes");
+function addToolCallResultAttributes(config, span, result) {
+  if (!areSensitiveSpanAttributesEnabled(config)) return;
+  writeJsonAttribute(config, span, "gen_ai.tool.call.result", result, true);
+}
+__name(addToolCallResultAttributes, "addToolCallResultAttributes");
+function writeJsonAttribute(config, span, key, value, requireObject = false) {
+  let serialized;
+  try {
+    serialized = stringifyGenAiJson(
+      value,
+      getMaxContentSize(config),
+      requireObject
+    );
+  } catch {
+    debugLogger.debug(`Failed to serialize ${key} span attribute`);
+    return;
+  }
+  if (serialized === void 0) return;
+  try {
+    span.setAttribute(key, serialized);
+  } catch {
+    debugLogger.debug(`Failed to set ${key} span attribute`);
+  }
+}
+__name(writeJsonAttribute, "writeJsonAttribute");
+
 // packages/core/src/telemetry/index.ts
-var TelemetryTarget = /* @__PURE__ */ ((TelemetryTarget2) => {
-  TelemetryTarget2["GCP"] = "gcp";
-  TelemetryTarget2["LOCAL"] = "local";
-  return TelemetryTarget2;
-})(TelemetryTarget || {});
 var DEFAULT_TELEMETRY_TARGET = "local" /* LOCAL */;
 var DEFAULT_OTLP_ENDPOINT = "http://localhost:4317";
 
@@ -799,6 +913,16 @@ function parseSensitiveSpanAttributeMaxLengthSetting(settingName, value) {
   return value;
 }
 __name(parseSensitiveSpanAttributeMaxLengthSetting, "parseSensitiveSpanAttributeMaxLengthSetting");
+function parseTelemetryUserId(source, value) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string") {
+    throw new FatalConfigError(
+      `Invalid ${source}: must be a string, got ${typeof value}`
+    );
+  }
+  return value.trim() || void 0;
+}
+__name(parseTelemetryUserId, "parseTelemetryUserId");
 async function resolveTelemetrySettings(options) {
   const argv = options.argv ?? {};
   const env = options.env ?? {};
@@ -826,6 +950,10 @@ async function resolveTelemetrySettings(options) {
     );
   }
   const logPrompts = argv.telemetryLogPrompts ?? parseBooleanEnvFlag(env["QWEN_TELEMETRY_LOG_PROMPTS"]) ?? settings.logPrompts;
+  const userId = parseTelemetryUserId(
+    "QWEN_TELEMETRY_USER_ID",
+    env["QWEN_TELEMETRY_USER_ID"]
+  ) ?? parseTelemetryUserId("telemetry.userId", settings.userId);
   const includeSensitiveSpanAttributes = parseBooleanEnvFlag(
     env["QWEN_TELEMETRY_INCLUDE_SENSITIVE_SPAN_ATTRIBUTES"]
   ) ?? settings.includeSensitiveSpanAttributes ?? false;
@@ -876,6 +1004,7 @@ async function resolveTelemetrySettings(options) {
     otlpLogsEndpoint,
     otlpMetricsEndpoint,
     logPrompts,
+    userId,
     includeSensitiveSpanAttributes,
     sensitiveSpanAttributeMaxLength,
     outfile,
@@ -888,21 +1017,16 @@ __name(resolveTelemetrySettings, "resolveTelemetrySettings");
 
 export {
   parseBooleanEnvFlag,
-  parseTelemetryTargetValue,
   resolveTelemetrySettings,
   DAEMON_TRACEPARENT_META_KEY,
   DAEMON_TRACESTATE_META_KEY,
   hashDaemonWorkspace,
   withDaemonSpan,
   withDaemonRequestSpan,
-  withDaemonBridgeSpan,
   recordDaemonHttpResponse,
   addDaemonRequestAttribute,
   recordDaemonError,
   emitDaemonLog,
-  captureDaemonTelemetryContext,
-  runWithDaemonTelemetryContext,
-  injectDaemonTraceContext,
   extractDaemonTraceContext,
   createDaemonBridgeTelemetry,
   initializeDaemonMetrics,
@@ -918,7 +1042,10 @@ export {
   startEventLoopLagMonitor,
   registerDaemonEventLoopLagGauge,
   registerAcpEventLoopLagGauge,
-  TelemetryTarget,
+  areSensitiveSpanAttributesEnabled,
+  addUserPromptAttributes,
+  addToolArgumentsAttributes,
+  addToolCallResultAttributes,
   DEFAULT_TELEMETRY_TARGET,
   DEFAULT_OTLP_ENDPOINT
 };

package/chunks/{chunk-U7M2DMGW.js → chunk-7AEJDLRA.js}

@@ -2,15 +2,15 @@
 "use strict";
 import {
   sanitizeFilenameForDisplay
-} from "./chunk-IPUUTYMV.js";
+} from "./chunk-YDLJGZHL.js";
 import {
   t
-} from "./chunk-LKEJ26GS.js";
+} from "./chunk-TCIFAA7K.js";
 import {
   fetchGitDiff,
   findProviderByCredentials,
   resolveMetadataKey
-} from "./chunk-PHOF65IG.js";
+} from "./chunk-X5WNMMIA.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -274,6 +274,115 @@ var diffCommand = {
   action: diffAction
 };
 
+// packages/cli/src/ui/utils/inline-math.ts
+init_esbuild_shims();
+var INLINE_MATH_MAX_CHARS = 1024;
+var INLINE_CODE_SPAN_PATTERN_SOURCE = String.raw`(?<!\`)(?<inlineCodeFence>\`+)(?!\`).+?(?<!\`)\k<inlineCodeFence>(?!\`)`;
+var INLINE_CODE_SPAN_RE = new RegExp(INLINE_CODE_SPAN_PATTERN_SOURCE, "g");
+function isEscapedAt(text, index) {
+  let slashCount = 0;
+  for (let cursor = index - 1; cursor >= 0 && text[cursor] === "\\"; cursor -= 1) {
+    slashCount += 1;
+  }
+  return slashCount % 2 === 1;
+}
+__name(isEscapedAt, "isEscapedAt");
+function isUnescapedDollarAt(text, index) {
+  return text[index] === "$" && !isEscapedAt(text, index);
+}
+__name(isUnescapedDollarAt, "isUnescapedDollarAt");
+function unescapeMarkdownDollars(text) {
+  return text.replace(
+    /(\\+)\$/g,
+    (_match, slashes) => `${"\\".repeat(Math.floor(slashes.length / 2))}$`
+  );
+}
+__name(unescapeMarkdownDollars, "unescapeMarkdownDollars");
+function unescapeMarkdownBeforeMath(text) {
+  return unescapeMarkdownDollars(`${text}$`).slice(0, -1);
+}
+__name(unescapeMarkdownBeforeMath, "unescapeMarkdownBeforeMath");
+function readInlineMathSpan(text, index) {
+  if (!isUnescapedDollarAt(text, index)) {
+    return null;
+  }
+  const previous = text[index - 1] ?? "";
+  const next = text[index + 1] ?? "";
+  if (/\w/.test(previous) || isUnescapedDollarAt(text, index - 1) || !next || /[\s\d$]/.test(next)) {
+    return null;
+  }
+  let closingIndex = index + 1;
+  while (closingIndex < text.length && text[closingIndex] !== "\n" && closingIndex - index - 1 <= INLINE_MATH_MAX_CHARS && !isUnescapedDollarAt(text, closingIndex)) {
+    closingIndex += 1;
+  }
+  if (!isUnescapedDollarAt(text, closingIndex)) {
+    return null;
+  }
+  const content = text.slice(index + 1, closingIndex);
+  const following = text[closingIndex + 1] ?? "";
+  if (content.length > INLINE_MATH_MAX_CHARS || /\s$/.test(content) || /[\w$]/.test(following)) {
+    return null;
+  }
+  return {
+    content,
+    index,
+    raw: text.slice(index, closingIndex + 1)
+  };
+}
+__name(readInlineMathSpan, "readInlineMathSpan");
+function findNextInlineMath(text, fromIndex = 0) {
+  for (let index = fromIndex; index < text.length; index += 1) {
+    const span = readInlineMathSpan(text, index);
+    if (span) {
+      return span;
+    }
+  }
+  return null;
+}
+__name(findNextInlineMath, "findNextInlineMath");
+function* mergeInlineMathMatches(text, markupRegex, enableInlineMath = true) {
+  markupRegex.lastIndex = 0;
+  const markupMatches = text.matchAll(markupRegex);
+  let nextMarkup = markupMatches.next();
+  let nextMath = enableInlineMath ? findNextInlineMath(text) : null;
+  let cursor = 0;
+  while (!nextMarkup.done || nextMath) {
+    while (!nextMarkup.done && (nextMarkup.value.index ?? 0) < cursor) {
+      nextMarkup = markupMatches.next();
+    }
+    if (nextMath && nextMath.index < cursor) {
+      nextMath = findNextInlineMath(text, cursor);
+    }
+    const markupIndex = nextMarkup.done ? Number.POSITIVE_INFINITY : nextMarkup.value.index ?? 0;
+    const mathIndex = nextMath?.index ?? Number.POSITIVE_INFINITY;
+    if (!nextMarkup.done && markupIndex <= mathIndex) {
+      const match = nextMarkup.value;
+      yield { kind: "markup", match };
+      cursor = markupIndex + match[0].length;
+      nextMarkup = markupMatches.next();
+    } else if (nextMath) {
+      yield { kind: "math", span: nextMath };
+      cursor = mathIndex + nextMath.raw.length;
+      nextMath = findNextInlineMath(text, cursor);
+    }
+  }
+}
+__name(mergeInlineMathMatches, "mergeInlineMathMatches");
+function findInlineMathExpressions(text) {
+  const expressions = [];
+  for (const token of mergeInlineMathMatches(text, INLINE_CODE_SPAN_RE)) {
+    if (token.kind === "math") {
+      expressions.push(token.span.content);
+    }
+  }
+  return expressions;
+}
+__name(findInlineMathExpressions, "findInlineMathExpressions");
+function readInlineMathSpanAt(text, index) {
+  return readInlineMathSpan(text, index)?.raw ?? null;
+}
+__name(readInlineMathSpanAt, "readInlineMathSpanAt");
+
 // packages/cli/src/utils/systemInfoFields.ts
 init_esbuild_shims();
 function getSystemInfoFields(info) {
@@ -390,10 +499,15 @@ init_esbuild_shims();
 function calculateCost(args) {
   const { inputTokens, outputTokens, pricing } = args;
   if (!pricing) return null;
+  if (pricing.inputPerMillionTokens == null && pricing.outputPerMillionTokens == null) {
+    return null;
+  }
+  if (inputTokens <= 0 && outputTokens <= 0) {
+    return null;
+  }
   const inputCost = pricing.inputPerMillionTokens != null ? inputTokens / 1e6 * pricing.inputPerMillionTokens : 0;
   const outputCost = pricing.outputPerMillionTokens != null ? outputTokens / 1e6 * pricing.outputPerMillionTokens : 0;
-  const total = inputCost + outputCost;
-  return total > 0 ? total : null;
+  return inputCost + outputCost;
 }
 __name(calculateCost, "calculateCost");
 
@@ -418,6 +532,12 @@ function levelLabel(level) {
 __name(levelLabel, "levelLabel");
 
 export {
+  INLINE_CODE_SPAN_PATTERN_SOURCE,
+  unescapeMarkdownDollars,
+  unescapeMarkdownBeforeMath,
+  mergeInlineMathMatches,
+  findInlineMathExpressions,
+  readInlineMathSpanAt,
   getSystemInfoFields,
   calculateErrorRate,
   calculateAverageLatency,
@@ -435,6 +555,11 @@ export {
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
 /**
  * @license
  * Copyright 2025 Qwen