@mastra/observability 1.17.8 → 1.17.9-alpha.1

package/dist/index.cjs

@@ -1870,6 +1870,57 @@ var CardinalityFilter = class {
 };
 //#endregion
 //#region src/usage.ts
+/**
+* For non-BYOK requests, `usage.cost` is the complete OpenRouter charge and
+* `usage.costDetails.upstreamInferenceCost` is only its upstream breakdown. For BYOK requests,
+* the upstream cost is billed separately and must be added to OpenRouter's own `usage.cost`.
+*
+* OpenRouter reports `usage.is_byok` on the wire, but published `@openrouter/ai-sdk-provider`
+* versions drop it from `providerMetadata.openrouter.usage`. When `isByok` is present it is
+* authoritative. When it is absent, only the unambiguous shapes are used: a non-BYOK response
+* reports an upstream cost that is absent, zero, or equal to `cost`, and a BYOK response reports
+* a zero `cost` with a positive upstream cost. Any other combination falls back to model price
+* inference rather than double-counting a non-BYOK charge or under-reporting a BYOK one.
+*/
+function extractOpenRouterCost(providerMetadata) {
+	const usage = providerMetadata?.openrouter?.usage;
+	if (!usage || typeof usage !== "object" || Array.isArray(usage)) return void 0;
+	const cost = usage.cost;
+	const isByok = usage.isByok;
+	const costDetails = usage.costDetails;
+	const upstreamCost = costDetails && typeof costDetails === "object" && !Array.isArray(costDetails) ? costDetails.upstreamInferenceCost : void 0;
+	const isValid = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0;
+	if (cost != null && !isValid(cost) || upstreamCost != null && !isValid(upstreamCost)) return void 0;
+	const validCost = isValid(cost) ? cost : void 0;
+	const validUpstreamCost = isValid(upstreamCost) ? upstreamCost : void 0;
+	const byok = typeof isByok === "boolean" ? isByok : inferByok(validCost, validUpstreamCost);
+	if (byok === void 0) return void 0;
+	if (!byok) {
+		if (validCost === void 0) return void 0;
+		return {
+			total: validCost,
+			usedCost: true,
+			usedUpstreamCost: false
+		};
+	}
+	if (validCost === void 0 && validUpstreamCost === void 0) return void 0;
+	const total = (validCost ?? 0) + (validUpstreamCost ?? 0);
+	if (!Number.isFinite(total)) return void 0;
+	return {
+		total,
+		usedCost: validCost !== void 0,
+		usedUpstreamCost: validUpstreamCost !== void 0
+	};
+}
+/**
+* Infer the BYOK mode from the cost fields alone. Returns `undefined` when the shape is
+* ambiguous, so the caller falls back to model price inference.
+*/
+function inferByok(cost, upstreamCost) {
+	if (cost === void 0) return void 0;
+	if (upstreamCost === void 0 || upstreamCost === 0 || upstreamCost === cost) return false;
+	if (cost === 0) return true;
+}
 function isV3RawUsage(raw) {
 	return typeof raw === "object" && raw !== null && "inputTokens" in raw;
 }
@@ -2057,6 +2108,31 @@ function getGatewayCostContext({ stepProviderMetadata }) {
 		}
 	};
 }
+function getOpenRouterCostContext({ providerMetadata, stepProviderMetadata }, model) {
+	const metadata = stepProviderMetadata ?? (providerMetadata ? [providerMetadata] : void 0);
+	if (!metadata?.some((step) => step?.openrouter !== void 0)) return void 0;
+	const results = metadata.map(extractOpenRouterCost);
+	if (results.some((result) => result === void 0)) return void 0;
+	const costs = results;
+	const estimatedCost = costs.reduce((total, result) => total + result.total, 0);
+	if (!Number.isFinite(estimatedCost)) return void 0;
+	const sdkCostFields = [];
+	if (costs.some((result) => result.usedCost)) sdkCostFields.push("openrouter.usage.cost");
+	if (costs.some((result) => result.usedUpstreamCost)) sdkCostFields.push("openrouter.usage.costDetails.upstreamInferenceCost");
+	return {
+		provider: "openrouter",
+		model,
+		estimatedCost,
+		costUnit: "USD",
+		costMetadata: {
+			source: "provider_reported",
+			sdkProvider: "openrouter",
+			sdkCostField: sdkCostFields.join("+"),
+			scope: "query_total",
+			reportedStepCount: costs.length
+		}
+	};
+}
 function formatPreviewLabel(label, fallback) {
 	return typeof label === "string" && label.length > 0 ? label : fallback;
 }
@@ -2239,9 +2315,16 @@ var ModelSpanTracker = class {
 	*/
 	endGeneration(options) {
 		const { usage, providerMetadata, stepProviderMetadata, ...spanOptions } = options ?? {};
+		const model = spanOptions.attributes?.responseModel ?? this.#modelSpan?.attributes?.responseModel ?? this.#modelSpan?.attributes?.model;
+		const providerCostContext = getOpenRouterCostContext({
+			providerMetadata,
+			stepProviderMetadata
+		}, model);
+		if (providerCostContext && !spanOptions.attributes) spanOptions.attributes = {};
 		if (spanOptions.attributes) {
 			spanOptions.attributes.completionStartTime = this.#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);
@@ -4930,7 +5013,12 @@ var BaseObservabilityInstance = class extends _mastra_core_base.MastraBase {
 		for (const processor of this.spanOutputProcessors) {
 			if (!span) break;
 			try {
-				span = processor.process(span);
+				const processed = processor.process(span);
+				if (processed !== void 0 && processed !== span) {
+					this.logger.error(`[Observability] Processor error [name=${processor.name}]: process() must return the span it received (or undefined to drop it), not a copy. Span dropped.`);
+					return;
+				}
+				span = processed;
 			} catch (error) {
 				this.logger.error(`[Observability] Processor error [name=${processor.name}]`, error);
 			}
@@ -9230,9 +9318,10 @@ var SensitiveDataFilter = class {
 	/**
 	* Process a span by filtering sensitive data across its key fields.
 	* Fields processed: attributes, metadata, input, output, errorInfo, requestContext.
+	* The span is mutated in place, as the SpanOutputProcessor contract requires.
 	*
 	* @param span - The input span to filter
-	* @returns A new span with sensitive values redacted
+	* @returns The same span instance with sensitive values redacted
 	*/
 	process(span) {
 		const indexedState = this.redactionStyle === "indexed" ? this.getTraceState(span.traceId) : void 0;