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

package/dist/index.d.ts

@@ -11,4 +11,5 @@ export * from './spans/index.js';
 export * from './exporters/index.js';
 export * from './span_processors/index.js';
 export * from './model-tracing.js';
+export * from './tracing-options.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAG1C,cAAc,UAAU,CAAC;AAGzB,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAG1C,cAAc,UAAU,CAAC;AAGzB,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAGhC,cAAc,mBAAmB,CAAC"}

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,9 +1005,23 @@ var ModelSpanTracker = class {
   #accumulator = {};
   #stepIndex = 0;
   #chunkSequence = 0;
+  #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) */
+  #streamedToolCallIds = /* @__PURE__ */ new Set();
   constructor(modelSpan) {
     this.#modelSpan = modelSpan;
   }
+  /**
+   * Capture the completion start time (time to first token) when the first content chunk arrives.
+   */
+  #captureCompletionStartTime() {
+    if (this.#completionStartTime) {
+      return;
+    }
+    this.#completionStartTime = /* @__PURE__ */ new Date();
+  }
   /**
    * Get the tracing context for creating child spans.
    * Returns the current step span if active, otherwise the model span.
@@ -972,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
@@ -1005,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;
@@ -1180,6 +1253,77 @@ var ModelSpanTracker = class {
         break;
     }
   }
+  /**
+   * Handle tool-output chunks from sub-agents.
+   * Consolidates streaming text/reasoning deltas into a single span per tool call.
+   */
+  #handleToolOutputChunk(chunk) {
+    if (chunk.type !== "tool-output") return;
+    const payload = chunk.payload;
+    const { output, toolCallId, toolName } = payload;
+    let acc = this.#toolOutputAccumulators.get(toolCallId);
+    if (!acc) {
+      if (!this.#currentStepSpan) {
+        this.#startStepSpan();
+      }
+      acc = {
+        toolName: toolName || "unknown",
+        toolCallId,
+        text: "",
+        reasoning: "",
+        sequenceNumber: this.#chunkSequence++,
+        // Name the span 'tool-result' for consistency (tool-call → tool-result)
+        span: this.#currentStepSpan?.createChildSpan({
+          name: `chunk: 'tool-result'`,
+          type: SpanType.MODEL_CHUNK,
+          attributes: {
+            chunkType: "tool-result",
+            sequenceNumber: this.#chunkSequence - 1
+          }
+        })
+      };
+      this.#toolOutputAccumulators.set(toolCallId, acc);
+    }
+    if (output && typeof output === "object" && "type" in output) {
+      const innerType = output.type;
+      switch (innerType) {
+        case "text-delta":
+          if (output.payload?.text) {
+            acc.text += output.payload.text;
+          }
+          break;
+        case "reasoning-delta":
+          if (output.payload?.text) {
+            acc.reasoning += output.payload.text;
+          }
+          break;
+        case "finish":
+        case "workflow-finish":
+          this.#endToolOutputSpan(toolCallId);
+          break;
+      }
+    }
+  }
+  /**
+   * End a tool output span and clean up the accumulator
+   */
+  #endToolOutputSpan(toolCallId) {
+    const acc = this.#toolOutputAccumulators.get(toolCallId);
+    if (!acc) return;
+    const output = {
+      toolCallId: acc.toolCallId,
+      toolName: acc.toolName
+    };
+    if (acc.text) {
+      output.text = acc.text;
+    }
+    if (acc.reasoning) {
+      output.reasoning = acc.reasoning;
+    }
+    acc.span?.end({ output });
+    this.#toolOutputAccumulators.delete(toolCallId);
+    this.#streamedToolCallIds.add(toolCallId);
+  }
   /**
    * Wraps a stream with model tracing transform to track MODEL_STEP and MODEL_CHUNK spans.
    *
@@ -1190,6 +1334,13 @@ var ModelSpanTracker = class {
     return stream.pipeThrough(
       new TransformStream({
         transform: (chunk, controller) => {
+          switch (chunk.type) {
+            case "text-delta":
+            case "tool-call-delta":
+            case "reasoning-delta":
+              this.#captureCompletionStartTime();
+              break;
+          }
           controller.enqueue(chunk);
           switch (chunk.type) {
             case "text-start":
@@ -1223,6 +1374,19 @@ var ModelSpanTracker = class {
             case "start":
             case "finish":
               break;
+            case "tool-output":
+              this.#handleToolOutputChunk(chunk);
+              break;
+            case "tool-result": {
+              const toolCallId = chunk.payload?.toolCallId;
+              if (toolCallId && this.#streamedToolCallIds.has(toolCallId)) {
+                this.#streamedToolCallIds.delete(toolCallId);
+                break;
+              }
+              const { args, ...cleanPayload } = chunk.payload || {};
+              this.#createEventSpan(chunk.type, cleanPayload);
+              break;
+            }
             // Default: auto-create event span for all other chunk types
             default: {
               let outputPayload = chunk.payload;
@@ -1434,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));
   }
@@ -2322,6 +2489,11 @@ var Observability = class extends MastraBase {
   }
 };
 
-export { BaseExporter, BaseObservabilityInstance, BaseSpan, CloudExporter, ConsoleExporter, DefaultExporter, DefaultObservabilityInstance, DefaultSpan, ModelSpanTracker, NoOpSpan, Observability, SamplingStrategyType, SensitiveDataFilter, TestExporter, deepClean, getExternalParentId, observabilityConfigValueSchema, observabilityInstanceConfigSchema, observabilityRegistryConfigSchema, samplingStrategySchema };
+// src/tracing-options.ts
+function buildTracingOptions(...updaters) {
+  return updaters.reduce((opts, updater) => updater(opts), {});
+}
+
+export { BaseExporter, BaseObservabilityInstance, BaseSpan, CloudExporter, ConsoleExporter, DefaultExporter, DefaultObservabilityInstance, DefaultSpan, ModelSpanTracker, NoOpSpan, Observability, SamplingStrategyType, SensitiveDataFilter, TestExporter, buildTracingOptions, deepClean, getExternalParentId, observabilityConfigValueSchema, observabilityInstanceConfigSchema, observabilityRegistryConfigSchema, samplingStrategySchema };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map