@mastra/observability 1.0.0-beta.3 → 1.0.0-beta.4

package/dist/index.js

@@ -946,6 +946,58 @@ var TestExporter = class extends BaseExporter {
     this.logger.info("TestExporter shutdown");
   }
 };
+
+// src/usage.ts
+function extractUsageMetrics(usage, providerMetadata) {
+  if (!usage) {
+    return {};
+  }
+  const inputDetails = {};
+  const outputDetails = {};
+  let inputTokens = usage.inputTokens;
+  const outputTokens = usage.outputTokens;
+  if (usage.cachedInputTokens) {
+    inputDetails.cacheRead = usage.cachedInputTokens;
+  }
+  if (usage.reasoningTokens) {
+    outputDetails.reasoning = usage.reasoningTokens;
+  }
+  const anthropic = providerMetadata?.anthropic;
+  if (anthropic) {
+    if (anthropic.cacheReadInputTokens) {
+      inputDetails.cacheRead = anthropic.cacheReadInputTokens;
+    }
+    if (anthropic.cacheCreationInputTokens) {
+      inputDetails.cacheWrite = anthropic.cacheCreationInputTokens;
+    }
+    if (anthropic.cacheReadInputTokens || anthropic.cacheCreationInputTokens) {
+      inputDetails.text = usage.inputTokens;
+      inputTokens = (usage.inputTokens ?? 0) + (anthropic.cacheReadInputTokens ?? 0) + (anthropic.cacheCreationInputTokens ?? 0);
+    }
+  }
+  const google = providerMetadata?.google;
+  if (google?.usageMetadata) {
+    if (google.usageMetadata.cachedContentTokenCount) {
+      inputDetails.cacheRead = google.usageMetadata.cachedContentTokenCount;
+    }
+    if (google.usageMetadata.thoughtsTokenCount) {
+      outputDetails.reasoning = google.usageMetadata.thoughtsTokenCount;
+    }
+  }
+  const result = {
+    inputTokens,
+    outputTokens
+  };
+  if (Object.keys(inputDetails).length > 0) {
+    result.inputDetails = inputDetails;
+  }
+  if (Object.keys(outputDetails).length > 0) {
+    result.outputDetails = outputDetails;
+  }
+  return result;
+}
+
+// src/model-tracing.ts
 var ModelSpanTracker = class {
   #modelSpan;
   #currentStepSpan;
@@ -953,8 +1005,7 @@ var ModelSpanTracker = class {
   #accumulator = {};
   #stepIndex = 0;
   #chunkSequence = 0;
-  /** Tracks whether completionStartTime has been captured for this generation */
-  #completionStartTimeCaptured = false;
+  #completionStartTime;
   /** Tracks tool output accumulators by toolCallId for consolidating sub-agent streams */
   #toolOutputAccumulators = /* @__PURE__ */ new Map();
   /** Tracks toolCallIds that had streaming output (to skip redundant tool-result spans) */
@@ -964,18 +1015,12 @@ var ModelSpanTracker = class {
   }
   /**
    * Capture the completion start time (time to first token) when the first content chunk arrives.
-   * This is used by observability providers like Langfuse to calculate TTFT metrics.
    */
   #captureCompletionStartTime() {
-    if (this.#completionStartTimeCaptured || !this.#modelSpan) {
+    if (this.#completionStartTime) {
       return;
     }
-    this.#completionStartTimeCaptured = true;
-    this.#modelSpan.update({
-      attributes: {
-        completionStartTime: /* @__PURE__ */ new Date()
-      }
-    });
+    this.#completionStartTime = /* @__PURE__ */ new Date();
   }
   /**
    * Get the tracing context for creating child spans.
@@ -993,10 +1038,16 @@ var ModelSpanTracker = class {
     this.#modelSpan?.error(options);
   }
   /**
-   * End the generation span
+   * End the generation span with optional raw usage data.
+   * If usage is provided, it will be converted to UsageStats with cache token details.
    */
   endGeneration(options) {
-    this.#modelSpan?.end(options);
+    const { usage, providerMetadata, ...spanOptions } = options ?? {};
+    if (spanOptions.attributes) {
+      spanOptions.attributes.completionStartTime = this.#completionStartTime;
+      spanOptions.attributes.usage = extractUsageMetrics(usage, providerMetadata);
+    }
+    this.#modelSpan?.end(spanOptions);
   }
   /**
    * Update the generation span
@@ -1026,9 +1077,10 @@ var ModelSpanTracker = class {
   #endStepSpan(payload) {
     if (!this.#currentStepSpan) return;
     const output = payload.output;
-    const { usage, ...otherOutput } = output;
+    const { usage: rawUsage, ...otherOutput } = output;
     const stepResult = payload.stepResult;
     const metadata = payload.metadata;
+    const usage = extractUsageMetrics(rawUsage, metadata?.providerMetadata);
     const cleanMetadata = metadata ? { ...metadata } : void 0;
     if (cleanMetadata?.request) {
       delete cleanMetadata.request;
@@ -1279,13 +1331,15 @@ var ModelSpanTracker = class {
    * create MODEL_STEP and MODEL_CHUNK spans for each semantic unit in the stream.
    */
   wrapStream(stream) {
-    let captureCompletionStartTime = false;
     return stream.pipeThrough(
       new TransformStream({
         transform: (chunk, controller) => {
-          if (!captureCompletionStartTime) {
-            captureCompletionStartTime = true;
-            this.#captureCompletionStartTime();
+          switch (chunk.type) {
+            case "text-delta":
+            case "tool-call-delta":
+            case "reasoning-delta":
+              this.#captureCompletionStartTime();
+              break;
           }
           controller.enqueue(chunk);
           switch (chunk.type) {
@@ -1544,6 +1598,9 @@ function deepClean(value, options = {}, _seen = /* @__PURE__ */ new WeakSet(), _
     return "[Circular]";
   }
   _seen.add(value);
+  if (value instanceof Date) {
+    return value;
+  }
   if (Array.isArray(value)) {
     return value.map((item) => deepClean(item, options, _seen, _depth + 1));
   }