@mastra/observability 1.20.2-alpha.0 → 1.21.0-alpha.2

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.
@@ -2767,6 +2819,26 @@ var ModelSpanTracker = class {
 		this.#stepIndex++;
 	}
 	/**
+	* A suspended step emits no step-finish; its suspension chunk carries the
+	* step usage instead. Close MODEL_INFERENCE and MODEL_STEP with that usage so
+	* the suspended call is not reported without tokens.
+	*/
+	#endSuspendedStep(chunk) {
+		if (chunk.type !== "tool-call-suspended" && chunk.type !== "tool-call-approval") return;
+		const usage = chunk.payload.usage;
+		if (!usage) return;
+		this.#inModelResponse = false;
+		this.#endStepSpan({
+			output: { usage },
+			stepResult: {
+				reason: "suspended",
+				isContinued: false,
+				warnings: []
+			},
+			metadata: {}
+		});
+	}
+	/**
 	* Returns the parent span for chunks. Chunks parent under MODEL_INFERENCE
 	* (the provider call) when available, falling back to MODEL_STEP only if
 	* startStep() was bypassed.
@@ -2938,8 +3010,8 @@ var ModelSpanTracker = class {
 	#handleToolApprovalChunk(chunk) {
 		if (chunk.type !== "tool-call-approval") return;
 		const payload = chunk.payload;
-		this.#ensureStepAndInference();
-		if (this.#chunkParent()?.createEventSpan({
+		if (payload.usage || this.#currentStepSpan) this.#ensureStepAndInference();
+		if ((this.#chunkParent() ?? this.#modelSpan)?.createEventSpan({
 			name: `chunk: 'tool-call-approval'`,
 			type: SpanType.MODEL_CHUNK,
 			attributes: {
@@ -2958,12 +3030,10 @@ 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();
+			if (chunk.type === "tool-call-suspended" || chunk.type === "tool-call-approval") {
+				if (chunk.type === "tool-call-approval") this.#handleToolApprovalChunk(chunk);
+				this.#endSuspendedStep(chunk);
 			}
 			controller.enqueue(chunk);
 			switch (chunk.type) {
@@ -2988,11 +3058,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();
@@ -3010,13 +3082,11 @@ var ModelSpanTracker = class {
 				case "tripwire":
 				case "watch":
 				case "tool-error":
-				case "tool-call-suspended":
 				case "reasoning-signature":
 				case "redacted-reasoning":
 				case "step-output": break;
-				case "tool-call-approval":
-					this.#handleToolApprovalChunk(chunk);
-					break;
+				case "tool-call-suspended":
+				case "tool-call-approval": break;
 				case "tool-output": break;
 				case "tool-result": {
 					const { toolCallId, toolName, isError, dynamic, providerExecuted, providerMetadata, result, args: _args } = chunk.payload || {};
@@ -3350,9 +3420,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() {