@mastra/observability 1.20.1 → 1.21.0-alpha.1

package/dist/index.js

@@ -1943,12 +1943,20 @@ function emitDurationMetrics(span, metrics) {
 	const durationMs = span.endTime.getTime() - span.startTime.getTime();
 	metrics.emit(durationMetricName, durationMs, { status: span.errorInfo ? "error" : "ok" });
 }
-/** Emit token usage metrics for a model-generation span. */
+/** Emit token usage metrics for a model-generation or classifier-evaluation span. */
 function emitTokenMetrics(span, metrics) {
-	if (span.type !== SpanType.MODEL_GENERATION) return;
-	const attrs = span.attributes;
-	if (!attrs?.usage) return;
-	emitUsageMetrics(attrs, attrs.usage, metrics);
+	if (span.type === SpanType.MODEL_GENERATION) {
+		const attrs = span.attributes;
+		if (attrs?.usage) emitUsageMetrics(attrs, attrs.usage, metrics);
+		return;
+	}
+	if (span.type === SpanType.CLASSIFIER_EVALUATION) {
+		const attrs = span.attributes;
+		if (attrs?.usage) emitUsageMetrics({
+			provider: attrs.provider,
+			model: attrs.modelId
+		}, attrs.usage, metrics);
+	}
 }
 /**
 * Emit token usage metrics from an explicit usage payload, using the supplied
@@ -2480,6 +2488,26 @@ function extractStepInput(payload) {
 	}
 }
 /**
+* Chunks that come from the model provider. The first one marks the response's
+* first chunk, matching OTel's `gen_ai.response.time_to_first_chunk`. Everything
+* else, such as lifecycle markers or `data-*` parts a processor writes before the
+* model call, is Mastra's own and does not count.
+*/
+const MODEL_RESPONSE_CHUNK_TYPES = /* @__PURE__ */ new Set([
+	"response-metadata",
+	"raw",
+	"text-start",
+	"text-delta",
+	"reasoning-start",
+	"reasoning-delta",
+	"reasoning-file",
+	"tool-call-input-streaming-start",
+	"tool-call-delta",
+	"tool-call",
+	"source",
+	"file"
+]);
+/**
 * Manages MODEL_STEP and MODEL_CHUNK span tracking for streaming Model responses.
 *
 * Should be instantiated once per MODEL_GENERATION span and shared across
@@ -2496,6 +2524,15 @@ var ModelSpanTracker = class {
 	#chunkSequence = 0;
 	#completionStartTime;
 	#inferenceCompletionStartTime;
+	/**
+	* True between a step's `step-start` and `step-finish` chunks, the window in which
+	* the provider responds. Chunks outside it, such as a `tool-call` replayed for a
+	* finished background task on resume, are Mastra's own and never start the clock.
+	* Durable runs wrap one step's provider stream at a time, so every chunk there counts.
+	*/
+	#inModelResponse = false;
+	/** Set only by the agent's main loop; receives the first chunk's completionStartTime. */
+	#agentRunSpan;
 	#currentStepInputIsFinal = false;
 	/** When true, step-finish chunks don't auto-close the step span (for durable execution) */
 	#deferStepClose = false;
@@ -2503,8 +2540,9 @@ var ModelSpanTracker = class {
 	#pendingStepFinishPayload;
 	/** Static request-side context applied to every MODEL_INFERENCE span */
 	#inferenceContext;
-	constructor(modelSpan) {
+	constructor(modelSpan, options) {
 		this.#modelSpan = modelSpan;
+		this.#agentRunSpan = options?.agentRunSpan;
 	}
 	/**
 	* Set request-side context applied to subsequent MODEL_INFERENCE spans.
@@ -2514,12 +2552,22 @@ var ModelSpanTracker = class {
 		this.#inferenceContext = context;
 	}
 	/**
-	* Capture the completion start time (time to first token) when the first content chunk arrives.
+	* Record when the provider's first chunk arrived and copy that clock up the
+	* agent's own chain (inference → step → generation → agent run), first write
+	* wins at each level. Time to first chunk is derived later as
+	* `completionStartTime - startTime` on whichever span is being read.
 	*/
 	#captureCompletionStartTime() {
+		this.#ensureStepAndInference();
+		if (this.#inferenceCompletionStartTime) return;
 		const now = /* @__PURE__ */ new Date();
+		this.#inferenceCompletionStartTime = now;
 		this.#completionStartTime ??= now;
-		this.#inferenceCompletionStartTime ??= now;
+		for (const span of [
+			this.#currentStepSpan,
+			this.#modelSpan,
+			this.#agentRunSpan
+		]) if (span && !span.attributes?.completionStartTime) span.update({ attributes: { completionStartTime: now } });
 	}
 	/**
 	* Get the tracing context for creating child spans.
@@ -2563,13 +2611,16 @@ var ModelSpanTracker = class {
 		}, model);
 		if (providerCostContext && !spanOptions.attributes) spanOptions.attributes = {};
 		if (spanOptions.attributes) {
-			spanOptions.attributes.completionStartTime = this.#completionStartTime;
+			spanOptions.attributes.completionStartTime = this.#completionStartTime ?? spanOptions.attributes.completionStartTime;
 			spanOptions.attributes.usage = extractUsageMetrics(usage, providerMetadata);
 			spanOptions.attributes.costContext = providerCostContext ?? spanOptions.attributes.costContext;
 			if (!spanOptions.attributes.costContext) spanOptions.attributes.costContext = getGatewayCostContext({ stepProviderMetadata });
 		}
 		this.#modelSpan?.end(spanOptions);
 	}
+	getCompletionStartTime() {
+		return this.#completionStartTime;
+	}
 	/**
 	* Update the generation span
 	*/
@@ -2637,6 +2688,7 @@ var ModelSpanTracker = class {
 		});
 		this.#currentStepInputIsFinal = Array.isArray(payload?.inputMessages);
 		this.#chunkSequence = 0;
+		this.#inferenceCompletionStartTime = void 0;
 	}
 	/**
 	* End the current MODEL_INFERENCE span when the provider stream finishes.
@@ -2958,13 +3010,7 @@ var ModelSpanTracker = class {
 	*/
 	wrapStream(stream) {
 		return stream.pipeThrough(new TransformStream({ transform: (chunk, controller) => {
-			switch (chunk.type) {
-				case "text-delta":
-				case "tool-call-delta":
-				case "reasoning-delta":
-					this.#captureCompletionStartTime();
-					break;
-			}
+			if ((this.#inModelResponse || this.#deferStepClose) && MODEL_RESPONSE_CHUNK_TYPES.has(chunk.type)) this.#captureCompletionStartTime();
 			controller.enqueue(chunk);
 			switch (chunk.type) {
 				case "text-start":
@@ -2988,11 +3034,13 @@ var ModelSpanTracker = class {
 					this.#handleObjectChunk(chunk);
 					break;
 				case "step-start":
+					this.#inModelResponse = true;
 					if (this.#currentStepSpan) this.updateStep(chunk.payload);
 					else this.startStep(chunk.payload);
 					if (!this.#currentInferenceSpan) this.startInference(chunk.payload);
 					break;
 				case "step-finish":
+					this.#inModelResponse = false;
 					if (this.#deferStepClose) {
 						this.#pendingStepFinishPayload = chunk.payload;
 						this.#endChunkSpan();
@@ -3350,9 +3398,9 @@ var BaseSpan = class BaseSpan {
 	* Create a ModelSpanTracker for this span (only works if this is a MODEL_GENERATION span)
 	* Returns undefined for non-MODEL_GENERATION spans
 	*/
-	createTracker() {
+	createTracker(options) {
 		if (this.type !== SpanType.MODEL_GENERATION) return;
-		return new ModelSpanTracker(this);
+		return new ModelSpanTracker(this, options);
 	}
 	/** Returns `TRUE` if the span is the root span of a trace */
 	get isRootSpan() {