fix(executor): guard loop and agent logs against memory growth

Long-running loops with agent blocks can accumulate large in-memory structures
(tool call payloads, loop iteration aggregates, and block logs) until the process
runs out of memory.

This adds bounded retention + compaction for agent tool calls, caps loop
iteration result retention with explicit truncation metadata, and limits block
log growth while preserving recent execution details.

Fixes #2525

Author: jayy-77

apps/sim/executor/execution/block-executor.ts

@@ -37,13 +37,15 @@ import {
 import { streamingResponseFormatProcessor } from '@/executor/utils'
 import { buildBlockExecutionError, normalizeError } from '@/executor/utils/errors'
 import { isJSONString } from '@/executor/utils/json'
+import { retainTailInPlace } from '@/executor/utils/memory'
 import { filterOutputForLog } from '@/executor/utils/output-filter'
 import type { VariableResolver } from '@/executor/variables/resolver'
 import type { SerializedBlock } from '@/serializer/types'
 import type { SubflowType } from '@/stores/workflows/workflow/types'
 import { SYSTEM_SUBBLOCK_IDS } from '@/triggers/constants'
 
 const logger = createLogger('BlockExecutor')
+const BLOCK_LOGS_RETAINED_LIMIT = 5000
 
 export class BlockExecutor {
   constructor(
@@ -74,6 +76,14 @@ export class BlockExecutor {
     if (!isSentinel) {
       blockLog = this.createBlockLog(ctx, node.id, block, node)
       ctx.blockLogs.push(blockLog)
+      const { dropped } = retainTailInPlace(ctx.blockLogs, BLOCK_LOGS_RETAINED_LIMIT)
+      if (dropped > 0) {
+        const prevDropped = ctx.metadata.logTruncation?.dropped ?? 0
+        ctx.metadata.logTruncation = {
+          dropped: prevDropped + dropped,
+          limit: BLOCK_LOGS_RETAINED_LIMIT,
+        }
+      }
       this.callOnBlockStart(ctx, node, block, blockLog.executionOrder)
     }
 

apps/sim/executor/execution/state.ts

@@ -8,6 +8,15 @@ export interface LoopScope {
   iteration: number
   currentIterationOutputs: Map<string, NormalizedBlockOutput>
   allIterationOutputs: NormalizedBlockOutput[][]
+  /**
+   * Number of iteration result entries dropped from the head of `allIterationOutputs`
+   * due to retention limits.
+   */
+  allIterationOutputsDroppedCount?: number
+  /**
+   * Max number of iterations retained in `allIterationOutputs` (tail retention).
+   */
+  allIterationOutputsLimit?: number
   maxIterations?: number
   item?: any
   items?: any[]

apps/sim/executor/handlers/agent/agent-handler.test.ts

@@ -1428,6 +1428,43 @@ describe('AgentBlockHandler', () => {
       expect((result as any).toolCalls.list[1].result.success).toBe(true)
     })
 
+    it('should truncate toolCalls list and compact payloads when many tool calls are returned', async () => {
+      const toolCalls = Array.from({ length: 60 }, (_, i) => ({
+        name: `tool_${i}`,
+        startTime: new Date().toISOString(),
+        endTime: new Date().toISOString(),
+        duration: 1,
+        arguments: { index: i, payload: 'a'.repeat(5000) },
+        result: 'b'.repeat(5000),
+      }))
+
+      mockExecuteProviderRequest.mockResolvedValueOnce({
+        content: 'Tool call heavy response',
+        model: 'gpt-4o',
+        tokens: { input: 10, output: 15, total: 25 },
+        toolCalls,
+        timing: { total: 100 },
+      })
+
+      const result = await handler.execute(mockContext, mockBlock, {
+        model: 'gpt-4o',
+        userPrompt: 'Do lots of tool calls',
+        apiKey: 'test-api-key',
+      })
+
+      expect((result as any).toolCalls.count).toBe(60)
+      expect((result as any).toolCalls.list).toHaveLength(50)
+      expect((result as any).toolCalls.truncated).toBe(true)
+      expect((result as any).toolCalls.omitted).toBe(10)
+      expect((result as any).toolCalls.limit).toBe(50)
+
+      expect((result as any).toolCalls.list[0].name).toBe('tool_10')
+      expect((result as any).toolCalls.list[49].name).toBe('tool_59')
+
+      expect((result as any).toolCalls.list[0].result).toContain('[truncated')
+      expect((result as any).toolCalls.list[0].arguments.payload).toContain('[truncated')
+    })
+
     it('should handle MCP tool execution errors', async () => {
       mockExecuteTool.mockImplementation((toolId, params) => {
         if (toolId === 'mcp-server1-failing_tool') {

apps/sim/executor/handlers/agent/agent-handler.ts

@@ -30,6 +30,7 @@ import type { BlockHandler, ExecutionContext, StreamingExecution } from '@/execu
 import { collectBlockData } from '@/executor/utils/block-data'
 import { buildAPIUrl, buildAuthHeaders } from '@/executor/utils/http'
 import { stringifyJSON } from '@/executor/utils/json'
+import { compactValue } from '@/executor/utils/memory'
 import { executeProviderRequest } from '@/providers'
 import { getProviderFromModel, transformBlockTool } from '@/providers/utils'
 import type { SerializedBlock } from '@/serializer/types'
@@ -38,6 +39,8 @@ import { getTool, getToolAsync } from '@/tools/utils'
 
 const logger = createLogger('AgentBlockHandler')
 
+const AGENT_TOOL_CALLS_LIST_LIMIT = 50
+
 /**
  * Handler for Agent blocks that process LLM requests with optional tools.
  */
@@ -1294,32 +1297,53 @@ export class AgentBlockHandler implements BlockHandler {
     timing?: any
     cost?: any
   }) {
+    const toolCalls = Array.isArray(result.toolCalls) ? result.toolCalls : []
+    const totalToolCalls = toolCalls.length
+    const slicedToolCalls =
+      totalToolCalls > AGENT_TOOL_CALLS_LIST_LIMIT
+        ? toolCalls.slice(-AGENT_TOOL_CALLS_LIST_LIMIT)
+        : toolCalls
+    const omittedToolCalls = totalToolCalls - slicedToolCalls.length
+
     return {
       tokens: result.tokens || {
         input: DEFAULTS.TOKENS.PROMPT,
         output: DEFAULTS.TOKENS.COMPLETION,
         total: DEFAULTS.TOKENS.TOTAL,
       },
       toolCalls: {
-        list: result.toolCalls?.map(this.formatToolCall.bind(this)) || [],
-        count: result.toolCalls?.length || DEFAULTS.EXECUTION_TIME,
+        list: slicedToolCalls.map(this.formatToolCall.bind(this)),
+        count: totalToolCalls,
+        ...(omittedToolCalls > 0
+          ? {
+              omitted: omittedToolCalls,
+              truncated: true,
+              limit: AGENT_TOOL_CALLS_LIST_LIMIT,
+            }
+          : {}),
       },
       providerTiming: result.timing,
       cost: result.cost,
     }
   }
 
   private formatToolCall(tc: any) {
-    const toolName = stripCustomToolPrefix(tc.name)
+    const toolName = stripCustomToolPrefix(typeof tc?.name === 'string' ? tc.name : '')
+    const compactOptions = {
+      maxDepth: 6,
+      maxStringLength: 2000,
+      maxArrayLength: 30,
+      maxObjectKeys: 80,
+    } as const
 
     return {
-      ...tc,
       name: toolName,
       startTime: tc.startTime,
       endTime: tc.endTime,
       duration: tc.duration,
-      arguments: tc.arguments || tc.input || {},
-      result: tc.result || tc.output,
+      arguments: compactValue(tc.arguments || tc.input || {}, compactOptions),
+      result: compactValue(tc.result || tc.output, compactOptions),
+      ...(tc?.error ? { error: compactValue(tc.error, compactOptions) } : {}),
     }
   }
 }

apps/sim/executor/orchestrators/loop.orchestrator.test.ts

@@ -0,0 +1,76 @@
+import { loggerMock } from '@sim/testing'
+import { describe, expect, it, vi } from 'vitest'
+import { LoopOrchestrator } from '@/executor/orchestrators/loop'
+
+vi.mock('@sim/logger', () => loggerMock)
+
+describe('LoopOrchestrator retention', () => {
+  it('retains only the tail of allIterationOutputs and tracks dropped count', async () => {
+    const state = { setBlockOutput: vi.fn() } as any
+    const orchestrator = new LoopOrchestrator({} as any, state, {} as any)
+
+    vi.spyOn(orchestrator as any, 'evaluateCondition').mockResolvedValue(true)
+
+    const scope: any = {
+      iteration: 0,
+      currentIterationOutputs: new Map(),
+      allIterationOutputs: [],
+      allIterationOutputsDroppedCount: 0,
+      allIterationOutputsLimit: 3,
+    }
+
+    const ctx: any = {
+      loopExecutions: new Map([['loop-1', scope]]),
+      metadata: { duration: 0 },
+    }
+
+    for (let i = 0; i < 5; i++) {
+      scope.currentIterationOutputs.set('block', { i })
+      const result = await orchestrator.evaluateLoopContinuation(ctx, 'loop-1')
+      expect(result.shouldContinue).toBe(true)
+    }
+
+    expect(scope.allIterationOutputs).toHaveLength(3)
+    expect(scope.allIterationOutputsDroppedCount).toBe(2)
+    expect(scope.allIterationOutputs[0][0]).toEqual({ i: 2 })
+    expect(scope.allIterationOutputs[2][0]).toEqual({ i: 4 })
+  })
+
+  it('includes truncation metadata in exit output', () => {
+    const state = { setBlockOutput: vi.fn() } as any
+    const orchestrator = new LoopOrchestrator({} as any, state, {} as any)
+
+    const scope: any = {
+      iteration: 0,
+      currentIterationOutputs: new Map(),
+      allIterationOutputs: [[{ a: 1 }]],
+      allIterationOutputsDroppedCount: 5,
+      allIterationOutputsLimit: 1,
+    }
+
+    const ctx: any = {
+      metadata: { duration: 0 },
+    }
+
+    const result = (orchestrator as any).createExitResult(ctx, 'loop-1', scope)
+
+    expect(result.resultsTruncated).toBe(true)
+    expect(result.totalIterations).toBe(6)
+    expect(result.droppedIterations).toBe(5)
+    expect(result.retainedIterations).toBe(1)
+    expect(result.retentionLimit).toBe(1)
+
+    expect(state.setBlockOutput).toHaveBeenCalledWith(
+      'loop-1',
+      expect.objectContaining({
+        results: scope.allIterationOutputs,
+        resultsTruncated: true,
+        totalIterations: 6,
+        droppedIterations: 5,
+        retainedIterations: 1,
+        retentionLimit: 1,
+      }),
+      expect.any(Number)
+    )
+  })
+})

apps/sim/executor/orchestrators/loop.ts

@@ -13,6 +13,7 @@ import {
   type NormalizedBlockOutput,
 } from '@/executor/types'
 import type { LoopConfigWithNodes } from '@/executor/types/loop'
+import { retainTailInPlace } from '@/executor/utils/memory'
 import { replaceValidReferences } from '@/executor/utils/reference-validation'
 import {
   addSubflowErrorLog,
@@ -28,6 +29,7 @@ import type { SerializedLoop } from '@/serializer/types'
 const logger = createLogger('LoopOrchestrator')
 
 const LOOP_CONDITION_TIMEOUT_MS = 5000
+const LOOP_RESULTS_RETAINED_LIMIT = 100
 
 export type LoopRoute = typeof EDGE.LOOP_CONTINUE | typeof EDGE.LOOP_EXIT
 
@@ -36,6 +38,11 @@ export interface LoopContinuationResult {
   shouldExit: boolean
   selectedRoute: LoopRoute
   aggregatedResults?: NormalizedBlockOutput[][]
+  totalIterations?: number
+  droppedIterations?: number
+  retainedIterations?: number
+  retentionLimit?: number
+  resultsTruncated?: boolean
 }
 
 export class LoopOrchestrator {
@@ -65,6 +72,8 @@ export class LoopOrchestrator {
       iteration: 0,
       currentIterationOutputs: new Map(),
       allIterationOutputs: [],
+      allIterationOutputsDroppedCount: 0,
+      allIterationOutputsLimit: LOOP_RESULTS_RETAINED_LIMIT,
     }
 
     const loopType = loopConfig.loopType
@@ -253,6 +262,12 @@ export class LoopOrchestrator {
 
     if (iterationResults.length > 0) {
       scope.allIterationOutputs.push(iterationResults)
+      const limit = scope.allIterationOutputsLimit ?? LOOP_RESULTS_RETAINED_LIMIT
+      const { dropped } = retainTailInPlace(scope.allIterationOutputs, limit)
+      if (dropped > 0) {
+        scope.allIterationOutputsDroppedCount =
+          (scope.allIterationOutputsDroppedCount ?? 0) + dropped
+      }
     }
 
     scope.currentIterationOutputs.clear()
@@ -280,7 +295,22 @@ export class LoopOrchestrator {
     scope: LoopScope
   ): LoopContinuationResult {
     const results = scope.allIterationOutputs
-    const output = { results }
+    const droppedIterations = scope.allIterationOutputsDroppedCount ?? 0
+    const retentionLimit = scope.allIterationOutputsLimit ?? LOOP_RESULTS_RETAINED_LIMIT
+    const totalIterations = droppedIterations + results.length
+    const resultsTruncated = droppedIterations > 0
+    const output = {
+      results,
+      totalIterations,
+      ...(resultsTruncated
+        ? {
+            resultsTruncated: true,
+            droppedIterations,
+            retainedIterations: results.length,
+            retentionLimit,
+          }
+        : {}),
+    }
     this.state.setBlockOutput(loopId, output, DEFAULTS.EXECUTION_TIME)
 
     // Emit onBlockComplete for the loop container so the UI can track it
@@ -300,6 +330,11 @@ export class LoopOrchestrator {
       shouldExit: true,
       selectedRoute: EDGE.LOOP_EXIT,
       aggregatedResults: results,
+      totalIterations,
+      droppedIterations: resultsTruncated ? droppedIterations : 0,
+      retainedIterations: results.length,
+      retentionLimit,
+      resultsTruncated,
     }
   }
 

apps/sim/executor/orchestrators/node.ts

@@ -6,6 +6,8 @@ import type { BlockStateController } from '@/executor/execution/types'
 import type { LoopOrchestrator } from '@/executor/orchestrators/loop'
 import type { ParallelOrchestrator } from '@/executor/orchestrators/parallel'
 import type { ExecutionContext, NormalizedBlockOutput } from '@/executor/types'
+import { compactValue } from '@/executor/utils/memory'
+import { filterOutputForLog } from '@/executor/utils/output-filter'
 import { extractBaseBlockId } from '@/executor/utils/subflow-utils'
 
 const logger = createLogger('NodeExecutionOrchestrator')
@@ -140,7 +142,16 @@ export class NodeExecutionOrchestrator {
           shouldContinue: false,
           shouldExit: true,
           selectedRoute: continuationResult.selectedRoute,
-          totalIterations: continuationResult.aggregatedResults?.length || 0,
+          totalIterations:
+            continuationResult.totalIterations ?? continuationResult.aggregatedResults?.length ?? 0,
+          ...(continuationResult.resultsTruncated
+            ? {
+                resultsTruncated: true,
+                droppedIterations: continuationResult.droppedIterations,
+                retainedIterations: continuationResult.retainedIterations,
+                retentionLimit: continuationResult.retentionLimit,
+              }
+            : {}),
         }
       }
 
@@ -233,7 +244,16 @@ export class NodeExecutionOrchestrator {
     output: NormalizedBlockOutput,
     loopId: string
   ): void {
-    this.loopOrchestrator.storeLoopNodeOutput(ctx, loopId, node.id, output)
+    const blockType = node.block.metadata?.id || ''
+    const filtered = filterOutputForLog(blockType, output, { block: node.block })
+    const compacted = compactValue(filtered, {
+      maxDepth: 6,
+      maxStringLength: 4000,
+      maxArrayLength: 50,
+      maxObjectKeys: 120,
+    }) as NormalizedBlockOutput
+
+    this.loopOrchestrator.storeLoopNodeOutput(ctx, loopId, node.id, compacted)
     this.state.setBlockOutput(node.id, output)
   }