@qwen-code/qwen-code 0.22.2 → 0.22.3-nightly.20260829.e5cb60ad48

package/chunks/{chunk-L6BZRIUL.js → chunk-B5PHIJGI.js}

@@ -877,6 +877,168 @@ function redactUrlCredentials(source) {
 }
 __name(redactUrlCredentials, "redactUrlCredentials");
 
+// packages/core/src/telemetry/context-usage.ts
+init_esbuild_shims();
+var CONTEXT_USAGE_ATTRIBUTE = "qwen-code.context.usage";
+var MAX_CONTEXT_USAGE_ATTRIBUTE_LENGTH = 1024;
+var MAX_SERIALIZED_NON_NEGATIVE_NUMBER = 10000000000000002e-22;
+var contextUsageAttributeLengthLimit = MAX_CONTEXT_USAGE_ATTRIBUTE_LENGTH;
+var FIXED_CATEGORY_KEYS = [
+  "system_prompt_tokens",
+  "builtin_tools_tokens",
+  "mcp_tools_tokens",
+  "memory_files_tokens",
+  "skills_tokens"
+];
+var CATEGORY_KEYS = [...FIXED_CATEGORY_KEYS, "messages_tokens"];
+function configureContextUsageAttributeLengthLimit(otelSpanAttributeValueLengthLimit) {
+  contextUsageAttributeLengthLimit = otelSpanAttributeValueLengthLimit !== void 0 && otelSpanAttributeValueLengthLimit > 0 ? Math.min(
+    MAX_CONTEXT_USAGE_ATTRIBUTE_LENGTH,
+    otelSpanAttributeValueLengthLimit
+  ) : MAX_CONTEXT_USAGE_ATTRIBUTE_LENGTH;
+}
+__name(configureContextUsageAttributeLengthLimit, "configureContextUsageAttributeLengthLimit");
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+__name(isRecord, "isRecord");
+function isNonNegativeFinite(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+__name(isNonNegativeFinite, "isNonNegativeFinite");
+function cloneContextUsage(value) {
+  try {
+    if (!isRecord(value)) return void 0;
+    const breakdown = value["breakdown"];
+    if (!isRecord(breakdown)) return void 0;
+    const windowSizeTokens = value["window_size_tokens"];
+    const compactionReserveTokens = value["compaction_reserve_tokens"];
+    const availableBeforeCompactionTokens = value["available_before_compaction_tokens"];
+    const categoryTokens = Object.fromEntries(
+      CATEGORY_KEYS.map((key) => [key, breakdown[key]])
+    );
+    const valid = value["version"] === 1 && value["estimated"] === true && Number.isSafeInteger(windowSizeTokens) && windowSizeTokens > 0 && isNonNegativeFinite(compactionReserveTokens) && (availableBeforeCompactionTokens === void 0 || isNonNegativeFinite(availableBeforeCompactionTokens)) && CATEGORY_KEYS.every(
+      (key) => Number.isSafeInteger(categoryTokens[key]) && categoryTokens[key] >= 0
+    );
+    if (!valid) return void 0;
+    return {
+      version: 1,
+      window_size_tokens: windowSizeTokens,
+      breakdown: {
+        system_prompt_tokens: categoryTokens.system_prompt_tokens,
+        builtin_tools_tokens: categoryTokens.builtin_tools_tokens,
+        mcp_tools_tokens: categoryTokens.mcp_tools_tokens,
+        memory_files_tokens: categoryTokens.memory_files_tokens,
+        skills_tokens: categoryTokens.skills_tokens,
+        messages_tokens: categoryTokens.messages_tokens
+      },
+      compaction_reserve_tokens: compactionReserveTokens,
+      ...availableBeforeCompactionTokens === void 0 ? {} : {
+        available_before_compaction_tokens: availableBeforeCompactionTokens
+      },
+      estimated: true
+    };
+  } catch {
+    return void 0;
+  }
+}
+__name(cloneContextUsage, "cloneContextUsage");
+function isValidContextUsage(value) {
+  return cloneContextUsage(value) !== void 0;
+}
+__name(isValidContextUsage, "isValidContextUsage");
+function normalizeContextUsage(snapshot, providerTotal) {
+  const validSnapshot = cloneContextUsage(snapshot);
+  if (!validSnapshot || !Number.isSafeInteger(providerTotal) || providerTotal < 0) {
+    return snapshot;
+  }
+  const providerTotalBigInt = BigInt(providerTotal);
+  const fixedSum = FIXED_CATEGORY_KEYS.reduce(
+    (sum, key) => sum + BigInt(validSnapshot.breakdown[key]),
+    0n
+  );
+  let fixed;
+  let messagesTokens;
+  if (fixedSum > providerTotalBigInt) {
+    const allocations = FIXED_CATEGORY_KEYS.map((key, index) => {
+      const numerator = BigInt(validSnapshot.breakdown[key]) * providerTotalBigInt;
+      return {
+        key,
+        index,
+        floor: numerator / fixedSum,
+        remainder: numerator % fixedSum
+      };
+    });
+    let remaining = providerTotalBigInt - allocations.reduce((sum, item) => sum + item.floor, 0n);
+    const rankedAllocations = [...allocations].sort((left, right) => {
+      if (left.remainder === right.remainder) {
+        return left.index - right.index;
+      }
+      return left.remainder > right.remainder ? -1 : 1;
+    });
+    for (const allocation of rankedAllocations) {
+      if (remaining === 0n) break;
+      allocation.floor += 1n;
+      remaining -= 1n;
+    }
+    fixed = Object.fromEntries(
+      allocations.map((allocation) => [
+        allocation.key,
+        Number(allocation.floor)
+      ])
+    );
+    messagesTokens = 0;
+  } else {
+    fixed = Object.fromEntries(
+      FIXED_CATEGORY_KEYS.map((key) => [key, validSnapshot.breakdown[key]])
+    );
+    messagesTokens = Number(providerTotalBigInt - fixedSum);
+  }
+  return {
+    ...validSnapshot,
+    breakdown: {
+      ...fixed,
+      messages_tokens: messagesTokens
+    },
+    available_before_compaction_tokens: Math.max(
+      0,
+      validSnapshot.window_size_tokens - validSnapshot.compaction_reserve_tokens - providerTotal
+    )
+  };
+}
+__name(normalizeContextUsage, "normalizeContextUsage");
+function serializeContextUsage(contextUsage) {
+  try {
+    const canonical = cloneContextUsage(contextUsage);
+    if (!canonical) return void 0;
+    return serializeCanonicalContextUsage(canonical);
+  } catch {
+    return void 0;
+  }
+}
+__name(serializeContextUsage, "serializeContextUsage");
+function serializeContextUsageForSpanStart(contextUsage) {
+  const canonical = cloneContextUsage(contextUsage);
+  if (!canonical) return void 0;
+  const serialized = serializeCanonicalContextUsage(canonical);
+  if (!serialized) return void 0;
+  const maximumFinalizedSize = serializeCanonicalContextUsage({
+    ...canonical,
+    breakdown: {
+      ...canonical.breakdown,
+      messages_tokens: Number.MAX_SAFE_INTEGER
+    },
+    available_before_compaction_tokens: MAX_SERIALIZED_NON_NEGATIVE_NUMBER
+  });
+  return maximumFinalizedSize ? serialized : void 0;
+}
+__name(serializeContextUsageForSpanStart, "serializeContextUsageForSpanStart");
+function serializeCanonicalContextUsage(contextUsage) {
+  const serialized = JSON.stringify(contextUsage);
+  return serialized.length <= contextUsageAttributeLengthLimit ? serialized : void 0;
+}
+__name(serializeCanonicalContextUsage, "serializeCanonicalContextUsage");
+
 // packages/core/src/telemetry/session-tracing.ts
 init_esbuild_shims();
 init_esm();
@@ -1054,7 +1216,7 @@ function initializeTelemetry(config) {
   telemetryInitPromise ??= (async () => {
     const debugLogger3 = createDebugLogger("OTEL");
     try {
-      const { startTelemetrySdk } = await import("./sdk-impl-HLSEDAEP.js");
+      const { startTelemetrySdk } = await import("./sdk-impl-UUMVYMAL.js");
       if (telemetryInitialized) return;
       const started = await startTelemetrySdk(config);
       if (!started) return;
@@ -1560,6 +1722,8 @@ function startLLMRequestSpanWithContext(model, promptId, options) {
   const ctx = resolveGenAiParentContext(parentCtx);
   const sessionId = resolveSessionId(parentCtx, options?.sessionId, ctx);
   const userId = resolveGenAiUserId(parentCtx, promptId, options?.userId);
+  const contextUsage = cloneContextUsage(options?.contextUsage);
+  const serializedContextUsage = serializeContextUsageForSpanStart(contextUsage);
   const attributes = {
     ...sessionId ? { "session.id": sessionId } : {},
     ...sessionId ? { "gen_ai.conversation.id": sessionId } : {},
@@ -1570,7 +1734,8 @@ function startLLMRequestSpanWithContext(model, promptId, options) {
     "gen_ai.request.model": model,
     ...options?.operationName ? { "gen_ai.operation.name": options.operationName } : {},
     ...options?.providerName ? { "gen_ai.provider.name": options.providerName } : {},
-    ...options?.outputType ? { "gen_ai.output.type": options.outputType } : {}
+    ...options?.outputType ? { "gen_ai.output.type": options.outputType } : {},
+    ...serializedContextUsage ? { [CONTEXT_USAGE_ATTRIBUTE]: serializedContextUsage } : {}
   };
   const sessionContext = setSessionIdOnContext(ctx, sessionId);
   const span = getTracer().startSpan(
@@ -1583,6 +1748,7 @@ function startLLMRequestSpanWithContext(model, promptId, options) {
     span,
     startTime: Date.now(),
     ...interactionParentCtx ? { interactionOwner: interactionParentCtx } : {},
+    ...serializedContextUsage && contextUsage ? { contextUsage } : {},
     attributes,
     type: "llm_request"
   };
@@ -1609,8 +1775,18 @@ function endLLMRequestSpan(span, metadata) {
     const duration = metadata?.durationMs ?? Date.now() - spanCtx.startTime;
     const endAttributes = { duration_ms: duration };
     if (metadata) {
-      if (metadata.inputTokens !== void 0 && Number.isSafeInteger(metadata.inputTokens) && metadata.inputTokens >= 0) {
-        endAttributes["gen_ai.usage.input_tokens"] = metadata.inputTokens;
+      const inputTokens = metadata.inputTokens;
+      const hasValidInputTokens = inputTokens !== void 0 && Number.isSafeInteger(inputTokens) && inputTokens >= 0;
+      if (hasValidInputTokens) {
+        endAttributes["gen_ai.usage.input_tokens"] = inputTokens;
+        if (spanCtx.contextUsage) {
+          const normalized = serializeContextUsage(
+            normalizeContextUsage(spanCtx.contextUsage, inputTokens)
+          );
+          if (normalized) {
+            endAttributes[CONTEXT_USAGE_ATTRIBUTE] = normalized;
+          }
+        }
       }
       if (metadata.outputTokens !== void 0 && Number.isSafeInteger(metadata.outputTokens) && metadata.outputTokens >= 0) {
         endAttributes["gen_ai.usage.output_tokens"] = metadata.outputTokens;
@@ -2382,6 +2558,8 @@ export {
   isBinary,
   normalizeContent,
   redactUrlCredentials,
+  configureContextUsageAttributeLengthLimit,
+  isValidContextUsage,
   isInNativeSubagentSpan,
   truncateSpanError,
   startInteractionSpan,