fix(logs): keep the skeleton of a child span tree too large to keep whole

A tree over the threshold as a whole now keeps its shape, names, timing,
status, and cost instead of disappearing, using the same content stripping
the execution log applies to oversized traces (moved to a shared module). Only
a tree whose skeleton is still over the threshold is dropped.

Author: waleedlatif1

apps/sim/lib/execution/payloads/serializer.test.ts

@@ -392,13 +392,26 @@ describe('compacting span trees', () => {
     expect(isLargeValueRef(spilled?.output?.result)).toBe(true)
   })
 
-  it('drops a block output child span tree too large as a whole', async () => {
+  it('keeps the skeleton of a block output child span tree too large as a whole', async () => {
     const compacted = await compactBlockOutput(
       { result: 'done', childTraceSpans: spansTooLargeAsAWhole() },
       options
     )
 
     expect(compacted.output).toEqual({ result: 'done' })
+    expectSpanTree(compacted.childTraceSpans)
+    const [loop] = compacted.childTraceSpans as TraceSpan[]
+    expect(loop.children?.[0].children?.[0].output).toBeUndefined()
+  })
+
+  it('drops a child span tree whose skeleton alone exceeds the threshold', async () => {
+    const spans = Array.from({ length: 64 }, (_, index) => ({
+      ...spansTooLargeAsAWhole()[0],
+      id: `loop-${index}`,
+    }))
+
+    const compacted = await compactBlockOutput({ childTraceSpans: spans }, options)
+
     expect(compacted.childTraceSpans).toBeUndefined()
   })
 
@@ -425,7 +438,7 @@ describe('compacting span trees', () => {
     expectSpanTree(compacted.childTraceSpans)
   })
 
-  it('keeps block log child span trees whole or drops them', async () => {
+  it('keeps block log child span trees whole or as a skeleton', async () => {
     const compacted =
       (await compactBlockLogs(
         [
@@ -436,7 +449,9 @@ describe('compacting span trees', () => {
       )) ?? []
 
     expectSpanTree(compacted[0]?.childTraceSpans)
-    expect(compacted[1]?.childTraceSpans).toBeUndefined()
+    expectSpanTree(compacted[1]?.childTraceSpans)
+    const [loop] = compacted[1]?.childTraceSpans ?? []
+    expect(loop.children?.[0].children?.[0].output).toBeUndefined()
   })
 
   it('keeps a nested child workflow span tree shaped as a tree', async () => {

apps/sim/lib/execution/payloads/serializer.ts

@@ -11,6 +11,7 @@ import {
   LARGE_VALUE_THRESHOLD_BYTES,
 } from '@/lib/execution/payloads/large-value-ref'
 import { type LargeValueStoreContext, storeLargeValue } from '@/lib/execution/payloads/store'
+import { summarizeTraceSpansWithoutIo } from '@/lib/logs/execution/trace-spans/summarize'
 import type { TraceSpan } from '@/lib/logs/types'
 import type { BlockLog } from '@/executor/types'
 
@@ -328,9 +329,10 @@ async function compactSpanOutput(
 
 /**
  * Compacts a block's child span tree for its log. Readers walk span trees as
- * arrays, so a tree is kept whole or not at all: payload fields spill
- * individually (see {@link compactTraceSpanTree}), and a tree still over the
- * threshold as a whole is dropped, bounding it as generic compaction did.
+ * arrays, so a tree is never collapsed: payload fields spill individually (see
+ * {@link compactTraceSpanTree}). A tree still over the threshold as a whole
+ * keeps only its skeleton (shape, names, timing, status, cost), and one whose
+ * skeleton is still over it is dropped, bounding it as generic compaction did.
  */
 async function compactChildTraceSpans(
   spans: unknown,
@@ -342,17 +344,34 @@ async function compactChildTraceSpans(
     }
     return undefined
   }
-  const compacted = await compactTraceSpanTree(spans, options, new WeakSet<object>())
-  const measured = getJsonAndSize(compacted)
+  const compacted = (await compactTraceSpanTree(
+    spans,
+    options,
+    new WeakSet<object>()
+  )) as TraceSpan[]
   const maxBytes = options.thresholdBytes ?? LARGE_VALUE_THRESHOLD_BYTES
-  if (measured && measured.size <= maxBytes) {
-    return compacted as TraceSpan[]
+  const measured = getJsonAndSize(compacted)
+  if (!measured) {
+    logger.warn('Dropping child trace spans that cannot be serialized')
+    return undefined
   }
-  if (measured && options.rejectLargeValues) {
+  if (measured.size <= maxBytes) {
+    return compacted
+  }
+  if (options.rejectLargeValues) {
     throw largeValueLimitError(options, measured.size)
   }
+  const skeleton = summarizeTraceSpansWithoutIo(compacted)
+  const skeletonSize = getJsonAndSize(skeleton)?.size
+  if (skeletonSize !== undefined && skeletonSize <= maxBytes) {
+    logger.warn('Kept only the skeleton of child trace spans too large to keep whole', {
+      observedBytes: measured.size,
+      maxBytes,
+    })
+    return skeleton
+  }
   logger.warn('Dropping child trace spans too large to keep', {
-    observedBytes: measured?.size,
+    observedBytes: skeletonSize ?? measured.size,
     maxBytes,
   })
   return undefined

apps/sim/lib/logs/execution/logger.ts

@@ -50,6 +50,11 @@ import {
 } from '@/lib/logs/execution/progress-markers'
 import { snapshotService } from '@/lib/logs/execution/snapshot/service'
 import { traceSpansHaveHandledErrors } from '@/lib/logs/execution/trace-spans/handled-errors'
+import {
+  stripLegacyToolCallContent,
+  stripModelToolCallArguments,
+  summarizeTraceSpansWithoutIo,
+} from '@/lib/logs/execution/trace-spans/summarize'
 import { traceSpansIndicateFailure } from '@/lib/logs/execution/trace-spans/trace-spans'
 import {
   copyTraceSpansWithoutCosts,
@@ -195,12 +200,6 @@ function retainBoundedTraceContent<T>(value: T, maxBytes = MAX_TRACE_IO_BYTES):
   return size !== undefined && size <= maxBytes ? value : undefined
 }
 
-function stripModelToolCallArguments(
-  calls: NonNullable<TraceSpan['modelToolCalls']>
-): NonNullable<TraceSpan['modelToolCalls']> {
-  return calls.map(({ arguments: _arguments, ...call }) => call as (typeof calls)[number])
-}
-
 function compactModelToolCalls(
   calls: NonNullable<TraceSpan['modelToolCalls']>
 ): NonNullable<TraceSpan['modelToolCalls']> | undefined {
@@ -226,12 +225,6 @@ function compactLegacyToolCalls(
   return retainBoundedTraceContent(compacted)
 }
 
-function stripLegacyToolCallContent(
-  calls: NonNullable<TraceSpan['toolCalls']>
-): NonNullable<TraceSpan['toolCalls']> {
-  return calls.map(({ input: _input, output: _output, error: _error, ...call }) => call)
-}
-
 function compactProviderTiming(
   providerTiming: NonNullable<TraceSpan['providerTiming']>
 ): NonNullable<TraceSpan['providerTiming']> {
@@ -253,26 +246,6 @@ function compactProviderTiming(
   }
 }
 
-function stripProviderTimingContent(
-  providerTiming: NonNullable<TraceSpan['providerTiming']>
-): NonNullable<TraceSpan['providerTiming']> {
-  return {
-    ...providerTiming,
-    segments: providerTiming.segments.map(
-      ({
-        assistantContent: _assistantContent,
-        thinkingContent: _thinkingContent,
-        errorMessage: _errorMessage,
-        toolCalls,
-        ...segment
-      }) => ({
-        ...segment,
-        ...(toolCalls ? { toolCalls: stripModelToolCallArguments(toolCalls) } : {}),
-      })
-    ),
-  }
-}
-
 function summarizeTraceSpansForExecutionData(traceSpans?: TraceSpan[]): TraceSpan[] | undefined {
   if (!traceSpans) {
     return traceSpans
@@ -317,33 +290,6 @@ function summarizeTraceSpansForExecutionData(traceSpans?: TraceSpan[]): TraceSpa
   })
 }
 
-function summarizeTraceSpansWithoutIo(traceSpans?: TraceSpan[]): TraceSpan[] | undefined {
-  if (!traceSpans) {
-    return traceSpans
-  }
-
-  return traceSpans.map((span) => {
-    const {
-      input: _input,
-      output: _output,
-      children,
-      thinking: _thinking,
-      errorMessage: _errorMessage,
-      modelToolCalls,
-      toolCalls,
-      providerTiming,
-      ...rest
-    } = span
-    return {
-      ...rest,
-      ...(modelToolCalls ? { modelToolCalls: stripModelToolCallArguments(modelToolCalls) } : {}),
-      ...(toolCalls ? { toolCalls: stripLegacyToolCallContent(toolCalls) } : {}),
-      ...(providerTiming ? { providerTiming: stripProviderTimingContent(providerTiming) } : {}),
-      ...(children?.length ? { children: summarizeTraceSpansWithoutIo(children) } : {}),
-    }
-  })
-}
-
 function summarizeExecutionState(executionState?: SerializableExecutionState) {
   if (!executionState) {
     return undefined

apps/sim/lib/logs/execution/trace-spans/summarize.ts

@@ -0,0 +1,65 @@
+import type { TraceSpan } from '@/lib/logs/types'
+
+export function stripModelToolCallArguments(
+  calls: NonNullable<TraceSpan['modelToolCalls']>
+): NonNullable<TraceSpan['modelToolCalls']> {
+  return calls.map(({ arguments: _arguments, ...call }) => call as (typeof calls)[number])
+}
+
+export function stripLegacyToolCallContent(
+  calls: NonNullable<TraceSpan['toolCalls']>
+): NonNullable<TraceSpan['toolCalls']> {
+  return calls.map(({ input: _input, output: _output, error: _error, ...call }) => call)
+}
+
+export function stripProviderTimingContent(
+  providerTiming: NonNullable<TraceSpan['providerTiming']>
+): NonNullable<TraceSpan['providerTiming']> {
+  return {
+    ...providerTiming,
+    segments: providerTiming.segments.map(
+      ({
+        assistantContent: _assistantContent,
+        thinkingContent: _thinkingContent,
+        errorMessage: _errorMessage,
+        toolCalls,
+        ...segment
+      }) => ({
+        ...segment,
+        ...(toolCalls ? { toolCalls: stripModelToolCallArguments(toolCalls) } : {}),
+      })
+    ),
+  }
+}
+
+/**
+ * A trace span tree with every span's content removed: inputs, outputs,
+ * thinking, error text, tool-call arguments, and provider content. Keeps the
+ * tree's shape, names, timing, status, and cost.
+ */
+export function summarizeTraceSpansWithoutIo(traceSpans?: TraceSpan[]): TraceSpan[] | undefined {
+  if (!traceSpans) {
+    return traceSpans
+  }
+
+  return traceSpans.map((span) => {
+    const {
+      input: _input,
+      output: _output,
+      children,
+      thinking: _thinking,
+      errorMessage: _errorMessage,
+      modelToolCalls,
+      toolCalls,
+      providerTiming,
+      ...rest
+    } = span
+    return {
+      ...rest,
+      ...(modelToolCalls ? { modelToolCalls: stripModelToolCallArguments(modelToolCalls) } : {}),
+      ...(toolCalls ? { toolCalls: stripLegacyToolCallContent(toolCalls) } : {}),
+      ...(providerTiming ? { providerTiming: stripProviderTimingContent(providerTiming) } : {}),
+      ...(children?.length ? { children: summarizeTraceSpansWithoutIo(children) } : {}),
+    }
+  })
+}