Skip to content

Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure

TypeScript
3.0 KB
Raw Blame
import { afterEach, describe, expect, it, vi } from 'vitest'
import { VISUAL_INPUT_LIMITS } from '../../visualInput/policy'
import {
  TaskExecutionBudget,
  TaskLimitError,
  parseTaskExecutionBudget,
} from '../taskExecutionBudget'

afterEach(() => vi.useRealTimers())
describe('TaskExecutionBudget', () => {
  it('reports the same remaining active deadline across approval pause and restore', () => {
    vi.useFakeTimers()
    let now = 0
    const first = new TaskExecutionBudget(100, 2, () => now)
    first.start(new AbortController())
    now = 25
    expect(first.remainingDurationMs).toBe(75)
    const saved = first.pause()
    now = 10000
    expect(first.remainingDurationMs).toBe(75)
    const restored = new TaskExecutionBudget(200, 4, () => now)
    restored.restore(saved)
    expect(restored.remainingDurationMs).toBe(75)
    restored.start(new AbortController())
    now += 20
    expect(restored.remainingDurationMs).toBe(55)
    now += 80
    expect(restored.remainingDurationMs).toBe(0)
    restored.pause()
  })
  it('retains consumption across approvals and restart, excluding approval wait', async () => {
    vi.useFakeTimers()
    let now = 0
    const first = new TaskExecutionBudget(100, 2, () => now)
    first.start(new AbortController())
    first.consumeIteration()
    now = 40
    const saved = first.pause()
    now = 10000
    const restored = new TaskExecutionBudget(200, 20, () => now)
    restored.restore(saved)
    expect(restored.durationMs).toBe(100)
    expect(restored.maxIterations).toBe(2)
    const controller = new AbortController()
    restored.start(controller)
    restored.consumeIteration()
    expect(restored.remainingIterations).toBe(0)
    expect(() => restored.consumeIteration()).toThrow(TaskLimitError)
    await vi.advanceTimersByTimeAsync(59)
    expect(controller.signal.aborted).toBe(false)
    await vi.advanceTimersByTimeAsync(1)
    expect(controller.signal.reason.code).toBe('TASK_DURATION_LIMIT')
    restored.pause()
    expect(vi.getTimerCount()).toBe(0)
  })
  it('clears its timer on successful completion', async () => {
    vi.useFakeTimers()
    const budget = new TaskExecutionBudget(100, 2)
    const controller = new AbortController()
    budget.start(controller)
    budget.pause()
    await vi.advanceTimersByTimeAsync(200)
    expect(controller.signal.aborted).toBe(false)
  })
  it('refuses exhausted restored time before work starts', () => {
    const budget = new TaskExecutionBudget(100, 2)
    budget.restore({ elapsedActiveMs: 100, iterationsUsed: 1, durationMs: 100, maxIterations: 2 })
    expect(() => budget.start(new AbortController())).toThrow(TaskLimitError)
  })
  it.each([
    null,
    {},
    { elapsedActiveMs: -1, iterationsUsed: 0 },
    { elapsedActiveMs: 0, iterationsUsed: NaN },
    {
      elapsedActiveMs: 0,
      iterationsUsed: 0,
      durationMs: 1,
      maxIterations: 1,
      visualReadBytes: VISUAL_INPUT_LIMITS.readBytesPerTurn + 1,
    },
  ])('rejects invalid durable accounting %s', value => {
    expect(() => parseTaskExecutionBudget(value)).toThrow('Invalid task execution budget')
  })
})