fix: prevent memory exhaustion in loops with bounded iteration outputs

This change addresses memory exhaustion issues that occur when running
workflows with loops containing agent blocks that make many tool calls.

## Problem

Memory accumulated unbounded in two key areas:
1. `allIterationOutputs` in LoopScope - every iteration pushed results
2. `blockLogs` in ExecutionContext - every block execution added logs

This caused OOM crashes on systems with 64GB+ RAM during long-running
workflow executions.

## Solution

Added memory management with configurable limits:

### Loop Orchestrator (`loop.ts`)
- New `addIterationOutputsWithMemoryLimit()` method
- Limits stored iterations to MAX_STORED_ITERATION_OUTPUTS (100)
- Monitors memory size with MAX_ITERATION_OUTPUTS_SIZE_BYTES (50MB)
- Discards oldest iterations when limits exceeded

### Block Executor (`block-executor.ts`)
- New `addBlockLogWithMemoryLimit()` method
- Limits stored logs to MAX_BLOCK_LOGS (500)
- Monitors memory size with MAX_BLOCK_LOGS_SIZE_BYTES (100MB)
- Periodic size checks (every 50 logs) to avoid serialization overhead

### Constants (`constants.ts`)
- Added new configurable defaults for all limits

## Trade-offs

- Final aggregated results contain only recent iterations
- Logs show warning when truncation occurs for debugging

Fixes #2525

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: aadamsx

apps/sim/executor/constants.ts

@@ -130,6 +130,26 @@ export const DEFAULTS = {
   MAX_LOOP_ITERATIONS: 1000,
   MAX_WORKFLOW_DEPTH: 10,
   EXECUTION_TIME: 0,
+  /**
+   * Maximum number of iteration outputs to retain in memory during loop execution.
+   * Older iterations are discarded to prevent memory exhaustion in long-running loops.
+   * The final aggregated results will contain only the most recent iterations.
+   */
+  MAX_STORED_ITERATION_OUTPUTS: 100,
+  /**
+   * Maximum size in bytes for iteration outputs before triggering truncation.
+   * This is an approximate estimate based on JSON serialization.
+   */
+  MAX_ITERATION_OUTPUTS_SIZE_BYTES: 50 * 1024 * 1024, // 50MB
+  /**
+   * Maximum number of block logs to retain in memory during execution.
+   * Older logs are discarded to prevent memory exhaustion in long-running workflows.
+   */
+  MAX_BLOCK_LOGS: 500,
+  /**
+   * Maximum size in bytes for block logs before triggering truncation.
+   */
+  MAX_BLOCK_LOGS_SIZE_BYTES: 100 * 1024 * 1024, // 100MB
   TOKENS: {
     PROMPT: 0,
     COMPLETION: 0,

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

@@ -59,7 +59,7 @@ export class BlockExecutor {
     let blockLog: BlockLog | undefined
     if (!isSentinel) {
       blockLog = this.createBlockLog(ctx, node.id, block, node)
-      ctx.blockLogs.push(blockLog)
+      this.addBlockLogWithMemoryLimit(ctx, blockLog)
       this.callOnBlockStart(ctx, node, block)
     }
 
@@ -658,4 +658,54 @@ export class BlockExecutor {
 
     executionOutput.content = fullContent
   }
+
+  /**
+   * Adds a block log to the execution context with memory management.
+   * Prevents unbounded memory growth by:
+   * 1. Limiting the number of stored logs (MAX_BLOCK_LOGS)
+   * 2. Checking estimated memory size (MAX_BLOCK_LOGS_SIZE_BYTES)
+   *
+   * When limits are exceeded, older logs are discarded to make room for newer ones.
+   */
+  private addBlockLogWithMemoryLimit(ctx: ExecutionContext, blockLog: BlockLog): void {
+    ctx.blockLogs.push(blockLog)
+
+    // Check log count limit
+    if (ctx.blockLogs.length > DEFAULTS.MAX_BLOCK_LOGS) {
+      const discardCount = ctx.blockLogs.length - DEFAULTS.MAX_BLOCK_LOGS
+      ctx.blockLogs = ctx.blockLogs.slice(discardCount)
+      logger.warn('Block logs exceeded count limit, discarding older logs', {
+        discardedCount: discardCount,
+        retainedCount: ctx.blockLogs.length,
+        maxAllowed: DEFAULTS.MAX_BLOCK_LOGS,
+      })
+    }
+
+    // Periodically check memory size (every 50 logs to avoid frequent serialization)
+    if (ctx.blockLogs.length % 50 === 0) {
+      const estimatedSize = this.estimateBlockLogsSize(ctx.blockLogs)
+      if (estimatedSize > DEFAULTS.MAX_BLOCK_LOGS_SIZE_BYTES) {
+        const halfLength = Math.floor(ctx.blockLogs.length / 2)
+        const discardCount = Math.max(halfLength, 1)
+        ctx.blockLogs = ctx.blockLogs.slice(discardCount)
+        logger.warn('Block logs exceeded memory limit, discarding older logs', {
+          estimatedSizeBytes: estimatedSize,
+          maxSizeBytes: DEFAULTS.MAX_BLOCK_LOGS_SIZE_BYTES,
+          discardedCount: discardCount,
+          retainedCount: ctx.blockLogs.length,
+        })
+      }
+    }
+  }
+
+  /**
+   * Estimates the memory size of block logs in bytes.
+   */
+  private estimateBlockLogsSize(logs: BlockLog[]): number {
+    try {
+      return JSON.stringify(logs).length * 2
+    } catch {
+      return DEFAULTS.MAX_BLOCK_LOGS_SIZE_BYTES
+    }
+  }
 }

apps/sim/executor/orchestrators/loop.ts

@@ -141,7 +141,7 @@ export class LoopOrchestrator {
     }
 
     if (iterationResults.length > 0) {
-      scope.allIterationOutputs.push(iterationResults)
+      this.addIterationOutputsWithMemoryLimit(scope, iterationResults, loopId)
     }
 
     scope.currentIterationOutputs.clear()
@@ -462,4 +462,69 @@ export class LoopOrchestrator {
       return []
     }
   }
+
+  /**
+   * Adds iteration outputs to the loop scope with memory management.
+   * Prevents unbounded memory growth by:
+   * 1. Limiting the number of stored iterations (MAX_STORED_ITERATION_OUTPUTS)
+   * 2. Checking estimated memory size (MAX_ITERATION_OUTPUTS_SIZE_BYTES)
+   *
+   * When limits are exceeded, older iterations are discarded to make room for newer ones.
+   * This ensures long-running loops don't cause memory exhaustion while still providing
+   * access to recent iteration results.
+   */
+  private addIterationOutputsWithMemoryLimit(
+    scope: LoopScope,
+    iterationResults: NormalizedBlockOutput[],
+    loopId: string
+  ): void {
+    scope.allIterationOutputs.push(iterationResults)
+
+    // Check iteration count limit
+    if (scope.allIterationOutputs.length > DEFAULTS.MAX_STORED_ITERATION_OUTPUTS) {
+      const discardCount = scope.allIterationOutputs.length - DEFAULTS.MAX_STORED_ITERATION_OUTPUTS
+      scope.allIterationOutputs = scope.allIterationOutputs.slice(discardCount)
+      logger.warn('Loop iteration outputs exceeded count limit, discarding older iterations', {
+        loopId,
+        iteration: scope.iteration,
+        discardedCount: discardCount,
+        retainedCount: scope.allIterationOutputs.length,
+        maxAllowed: DEFAULTS.MAX_STORED_ITERATION_OUTPUTS,
+      })
+    }
+
+    // Check memory size limit (approximate)
+    const estimatedSize = this.estimateObjectSize(scope.allIterationOutputs)
+    if (estimatedSize > DEFAULTS.MAX_ITERATION_OUTPUTS_SIZE_BYTES) {
+      // Discard oldest half of iterations when memory limit exceeded
+      const halfLength = Math.floor(scope.allIterationOutputs.length / 2)
+      const discardCount = Math.max(halfLength, 1)
+      scope.allIterationOutputs = scope.allIterationOutputs.slice(discardCount)
+      logger.warn('Loop iteration outputs exceeded memory limit, discarding older iterations', {
+        loopId,
+        iteration: scope.iteration,
+        estimatedSizeBytes: estimatedSize,
+        maxSizeBytes: DEFAULTS.MAX_ITERATION_OUTPUTS_SIZE_BYTES,
+        discardedCount: discardCount,
+        retainedCount: scope.allIterationOutputs.length,
+      })
+    }
+  }
+
+  /**
+   * Estimates the memory size of an object in bytes.
+   * This is an approximation based on JSON serialization size.
+   * Actual memory usage may vary due to object overhead and references.
+   */
+  private estimateObjectSize(obj: unknown): number {
+    try {
+      // Use JSON.stringify length as a rough estimate
+      // Multiply by 2 for UTF-16 encoding overhead in JS strings
+      return JSON.stringify(obj).length * 2
+    } catch {
+      // If serialization fails (circular refs, etc.), return a large estimate
+      // to trigger cleanup as a safety measure
+      return DEFAULTS.MAX_ITERATION_OUTPUTS_SIZE_BYTES
+    }
+  }
 }