@mastra/observability 1.5.0 → 1.5.1-alpha.1

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @mastra/observability
 
+## 1.5.1-alpha.1
+
+### Patch Changes
+
+- Fix cache token extraction in multi-step agent runs. Prefer AI SDK aggregated `inputTokenDetails` over `providerMetadata` (which only reflects the last step). Also fix truthiness checks to correctly handle zero values for cache and reasoning tokens. ([#14492](https://github.com/mastra-ai/mastra/pull/14492))
+
+  Fix Datadog metric keys to match dd-trace expected format: `cacheReadTokens`, `cacheWriteTokens`, `reasoningOutputTokens`.
+
+- Updated dependencies [[`9e1a3ed`](https://github.com/mastra-ai/mastra/commit/9e1a3ed07cfafb5e8e19a796ce0bee817002d7c0), [`a579f7a`](https://github.com/mastra-ai/mastra/commit/a579f7a31e582674862b5679bc79af7ccf7429b8)]:
+  - @mastra/core@1.15.0-alpha.2
+
+## 1.5.1-alpha.0
+
+### Patch Changes
+
+- Fixed span serialization to avoid incorrect [Circular] placeholders in traces. ([#14263](https://github.com/mastra-ai/mastra/pull/14263))
+
+- Updated dependencies [[`cb611a1`](https://github.com/mastra-ai/mastra/commit/cb611a1e89a4f4cf74c97b57e0c27bb56f2eceb5), [`62d1d3c`](https://github.com/mastra-ai/mastra/commit/62d1d3cc08fe8182e7080237fd975de862ec8c91), [`8681ecb`](https://github.com/mastra-ai/mastra/commit/8681ecb86184d5907267000e4576cc442a9a83fc), [`28d0249`](https://github.com/mastra-ai/mastra/commit/28d0249295782277040ad1e0d243e695b7ab1ce4), [`bb0f09d`](https://github.com/mastra-ai/mastra/commit/bb0f09dbac58401b36069f483acf5673202db5b5), [`5f7e9d0`](https://github.com/mastra-ai/mastra/commit/5f7e9d0db664020e1f3d97d7d18c6b0b9d4843d0)]:
+  - @mastra/core@1.15.0-alpha.0
+
 ## 1.5.0
 
 ### Minor Changes

package/dist/index.cjs

@@ -17426,6 +17426,9 @@ var MetricsContextImpl = class {
 };
 
 // src/usage.ts
+function isDefined(value) {
+  return value != null;
+}
 function extractUsageMetrics(usage, providerMetadata) {
   if (!usage) {
     return {};
@@ -17434,31 +17437,38 @@ function extractUsageMetrics(usage, providerMetadata) {
   const outputDetails = {};
   let inputTokens = usage.inputTokens;
   const outputTokens = usage.outputTokens;
-  if (usage.cachedInputTokens) {
+  const aiSdkDetails = usage.inputTokenDetails;
+  if (isDefined(aiSdkDetails?.cacheReadTokens)) {
+    inputDetails.cacheRead = aiSdkDetails.cacheReadTokens;
+  }
+  if (isDefined(aiSdkDetails?.cacheWriteTokens)) {
+    inputDetails.cacheWrite = aiSdkDetails.cacheWriteTokens;
+  }
+  if (!isDefined(inputDetails.cacheRead) && isDefined(usage.cachedInputTokens)) {
     inputDetails.cacheRead = usage.cachedInputTokens;
   }
-  if (usage.reasoningTokens) {
+  if (isDefined(usage.reasoningTokens)) {
     outputDetails.reasoning = usage.reasoningTokens;
   }
   const anthropic = providerMetadata?.anthropic;
   if (anthropic) {
-    if (anthropic.cacheReadInputTokens) {
+    if (!isDefined(inputDetails.cacheRead) && isDefined(anthropic.cacheReadInputTokens)) {
       inputDetails.cacheRead = anthropic.cacheReadInputTokens;
     }
-    if (anthropic.cacheCreationInputTokens) {
+    if (!isDefined(inputDetails.cacheWrite) && isDefined(anthropic.cacheCreationInputTokens)) {
       inputDetails.cacheWrite = anthropic.cacheCreationInputTokens;
     }
-    if (anthropic.cacheReadInputTokens || anthropic.cacheCreationInputTokens) {
+    if (isDefined(inputDetails.cacheRead) || isDefined(inputDetails.cacheWrite)) {
       inputDetails.text = usage.inputTokens;
-      inputTokens = (usage.inputTokens ?? 0) + (anthropic.cacheReadInputTokens ?? 0) + (anthropic.cacheCreationInputTokens ?? 0);
+      inputTokens = (usage.inputTokens ?? 0) + (inputDetails.cacheRead ?? 0) + (inputDetails.cacheWrite ?? 0);
     }
   }
   const google = providerMetadata?.google;
   if (google?.usageMetadata) {
-    if (google.usageMetadata.cachedContentTokenCount) {
+    if (!isDefined(inputDetails.cacheRead) && isDefined(google.usageMetadata.cachedContentTokenCount)) {
       inputDetails.cacheRead = google.usageMetadata.cachedContentTokenCount;
     }
-    if (google.usageMetadata.thoughtsTokenCount) {
+    if (isDefined(google.usageMetadata.thoughtsTokenCount)) {
       outputDetails.reasoning = google.usageMetadata.thoughtsTokenCount;
     }
   }
@@ -17950,6 +17960,17 @@ function compressJsonSchema(schema, depth = 0) {
   if (depth > 3) {
     return schema.type || "object";
   }
+  const compositionKeys = ["oneOf", "anyOf", "allOf"].filter((key) => Array.isArray(schema[key]));
+  if (compositionKeys.length > 0) {
+    const compressed2 = {};
+    for (const key of compositionKeys) {
+      compressed2[key] = schema[key].map((entry) => compressJsonSchema(entry, depth + 1));
+    }
+    if (typeof schema.type === "string") {
+      compressed2.type = schema.type;
+    }
+    return compressed2;
+  }
   if (schema.type !== "object" || !schema.properties) {
     return schema.type || schema;
   }
@@ -17983,7 +18004,7 @@ function compressJsonSchema(schema, depth = 0) {
 function deepClean(value, options = DEFAULT_DEEP_CLEAN_OPTIONS) {
   const { keysToStrip, maxDepth, maxStringLength, maxArrayLength, maxObjectKeys } = options;
   const stripSet = keysToStrip instanceof Set ? keysToStrip : new Set(Array.isArray(keysToStrip) ? keysToStrip : Object.keys(keysToStrip));
-  const seen = /* @__PURE__ */ new WeakSet();
+  const ancestors = /* @__PURE__ */ new WeakSet();
   function helper(val, depth) {
     if (depth > maxDepth) {
       return "[MaxDepth]";
@@ -18016,59 +18037,85 @@ function deepClean(value, options = DEFAULT_DEEP_CLEAN_OPTIONS) {
       };
     }
     if (typeof val === "object") {
-      if (seen.has(val)) {
+      if (ancestors.has(val)) {
         return "[Circular]";
       }
-      seen.add(val);
+      ancestors.add(val);
     }
-    if (Array.isArray(val)) {
-      const limitedArray = val.slice(0, maxArrayLength);
-      const cleaned2 = limitedArray.map((item) => helper(item, depth + 1));
-      if (val.length > maxArrayLength) {
-        cleaned2.push(`[\u2026${val.length - maxArrayLength} more items]`);
+    try {
+      if (Array.isArray(val)) {
+        const cleaned2 = [];
+        for (let i = 0; i < Math.min(val.length, maxArrayLength); i++) {
+          try {
+            cleaned2.push(helper(val[i], depth + 1));
+          } catch (error48) {
+            cleaned2.push(`[${error48 instanceof Error ? truncateString(error48.message, 256) : "unknown error"}]`);
+          }
+        }
+        if (val.length > maxArrayLength) {
+          cleaned2.push(`[\u2026${val.length - maxArrayLength} more items]`);
+        }
+        return cleaned2;
       }
-      return cleaned2;
-    }
-    if (typeof Buffer !== "undefined" && Buffer.isBuffer(val)) {
-      return `[Buffer length=${val.length}]`;
-    }
-    if (ArrayBuffer.isView(val)) {
-      const ctor = val.constructor?.name ?? "TypedArray";
-      const byteLength = val.byteLength ?? "?";
-      return `[${ctor} byteLength=${byteLength}]`;
-    }
-    if (val instanceof ArrayBuffer) {
-      return `[ArrayBuffer byteLength=${val.byteLength}]`;
-    }
-    if (typeof val.serializeForSpan === "function") {
-      try {
-        return helper(val.serializeForSpan(), depth);
-      } catch {
+      if (typeof Buffer !== "undefined" && Buffer.isBuffer(val)) {
+        return `[Buffer length=${val.length}]`;
       }
-    }
-    if (isJsonSchema(val)) {
-      return helper(compressJsonSchema(val), depth);
-    }
-    const cleaned = {};
-    const entries = Object.entries(val);
-    let keyCount = 0;
-    for (const [key, v] of entries) {
-      if (stripSet.has(key)) {
-        continue;
+      if (ArrayBuffer.isView(val)) {
+        const ctor = val.constructor?.name ?? "TypedArray";
+        const byteLength = val.byteLength ?? "?";
+        return `[${ctor} byteLength=${byteLength}]`;
       }
-      if (keyCount >= maxObjectKeys) {
-        cleaned["__truncated"] = `${entries.length - keyCount} more keys omitted`;
-        break;
+      if (val instanceof ArrayBuffer) {
+        return `[ArrayBuffer byteLength=${val.byteLength}]`;
       }
+      let serializeForSpan;
       try {
-        cleaned[key] = helper(v, depth + 1);
-        keyCount++;
+        serializeForSpan = val.serializeForSpan;
       } catch (error48) {
-        cleaned[key] = `[${error48 instanceof Error ? error48.message : String(error48)}]`;
-        keyCount++;
+        return `[serializeForSpan failed: ${error48 instanceof Error ? truncateString(error48.message, 256) : "unknown error"}]`;
+      }
+      if (typeof serializeForSpan === "function") {
+        try {
+          return helper(serializeForSpan.call(val), depth);
+        } catch (error48) {
+          return `[serializeForSpan failed: ${error48 instanceof Error ? truncateString(error48.message, 256) : "unknown error"}]`;
+        }
+      }
+      let looksLikeJsonSchema = false;
+      try {
+        looksLikeJsonSchema = isJsonSchema(val);
+      } catch {
+        looksLikeJsonSchema = false;
+      }
+      if (looksLikeJsonSchema) {
+        try {
+          const compressed = compressJsonSchema(val);
+          return compressed === val ? "[JSONSchema]" : helper(compressed, depth);
+        } catch {
+        }
+      }
+      const cleaned = {};
+      const keys = Object.keys(val).filter((key) => !stripSet.has(key));
+      let keyCount = 0;
+      for (const key of keys) {
+        if (keyCount >= maxObjectKeys) {
+          cleaned["__truncated"] = `${keys.length - keyCount} more keys omitted`;
+          break;
+        }
+        try {
+          cleaned[key] = helper(val[key], depth + 1);
+          keyCount++;
+        } catch (error48) {
+          cleaned[key] = `[${error48 instanceof Error ? truncateString(error48.message, 256) : "unknown error"}]`;
+          keyCount++;
+        }
+      }
+      return cleaned;
+    } finally {
+      if (typeof val === "object" && val !== null) {
+        ancestors.delete(val);
       }
     }
-    return cleaned;
   }
   return helper(value, 0);
 }