@qwen-code/qwen-code 0.20.2-headless-image-routing.1 → 0.21.0

package/chunks/chunk-LS77BEZP.js

@@ -0,0 +1,405 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/core/tool-call-preparation.ts
+init_esbuild_shims();
+var preparationsByResponse = /* @__PURE__ */ new WeakMap();
+function setToolCallPreparations(response, preparations) {
+  preparationsByResponse.set(response, preparations);
+}
+__name(setToolCallPreparations, "setToolCallPreparations");
+function getToolCallPreparations(response) {
+  return preparationsByResponse.get(response) ?? [];
+}
+__name(getToolCallPreparations, "getToolCallPreparations");
+
+// packages/core/src/utils/runtimeDiagnostics.ts
+init_esbuild_shims();
+var RUNTIME_PROFILE_ENV = "QWEN_CODE_PROFILE_RUNTIME";
+function isRuntimeDiagnosticsEnabled(env = process.env) {
+  return env[RUNTIME_PROFILE_ENV] === "1";
+}
+__name(isRuntimeDiagnosticsEnabled, "isRuntimeDiagnosticsEnabled");
+var RuntimeDiagnosticsCollector = class {
+  static {
+    __name(this, "RuntimeDiagnosticsCollector");
+  }
+  enabled;
+  now;
+  startedAt;
+  requestIndex = 0;
+  openAIWireRequestIndex = 0;
+  anthropicWireRequestIndex = 0;
+  requests = [];
+  openaiWireRequests = [];
+  anthropicWireRequests = [];
+  tools = createInitialToolDiagnostics();
+  constructor(options = {}) {
+    this.enabled = options.enabled ?? isRuntimeDiagnosticsEnabled();
+    this.now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+    this.startedAt = this.now();
+  }
+  reset(options = {}) {
+    this.enabled = options.enabled ?? isRuntimeDiagnosticsEnabled();
+    this.startedAt = this.now();
+    this.requestIndex = 0;
+    this.openAIWireRequestIndex = 0;
+    this.anthropicWireRequestIndex = 0;
+    this.requests = [];
+    this.openaiWireRequests = [];
+    this.anthropicWireRequests = [];
+    this.tools = createInitialToolDiagnostics();
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  recordGenerateContentRequest(request, options) {
+    if (!this.enabled) {
+      return;
+    }
+    this.requestIndex += 1;
+    this.requests.push({
+      index: this.requestIndex,
+      timestamp: this.now(),
+      source: options.source,
+      model: request.model,
+      stream: options.stream,
+      serializedBytes: utf8Bytes(toJsonSafeRequest(request)),
+      contents: summarizeContents(request.contents),
+      systemInstructionBytes: summarizeContentTextBytes(
+        request.config?.systemInstruction
+      ),
+      generationConfigBytes: utf8Bytes(toJsonSafeConfig(request.config)),
+      tools: summarizeToolSchemas(request.config?.tools)
+    });
+  }
+  recordOpenAIWireRequest(request) {
+    if (!this.enabled) {
+      return;
+    }
+    this.openAIWireRequestIndex += 1;
+    this.openaiWireRequests.push({
+      index: this.openAIWireRequestIndex,
+      timestamp: this.now(),
+      ...summarizeOpenAIWireRequest(request)
+    });
+  }
+  recordAnthropicWireRequest(request) {
+    if (!this.enabled) {
+      return;
+    }
+    this.anthropicWireRequestIndex += 1;
+    this.anthropicWireRequests.push({
+      index: this.anthropicWireRequestIndex,
+      timestamp: this.now(),
+      ...summarizeAnthropicWireRequest(request)
+    });
+  }
+  recordToolUse(name, args) {
+    if (!this.enabled) {
+      return;
+    }
+    const argBytes = utf8Bytes(args);
+    const tool = this.getToolNameDiagnostics(name);
+    tool.uses += 1;
+    tool.argBytes += argBytes;
+    tool.maxArgBytes = Math.max(tool.maxArgBytes, argBytes);
+    this.tools.toolUseCount += 1;
+    this.tools.totalToolUseArgBytes += argBytes;
+    this.tools.maxToolUseArgBytes = Math.max(
+      this.tools.maxToolUseArgBytes,
+      argBytes
+    );
+  }
+  recordToolResult(record) {
+    if (!this.enabled) {
+      return;
+    }
+    const tool = this.getToolNameDiagnostics(record.name);
+    tool.results += 1;
+    tool.resultBytes += record.resultBytes;
+    tool.maxResultBytes = Math.max(tool.maxResultBytes, record.resultBytes);
+    if (record.isError) {
+      tool.errors += 1;
+      this.tools.toolResultErrorCount += 1;
+    }
+    this.tools.toolResultCount += 1;
+    this.tools.totalToolResultBytes += record.resultBytes;
+    this.tools.maxToolResultBytes = Math.max(
+      this.tools.maxToolResultBytes,
+      record.resultBytes
+    );
+  }
+  snapshot() {
+    return {
+      enabled: this.enabled,
+      startedAt: this.startedAt,
+      requests: this.requests.map((request) => ({
+        ...request,
+        contents: {
+          ...request.contents,
+          roleCounts: { ...request.contents.roleCounts }
+        },
+        tools: { ...request.tools }
+      })),
+      openaiWireRequests: this.openaiWireRequests.map((request) => ({
+        ...request,
+        messageBytesByRole: { ...request.messageBytesByRole },
+        topLevelKeys: [...request.topLevelKeys]
+      })),
+      anthropicWireRequests: this.anthropicWireRequests.map((request) => ({
+        ...request,
+        messageBytesByRole: { ...request.messageBytesByRole },
+        topLevelKeys: [...request.topLevelKeys]
+      })),
+      tools: {
+        ...this.tools,
+        byName: Object.fromEntries(
+          Object.entries(this.tools.byName).map(([name, value]) => [
+            name,
+            { ...value }
+          ])
+        )
+      }
+    };
+  }
+  getToolNameDiagnostics(name) {
+    const existing = this.tools.byName[name];
+    if (existing) {
+      return existing;
+    }
+    const created = createInitialToolNameDiagnostics();
+    this.tools.byName[name] = created;
+    return created;
+  }
+};
+var runtimeDiagnostics = new RuntimeDiagnosticsCollector();
+function summarizeOpenAIWireRequest(request) {
+  const requestRecord = asRecord(request);
+  const messages = Array.isArray(requestRecord["messages"]) ? requestRecord["messages"] : [];
+  const tools = Array.isArray(requestRecord["tools"]) ? requestRecord["tools"] : [];
+  const messageBytesByRole = {};
+  for (const message of messages) {
+    const messageRecord = asRecord(message);
+    const role = typeof messageRecord["role"] === "string" ? messageRecord["role"] : "unknown";
+    messageBytesByRole[role] = (messageBytesByRole[role] ?? 0) + utf8Bytes(messageRecord["content"]);
+  }
+  return {
+    model: typeof requestRecord["model"] === "string" ? requestRecord["model"] : "unknown",
+    stream: requestRecord["stream"] === true,
+    bodyBytes: utf8Bytes(request),
+    messageCount: messages.length,
+    messageBytesByRole,
+    toolsCount: tools.length,
+    toolSchemaBytes: utf8Bytes(tools),
+    topLevelKeys: Object.keys(requestRecord).sort()
+  };
+}
+__name(summarizeOpenAIWireRequest, "summarizeOpenAIWireRequest");
+function summarizeAnthropicWireRequest(request) {
+  const requestRecord = asRecord(request);
+  const messages = Array.isArray(requestRecord["messages"]) ? requestRecord["messages"] : [];
+  const tools = Array.isArray(requestRecord["tools"]) ? requestRecord["tools"] : [];
+  const messageBytesByRole = {};
+  for (const message of messages) {
+    const messageRecord = asRecord(message);
+    const role = typeof messageRecord["role"] === "string" ? messageRecord["role"] : "unknown";
+    messageBytesByRole[role] = (messageBytesByRole[role] ?? 0) + utf8Bytes(messageRecord["content"]);
+  }
+  return {
+    model: typeof requestRecord["model"] === "string" ? requestRecord["model"] : "unknown",
+    stream: requestRecord["stream"] === true,
+    bodyBytes: utf8Bytes(request),
+    messageCount: messages.length,
+    messageBytesByRole,
+    systemBytes: utf8Bytes(requestRecord["system"]),
+    toolsCount: tools.length,
+    toolSchemaBytes: utf8Bytes(tools),
+    topLevelKeys: Object.keys(requestRecord).sort()
+  };
+}
+__name(summarizeAnthropicWireRequest, "summarizeAnthropicWireRequest");
+function createInitialToolDiagnostics() {
+  return {
+    toolUseCount: 0,
+    toolResultCount: 0,
+    toolResultErrorCount: 0,
+    totalToolUseArgBytes: 0,
+    maxToolUseArgBytes: 0,
+    totalToolResultBytes: 0,
+    maxToolResultBytes: 0,
+    byName: /* @__PURE__ */ Object.create(null)
+  };
+}
+__name(createInitialToolDiagnostics, "createInitialToolDiagnostics");
+function createInitialToolNameDiagnostics() {
+  return {
+    uses: 0,
+    argBytes: 0,
+    maxArgBytes: 0,
+    results: 0,
+    errors: 0,
+    resultBytes: 0,
+    maxResultBytes: 0
+  };
+}
+__name(createInitialToolNameDiagnostics, "createInitialToolNameDiagnostics");
+function summarizeContents(contents) {
+  const summary = {
+    count: 0,
+    roleCounts: {},
+    partCount: 0,
+    textBytes: 0,
+    functionCallCount: 0,
+    functionCallArgBytes: 0,
+    functionResponseCount: 0,
+    functionResponseBytes: 0,
+    inlineDataCount: 0,
+    inlineDataBytes: 0,
+    fileDataCount: 0
+  };
+  const contentItems = Array.isArray(contents) ? contents : contents === void 0 || contents === null ? [] : [contents];
+  for (const content of contentItems) {
+    summary.count += 1;
+    if (typeof content === "string") {
+      summary.roleCounts["user"] = (summary.roleCounts["user"] ?? 0) + 1;
+      summary.partCount += 1;
+      summary.textBytes += utf8Bytes(content);
+      continue;
+    }
+    const contentRecord = asRecord(content);
+    const role = typeof contentRecord["role"] === "string" ? contentRecord["role"] : "unknown";
+    summary.roleCounts[role] = (summary.roleCounts[role] ?? 0) + 1;
+    const parts = Array.isArray(contentRecord["parts"]) ? contentRecord["parts"] : [];
+    summarizeParts(parts, summary);
+  }
+  return summary;
+}
+__name(summarizeContents, "summarizeContents");
+function summarizeContentTextBytes(content) {
+  const summary = summarizeContents(content);
+  return summary.textBytes;
+}
+__name(summarizeContentTextBytes, "summarizeContentTextBytes");
+function summarizeParts(parts, summary) {
+  for (const part of parts) {
+    summary.partCount += 1;
+    if (typeof part === "string") {
+      summary.textBytes += utf8Bytes(part);
+      continue;
+    }
+    const partRecord = asRecord(part);
+    if (typeof partRecord["text"] === "string") {
+      summary.textBytes += utf8Bytes(partRecord["text"]);
+    }
+    const functionCall = asOptionalRecord(partRecord["functionCall"]);
+    if (functionCall) {
+      summary.functionCallCount += 1;
+      summary.functionCallArgBytes += utf8Bytes(functionCall["args"]);
+    }
+    const functionResponse = asOptionalRecord(partRecord["functionResponse"]);
+    if (functionResponse) {
+      summary.functionResponseCount += 1;
+      summary.functionResponseBytes += utf8Bytes(functionResponse["response"]) + utf8Bytes(functionResponse["parts"]);
+    }
+    const inlineData = asOptionalRecord(partRecord["inlineData"]);
+    if (inlineData) {
+      summary.inlineDataCount += 1;
+      summary.inlineDataBytes += utf8Bytes(inlineData["data"]);
+    }
+    if (partRecord["fileData"]) {
+      summary.fileDataCount += 1;
+    }
+  }
+}
+__name(summarizeParts, "summarizeParts");
+function summarizeToolSchemas(tools) {
+  const toolList = Array.isArray(tools) ? tools : [];
+  let functionDeclarationCount = 0;
+  for (const tool of toolList) {
+    const toolRecord = asRecord(tool);
+    const declarations = Array.isArray(toolRecord["functionDeclarations"]) ? toolRecord["functionDeclarations"] : [];
+    functionDeclarationCount += declarations.length;
+  }
+  return {
+    count: toolList.length,
+    functionDeclarationCount,
+    schemaBytes: utf8Bytes(toolList)
+  };
+}
+__name(summarizeToolSchemas, "summarizeToolSchemas");
+function toJsonSafeRequest(request) {
+  return {
+    model: request.model,
+    contents: request.contents,
+    config: toJsonSafeConfig(request.config)
+  };
+}
+__name(toJsonSafeRequest, "toJsonSafeRequest");
+function toJsonSafeConfig(config) {
+  if (!config) {
+    return void 0;
+  }
+  const configRecord = asRecord(config);
+  const safeConfig = {};
+  for (const [key, value] of Object.entries(configRecord)) {
+    if (key === "abortSignal") {
+      continue;
+    }
+    safeConfig[key] = value;
+  }
+  return safeConfig;
+}
+__name(toJsonSafeConfig, "toJsonSafeConfig");
+function utf8Bytes(value) {
+  if (value === void 0 || value === null) {
+    return 0;
+  }
+  if (typeof value === "string") {
+    return Buffer.byteLength(value, "utf8");
+  }
+  return Buffer.byteLength(safeStringify(value), "utf8");
+}
+__name(utf8Bytes, "utf8Bytes");
+function safeStringify(value) {
+  try {
+    return JSON.stringify(value) ?? "";
+  } catch {
+    return "[unserializable]";
+  }
+}
+__name(safeStringify, "safeStringify");
+function asRecord(value) {
+  return typeof value === "object" && value !== null ? value : {};
+}
+__name(asRecord, "asRecord");
+function asOptionalRecord(value) {
+  return typeof value === "object" && value !== null ? value : null;
+}
+__name(asOptionalRecord, "asOptionalRecord");
+
+export {
+  setToolCallPreparations,
+  getToolCallPreparations,
+  isRuntimeDiagnosticsEnabled,
+  RuntimeDiagnosticsCollector,
+  runtimeDiagnostics,
+  summarizeOpenAIWireRequest,
+  summarizeAnthropicWireRequest
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2026 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-BSHD62QJ.js → chunk-M4FMGVY4.js}

@@ -8,13 +8,13 @@ import {
 } from "./chunk-3Z43GZUQ.js";
 import {
   t
-} from "./chunk-VRRF3GW5.js";
+} from "./chunk-LKEJ26GS.js";
 import {
   So
-} from "./chunk-OTQ6PSZC.js";
+} from "./chunk-PHOF65IG.js";
 import {
   createDebugLogger
-} from "./chunk-OQB4EXO4.js";
+} from "./chunk-NL7LTRLR.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-57FIIFJN.js → chunk-M5JM7OSF.js}

@@ -3,7 +3,7 @@
 import {
   createDebugLogger,
   isNodeError
-} from "./chunk-OQB4EXO4.js";
+} from "./chunk-NL7LTRLR.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-7362QS5B.js → chunk-MB4MZHMJ.js}

@@ -12,13 +12,13 @@ import {
   SPAN_TOOL_BLOCKED_ON_USER,
   SPAN_TOOL_EXECUTION,
   safeJsonStringify
-} from "./chunk-M7WBGLYP.js";
+} from "./chunk-BULDBTYC.js";
 import {
   createDebugLogger,
   getCurrentSessionId,
   setSessionContext,
   setShellTracePropagation
-} from "./chunk-OQB4EXO4.js";
+} from "./chunk-NL7LTRLR.js";
 import {
   DiagLogLevel,
   ROOT_CONTEXT,
@@ -31,7 +31,7 @@ import {
   init_esm,
   metrics,
   trace
-} from "./chunk-THJNPLI4.js";
+} from "./chunk-TARRHLLG.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -81,6 +81,8 @@ var MEMORY_RECALL_DURATION = `${SERVICE_NAME}.memory.recall.duration`;
 var CHANNEL_MEMORY_RECALL_COUNT = `${SERVICE_NAME}.channel.memory.recall.count`;
 var CHANNEL_MEMORY_RECALL_DURATION = `${SERVICE_NAME}.channel.memory.recall.duration`;
 var CHANNEL_MEMORY_RECALL_SELECTED_COUNT = `${SERVICE_NAME}.channel.memory.recall.selected_count`;
+var MEMORY_RECALL_DELIVERY_COUNT = `${SERVICE_NAME}.memory.recall.delivery.count`;
+var MEMORY_RECALL_DELIVERY_LATENCY = `${SERVICE_NAME}.memory.recall.delivery.latency`;
 var baseMetricDefinition = {
   // session.id on metrics is opt-in: each session is a new value, so
   // attaching it by default would create unbounded time-series fan-out on
@@ -337,6 +339,8 @@ var memoryRecallDurationHistogram;
 var channelMemoryRecallCounter;
 var channelMemoryRecallDurationHistogram;
 var channelMemoryRecallSelectedCountHistogram;
+var memoryRecallDeliveryCounter;
+var memoryRecallDeliveryLatencyHistogram;
 var isMetricsInitialized = false;
 var isPerformanceMonitoringEnabled = false;
 function getMeter() {
@@ -452,6 +456,21 @@ function initializeMetrics(config) {
       valueType: ValueType.INT
     }
   );
+  memoryRecallDeliveryCounter = meter.createCounter(
+    MEMORY_RECALL_DELIVERY_COUNT,
+    {
+      description: "Counts auto-memory recall delivery outcomes, tagged by phase and delivery point.",
+      valueType: ValueType.INT
+    }
+  );
+  memoryRecallDeliveryLatencyHistogram = meter.createHistogram(
+    MEMORY_RECALL_DELIVERY_LATENCY,
+    {
+      description: "Latency from auto-memory recall prefetch start to delivery or discard.",
+      unit: "ms",
+      valueType: ValueType.INT
+    }
+  );
   initializePerformanceMonitoring(config);
   isMetricsInitialized = true;
 }
@@ -811,6 +830,20 @@ function recordChannelMemoryRecallMetrics(observation) {
   );
 }
 __name(recordChannelMemoryRecallMetrics, "recordChannelMemoryRecallMetrics");
+function recordMemoryRecallDeliveryMetrics(config, latencyMs, attrs) {
+  if (!isMetricsInitialized) return;
+  const common = baseMetricDefinition.getCommonAttributes(config);
+  const metricAttributes = {
+    ...common,
+    phase: attrs.phase,
+    delivery_point: attrs.delivery_point,
+    strategy: attrs.strategy,
+    ...attrs.discard_reason ? { discard_reason: attrs.discard_reason } : {}
+  };
+  memoryRecallDeliveryCounter?.add(1, metricAttributes);
+  memoryRecallDeliveryLatencyHistogram?.record(latencyMs, metricAttributes);
+}
+__name(recordMemoryRecallDeliveryMetrics, "recordMemoryRecallDeliveryMetrics");
 
 // packages/core/src/telemetry/detailed-span-attributes.ts
 init_esbuild_shims();
@@ -962,7 +995,7 @@ function sweepStaleSpans(now) {
     if (!ctx.ended) {
       ctx.ended = true;
       const ageMs = now - ctx.startTime;
-      const toolName = ctx.attributes["tool.name"];
+      const toolName = ctx.attributes["gen_ai.tool.name"] ?? ctx.attributes["tool.name"];
       const callId = ctx.attributes["tool.call_id"];
       try {
         ctx.span.setAttributes({
@@ -1018,14 +1051,18 @@ function getSpanId(span) {
   return span.spanContext().spanId || "";
 }
 __name(getSpanId, "getSpanId");
-var SPAN_ERROR_MAX_CHARS = 1024;
-function truncateSpanError(s) {
-  if (s.length <= SPAN_ERROR_MAX_CHARS) return s;
-  let end = SPAN_ERROR_MAX_CHARS;
+var SPAN_TEXT_MAX_CHARS = 1024;
+function truncateSpanText(s) {
+  if (s.length <= SPAN_TEXT_MAX_CHARS) return s;
+  let end = SPAN_TEXT_MAX_CHARS;
   const code = s.charCodeAt(end - 1);
   if (code >= 55296 && code <= 56319) end--;
   return s.slice(0, end) + "\u2026[truncated]";
 }
+__name(truncateSpanText, "truncateSpanText");
+function truncateSpanError(s) {
+  return truncateSpanText(s);
+}
 __name(truncateSpanError, "truncateSpanError");
 function getTracer() {
   return trace.getTracer(SERVICE_NAME, "1.0.0");
@@ -1167,7 +1204,7 @@ async function withInteractionSpan(config, options, fn, getResultStatus) {
   );
 }
 __name(withInteractionSpan, "withInteractionSpan");
-function startLLMRequestSpan(model, promptId) {
+function startLLMRequestSpan(model, promptId, options) {
   if (!isTelemetrySdkInitialized()) {
     return NOOP_SPAN;
   }
@@ -1176,13 +1213,14 @@ function startLLMRequestSpan(model, promptId) {
   const sessionId = resolveSessionId(parentCtx);
   const attributes = {
     ...sessionId ? { "session.id": sessionId } : {},
-    "qwen-code.model": model,
+    ...sessionId ? { "gen_ai.conversation.id": sessionId } : {},
     "qwen-code.prompt_id": promptId,
     "llm_request.context": subagentContext.getStore() ? "subagent" : interactionContext.getStore() ? "interaction" : "standalone",
-    // Dual-emit OTel GenAI semantic convention (Stable). Private name
-    // (qwen-code.model) remains authoritative; gen_ai.* is a compat layer
-    // for spec-aware backends. See docs/design/telemetry-llm-request-timing-design.md (D8).
-    "gen_ai.request.model": model
+    // Emit the version-pinned OTel GenAI semantic convention.
+    "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 } : {}
   };
   const span = getTracer().startSpan(
     SPAN_LLM_REQUEST,
@@ -1216,21 +1254,20 @@ function endLLMRequestSpan(span, metadata) {
     const duration = metadata?.durationMs ?? Date.now() - spanCtx.startTime;
     const endAttributes = { duration_ms: duration };
     if (metadata) {
-      if (metadata.inputTokens !== void 0) {
-        endAttributes["input_tokens"] = metadata.inputTokens;
+      if (metadata.inputTokens !== void 0 && Number.isSafeInteger(metadata.inputTokens) && metadata.inputTokens >= 0) {
         endAttributes["gen_ai.usage.input_tokens"] = metadata.inputTokens;
       }
-      if (metadata.outputTokens !== void 0) {
-        endAttributes["output_tokens"] = metadata.outputTokens;
+      if (metadata.outputTokens !== void 0 && Number.isSafeInteger(metadata.outputTokens) && metadata.outputTokens >= 0) {
         endAttributes["gen_ai.usage.output_tokens"] = metadata.outputTokens;
       }
-      if (metadata.cachedInputTokens !== void 0) {
-        endAttributes["cached_input_tokens"] = metadata.cachedInputTokens;
-        endAttributes["gen_ai.usage.cached_tokens"] = metadata.cachedInputTokens;
+      if (metadata.cachedInputTokensReported && metadata.cachedInputTokens !== void 0 && Number.isSafeInteger(metadata.cachedInputTokens) && metadata.cachedInputTokens >= 0) {
+        endAttributes["gen_ai.usage.cache_read.input_tokens"] = metadata.cachedInputTokens;
+      }
+      if (metadata.cacheCreationInputTokens !== void 0 && Number.isSafeInteger(metadata.cacheCreationInputTokens) && metadata.cacheCreationInputTokens >= 0) {
+        endAttributes["gen_ai.usage.cache_creation.input_tokens"] = metadata.cacheCreationInputTokens;
       }
       if (metadata.ttftMs !== void 0) {
         endAttributes["ttft_ms"] = metadata.ttftMs;
-        endAttributes["gen_ai.server.time_to_first_token"] = metadata.ttftMs / 1e3;
       }
       if (metadata.requestSetupMs !== void 0) {
         endAttributes["request_setup_ms"] = metadata.requestSetupMs;
@@ -1252,18 +1289,18 @@ function endLLMRequestSpan(span, metadata) {
       if (metadata.error !== void 0)
         endAttributes["error"] = truncateSpanError(metadata.error);
       if (metadata.responseId !== void 0) {
-        endAttributes["response_id"] = metadata.responseId;
         endAttributes["gen_ai.response.id"] = metadata.responseId;
       }
-      if (metadata.finishReason !== void 0) {
-        endAttributes["finish_reason"] = metadata.finishReason;
-        endAttributes["gen_ai.response.finish_reasons"] = [
-          metadata.finishReason
-        ];
+      if (metadata.responseModel !== void 0) {
+        endAttributes["gen_ai.response.model"] = metadata.responseModel;
+      }
+      const finishReasons = metadata.finishReasons?.length ? metadata.finishReasons : metadata.finishReason !== void 0 ? [metadata.finishReason] : void 0;
+      if (finishReasons) {
+        endAttributes["finish_reason"] = finishReasons[0];
+        endAttributes["gen_ai.response.finish_reasons"] = finishReasons;
       }
       if (metadata.thoughtsTokenCount !== void 0) {
         endAttributes["thoughts_token_count"] = metadata.thoughtsTokenCount;
-        endAttributes["gen_ai.usage.reasoning_tokens"] = metadata.thoughtsTokenCount;
       }
       if (metadata.subagentName !== void 0) {
         endAttributes["subagent_name"] = metadata.subagentName;
@@ -1279,7 +1316,7 @@ function endLLMRequestSpan(span, metadata) {
     spanCtx.span.setAttributes(endAttributes);
     try {
       if (metadata?.config && metadata.success) {
-        const model = String(spanCtx.attributes["qwen-code.model"] ?? "");
+        const model = String(spanCtx.attributes["gen_ai.request.model"] ?? "");
         if (metadata.requestSetupMs !== void 0) {
           recordApiRequestBreakdown(metadata.config, metadata.requestSetupMs, {
             model,
@@ -1338,8 +1375,10 @@ function startToolSpan(toolName, attrs) {
   const sessionId = resolveSessionId(parentCtx);
   const attributes = {
     ...sessionId ? { "session.id": sessionId } : {},
-    "tool.name": toolName,
-    ...attrs
+    ...attrs,
+    "gen_ai.operation.name": "execute_tool",
+    "gen_ai.tool.name": toolName,
+    "gen_ai.tool.type": "function"
   };
   const span = getTracer().startSpan(
     SPAN_TOOL,
@@ -1666,18 +1705,21 @@ function startSubagentSpan(opts) {
   const attributes = {
     // Spec-aligned (OTel GenAI Agent Spans, Development status).
     "gen_ai.operation.name": "invoke_agent",
-    "gen_ai.provider.name": SERVICE_NAME,
-    "gen_ai.agent.id": opts.agentId,
     "gen_ai.agent.name": opts.subagentName,
     "gen_ai.conversation.id": opts.sessionId,
-    // Vendor (qwen-code-specific). Dual-emit id/name so dashboards already
-    // querying spec keys still work.
+    // Vendor identity and lifecycle. The per-invocation ID stays private;
+    // gen_ai.agent.id is reserved for a stable agent definition identity.
     "qwen-code.subagent.id": opts.agentId,
     "qwen-code.subagent.name": opts.subagentName,
     "qwen-code.subagent.invocation_kind": opts.invocationKind,
     "qwen-code.subagent.is_built_in": opts.isBuiltIn,
     "qwen-code.subagent.depth": opts.depth
   };
+  if (opts.agentDescription !== void 0) {
+    attributes["gen_ai.agent.description"] = truncateSpanText(
+      opts.agentDescription
+    );
+  }
   if (opts.modelOverride !== void 0) {
     attributes["gen_ai.request.model"] = opts.modelOverride;
   }
@@ -1830,7 +1872,7 @@ function initializeTelemetry(config) {
   telemetryInitPromise ??= (async () => {
     const debugLogger3 = createDebugLogger("OTEL");
     try {
-      const { startTelemetrySdk } = await import("./sdk-impl-NSLPDH6I.js");
+      const { startTelemetrySdk } = await import("./sdk-impl-GMVPB7NB.js");
       if (telemetryInitialized) return;
       const started = await startTelemetrySdk(config);
       if (!started) return;
@@ -2203,6 +2245,7 @@ export {
   recordMemoryDreamMetrics,
   recordMemoryRecallMetrics,
   recordChannelMemoryRecallMetrics,
+  recordMemoryRecallDeliveryMetrics,
   deriveTraceId,
   randomSpanId,
   randomHexString,