@qwen-code/qwen-code 0.20.1-preview.7215 → 0.20.2-gdpval-vl-agent.0

package/chunks/chunk-RCUEYZDE.js

@@ -0,0 +1,2290 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  DEFAULT_SENSITIVE_SPAN_ATTRIBUTE_MAX_LENGTH,
+  EVENT_CHAT_COMPRESSION,
+  SERVICE_NAME,
+  SPAN_HOOK,
+  SPAN_INTERACTION,
+  SPAN_LLM_REQUEST,
+  SPAN_SUBAGENT,
+  SPAN_TOOL,
+  SPAN_TOOL_BLOCKED_ON_USER,
+  SPAN_TOOL_EXECUTION,
+  safeJsonStringify
+} from "./chunk-BULDBTYC.js";
+import {
+  createDebugLogger,
+  getCurrentSessionId,
+  setSessionContext,
+  setShellTracePropagation
+} from "./chunk-OQB4EXO4.js";
+import {
+  DiagLogLevel,
+  ROOT_CONTEXT,
+  SpanKind,
+  SpanStatusCode,
+  TraceFlags,
+  ValueType,
+  context,
+  diag,
+  init_esm,
+  metrics,
+  trace
+} from "./chunk-THJNPLI4.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/telemetry/metrics.ts
+init_esbuild_shims();
+init_esm();
+var TOOL_CALL_COUNT = `${SERVICE_NAME}.tool.call.count`;
+var TOOL_CALL_LATENCY = `${SERVICE_NAME}.tool.call.latency`;
+var API_REQUEST_COUNT = `${SERVICE_NAME}.api.request.count`;
+var API_REQUEST_LATENCY = `${SERVICE_NAME}.api.request.latency`;
+var TOKEN_USAGE = `${SERVICE_NAME}.token.usage`;
+var SESSION_COUNT = `${SERVICE_NAME}.session.count`;
+var FILE_OPERATION_COUNT = `${SERVICE_NAME}.file.operation.count`;
+var INVALID_CHUNK_COUNT = `${SERVICE_NAME}.chat.invalid_chunk.count`;
+var CONTENT_RETRY_COUNT = `${SERVICE_NAME}.chat.content_retry.count`;
+var CONTENT_RETRY_FAILURE_COUNT = `${SERVICE_NAME}.chat.content_retry_failure.count`;
+var API_RETRY_COUNT = `${SERVICE_NAME}.api.retry.count`;
+var MODEL_SLASH_COMMAND_CALL_COUNT = `${SERVICE_NAME}.slash_command.model.call_count`;
+var SUBAGENT_EXECUTION_COUNT = `${SERVICE_NAME}.subagent.execution.count`;
+var ARENA_SESSION_COUNT = `${SERVICE_NAME}.arena.session.count`;
+var ARENA_SESSION_DURATION = `${SERVICE_NAME}.arena.session.duration`;
+var ARENA_AGENT_COUNT = `${SERVICE_NAME}.arena.agent.count`;
+var ARENA_AGENT_DURATION = `${SERVICE_NAME}.arena.agent.duration`;
+var ARENA_AGENT_TOKENS = `${SERVICE_NAME}.arena.agent.tokens`;
+var ARENA_RESULT_SELECTED = `${SERVICE_NAME}.arena.result.selected`;
+var STARTUP_TIME = `${SERVICE_NAME}.startup.duration`;
+var MEMORY_USAGE = `${SERVICE_NAME}.memory.usage`;
+var CPU_USAGE = `${SERVICE_NAME}.cpu.usage`;
+var TOOL_QUEUE_DEPTH = `${SERVICE_NAME}.tool.queue.depth`;
+var TOOL_EXECUTION_BREAKDOWN = `${SERVICE_NAME}.tool.execution.breakdown`;
+var TOKEN_EFFICIENCY = `${SERVICE_NAME}.token.efficiency`;
+var API_REQUEST_BREAKDOWN = `${SERVICE_NAME}.api.request.breakdown`;
+var PERFORMANCE_SCORE = `${SERVICE_NAME}.performance.score`;
+var REGRESSION_DETECTION = `${SERVICE_NAME}.performance.regression`;
+var REGRESSION_PERCENTAGE_CHANGE = `${SERVICE_NAME}.performance.regression.percentage_change`;
+var BASELINE_COMPARISON = `${SERVICE_NAME}.performance.baseline.comparison`;
+var MEMORY_EXTRACT_COUNT = `${SERVICE_NAME}.memory.extract.count`;
+var MEMORY_EXTRACT_DURATION = `${SERVICE_NAME}.memory.extract.duration`;
+var MEMORY_DREAM_COUNT = `${SERVICE_NAME}.memory.dream.count`;
+var MEMORY_DREAM_DURATION = `${SERVICE_NAME}.memory.dream.duration`;
+var MEMORY_RECALL_COUNT = `${SERVICE_NAME}.memory.recall.count`;
+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
+  // every metric backend. Operators who need session-level metric slicing
+  // can enable QWEN_TELEMETRY_METRICS_INCLUDE_SESSION_ID or
+  // telemetry.metrics.includeSessionId. Spans and logs always carry
+  // session.id for trace/log correlation.
+  getCommonAttributes: /* @__PURE__ */ __name((config) => {
+    const out = {};
+    if (config.getTelemetryMetricsIncludeSessionId()) {
+      out["session.id"] = config.getSessionId();
+    }
+    return out;
+  }, "getCommonAttributes")
+};
+var COUNTER_DEFINITIONS = {
+  [TOOL_CALL_COUNT]: {
+    description: "Counts tool calls, tagged by function name and success.",
+    valueType: ValueType.INT,
+    assign: /* @__PURE__ */ __name((c) => toolCallCounter = c, "assign"),
+    attributes: {}
+  },
+  [API_REQUEST_COUNT]: {
+    description: "Counts API requests, tagged by model and status.",
+    valueType: ValueType.INT,
+    assign: /* @__PURE__ */ __name((c) => apiRequestCounter = c, "assign"),
+    attributes: {}
+  },
+  [TOKEN_USAGE]: {
+    description: "Counts the total number of tokens used.",
+    valueType: ValueType.INT,
+    assign: /* @__PURE__ */ __name((c) => tokenUsageCounter = c, "assign"),
+    attributes: {}
+  },
+  [SESSION_COUNT]: {
+    description: "Count of CLI sessions started.",
+    valueType: ValueType.INT,
+    assign: /* @__PURE__ */ __name((c) => sessionCounter = c, "assign"),
+    attributes: {}
+  },
+  [FILE_OPERATION_COUNT]: {
+    description: "Counts file operations (create, read, update).",
+    valueType: ValueType.INT,
+    assign: /* @__PURE__ */ __name((c) => fileOperationCounter = c, "assign"),
+    attributes: {}
+  },
+  [INVALID_CHUNK_COUNT]: {
+    description: "Counts invalid chunks received from a stream.",
+    valueType: ValueType.INT,
+    assign: /* @__PURE__ */ __name((c) => invalidChunkCounter = c, "assign"),
+    attributes: {}
+  },
+  [CONTENT_RETRY_COUNT]: {
+    description: "Counts retries due to content errors (e.g., empty stream).",
+    valueType: ValueType.INT,
+    assign: /* @__PURE__ */ __name((c) => contentRetryCounter = c, "assign"),
+    attributes: {}
+  },
+  [CONTENT_RETRY_FAILURE_COUNT]: {
+    description: "Counts occurrences of all content retries failing.",
+    valueType: ValueType.INT,
+    assign: /* @__PURE__ */ __name((c) => contentRetryFailureCounter = c, "assign"),
+    attributes: {}
+  },
+  [API_RETRY_COUNT]: {
+    description: "Counts HTTP-status retries (429/5xx) at LLM call sites, emitted by retryWithBackoff onRetry callback.",
+    valueType: ValueType.INT,
+    assign: /* @__PURE__ */ __name((c) => apiRetryCounter = c, "assign"),
+    attributes: {}
+  },
+  [MODEL_SLASH_COMMAND_CALL_COUNT]: {
+    description: "Counts model slash command calls.",
+    valueType: ValueType.INT,
+    assign: /* @__PURE__ */ __name((c) => modelSlashCommandCallCounter = c, "assign"),
+    attributes: {}
+  },
+  [EVENT_CHAT_COMPRESSION]: {
+    description: "Counts chat compression events.",
+    valueType: ValueType.INT,
+    assign: /* @__PURE__ */ __name((c) => chatCompressionCounter = c, "assign"),
+    attributes: {}
+  }
+};
+var HISTOGRAM_DEFINITIONS = {
+  [TOOL_CALL_LATENCY]: {
+    description: "Latency of tool calls in milliseconds.",
+    unit: "ms",
+    valueType: ValueType.INT,
+    assign: /* @__PURE__ */ __name((h) => toolCallLatencyHistogram = h, "assign"),
+    attributes: {}
+  },
+  [API_REQUEST_LATENCY]: {
+    description: "Latency of API requests in milliseconds.",
+    unit: "ms",
+    valueType: ValueType.INT,
+    assign: /* @__PURE__ */ __name((h) => apiRequestLatencyHistogram = h, "assign"),
+    attributes: {}
+  }
+};
+var PERFORMANCE_COUNTER_DEFINITIONS = {
+  [REGRESSION_DETECTION]: {
+    description: "Performance regression detection events.",
+    valueType: ValueType.INT,
+    assign: /* @__PURE__ */ __name((c) => regressionDetectionCounter = c, "assign"),
+    attributes: {}
+  }
+};
+var PERFORMANCE_HISTOGRAM_DEFINITIONS = {
+  [STARTUP_TIME]: {
+    description: "CLI startup time in milliseconds, broken down by initialization phase.",
+    unit: "ms",
+    valueType: ValueType.DOUBLE,
+    assign: /* @__PURE__ */ __name((h) => startupTimeHistogram = h, "assign"),
+    attributes: {}
+  },
+  [MEMORY_USAGE]: {
+    description: "Memory usage in bytes.",
+    unit: "bytes",
+    valueType: ValueType.INT,
+    assign: /* @__PURE__ */ __name((h) => memoryUsageGauge = h, "assign"),
+    attributes: {}
+  },
+  [CPU_USAGE]: {
+    description: "CPU usage percentage.",
+    unit: "percent",
+    valueType: ValueType.DOUBLE,
+    assign: /* @__PURE__ */ __name((h) => cpuUsageGauge = h, "assign"),
+    attributes: {}
+  },
+  [TOOL_QUEUE_DEPTH]: {
+    description: "Number of tools in execution queue.",
+    unit: "count",
+    valueType: ValueType.INT,
+    assign: /* @__PURE__ */ __name((h) => toolQueueDepthGauge = h, "assign"),
+    attributes: {}
+  },
+  [TOOL_EXECUTION_BREAKDOWN]: {
+    description: "Tool execution time breakdown by phase in milliseconds.",
+    unit: "ms",
+    valueType: ValueType.INT,
+    assign: /* @__PURE__ */ __name((h) => toolExecutionBreakdownHistogram = h, "assign"),
+    attributes: {}
+  },
+  [TOKEN_EFFICIENCY]: {
+    description: "Token efficiency metrics (tokens per operation, cache hit rate, etc.).",
+    unit: "ratio",
+    valueType: ValueType.DOUBLE,
+    assign: /* @__PURE__ */ __name((h) => tokenEfficiencyHistogram = h, "assign"),
+    attributes: {}
+  },
+  [API_REQUEST_BREAKDOWN]: {
+    description: "API request time breakdown by phase in milliseconds.",
+    unit: "ms",
+    valueType: ValueType.INT,
+    assign: /* @__PURE__ */ __name((h) => apiRequestBreakdownHistogram = h, "assign"),
+    attributes: {}
+  },
+  [PERFORMANCE_SCORE]: {
+    description: "Composite performance score (0-100).",
+    unit: "score",
+    valueType: ValueType.DOUBLE,
+    assign: /* @__PURE__ */ __name((h) => performanceScoreGauge = h, "assign"),
+    attributes: {}
+  },
+  [REGRESSION_PERCENTAGE_CHANGE]: {
+    description: "Percentage change compared to baseline for detected regressions.",
+    unit: "percent",
+    valueType: ValueType.DOUBLE,
+    assign: /* @__PURE__ */ __name((h) => regressionPercentageChangeHistogram = h, "assign"),
+    attributes: {}
+  },
+  [BASELINE_COMPARISON]: {
+    description: "Performance comparison to established baseline (percentage change).",
+    unit: "percent",
+    valueType: ValueType.DOUBLE,
+    assign: /* @__PURE__ */ __name((h) => baselineComparisonHistogram = h, "assign"),
+    attributes: {}
+  }
+};
+var FileOperation = /* @__PURE__ */ ((FileOperation2) => {
+  FileOperation2["CREATE"] = "create";
+  FileOperation2["READ"] = "read";
+  FileOperation2["UPDATE"] = "update";
+  return FileOperation2;
+})(FileOperation || {});
+var PerformanceMetricType = /* @__PURE__ */ ((PerformanceMetricType2) => {
+  PerformanceMetricType2["STARTUP"] = "startup";
+  PerformanceMetricType2["MEMORY"] = "memory";
+  PerformanceMetricType2["CPU"] = "cpu";
+  PerformanceMetricType2["TOOL_EXECUTION"] = "tool_execution";
+  PerformanceMetricType2["API_REQUEST"] = "api_request";
+  PerformanceMetricType2["TOKEN_EFFICIENCY"] = "token_efficiency";
+  return PerformanceMetricType2;
+})(PerformanceMetricType || {});
+var MemoryMetricType = /* @__PURE__ */ ((MemoryMetricType2) => {
+  MemoryMetricType2["HEAP_USED"] = "heap_used";
+  MemoryMetricType2["HEAP_TOTAL"] = "heap_total";
+  MemoryMetricType2["EXTERNAL"] = "external";
+  MemoryMetricType2["RSS"] = "rss";
+  return MemoryMetricType2;
+})(MemoryMetricType || {});
+var ToolExecutionPhase = /* @__PURE__ */ ((ToolExecutionPhase2) => {
+  ToolExecutionPhase2["VALIDATION"] = "validation";
+  ToolExecutionPhase2["PREPARATION"] = "preparation";
+  ToolExecutionPhase2["EXECUTION"] = "execution";
+  ToolExecutionPhase2["RESULT_PROCESSING"] = "result_processing";
+  return ToolExecutionPhase2;
+})(ToolExecutionPhase || {});
+var ApiRequestPhase = /* @__PURE__ */ ((ApiRequestPhase2) => {
+  ApiRequestPhase2["REQUEST_PREPARATION"] = "request_preparation";
+  ApiRequestPhase2["NETWORK_LATENCY"] = "network_latency";
+  ApiRequestPhase2["RESPONSE_PROCESSING"] = "response_processing";
+  ApiRequestPhase2["TOKEN_PROCESSING"] = "token_processing";
+  return ApiRequestPhase2;
+})(ApiRequestPhase || {});
+var cliMeter;
+var toolCallCounter;
+var toolCallLatencyHistogram;
+var apiRequestCounter;
+var apiRequestLatencyHistogram;
+var tokenUsageCounter;
+var sessionCounter;
+var fileOperationCounter;
+var chatCompressionCounter;
+var invalidChunkCounter;
+var contentRetryCounter;
+var contentRetryFailureCounter;
+var apiRetryCounter;
+var subagentExecutionCounter;
+var modelSlashCommandCallCounter;
+var startupTimeHistogram;
+var memoryUsageGauge;
+var cpuUsageGauge;
+var toolQueueDepthGauge;
+var toolExecutionBreakdownHistogram;
+var tokenEfficiencyHistogram;
+var apiRequestBreakdownHistogram;
+var performanceScoreGauge;
+var regressionDetectionCounter;
+var regressionPercentageChangeHistogram;
+var baselineComparisonHistogram;
+var arenaSessionCounter;
+var arenaSessionDurationHistogram;
+var arenaAgentCounter;
+var arenaAgentDurationHistogram;
+var arenaAgentTokensCounter;
+var arenaResultSelectedCounter;
+var memoryExtractCounter;
+var memoryExtractDurationHistogram;
+var memoryDreamCounter;
+var memoryDreamDurationHistogram;
+var memoryRecallCounter;
+var memoryRecallDurationHistogram;
+var channelMemoryRecallCounter;
+var channelMemoryRecallDurationHistogram;
+var channelMemoryRecallSelectedCountHistogram;
+var memoryRecallDeliveryCounter;
+var memoryRecallDeliveryLatencyHistogram;
+var isMetricsInitialized = false;
+var isPerformanceMonitoringEnabled = false;
+function getMeter() {
+  if (!cliMeter) {
+    cliMeter = metrics.getMeter(SERVICE_NAME);
+  }
+  return cliMeter;
+}
+__name(getMeter, "getMeter");
+function initializeMetrics(config) {
+  if (isMetricsInitialized) return;
+  const meter = getMeter();
+  if (!meter) return;
+  Object.entries(COUNTER_DEFINITIONS).forEach(
+    ([name, { description, valueType, assign }]) => {
+      assign(meter.createCounter(name, { description, valueType }));
+    }
+  );
+  subagentExecutionCounter = meter.createCounter(SUBAGENT_EXECUTION_COUNT, {
+    description: "Counts subagent execution events, tagged by status and subagent name.",
+    valueType: ValueType.INT
+  });
+  arenaSessionCounter = meter.createCounter(ARENA_SESSION_COUNT, {
+    description: "Counts arena sessions by status and display backend.",
+    valueType: ValueType.INT
+  });
+  arenaSessionDurationHistogram = meter.createHistogram(
+    ARENA_SESSION_DURATION,
+    {
+      description: "Duration of arena sessions in milliseconds.",
+      unit: "ms",
+      valueType: ValueType.INT
+    }
+  );
+  arenaAgentCounter = meter.createCounter(ARENA_AGENT_COUNT, {
+    description: "Counts arena agent completions by status and model.",
+    valueType: ValueType.INT
+  });
+  arenaAgentDurationHistogram = meter.createHistogram(ARENA_AGENT_DURATION, {
+    description: "Duration of arena agent execution in milliseconds.",
+    unit: "ms",
+    valueType: ValueType.INT
+  });
+  arenaAgentTokensCounter = meter.createCounter(ARENA_AGENT_TOKENS, {
+    description: "Token usage by arena agents.",
+    valueType: ValueType.INT
+  });
+  arenaResultSelectedCounter = meter.createCounter(ARENA_RESULT_SELECTED, {
+    description: "Counts arena result selections by model.",
+    valueType: ValueType.INT
+  });
+  Object.entries(HISTOGRAM_DEFINITIONS).forEach(
+    ([name, { description, unit, valueType, assign }]) => {
+      assign(meter.createHistogram(name, { description, unit, valueType }));
+    }
+  );
+  sessionCounter?.add(1, baseMetricDefinition.getCommonAttributes(config));
+  memoryExtractCounter = meter.createCounter(MEMORY_EXTRACT_COUNT, {
+    description: "Counts auto-memory extraction runs, tagged by trigger and status.",
+    valueType: ValueType.INT
+  });
+  memoryExtractDurationHistogram = meter.createHistogram(
+    MEMORY_EXTRACT_DURATION,
+    {
+      description: "Duration of auto-memory extraction in milliseconds.",
+      unit: "ms",
+      valueType: ValueType.INT
+    }
+  );
+  memoryDreamCounter = meter.createCounter(MEMORY_DREAM_COUNT, {
+    description: "Counts auto-memory dream (consolidation) runs, tagged by trigger and status.",
+    valueType: ValueType.INT
+  });
+  memoryDreamDurationHistogram = meter.createHistogram(MEMORY_DREAM_DURATION, {
+    description: "Duration of auto-memory dream runs in milliseconds.",
+    unit: "ms",
+    valueType: ValueType.INT
+  });
+  memoryRecallCounter = meter.createCounter(MEMORY_RECALL_COUNT, {
+    description: "Counts auto-memory recall operations, tagged by strategy.",
+    valueType: ValueType.INT
+  });
+  memoryRecallDurationHistogram = meter.createHistogram(
+    MEMORY_RECALL_DURATION,
+    {
+      description: "Duration of auto-memory recall operations in milliseconds.",
+      unit: "ms",
+      valueType: ValueType.INT
+    }
+  );
+  channelMemoryRecallCounter = meter.createCounter(
+    CHANNEL_MEMORY_RECALL_COUNT,
+    {
+      description: "Counts channel memory recall attempts by cache path and bounded result.",
+      valueType: ValueType.INT
+    }
+  );
+  channelMemoryRecallDurationHistogram = meter.createHistogram(
+    CHANNEL_MEMORY_RECALL_DURATION,
+    {
+      description: "Duration of channel memory recall attempts.",
+      unit: "ms",
+      valueType: ValueType.DOUBLE,
+      advice: {
+        explicitBucketBoundaries: [0.1, 0.5, 1, 2, 5, 10, 25, 50, 100, 250]
+      }
+    }
+  );
+  channelMemoryRecallSelectedCountHistogram = meter.createHistogram(
+    CHANNEL_MEMORY_RECALL_SELECTED_COUNT,
+    {
+      description: "Number of channel memory entries selected per attempt.",
+      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;
+}
+__name(initializeMetrics, "initializeMetrics");
+function recordChatCompressionMetrics(config, attributes) {
+  if (!chatCompressionCounter || !isMetricsInitialized) return;
+  chatCompressionCounter.add(1, {
+    ...baseMetricDefinition.getCommonAttributes(config),
+    ...attributes
+  });
+}
+__name(recordChatCompressionMetrics, "recordChatCompressionMetrics");
+function recordToolCallMetrics(config, durationMs, attributes) {
+  if (!toolCallCounter || !toolCallLatencyHistogram || !isMetricsInitialized)
+    return;
+  const metricAttributes = {
+    ...baseMetricDefinition.getCommonAttributes(config),
+    ...attributes
+  };
+  toolCallCounter.add(1, metricAttributes);
+  toolCallLatencyHistogram.record(durationMs, {
+    ...baseMetricDefinition.getCommonAttributes(config),
+    function_name: attributes.function_name
+  });
+}
+__name(recordToolCallMetrics, "recordToolCallMetrics");
+function recordTokenUsageMetrics(config, tokenCount, attributes) {
+  if (!tokenUsageCounter || !isMetricsInitialized) return;
+  tokenUsageCounter.add(tokenCount, {
+    ...baseMetricDefinition.getCommonAttributes(config),
+    ...attributes
+  });
+}
+__name(recordTokenUsageMetrics, "recordTokenUsageMetrics");
+function recordApiResponseMetrics(config, durationMs, attributes) {
+  if (!apiRequestCounter || !apiRequestLatencyHistogram || !isMetricsInitialized)
+    return;
+  const metricAttributes = {
+    ...baseMetricDefinition.getCommonAttributes(config),
+    model: attributes.model,
+    status_code: attributes.status_code ?? "ok"
+  };
+  apiRequestCounter.add(1, metricAttributes);
+  apiRequestLatencyHistogram.record(durationMs, {
+    ...baseMetricDefinition.getCommonAttributes(config),
+    model: attributes.model
+  });
+}
+__name(recordApiResponseMetrics, "recordApiResponseMetrics");
+function recordApiErrorMetrics(config, durationMs, attributes) {
+  if (!apiRequestCounter || !apiRequestLatencyHistogram || !isMetricsInitialized)
+    return;
+  const metricAttributes = {
+    ...baseMetricDefinition.getCommonAttributes(config),
+    model: attributes.model,
+    status_code: attributes.status_code ?? "error",
+    error_type: attributes.error_type ?? "unknown"
+  };
+  apiRequestCounter.add(1, metricAttributes);
+  apiRequestLatencyHistogram.record(durationMs, {
+    ...baseMetricDefinition.getCommonAttributes(config),
+    model: attributes.model
+  });
+}
+__name(recordApiErrorMetrics, "recordApiErrorMetrics");
+function recordFileOperationMetric(config, attributes) {
+  if (!fileOperationCounter || !isMetricsInitialized) return;
+  fileOperationCounter.add(1, {
+    ...baseMetricDefinition.getCommonAttributes(config),
+    ...attributes
+  });
+}
+__name(recordFileOperationMetric, "recordFileOperationMetric");
+function recordInvalidChunk(config) {
+  if (!invalidChunkCounter || !isMetricsInitialized) return;
+  invalidChunkCounter.add(1, baseMetricDefinition.getCommonAttributes(config));
+}
+__name(recordInvalidChunk, "recordInvalidChunk");
+function recordContentRetry(config) {
+  if (!contentRetryCounter || !isMetricsInitialized) return;
+  contentRetryCounter.add(1, baseMetricDefinition.getCommonAttributes(config));
+}
+__name(recordContentRetry, "recordContentRetry");
+function recordContentRetryFailure(config) {
+  if (!contentRetryFailureCounter || !isMetricsInitialized) return;
+  contentRetryFailureCounter.add(
+    1,
+    baseMetricDefinition.getCommonAttributes(config)
+  );
+}
+__name(recordContentRetryFailure, "recordContentRetryFailure");
+function recordApiRetry(config, attributes) {
+  if (!apiRetryCounter || !isMetricsInitialized) return;
+  apiRetryCounter.add(1, {
+    ...baseMetricDefinition.getCommonAttributes(config),
+    ...attributes
+  });
+}
+__name(recordApiRetry, "recordApiRetry");
+function recordModelSlashCommand(config, event) {
+  if (!modelSlashCommandCallCounter || !isMetricsInitialized) return;
+  modelSlashCommandCallCounter.add(1, {
+    ...baseMetricDefinition.getCommonAttributes(config),
+    "slash_command.model.model_name": event.model_name
+  });
+}
+__name(recordModelSlashCommand, "recordModelSlashCommand");
+function initializePerformanceMonitoring(config) {
+  const meter = getMeter();
+  if (!meter) return;
+  isPerformanceMonitoringEnabled = config.getTelemetryEnabled();
+  if (!isPerformanceMonitoringEnabled) return;
+  Object.entries(PERFORMANCE_COUNTER_DEFINITIONS).forEach(
+    ([name, { description, valueType, assign }]) => {
+      assign(meter.createCounter(name, { description, valueType }));
+    }
+  );
+  Object.entries(PERFORMANCE_HISTOGRAM_DEFINITIONS).forEach(
+    ([name, { description, unit, valueType, assign }]) => {
+      assign(meter.createHistogram(name, { description, unit, valueType }));
+    }
+  );
+}
+__name(initializePerformanceMonitoring, "initializePerformanceMonitoring");
+function recordStartupPerformance(config, durationMs, attributes) {
+  if (!startupTimeHistogram || !isPerformanceMonitoringEnabled) return;
+  const metricAttributes = {
+    ...baseMetricDefinition.getCommonAttributes(config),
+    phase: attributes.phase,
+    ...attributes.details
+  };
+  startupTimeHistogram.record(durationMs, metricAttributes);
+}
+__name(recordStartupPerformance, "recordStartupPerformance");
+function recordMemoryUsage(config, bytes, attributes) {
+  if (!memoryUsageGauge || !isPerformanceMonitoringEnabled) return;
+  const metricAttributes = {
+    ...baseMetricDefinition.getCommonAttributes(config),
+    ...attributes
+  };
+  memoryUsageGauge.record(bytes, metricAttributes);
+}
+__name(recordMemoryUsage, "recordMemoryUsage");
+function recordCpuUsage(config, percentage, attributes) {
+  if (!cpuUsageGauge || !isPerformanceMonitoringEnabled) return;
+  const metricAttributes = {
+    ...baseMetricDefinition.getCommonAttributes(config),
+    ...attributes
+  };
+  cpuUsageGauge.record(percentage, metricAttributes);
+}
+__name(recordCpuUsage, "recordCpuUsage");
+function recordToolQueueDepth(config, queueDepth) {
+  if (!toolQueueDepthGauge || !isPerformanceMonitoringEnabled) return;
+  const attributes = {
+    ...baseMetricDefinition.getCommonAttributes(config)
+  };
+  toolQueueDepthGauge.record(queueDepth, attributes);
+}
+__name(recordToolQueueDepth, "recordToolQueueDepth");
+function recordToolExecutionBreakdown(config, durationMs, attributes) {
+  if (!toolExecutionBreakdownHistogram || !isPerformanceMonitoringEnabled)
+    return;
+  const metricAttributes = {
+    ...baseMetricDefinition.getCommonAttributes(config),
+    ...attributes
+  };
+  toolExecutionBreakdownHistogram.record(durationMs, metricAttributes);
+}
+__name(recordToolExecutionBreakdown, "recordToolExecutionBreakdown");
+function recordTokenEfficiency(config, value, attributes) {
+  if (!tokenEfficiencyHistogram || !isPerformanceMonitoringEnabled) return;
+  const metricAttributes = {
+    ...baseMetricDefinition.getCommonAttributes(config),
+    ...attributes
+  };
+  tokenEfficiencyHistogram.record(value, metricAttributes);
+}
+__name(recordTokenEfficiency, "recordTokenEfficiency");
+function recordApiRequestBreakdown(config, durationMs, attributes) {
+  if (!apiRequestBreakdownHistogram || !isPerformanceMonitoringEnabled) return;
+  const metricAttributes = {
+    ...baseMetricDefinition.getCommonAttributes(config),
+    ...attributes
+  };
+  apiRequestBreakdownHistogram.record(durationMs, metricAttributes);
+}
+__name(recordApiRequestBreakdown, "recordApiRequestBreakdown");
+function recordPerformanceScore(config, score, attributes) {
+  if (!performanceScoreGauge || !isPerformanceMonitoringEnabled) return;
+  const metricAttributes = {
+    ...baseMetricDefinition.getCommonAttributes(config),
+    ...attributes
+  };
+  performanceScoreGauge.record(score, metricAttributes);
+}
+__name(recordPerformanceScore, "recordPerformanceScore");
+function recordPerformanceRegression(config, attributes) {
+  if (!regressionDetectionCounter || !isPerformanceMonitoringEnabled) return;
+  const metricAttributes = {
+    ...baseMetricDefinition.getCommonAttributes(config),
+    ...attributes
+  };
+  regressionDetectionCounter.add(1, metricAttributes);
+  if (attributes.baseline_value !== 0 && regressionPercentageChangeHistogram) {
+    const percentageChange = (attributes.current_value - attributes.baseline_value) / attributes.baseline_value * 100;
+    regressionPercentageChangeHistogram.record(
+      percentageChange,
+      metricAttributes
+    );
+  }
+}
+__name(recordPerformanceRegression, "recordPerformanceRegression");
+function recordBaselineComparison(config, attributes) {
+  if (!baselineComparisonHistogram || !isPerformanceMonitoringEnabled) return;
+  if (attributes.baseline_value === 0) {
+    diag.warn("Baseline value is zero, skipping comparison.");
+    return;
+  }
+  const percentageChange = (attributes.current_value - attributes.baseline_value) / attributes.baseline_value * 100;
+  const metricAttributes = {
+    ...baseMetricDefinition.getCommonAttributes(config),
+    ...attributes
+  };
+  baselineComparisonHistogram.record(percentageChange, metricAttributes);
+}
+__name(recordBaselineComparison, "recordBaselineComparison");
+function isPerformanceMonitoringActive() {
+  return isPerformanceMonitoringEnabled && isMetricsInitialized;
+}
+__name(isPerformanceMonitoringActive, "isPerformanceMonitoringActive");
+function recordSubagentExecutionMetrics(config, subagentName, status, terminateReason) {
+  if (!subagentExecutionCounter || !isMetricsInitialized) return;
+  const attributes = {
+    ...baseMetricDefinition.getCommonAttributes(config),
+    subagent_name: subagentName,
+    status
+  };
+  if (terminateReason) {
+    attributes["terminate_reason"] = terminateReason;
+  }
+  subagentExecutionCounter.add(1, attributes);
+}
+__name(recordSubagentExecutionMetrics, "recordSubagentExecutionMetrics");
+function recordArenaSessionStartedMetrics(config) {
+  if (!isMetricsInitialized) return;
+  arenaSessionCounter?.add(1, {
+    ...baseMetricDefinition.getCommonAttributes(config),
+    status: "started"
+  });
+}
+__name(recordArenaSessionStartedMetrics, "recordArenaSessionStartedMetrics");
+function recordArenaAgentCompletedMetrics(config, modelId, status, durationMs, inputTokens, outputTokens) {
+  if (!isMetricsInitialized) return;
+  const common = baseMetricDefinition.getCommonAttributes(config);
+  arenaAgentCounter?.add(1, {
+    ...common,
+    status,
+    model_id: modelId
+  });
+  arenaAgentDurationHistogram?.record(durationMs, {
+    ...common,
+    model_id: modelId
+  });
+  if (inputTokens > 0) {
+    arenaAgentTokensCounter?.add(inputTokens, {
+      ...common,
+      model_id: modelId,
+      type: "input"
+    });
+  }
+  if (outputTokens > 0) {
+    arenaAgentTokensCounter?.add(outputTokens, {
+      ...common,
+      model_id: modelId,
+      type: "output"
+    });
+  }
+}
+__name(recordArenaAgentCompletedMetrics, "recordArenaAgentCompletedMetrics");
+function recordArenaSessionEndedMetrics(config, status, displayBackend, durationMs, winnerModelId) {
+  if (!isMetricsInitialized) return;
+  const common = baseMetricDefinition.getCommonAttributes(config);
+  arenaSessionCounter?.add(1, {
+    ...common,
+    status,
+    ...displayBackend ? { display_backend: displayBackend } : {}
+  });
+  if (durationMs !== void 0 && arenaSessionDurationHistogram) {
+    arenaSessionDurationHistogram.record(durationMs, {
+      ...common,
+      status
+    });
+  }
+  if (winnerModelId) {
+    arenaResultSelectedCounter?.add(1, {
+      ...common,
+      model_id: winnerModelId
+    });
+  }
+}
+__name(recordArenaSessionEndedMetrics, "recordArenaSessionEndedMetrics");
+function recordMemoryExtractMetrics(config, durationMs, attrs) {
+  if (!isMetricsInitialized) return;
+  const common = baseMetricDefinition.getCommonAttributes(config);
+  memoryExtractCounter?.add(1, {
+    ...common,
+    trigger: attrs.trigger,
+    status: attrs.status
+  });
+  memoryExtractDurationHistogram?.record(durationMs, {
+    ...common,
+    trigger: attrs.trigger,
+    status: attrs.status
+  });
+}
+__name(recordMemoryExtractMetrics, "recordMemoryExtractMetrics");
+function recordMemoryDreamMetrics(config, durationMs, attrs) {
+  if (!isMetricsInitialized) return;
+  const common = baseMetricDefinition.getCommonAttributes(config);
+  memoryDreamCounter?.add(1, {
+    ...common,
+    trigger: attrs.trigger,
+    status: attrs.status
+  });
+  memoryDreamDurationHistogram?.record(durationMs, {
+    ...common,
+    trigger: attrs.trigger,
+    status: attrs.status
+  });
+}
+__name(recordMemoryDreamMetrics, "recordMemoryDreamMetrics");
+function recordMemoryRecallMetrics(config, durationMs, attrs) {
+  if (!isMetricsInitialized) return;
+  const common = baseMetricDefinition.getCommonAttributes(config);
+  memoryRecallCounter?.add(1, { ...common, strategy: attrs.strategy });
+  memoryRecallDurationHistogram?.record(durationMs, {
+    ...common,
+    strategy: attrs.strategy
+  });
+}
+__name(recordMemoryRecallMetrics, "recordMemoryRecallMetrics");
+function recordChannelMemoryRecallMetrics(observation) {
+  if (!isMetricsInitialized) return;
+  const attributes = {
+    cache: observation.cache,
+    result: observation.result
+  };
+  channelMemoryRecallCounter?.add(1, attributes);
+  channelMemoryRecallDurationHistogram?.record(
+    observation.durationMs,
+    attributes
+  );
+  channelMemoryRecallSelectedCountHistogram?.record(
+    observation.selectedCount,
+    attributes
+  );
+}
+__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();
+import { createHash as createHash2 } from "node:crypto";
+
+// packages/core/src/telemetry/sdk.ts
+init_esbuild_shims();
+init_esm();
+
+// packages/core/src/telemetry/tracer.ts
+init_esbuild_shims();
+init_esm();
+
+// packages/core/src/telemetry/trace-id-utils.ts
+init_esbuild_shims();
+import { createHash } from "node:crypto";
+function deriveTraceId(sessionId) {
+  return createHash("sha256").update(sessionId).digest("hex").slice(0, 32);
+}
+__name(deriveTraceId, "deriveTraceId");
+function randomSpanId() {
+  const bytes = new Uint8Array(8);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+__name(randomSpanId, "randomSpanId");
+function randomHexString(length) {
+  const bytes = new Uint8Array(Math.ceil(length / 2));
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("").slice(0, length);
+}
+__name(randomHexString, "randomHexString");
+
+// packages/core/src/telemetry/tracer.ts
+var tracer = trace.getTracer(SERVICE_NAME);
+var debugLogger = createDebugLogger("OTEL_TRACER");
+var TELEMETRY_WARNING_INTERVAL_MS = 3e4;
+var API_CALL_FAILED_SPAN_STATUS_MESSAGE = "API call failed";
+var API_CALL_ABORTED_SPAN_STATUS_MESSAGE = "API call aborted";
+var lastTelemetryWarningMs;
+var suppressedTelemetryWarnings = 0;
+function warnTelemetryOperationFailed(operation, error) {
+  const now = Date.now();
+  if (lastTelemetryWarningMs !== void 0 && now - lastTelemetryWarningMs < TELEMETRY_WARNING_INTERVAL_MS) {
+    suppressedTelemetryWarnings += 1;
+    return;
+  }
+  const suppressedSuffix = suppressedTelemetryWarnings > 0 ? `; suppressed ${suppressedTelemetryWarnings} similar warning(s)` : "";
+  suppressedTelemetryWarnings = 0;
+  lastTelemetryWarningMs = now;
+  try {
+    debugLogger.warn(
+      `OTel span ${operation} failed: ${error instanceof Error ? error.message : String(error)}${suppressedSuffix}`
+    );
+  } catch {
+  }
+}
+__name(warnTelemetryOperationFailed, "warnTelemetryOperationFailed");
+function safeSetStatus(span, status) {
+  try {
+    span.setStatus(status);
+  } catch (error) {
+    warnTelemetryOperationFailed("setStatus", error);
+  }
+}
+__name(safeSetStatus, "safeSetStatus");
+function shouldForceSampled() {
+  const sampler = process.env["OTEL_TRACES_SAMPLER"]?.trim().toLowerCase() ?? "";
+  if (!sampler || sampler.startsWith("parentbased_")) {
+    if (sampler.includes("always_off")) return false;
+    return true;
+  }
+  return sampler === "always_on";
+}
+__name(shouldForceSampled, "shouldForceSampled");
+function createSessionRootContext(sessionId) {
+  const traceId = deriveTraceId(sessionId);
+  const spanId = randomSpanId();
+  const rootSpan = trace.wrapSpanContext({
+    traceId,
+    spanId,
+    traceFlags: shouldForceSampled() ? TraceFlags.SAMPLED : TraceFlags.NONE,
+    isRemote: false
+  });
+  return trace.setSpan(ROOT_CONTEXT, rootSpan);
+}
+__name(createSessionRootContext, "createSessionRootContext");
+
+// packages/core/src/telemetry/session-tracing.ts
+init_esbuild_shims();
+init_esm();
+import { AsyncLocalStorage } from "node:async_hooks";
+var debugLogger2 = createDebugLogger("SESSION_TRACING");
+function resolveParentContext(parent) {
+  if (parent) {
+    return trace.setSpan(context.active(), parent.span);
+  }
+  return context.active();
+}
+__name(resolveParentContext, "resolveParentContext");
+var NOOP_SPAN = trace.wrapSpanContext({
+  traceId: "0".repeat(32),
+  spanId: "0".repeat(16),
+  traceFlags: 0
+});
+var interactionContext = new AsyncLocalStorage();
+var toolContext = new AsyncLocalStorage();
+var subagentContext = new AsyncLocalStorage();
+function isInNativeSubagentSpan() {
+  const ctx = subagentContext.getStore();
+  return ctx !== void 0 && !ctx.ended;
+}
+__name(isInNativeSubagentSpan, "isInNativeSubagentSpan");
+function resolveSessionId(parentCtx) {
+  const fromParent = parentCtx?.attributes?.["session.id"];
+  return typeof fromParent === "string" && fromParent ? fromParent : getCurrentSessionId();
+}
+__name(resolveSessionId, "resolveSessionId");
+var activeSpans = /* @__PURE__ */ new Map();
+var strongSpans = /* @__PURE__ */ new Map();
+var interactionSequence = 0;
+var lastInteractionCtx;
+var cleanupIntervalStarted = false;
+var SPAN_TTL_MS_DEFAULT = 30 * 60 * 1e3;
+var SPAN_TTL_MS_LONG = 4 * 60 * 60 * 1e3;
+var LONG_TTL_SUBAGENT_KINDS = /* @__PURE__ */ new Set([
+  "fork",
+  "background"
+]);
+function ttlFor(ctx) {
+  if (ctx.type === "subagent") {
+    const kind = ctx.attributes["qwen-code.subagent.invocation_kind"];
+    if (typeof kind === "string" && LONG_TTL_SUBAGENT_KINDS.has(kind)) {
+      return SPAN_TTL_MS_LONG;
+    }
+  }
+  return SPAN_TTL_MS_DEFAULT;
+}
+__name(ttlFor, "ttlFor");
+function sweepStaleSpans(now) {
+  for (const [spanId, weakRef] of activeSpans) {
+    const ctx = weakRef.deref();
+    if (ctx === void 0) {
+      activeSpans.delete(spanId);
+      strongSpans.delete(spanId);
+      continue;
+    }
+    if (now - ctx.startTime < ttlFor(ctx)) continue;
+    if (!ctx.ended) {
+      ctx.ended = true;
+      const ageMs = now - ctx.startTime;
+      const toolName = ctx.attributes["tool.name"];
+      const callId = ctx.attributes["tool.call_id"];
+      try {
+        ctx.span.setAttributes({
+          "qwen-code.span.ttl_expired": true,
+          "qwen-code.span.duration_ms": ageMs,
+          ...ctx.type === "tool.blocked_on_user" ? {
+            decision: "aborted",
+            source: "system"
+          } : {},
+          ...ctx.type === "subagent" ? {
+            "qwen-code.subagent.status": "aborted",
+            "qwen-code.subagent.terminate_reason": "ttl_swept",
+            // Mirror the subagent-specific duration_ms key that
+            // endSubagentSpan stamps so dashboards querying that
+            // namespace see TTL-swept spans too (they currently
+            // only get the generic qwen-code.span.duration_ms
+            // above). wenshao @ #4410.
+            "qwen-code.subagent.duration_ms": ageMs
+          } : {}
+        });
+      } catch (error) {
+        debugLogger2.warn(
+          `Failed to stamp TTL attrs on stale span ${spanId}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+      const ctxLabel = toolName && callId ? `${ctx.type} (tool.name=${toolName}, tool.call_id=${callId})` : ctx.type;
+      debugLogger2.warn(
+        `Stale ${ctxLabel} span ended by TTL safety net (age=${ageMs}ms, spanId=${spanId})`
+      );
+      try {
+        ctx.span.end();
+      } catch (error) {
+        debugLogger2.warn(
+          `Failed to end stale span ${spanId}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    activeSpans.delete(spanId);
+    strongSpans.delete(spanId);
+  }
+}
+__name(sweepStaleSpans, "sweepStaleSpans");
+function ensureCleanupInterval() {
+  if (cleanupIntervalStarted) return;
+  cleanupIntervalStarted = true;
+  const interval = setInterval(() => sweepStaleSpans(Date.now()), 6e4);
+  if (typeof interval.unref === "function") {
+    interval.unref();
+  }
+}
+__name(ensureCleanupInterval, "ensureCleanupInterval");
+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;
+  const code = s.charCodeAt(end - 1);
+  if (code >= 55296 && code <= 56319) end--;
+  return s.slice(0, end) + "\u2026[truncated]";
+}
+__name(truncateSpanError, "truncateSpanError");
+function getTracer() {
+  return trace.getTracer(SERVICE_NAME, "1.0.0");
+}
+__name(getTracer, "getTracer");
+function startInteractionSpan(config, options) {
+  if (!isTelemetrySdkInitialized()) return;
+  ensureCleanupInterval();
+  interactionSequence++;
+  const attributes = {
+    "session.id": config.getSessionId(),
+    "qwen-code.prompt_id": options.promptId,
+    "qwen-code.message_type": options.messageType,
+    "qwen-code.model": options.model,
+    "qwen-code.approval_mode": config.getApprovalMode(),
+    "interaction.sequence": interactionSequence
+  };
+  const span = getTracer().startSpan(
+    SPAN_INTERACTION,
+    { kind: SpanKind.INTERNAL, attributes },
+    ROOT_CONTEXT
+  );
+  const spanId = getSpanId(span);
+  const spanContextObj = {
+    span,
+    startTime: Date.now(),
+    attributes,
+    type: "interaction"
+  };
+  activeSpans.set(spanId, new WeakRef(spanContextObj));
+  strongSpans.set(spanId, spanContextObj);
+  lastInteractionCtx = spanContextObj;
+  interactionContext.enterWith(spanContextObj);
+}
+__name(startInteractionSpan, "startInteractionSpan");
+function endInteractionSpan(status, metadata) {
+  const spanCtx = interactionContext.getStore() ?? lastInteractionCtx;
+  if (!spanCtx) return;
+  if (spanCtx.ended) {
+    debugLogger2.debug(
+      `endInteractionSpan: span ${getSpanId(spanCtx.span)} already ended (possible TTL sweep race)`
+    );
+    return;
+  }
+  spanCtx.ended = true;
+  lastInteractionCtx = void 0;
+  const duration = Date.now() - spanCtx.startTime;
+  spanCtx.span.setAttributes({
+    "interaction.duration_ms": duration,
+    "qwen-code.turn_status": status
+  });
+  if (status === "error") {
+    spanCtx.span.setStatus({
+      code: SpanStatusCode.ERROR,
+      message: metadata?.errorMessage ?? "unknown error"
+    });
+  } else {
+    spanCtx.span.setStatus({ code: SpanStatusCode.OK });
+  }
+  spanCtx.span.end();
+  const spanId = getSpanId(spanCtx.span);
+  activeSpans.delete(spanId);
+  strongSpans.delete(spanId);
+  interactionContext.enterWith(void 0);
+}
+__name(endInteractionSpan, "endInteractionSpan");
+async function withInteractionSpan(config, options, fn, getResultStatus) {
+  if (!isTelemetrySdkInitialized()) return await fn();
+  ensureCleanupInterval();
+  interactionSequence++;
+  const attributes = {
+    "session.id": config.getSessionId(),
+    "qwen-code.prompt_id": options.promptId,
+    "qwen-code.message_type": options.messageType,
+    "qwen-code.model": options.model,
+    "qwen-code.approval_mode": config.getApprovalMode(),
+    "interaction.sequence": interactionSequence
+  };
+  const parentContext = options.parentContext ?? ROOT_CONTEXT;
+  const span = getTracer().startSpan(
+    SPAN_INTERACTION,
+    {
+      kind: SpanKind.INTERNAL,
+      attributes
+    },
+    parentContext
+  );
+  const spanId = getSpanId(span);
+  const spanContextObj = {
+    span,
+    startTime: Date.now(),
+    attributes,
+    type: "interaction"
+  };
+  activeSpans.set(spanId, new WeakRef(spanContextObj));
+  strongSpans.set(spanId, spanContextObj);
+  const activeContext = trace.setSpan(parentContext, span);
+  return await context.with(
+    activeContext,
+    async () => interactionContext.run(spanContextObj, async () => {
+      let terminalStatus = "ok";
+      let errorStatusSet = false;
+      try {
+        const result = await fn();
+        terminalStatus = getResultStatus?.(result) ?? "ok";
+        return result;
+      } catch (error) {
+        terminalStatus = "error";
+        span.setStatus({
+          code: SpanStatusCode.ERROR,
+          message: truncateSpanError(
+            error instanceof Error ? error.message : String(error)
+          )
+        });
+        errorStatusSet = true;
+        throw error;
+      } finally {
+        if (!spanContextObj.ended) {
+          spanContextObj.ended = true;
+          const duration = Date.now() - spanContextObj.startTime;
+          span.setAttributes({
+            "interaction.duration_ms": duration,
+            "qwen-code.turn_status": terminalStatus
+          });
+          if (terminalStatus === "ok") {
+            span.setStatus({ code: SpanStatusCode.OK });
+          } else if (terminalStatus === "error" && !errorStatusSet) {
+            span.setStatus({
+              code: SpanStatusCode.ERROR,
+              message: "interaction error"
+            });
+          }
+          span.end();
+          activeSpans.delete(spanId);
+          strongSpans.delete(spanId);
+        }
+      }
+    })
+  );
+}
+__name(withInteractionSpan, "withInteractionSpan");
+function startLLMRequestSpan(model, promptId) {
+  if (!isTelemetrySdkInitialized()) {
+    return NOOP_SPAN;
+  }
+  const parentCtx = subagentContext.getStore() ?? interactionContext.getStore();
+  const ctx = resolveParentContext(parentCtx);
+  const sessionId = resolveSessionId(parentCtx);
+  const attributes = {
+    ...sessionId ? { "session.id": sessionId } : {},
+    "qwen-code.model": model,
+    "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
+  };
+  const span = getTracer().startSpan(
+    SPAN_LLM_REQUEST,
+    { kind: SpanKind.INTERNAL, attributes },
+    ctx
+  );
+  const spanId = getSpanId(span);
+  const spanContextObj = {
+    span,
+    startTime: Date.now(),
+    attributes,
+    type: "llm_request"
+  };
+  activeSpans.set(spanId, new WeakRef(spanContextObj));
+  strongSpans.set(spanId, spanContextObj);
+  return span;
+}
+__name(startLLMRequestSpan, "startLLMRequestSpan");
+function endLLMRequestSpan(span, metadata) {
+  const spanId = getSpanId(span);
+  const spanCtx = activeSpans.get(spanId)?.deref();
+  if (!spanCtx) return;
+  if (spanCtx.ended) {
+    debugLogger2.debug(
+      `endLLMRequestSpan: span ${spanId} already ended (possible TTL sweep race)`
+    );
+    return;
+  }
+  spanCtx.ended = true;
+  try {
+    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;
+        endAttributes["gen_ai.usage.input_tokens"] = metadata.inputTokens;
+      }
+      if (metadata.outputTokens !== void 0) {
+        endAttributes["output_tokens"] = metadata.outputTokens;
+        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.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;
+      }
+      if (metadata.attempt !== void 0) {
+        endAttributes["attempt"] = metadata.attempt;
+      }
+      if (metadata.retryTotalDelayMs !== void 0) {
+        endAttributes["retry_total_delay_ms"] = metadata.retryTotalDelayMs;
+      }
+      if (metadata.ttftMs !== void 0) {
+        const samplingMs = Math.max(0, duration - metadata.ttftMs);
+        endAttributes["sampling_ms"] = samplingMs;
+        if (samplingMs > 0 && metadata.outputTokens !== void 0) {
+          endAttributes["output_tokens_per_second"] = Math.round(metadata.outputTokens / (samplingMs / 1e3) * 100) / 100;
+        }
+      }
+      endAttributes["success"] = metadata.success;
+      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.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;
+      }
+      if (metadata.errorType !== void 0) {
+        endAttributes["error_type"] = metadata.errorType;
+        endAttributes["error.type"] = metadata.errorType;
+      }
+      if (metadata.errorStatusCode !== void 0) {
+        endAttributes["error_status_code"] = metadata.errorStatusCode;
+      }
+    }
+    spanCtx.span.setAttributes(endAttributes);
+    try {
+      if (metadata?.config && metadata.success) {
+        const model = String(spanCtx.attributes["qwen-code.model"] ?? "");
+        if (metadata.requestSetupMs !== void 0) {
+          recordApiRequestBreakdown(metadata.config, metadata.requestSetupMs, {
+            model,
+            phase: "request_preparation" /* REQUEST_PREPARATION */
+          });
+        }
+        if (metadata.ttftMs !== void 0) {
+          recordApiRequestBreakdown(metadata.config, metadata.ttftMs, {
+            model,
+            phase: "network_latency" /* NETWORK_LATENCY */
+          });
+        }
+        const breakdownSamplingMs = metadata.ttftMs !== void 0 ? Math.max(0, duration - metadata.ttftMs) : void 0;
+        if (breakdownSamplingMs !== void 0 && breakdownSamplingMs > 0) {
+          recordApiRequestBreakdown(metadata.config, breakdownSamplingMs, {
+            model,
+            phase: "response_processing" /* RESPONSE_PROCESSING */
+          });
+        }
+      }
+    } catch (error) {
+      debugLogger2.warn(
+        `Failed to record API request breakdown histogram: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    if (metadata === void 0 || metadata.success) {
+      spanCtx.span.setStatus({ code: SpanStatusCode.OK });
+    } else {
+      spanCtx.span.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: metadata.error ? truncateSpanError(metadata.error) : "unknown error"
+      });
+    }
+  } catch (error) {
+    debugLogger2.warn(
+      `Failed to update LLM request span attributes/status: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  try {
+    spanCtx.span.end();
+  } catch (error) {
+    debugLogger2.warn(
+      `Failed to end LLM request span: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  activeSpans.delete(spanId);
+  strongSpans.delete(spanId);
+}
+__name(endLLMRequestSpan, "endLLMRequestSpan");
+function startToolSpan(toolName, attrs) {
+  if (!isTelemetrySdkInitialized()) {
+    return NOOP_SPAN;
+  }
+  const parentCtx = subagentContext.getStore() ?? interactionContext.getStore();
+  const ctx = resolveParentContext(parentCtx);
+  const sessionId = resolveSessionId(parentCtx);
+  const attributes = {
+    ...sessionId ? { "session.id": sessionId } : {},
+    "tool.name": toolName,
+    ...attrs
+  };
+  const span = getTracer().startSpan(
+    SPAN_TOOL,
+    { kind: SpanKind.INTERNAL, attributes },
+    ctx
+  );
+  const spanId = getSpanId(span);
+  const spanContextObj = {
+    span,
+    startTime: Date.now(),
+    attributes,
+    type: "tool"
+  };
+  activeSpans.set(spanId, new WeakRef(spanContextObj));
+  strongSpans.set(spanId, spanContextObj);
+  return span;
+}
+__name(startToolSpan, "startToolSpan");
+function runInToolSpanContext(span, fn) {
+  const spanId = getSpanId(span);
+  const spanCtx = activeSpans.get(spanId)?.deref();
+  if (!spanCtx) return fn();
+  const otelCtxWithSpan = trace.setSpan(context.active(), span);
+  return toolContext.run(spanCtx, () => context.with(otelCtxWithSpan, fn));
+}
+__name(runInToolSpanContext, "runInToolSpanContext");
+function endToolSpan(span, metadata) {
+  const spanId = getSpanId(span);
+  const spanCtx = activeSpans.get(spanId)?.deref();
+  if (!spanCtx) return;
+  if (spanCtx.ended) {
+    debugLogger2.debug(
+      `endToolSpan: span ${spanId} already ended (possible TTL sweep race)`
+    );
+    return;
+  }
+  spanCtx.ended = true;
+  try {
+    const duration = Date.now() - spanCtx.startTime;
+    const endAttributes = { duration_ms: duration };
+    if (metadata) {
+      if (metadata.success !== void 0)
+        endAttributes["success"] = metadata.success;
+      if (metadata.error !== void 0)
+        endAttributes["error"] = truncateSpanError(metadata.error);
+    }
+    spanCtx.span.setAttributes(endAttributes);
+    if (metadata) {
+      if (metadata.success !== false) {
+        spanCtx.span.setStatus({ code: SpanStatusCode.OK });
+      } else {
+        spanCtx.span.setStatus({
+          code: SpanStatusCode.ERROR,
+          message: metadata.error ? truncateSpanError(metadata.error) : "tool error"
+        });
+      }
+    }
+  } catch (error) {
+    debugLogger2.warn(
+      `Failed to update tool span attributes/status: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  try {
+    spanCtx.span.end();
+  } catch (error) {
+    debugLogger2.warn(
+      `Failed to end tool span: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  activeSpans.delete(spanId);
+  strongSpans.delete(spanId);
+}
+__name(endToolSpan, "endToolSpan");
+function startToolExecutionSpan() {
+  if (!isTelemetrySdkInitialized()) {
+    return NOOP_SPAN;
+  }
+  const parentCtx = toolContext.getStore();
+  if (!parentCtx) {
+    debugLogger2.warn(
+      "startToolExecutionSpan called outside runInToolSpanContext \u2014 span will not be parented to tool span"
+    );
+  }
+  const ctx = resolveParentContext(parentCtx);
+  const sessionId = resolveSessionId(
+    parentCtx ?? interactionContext.getStore()
+  );
+  const span = getTracer().startSpan(
+    SPAN_TOOL_EXECUTION,
+    {
+      kind: SpanKind.INTERNAL,
+      attributes: sessionId ? { "session.id": sessionId } : {}
+    },
+    ctx
+  );
+  const spanId = getSpanId(span);
+  const spanContextObj = {
+    span,
+    startTime: Date.now(),
+    attributes: sessionId ? { "session.id": sessionId } : {},
+    type: "tool.execution"
+  };
+  activeSpans.set(spanId, new WeakRef(spanContextObj));
+  strongSpans.set(spanId, spanContextObj);
+  return span;
+}
+__name(startToolExecutionSpan, "startToolExecutionSpan");
+function endToolExecutionSpan(span, metadata) {
+  const spanId = getSpanId(span);
+  const spanCtx = activeSpans.get(spanId)?.deref();
+  if (!spanCtx) return;
+  if (spanCtx.ended) {
+    debugLogger2.debug(
+      `endToolExecutionSpan: span ${spanId} already ended (possible TTL sweep race)`
+    );
+    return;
+  }
+  spanCtx.ended = true;
+  try {
+    const duration = Date.now() - spanCtx.startTime;
+    const endAttributes = {};
+    if (metadata?.attributes) {
+      Object.assign(endAttributes, metadata.attributes);
+    }
+    endAttributes["duration_ms"] = duration;
+    if (metadata) {
+      if (metadata.success !== void 0)
+        endAttributes["success"] = metadata.success;
+      if (metadata.error !== void 0)
+        endAttributes["error"] = truncateSpanError(metadata.error);
+    }
+    spanCtx.span.setAttributes(endAttributes);
+    if (metadata && !metadata.cancelled) {
+      if (metadata.success !== false) {
+        spanCtx.span.setStatus({ code: SpanStatusCode.OK });
+      } else {
+        spanCtx.span.setStatus({
+          code: SpanStatusCode.ERROR,
+          message: metadata.error ? truncateSpanError(metadata.error) : "tool execution error"
+        });
+      }
+    }
+  } catch (error) {
+    debugLogger2.warn(
+      `Failed to update tool execution span attributes/status: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  try {
+    spanCtx.span.end();
+  } catch (error) {
+    debugLogger2.warn(
+      `Failed to end tool execution span: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  activeSpans.delete(spanId);
+  strongSpans.delete(spanId);
+}
+__name(endToolExecutionSpan, "endToolExecutionSpan");
+function startToolBlockedOnUserSpan(toolSpan, attrs) {
+  if (!isTelemetrySdkInitialized()) {
+    return NOOP_SPAN;
+  }
+  ensureCleanupInterval();
+  const parentSpanId = getSpanId(toolSpan);
+  const parentSpanCtx = activeSpans.get(parentSpanId)?.deref();
+  if (!parentSpanCtx) {
+    debugLogger2.debug(
+      "startToolBlockedOnUserSpan: tool span not in activeSpans (already ended?) \u2014 using resolveParentContext fallback"
+    );
+  }
+  const ctx = parentSpanCtx ? trace.setSpan(context.active(), parentSpanCtx.span) : resolveParentContext(void 0);
+  const sessionParentCtx = parentSpanCtx ?? subagentContext.getStore() ?? interactionContext.getStore() ?? void 0;
+  const sessionId = resolveSessionId(sessionParentCtx);
+  const attributes = {
+    ...sessionId ? { "session.id": sessionId } : {}
+  };
+  if (attrs?.tool_name !== void 0) attributes["tool.name"] = attrs.tool_name;
+  if (attrs?.call_id !== void 0) attributes["tool.call_id"] = attrs.call_id;
+  const span = getTracer().startSpan(
+    SPAN_TOOL_BLOCKED_ON_USER,
+    { kind: SpanKind.INTERNAL, attributes },
+    ctx
+  );
+  const spanId = getSpanId(span);
+  const spanContextObj = {
+    span,
+    startTime: Date.now(),
+    attributes,
+    type: "tool.blocked_on_user"
+  };
+  activeSpans.set(spanId, new WeakRef(spanContextObj));
+  strongSpans.set(spanId, spanContextObj);
+  return span;
+}
+__name(startToolBlockedOnUserSpan, "startToolBlockedOnUserSpan");
+function endToolBlockedOnUserSpan(span, metadata) {
+  const spanId = getSpanId(span);
+  const spanCtx = activeSpans.get(spanId)?.deref();
+  if (!spanCtx) return;
+  if (spanCtx.ended) {
+    debugLogger2.debug(
+      `endToolBlockedOnUserSpan: span ${spanId} already ended (possible TTL sweep race)`
+    );
+    return;
+  }
+  spanCtx.ended = true;
+  try {
+    const duration = Date.now() - spanCtx.startTime;
+    const endAttributes = { duration_ms: duration };
+    if (metadata?.decision !== void 0)
+      endAttributes["decision"] = metadata.decision;
+    if (metadata?.source !== void 0)
+      endAttributes["source"] = metadata.source;
+    spanCtx.span.setAttributes(endAttributes);
+  } catch (error) {
+    debugLogger2.warn(
+      `Failed to update blocked_on_user span attributes: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  try {
+    spanCtx.span.end();
+  } catch (error) {
+    debugLogger2.warn(
+      `Failed to end blocked_on_user span: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  activeSpans.delete(spanId);
+  strongSpans.delete(spanId);
+}
+__name(endToolBlockedOnUserSpan, "endToolBlockedOnUserSpan");
+function startHookSpan(opts) {
+  if (!isTelemetrySdkInitialized()) {
+    return NOOP_SPAN;
+  }
+  ensureCleanupInterval();
+  const parentCtx = toolContext.getStore() ?? subagentContext.getStore() ?? interactionContext.getStore() ?? void 0;
+  const ctx = resolveParentContext(parentCtx);
+  const sessionId = resolveSessionId(parentCtx);
+  const attributes = {
+    ...sessionId ? { "session.id": sessionId } : {},
+    hook_event: opts.hookEvent,
+    "tool.name": opts.toolName
+  };
+  if (opts.toolUseId !== void 0) attributes["tool.use_id"] = opts.toolUseId;
+  if (opts.isInterrupt !== void 0)
+    attributes["is_interrupt"] = opts.isInterrupt;
+  const span = getTracer().startSpan(
+    SPAN_HOOK,
+    { kind: SpanKind.INTERNAL, attributes },
+    ctx
+  );
+  const spanId = getSpanId(span);
+  const spanContextObj = {
+    span,
+    startTime: Date.now(),
+    attributes,
+    type: "hook"
+  };
+  activeSpans.set(spanId, new WeakRef(spanContextObj));
+  strongSpans.set(spanId, spanContextObj);
+  return span;
+}
+__name(startHookSpan, "startHookSpan");
+function endHookSpan(span, metadata) {
+  const spanId = getSpanId(span);
+  const spanCtx = activeSpans.get(spanId)?.deref();
+  if (!spanCtx) return;
+  if (spanCtx.ended) {
+    debugLogger2.debug(
+      `endHookSpan: span ${spanId} already ended (possible TTL sweep race)`
+    );
+    return;
+  }
+  spanCtx.ended = true;
+  try {
+    const duration = Date.now() - spanCtx.startTime;
+    const endAttributes = { duration_ms: duration };
+    if (metadata) {
+      if (metadata.success !== void 0)
+        endAttributes["success"] = metadata.success;
+      if (metadata.shouldProceed !== void 0)
+        endAttributes["should_proceed"] = metadata.shouldProceed;
+      if (metadata.shouldStop !== void 0)
+        endAttributes["should_stop"] = metadata.shouldStop;
+      if (metadata.blockType !== void 0)
+        endAttributes["block_type"] = metadata.blockType;
+      if (metadata.hasAdditionalContext !== void 0)
+        endAttributes["has_additional_context"] = metadata.hasAdditionalContext;
+      if (metadata.postBatchStop !== void 0)
+        endAttributes["post_batch_stop"] = metadata.postBatchStop;
+      if (metadata.postBatchStopReason !== void 0)
+        endAttributes["post_batch_stop_reason"] = truncateSpanError(
+          metadata.postBatchStopReason
+        );
+      if (metadata.error !== void 0)
+        endAttributes["error"] = truncateSpanError(metadata.error);
+    }
+    spanCtx.span.setAttributes(endAttributes);
+    if (metadata?.error !== void 0) {
+      spanCtx.span.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: truncateSpanError(metadata.error)
+      });
+    }
+  } catch (error) {
+    debugLogger2.warn(
+      `Failed to update hook span attributes/status: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  try {
+    spanCtx.span.end();
+  } catch (error) {
+    debugLogger2.warn(
+      `Failed to end hook span: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  activeSpans.delete(spanId);
+  strongSpans.delete(spanId);
+}
+__name(endHookSpan, "endHookSpan");
+function startSubagentSpan(opts) {
+  if (!isTelemetrySdkInitialized()) return NOOP_SPAN;
+  ensureCleanupInterval();
+  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.
+    "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.modelOverride !== void 0) {
+    attributes["gen_ai.request.model"] = opts.modelOverride;
+  }
+  if (opts.parentAgentId !== void 0) {
+    attributes["qwen-code.subagent.parent_agent_id"] = opts.parentAgentId;
+  }
+  if (opts.invokingRequestId !== void 0) {
+    attributes["qwen-code.subagent.invoking_request_id"] = opts.invokingRequestId;
+  }
+  const tracer2 = getTracer();
+  let span;
+  if (opts.invocationKind === "foreground") {
+    span = tracer2.startSpan(SPAN_SUBAGENT, {
+      kind: SpanKind.INTERNAL,
+      attributes
+    });
+  } else {
+    span = tracer2.startSpan(SPAN_SUBAGENT, {
+      kind: SpanKind.INTERNAL,
+      attributes,
+      root: true,
+      links: opts.invokerSpanContext ? [
+        {
+          context: opts.invokerSpanContext,
+          attributes: { "qwen-code.link.kind": "invoker" }
+        }
+      ] : void 0
+    });
+  }
+  const spanId = getSpanId(span);
+  const spanContextObj = {
+    span,
+    startTime: Date.now(),
+    attributes,
+    type: "subagent"
+  };
+  activeSpans.set(spanId, new WeakRef(spanContextObj));
+  strongSpans.set(spanId, spanContextObj);
+  return span;
+}
+__name(startSubagentSpan, "startSubagentSpan");
+function runInSubagentSpanContext(span, fn) {
+  const spanId = getSpanId(span);
+  const spanCtx = activeSpans.get(spanId)?.deref();
+  if (!spanCtx) return fn();
+  const otelCtxWithSpan = trace.setSpan(context.active(), span);
+  return subagentContext.run(
+    spanCtx,
+    () => toolContext.run(void 0, () => context.with(otelCtxWithSpan, fn))
+  );
+}
+__name(runInSubagentSpanContext, "runInSubagentSpanContext");
+function endSubagentSpan(span, metadata) {
+  const spanId = getSpanId(span);
+  const spanCtx = activeSpans.get(spanId)?.deref();
+  if (!spanCtx) {
+    if (isTelemetrySdkInitialized()) {
+      debugLogger2.warn(
+        `endSubagentSpan: span ${spanId} not found in activeSpans (already swept?) \u2014 intended status=${metadata.status}, reason=${metadata.terminateReason ?? "none"}`
+      );
+    }
+    return;
+  }
+  if (spanCtx.ended) {
+    debugLogger2.warn(
+      `endSubagentSpan: span ${spanId} already ended \u2014 intended status=${metadata.status}, reason=${metadata.terminateReason ?? "none"} (possible TTL sweep race)`
+    );
+    return;
+  }
+  spanCtx.ended = true;
+  try {
+    const duration = Date.now() - spanCtx.startTime;
+    const endAttributes = {
+      duration_ms: duration,
+      "qwen-code.subagent.duration_ms": duration,
+      "qwen-code.subagent.status": metadata.status
+    };
+    if (metadata.terminateReason !== void 0) {
+      endAttributes["qwen-code.subagent.terminate_reason"] = metadata.terminateReason;
+    }
+    if (metadata.resultSummaryPresent !== void 0) {
+      endAttributes["qwen-code.subagent.result_summary_present"] = metadata.resultSummaryPresent;
+    }
+    if (metadata.error !== void 0) {
+      const truncated = truncateSpanError(metadata.error);
+      endAttributes["exception.message"] = truncated;
+    }
+    if (metadata.errorType !== void 0) {
+      endAttributes["error.type"] = metadata.errorType;
+    }
+    spanCtx.span.setAttributes(endAttributes);
+    if (metadata.status === "completed") {
+      spanCtx.span.setStatus({ code: SpanStatusCode.OK });
+    } else if (metadata.status === "failed") {
+      spanCtx.span.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: metadata.error ? truncateSpanError(metadata.error) : "subagent failed"
+      });
+    }
+  } catch (error) {
+    debugLogger2.warn(
+      `Failed to update subagent span attributes/status: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  try {
+    spanCtx.span.end();
+  } catch (error) {
+    debugLogger2.warn(
+      `Failed to end subagent span: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  activeSpans.delete(spanId);
+  strongSpans.delete(spanId);
+}
+__name(endSubagentSpan, "endSubagentSpan");
+function getActiveInteractionSpan() {
+  const ctx = interactionContext.getStore() ?? lastInteractionCtx;
+  if (!ctx || ctx.ended) return void 0;
+  return ctx.span;
+}
+__name(getActiveInteractionSpan, "getActiveInteractionSpan");
+
+// packages/core/src/telemetry/sdk.ts
+function createTelemetryDiagLogger() {
+  const debugLogger3 = createDebugLogger("OTEL");
+  return {
+    error: /* @__PURE__ */ __name((message, ...args) => debugLogger3.error(message, ...args), "error"),
+    warn: /* @__PURE__ */ __name((message, ...args) => debugLogger3.warn(message, ...args), "warn"),
+    info: /* @__PURE__ */ __name((message, ...args) => debugLogger3.info(message, ...args), "info"),
+    debug: /* @__PURE__ */ __name((message, ...args) => debugLogger3.debug(message, ...args), "debug"),
+    verbose: /* @__PURE__ */ __name((message, ...args) => debugLogger3.debug(message, ...args), "verbose")
+  };
+}
+__name(createTelemetryDiagLogger, "createTelemetryDiagLogger");
+diag.setLogger(createTelemetryDiagLogger(), DiagLogLevel.WARN);
+var SHUTDOWN_TIMEOUT_MS = 1e4;
+var sdk;
+var telemetryInitialized = false;
+var telemetryInitPromise;
+var telemetryShutdownPromise;
+var activeMetricReader;
+function isTelemetrySdkInitialized() {
+  return telemetryInitialized;
+}
+__name(isTelemetrySdkInitialized, "isTelemetrySdkInitialized");
+function initializeTelemetry(config) {
+  if (telemetryInitialized || !config.getTelemetryEnabled()) {
+    return Promise.resolve();
+  }
+  telemetryInitPromise ??= (async () => {
+    const debugLogger3 = createDebugLogger("OTEL");
+    try {
+      const { startTelemetrySdk } = await import("./sdk-impl-HOLWAXC6.js");
+      if (telemetryInitialized) return;
+      const started = await startTelemetrySdk(config);
+      if (!started) return;
+      sdk = started.sdk;
+      sdk.start();
+      debugLogger3.debug("OpenTelemetry SDK started successfully.");
+      telemetryInitialized = true;
+      activeMetricReader = started.metricReader;
+      const sessionId = config.getSessionId();
+      setSessionContext(createSessionRootContext(sessionId), sessionId);
+      setShellTracePropagation(
+        config.getOutboundCorrelationPropagateTraceContext()
+      );
+      initializeMetrics(config);
+    } catch (error) {
+      debugLogger3.error("Error starting OpenTelemetry SDK:", error);
+    }
+  })().finally(() => {
+    telemetryInitPromise = void 0;
+  });
+  return telemetryInitPromise;
+}
+__name(initializeTelemetry, "initializeTelemetry");
+function refreshSessionContext(sessionId) {
+  if (!telemetryInitialized) return;
+  try {
+    setSessionContext(createSessionRootContext(sessionId), sessionId);
+  } catch (error) {
+    createDebugLogger("OTEL").warn("Failed to refresh session context:", error);
+  }
+}
+__name(refreshSessionContext, "refreshSessionContext");
+function shutdownTelemetry() {
+  if (telemetryShutdownPromise) {
+    return telemetryShutdownPromise;
+  }
+  const pendingInit = telemetryInitPromise;
+  if (!pendingInit && (!telemetryInitialized || !sdk)) {
+    return Promise.resolve();
+  }
+  telemetryShutdownPromise = (async () => {
+    if (pendingInit) {
+      await pendingInit.catch(() => {
+      });
+    }
+    if (!telemetryInitialized || !sdk) {
+      telemetryShutdownPromise = void 0;
+      return;
+    }
+    endInteractionSpan("cancelled");
+    const currentSdk = sdk;
+    const debugLogger3 = createDebugLogger("OTEL");
+    let timer;
+    let timedOut = false;
+    try {
+      const sdkShutdown = Promise.resolve(currentSdk.shutdown());
+      sdkShutdown.catch((err) => {
+        if (timedOut) {
+          debugLogger3.warn(
+            "SDK shutdown rejected after timeout:",
+            err instanceof Error ? err.message : err
+          );
+        }
+      });
+      const timeout = new Promise((resolve) => {
+        timer = setTimeout(() => {
+          timedOut = true;
+          resolve("timeout");
+        }, SHUTDOWN_TIMEOUT_MS);
+        timer.unref?.();
+      });
+      const result = await Promise.race([sdkShutdown, timeout]);
+      clearTimeout(timer);
+      if (result === "timeout") {
+        const msg = `Telemetry shutdown timed out after ${SHUTDOWN_TIMEOUT_MS}ms.`;
+        diag.warn(msg);
+        debugLogger3.warn(msg);
+      } else {
+        debugLogger3.debug("OpenTelemetry SDK shut down successfully.");
+      }
+    } catch (error) {
+      clearTimeout(timer);
+      diag.error("Error shutting down SDK:", error);
+      debugLogger3.error("Error shutting down SDK:", error);
+    } finally {
+      telemetryInitialized = false;
+      sdk = void 0;
+      activeMetricReader = void 0;
+      telemetryShutdownPromise = void 0;
+      setSessionContext(void 0);
+      setShellTracePropagation(false);
+    }
+  })();
+  return telemetryShutdownPromise;
+}
+__name(shutdownTelemetry, "shutdownTelemetry");
+var FORCE_FLUSH_TIMEOUT_MS = 2e3;
+async function forceFlushMetrics() {
+  if (!telemetryInitialized || !activeMetricReader) return;
+  const flush = activeMetricReader.forceFlush();
+  flush.catch(() => {
+  });
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(
+      () => reject(
+        new Error(
+          `forceFlushMetrics timed out after ${FORCE_FLUSH_TIMEOUT_MS}ms`
+        )
+      ),
+      FORCE_FLUSH_TIMEOUT_MS
+    );
+    timer.unref?.();
+  });
+  try {
+    await Promise.race([flush, timeout]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+__name(forceFlushMetrics, "forceFlushMetrics");
+
+// packages/core/src/telemetry/detailed-span-attributes.ts
+var SYSTEM_PROMPT_PREVIEW_LENGTH = 500;
+var SHORT_TRUNCATION_SUFFIX = "...[TRUNCATED]";
+var seenHashes = /* @__PURE__ */ new Set();
+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 shortHash(content) {
+  return createHash2("sha256").update(content).digest("hex").slice(0, 12);
+}
+__name(shortHash, "shortHash");
+function stringifyContentUnion(value) {
+  if (typeof value === "string") return value;
+  return safeJsonStringify(value) ?? "";
+}
+__name(stringifyContentUnion, "stringifyContentUnion");
+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 addSystemPromptAttributes(config, span, systemInstruction) {
+  if (!areSensitiveSpanAttributesEnabled(config) || !systemInstruction) return;
+  const text = stringifyContentUnion(systemInstruction);
+  if (!text) return;
+  const hash = `sp_${shortHash(text)}`;
+  span.setAttributes({
+    system_prompt_hash: hash,
+    system_prompt_preview: text.slice(0, SYSTEM_PROMPT_PREVIEW_LENGTH),
+    system_prompt_length: text.length
+  });
+  if (!seenHashes.has(hash)) {
+    seenHashes.add(hash);
+    const { content, truncated } = truncateContent(
+      text,
+      getMaxContentSize(config)
+    );
+    span.setAttribute("system_prompt", content);
+    if (truncated) {
+      span.setAttribute("system_prompt_truncated", true);
+    }
+  }
+}
+__name(addSystemPromptAttributes, "addSystemPromptAttributes");
+function addToolSchemaAttributes(config, span, tools) {
+  if (!areSensitiveSpanAttributesEnabled(config) || !tools?.length) return;
+  const declarations = [];
+  for (const tool of tools) {
+    const inner = tool["functionDeclarations"];
+    if (Array.isArray(inner)) {
+      declarations.push(...inner);
+    } else {
+      declarations.push(tool);
+    }
+  }
+  const summary = [];
+  for (const decl of declarations) {
+    const declObj = decl;
+    const name = typeof declObj["name"] === "string" ? declObj["name"] : "unknown_tool";
+    const declJson = safeJsonStringify(decl) ?? `unstringifiable_${name}`;
+    const hash = shortHash(declJson);
+    summary.push({ name, hash });
+    const hashKey = `tool_${hash}`;
+    if (!seenHashes.has(hashKey)) {
+      seenHashes.add(hashKey);
+      const { content, truncated } = truncateContent(
+        declJson,
+        getMaxContentSize(config)
+      );
+      span.addEvent("tool_schema", {
+        tool_name: name,
+        tool_hash: hash,
+        tool_definition: content,
+        ...truncated && {
+          tool_definition_truncated: true,
+          tool_definition_original_length: declJson.length
+        }
+      });
+    }
+  }
+  span.setAttributes({
+    tools: safeJsonStringify(summary) ?? "[]",
+    tools_count: summary.length
+  });
+}
+__name(addToolSchemaAttributes, "addToolSchemaAttributes");
+function addModelOutputAttributes(config, span, responseText, originalLength) {
+  if (!areSensitiveSpanAttributesEnabled(config) || !responseText) return;
+  const responseTextOriginalLength = originalLength ?? responseText.length;
+  const { content, truncated } = truncateContent(
+    responseText,
+    getMaxContentSize(config),
+    responseTextOriginalLength
+  );
+  span.setAttributes({
+    "response.model_output": content,
+    ...truncated && {
+      "response.model_output_truncated": true,
+      "response.model_output_original_length": responseTextOriginalLength
+    }
+  });
+}
+__name(addModelOutputAttributes, "addModelOutputAttributes");
+function addToolInputAttributes(config, span, toolName, toolInput) {
+  if (!areSensitiveSpanAttributesEnabled(config)) return;
+  const { content, truncated, originalLength } = truncatePrefixedContent(
+    `[TOOL INPUT: ${toolName}]
+`,
+    toolInput,
+    getMaxContentSize(config)
+  );
+  span.setAttributes({
+    tool_input: content,
+    ...truncated && {
+      tool_input_truncated: true,
+      tool_input_original_length: originalLength
+    }
+  });
+}
+__name(addToolInputAttributes, "addToolInputAttributes");
+function addToolResultAttributes(config, span, toolName, toolResult) {
+  if (!areSensitiveSpanAttributesEnabled(config)) return;
+  const { content, truncated, originalLength } = truncatePrefixedContent(
+    `[TOOL RESULT: ${toolName}]
+`,
+    toolResult,
+    getMaxContentSize(config)
+  );
+  span.setAttributes({
+    tool_result: content,
+    ...truncated && {
+      tool_result_truncated: true,
+      tool_result_original_length: originalLength
+    }
+  });
+}
+__name(addToolResultAttributes, "addToolResultAttributes");
+function clearDetailedSpanState() {
+  seenHashes.clear();
+}
+__name(clearDetailedSpanState, "clearDetailedSpanState");
+
+export {
+  FileOperation,
+  PerformanceMetricType,
+  MemoryMetricType,
+  ToolExecutionPhase,
+  ApiRequestPhase,
+  getMeter,
+  recordChatCompressionMetrics,
+  recordToolCallMetrics,
+  recordTokenUsageMetrics,
+  recordApiResponseMetrics,
+  recordApiErrorMetrics,
+  recordFileOperationMetric,
+  recordInvalidChunk,
+  recordContentRetry,
+  recordContentRetryFailure,
+  recordApiRetry,
+  recordModelSlashCommand,
+  recordStartupPerformance,
+  recordMemoryUsage,
+  recordCpuUsage,
+  recordToolQueueDepth,
+  recordToolExecutionBreakdown,
+  recordTokenEfficiency,
+  recordApiRequestBreakdown,
+  recordPerformanceScore,
+  recordPerformanceRegression,
+  recordBaselineComparison,
+  isPerformanceMonitoringActive,
+  recordSubagentExecutionMetrics,
+  recordArenaSessionStartedMetrics,
+  recordArenaAgentCompletedMetrics,
+  recordArenaSessionEndedMetrics,
+  recordMemoryExtractMetrics,
+  recordMemoryDreamMetrics,
+  recordMemoryRecallMetrics,
+  recordChannelMemoryRecallMetrics,
+  recordMemoryRecallDeliveryMetrics,
+  deriveTraceId,
+  randomSpanId,
+  randomHexString,
+  API_CALL_FAILED_SPAN_STATUS_MESSAGE,
+  API_CALL_ABORTED_SPAN_STATUS_MESSAGE,
+  safeSetStatus,
+  areSensitiveSpanAttributesEnabled,
+  truncateContent,
+  addUserPromptAttributes,
+  addSystemPromptAttributes,
+  addToolSchemaAttributes,
+  addModelOutputAttributes,
+  addToolInputAttributes,
+  addToolResultAttributes,
+  clearDetailedSpanState,
+  isInNativeSubagentSpan,
+  truncateSpanError,
+  startInteractionSpan,
+  endInteractionSpan,
+  withInteractionSpan,
+  startLLMRequestSpan,
+  endLLMRequestSpan,
+  startToolSpan,
+  runInToolSpanContext,
+  endToolSpan,
+  startToolExecutionSpan,
+  endToolExecutionSpan,
+  startToolBlockedOnUserSpan,
+  endToolBlockedOnUserSpan,
+  startHookSpan,
+  endHookSpan,
+  startSubagentSpan,
+  runInSubagentSpanContext,
+  endSubagentSpan,
+  getActiveInteractionSpan,
+  isTelemetrySdkInitialized,
+  initializeTelemetry,
+  refreshSessionContext,
+  shutdownTelemetry,
+  forceFlushMetrics
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */