Skip to content

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

TypeScript
12.1 KB
Raw Blame
import { afterEach, describe, expect, it, vi } from 'vitest'
import { BudgetClient } from '../../budget/budgetClient'
import type { BudgetCheckRequest } from '../../budget/types'
import { config as appConfig } from '../../config'
import { TaskLifecycle } from '../../lifecycle/taskLifecycle'
import { MessageQueue } from '../../queue'
import type { Task } from '../../queue/types'
import { AgentStateMachine } from '../stateMachine'

function makeMachine() {
  const queue = new MessageQueue()
  const machine = new AgentStateMachine(queue, new TaskLifecycle())
  return { machine, queue }
}

/** Minimal SingleTurnProvider stub exposing getProviderType. */
function stubProvider(providerType: string) {
  return { getProviderType: () => providerType } as unknown as Parameters<
    AgentStateMachine['setLLMProvider']
  >[0]
}

describe('AgentStateMachine.checkTaskBudget', () => {
  afterEach(() => {
    vi.restoreAllMocks()
    appConfig.budgetsEnabled = false
  })

  it('is a no-op {allowed:true} with no network when the flag is off', async () => {
    appConfig.budgetsEnabled = false
    const { machine, queue } = makeMachine()
    const fetchImpl = vi.fn()
    const client = new BudgetClient({
      baseUrl: 'http://gw',
      getAccessToken: () => 't',
      fetchImpl: fetchImpl as unknown as typeof fetch,
    })
    machine.setLLMProvider(stubProvider('openai'), 'gpt-4o')
    machine.setBudgetCheck(client, () => ({
      host_ref: 'trader',
      context_ref: 'ctx',
      llm_secret_name: 'sec',
    }))

    const task = queue.createInternalTask('hi')
    const out = await machine.checkTaskBudget(task)

    expect(out).toEqual({ allowed: true })
    expect(fetchImpl).not.toHaveBeenCalled()
  })

  it('is a no-op when budgets are on but no client/host context is wired', async () => {
    appConfig.budgetsEnabled = true
    const { machine, queue } = makeMachine()
    machine.setLLMProvider(stubProvider('openai'), 'gpt-4o')
    const out = await machine.checkTaskBudget(queue.createInternalTask('hi'))
    expect(out).toEqual({ allowed: true })
  })

  it('builds the request body from host context + provider/model + task attribution', async () => {
    appConfig.budgetsEnabled = true
    const { machine, queue } = makeMachine()
    let captured: BudgetCheckRequest | undefined
    const fetchImpl = vi.fn().mockImplementation((_url: string, init: { body: string }) => {
      captured = JSON.parse(init.body) as BudgetCheckRequest
      return Promise.resolve({ ok: true, status: 200, json: async () => ({ allowed: true }) })
    })
    const client = new BudgetClient({
      baseUrl: 'http://gw',
      getAccessToken: () => 't',
      fetchImpl: fetchImpl as unknown as typeof fetch,
    })
    machine.setLLMProvider(stubProvider('claude'), 'claude-sonnet-4')
    machine.setBudgetCheck(client, () => ({
      host_ref: 'trader',
      context_ref: 'trader-context',
      llm_secret_name: 'anthropic-key',
    }))

    const task: Task = {
      ...queue.createInternalTask('hi'),
      source: 'cron',
      cronJobId: 'cron-9',
    }
    const out = await machine.checkTaskBudget(task)

    expect(out).toEqual({ allowed: true })
    expect(captured).toEqual({
      host_ref: 'trader',
      context_ref: 'trader-context',
      llm_secret_name: 'anthropic-key',
      provider: 'claude',
      model: 'claude-sonnet-4',
      source_kind: 'cron',
      user_id: null,
      team_id: null,
      recipe_name: null,
      cron_job_id: 'cron-9',
      // P2b (§5.4): stable task correlation for early reservation release.
      task_ref: task.id,
    })
  })

  it('returns the deny verdict from control-api', async () => {
    appConfig.budgetsEnabled = true
    const { machine, queue } = makeMachine()
    const fetchImpl = vi.fn().mockResolvedValue({
      ok: true,
      status: 200,
      json: async () => ({ allowed: false, reason: 'global_tokens_exceeded' }),
    })
    const client = new BudgetClient({
      baseUrl: 'http://gw',
      getAccessToken: () => 't',
      fetchImpl: fetchImpl as unknown as typeof fetch,
    })
    machine.setLLMProvider(stubProvider('openai'), 'gpt-4o')
    machine.setBudgetCheck(client, () => ({
      host_ref: 'trader',
      context_ref: 'ctx',
      llm_secret_name: 'sec',
    }))

    const out = await machine.checkTaskBudget(queue.createInternalTask('hi'))
    expect(out).toEqual({ allowed: false, reason: 'global_tokens_exceeded' })
  })
})

describe('AgentStateMachine — P2b early reservation release on terminal', () => {
  afterEach(() => {
    vi.restoreAllMocks()
    appConfig.budgetsEnabled = false
  })

  /** Wire a machine whose budget check returns the given verdict, run the check,
   *  then drive the task to the given terminal status; resolves the captured
   *  release request bodies (one per release call observed). */
  async function runCheckThenTerminal(opts: {
    verdict: Record<string, unknown>
    terminal: 'completed' | 'failed' | 'cancelled'
  }): Promise<{ releaseBodies: unknown[]; releaseUrls: string[] }> {
    appConfig.budgetsEnabled = true
    const queue = new MessageQueue()
    const lifecycle = new TaskLifecycle()
    queue.setLifecycle(lifecycle)
    const machine = new AgentStateMachine(queue, lifecycle)
    machine.setLLMProvider(stubProvider('openai'), 'gpt-4o')

    const releaseBodies: unknown[] = []
    const releaseUrls: string[] = []
    const fetchImpl = vi.fn().mockImplementation((url: string, init: { body: string }) => {
      if (String(url).endsWith('/budgets/check')) {
        return Promise.resolve({ ok: true, status: 200, json: async () => opts.verdict })
      }
      // /budgets/release
      releaseUrls.push(String(url))
      releaseBodies.push(JSON.parse(init.body))
      return Promise.resolve({ ok: true, status: 200, json: async () => ({ released: 1 }) })
    })
    const client = new BudgetClient({
      baseUrl: 'http://gw',
      getAccessToken: () => 't',
      fetchImpl: fetchImpl as unknown as typeof fetch,
    })
    machine.setBudgetCheck(client, () => ({
      host_ref: 'trader',
      context_ref: 'ctx',
      llm_secret_name: 'sec',
    }))

    const task = queue.createInternalTask('hi')
    lifecycle.register(task)
    lifecycle.transition(task.id, 'processing', 'dispatched')

    await machine.checkTaskBudget(task)

    if (opts.terminal === 'completed') queue.completeTask(task)
    else if (opts.terminal === 'failed')
      queue.failTask(task, { code: 'X', message: 'm', retryable: false, provider: 'openai' })
    else lifecycle.transition(task.id, 'cancelled', 'user_requested')

    // Let the fire-and-forget release microtask settle.
    await new Promise(r => setImmediate(r))
    return { releaseBodies, releaseUrls }
  }

  it('releases by task_ref when the verdict carried reservationIds and the task completes', async () => {
    const { releaseBodies, releaseUrls } = await runCheckThenTerminal({
      verdict: { allowed: true, reservationIds: ['res-1'] },
      terminal: 'completed',
    })
    expect(releaseBodies).toHaveLength(1)
    // host_ref MUST match the one the check sent (getHostBudgetContext → 'trader')
    // so control-api's claim-binding + host-scoping matches the reservation.
    expect(releaseBodies[0]).toEqual({ task_ref: expect.any(String), host_ref: 'trader' })
    expect(releaseUrls[0]).toBe('http://gw/api/v1/internal/budgets/release')
  })

  it('also releases when the task FAILS (terminal branch covers errors)', async () => {
    const { releaseBodies } = await runCheckThenTerminal({
      verdict: { allowed: true, reservationIds: ['res-1'] },
      terminal: 'failed',
    })
    expect(releaseBodies).toHaveLength(1)
  })

  it('also releases when the task is CANCELLED', async () => {
    const { releaseBodies } = await runCheckThenTerminal({
      verdict: { allowed: true, reservationIds: ['res-1'] },
      terminal: 'cancelled',
    })
    expect(releaseBodies).toHaveLength(1)
  })

  it('does NOT release when the verdict had no reservationIds (no danger-zone reservation)', async () => {
    const { releaseBodies } = await runCheckThenTerminal({
      verdict: { allowed: true },
      terminal: 'completed',
    })
    expect(releaseBodies).toHaveLength(0)
  })

  it('does NOT release when the verdict had an empty reservationIds array', async () => {
    const { releaseBodies } = await runCheckThenTerminal({
      verdict: { allowed: true, reservationIds: [] },
      terminal: 'completed',
    })
    expect(releaseBodies).toHaveLength(0)
  })

  it('flag OFF: never sends task_ref and never releases (total no-op)', async () => {
    appConfig.budgetsEnabled = false
    const queue = new MessageQueue()
    const lifecycle = new TaskLifecycle()
    queue.setLifecycle(lifecycle)
    const machine = new AgentStateMachine(queue, lifecycle)
    machine.setLLMProvider(stubProvider('openai'), 'gpt-4o')

    const fetchImpl = vi.fn()
    const client = new BudgetClient({
      baseUrl: 'http://gw',
      getAccessToken: () => 't',
      fetchImpl: fetchImpl as unknown as typeof fetch,
    })
    machine.setBudgetCheck(client, () => ({
      host_ref: 'trader',
      context_ref: 'ctx',
      llm_secret_name: 'sec',
    }))

    const task = queue.createInternalTask('hi')
    lifecycle.register(task)
    lifecycle.transition(task.id, 'processing', 'dispatched')
    await machine.checkTaskBudget(task)
    queue.completeTask(task)
    await new Promise(r => setImmediate(r))

    expect(fetchImpl).not.toHaveBeenCalled()
  })

  it('release fail-open: a throwing release never surfaces an error on the terminal path', async () => {
    appConfig.budgetsEnabled = true
    const queue = new MessageQueue()
    const lifecycle = new TaskLifecycle()
    queue.setLifecycle(lifecycle)
    const machine = new AgentStateMachine(queue, lifecycle)
    machine.setLLMProvider(stubProvider('openai'), 'gpt-4o')
    vi.spyOn(console, 'warn').mockImplementation(() => undefined)

    const fetchImpl = vi.fn().mockImplementation((url: string) => {
      if (String(url).endsWith('/budgets/check')) {
        return Promise.resolve({
          ok: true,
          status: 200,
          json: async () => ({ allowed: true, reservationIds: ['res-1'] }),
        })
      }
      return Promise.reject(new Error('release boom'))
    })
    const client = new BudgetClient({
      baseUrl: 'http://gw',
      getAccessToken: () => 't',
      fetchImpl: fetchImpl as unknown as typeof fetch,
    })
    machine.setBudgetCheck(client, () => ({
      host_ref: 'trader',
      context_ref: 'ctx',
      llm_secret_name: 'sec',
    }))

    const task = queue.createInternalTask('hi')
    lifecycle.register(task)
    lifecycle.transition(task.id, 'processing', 'dispatched')
    await machine.checkTaskBudget(task)

    // completeTask drives the terminal transition; it must not throw despite the
    // failing release fired by the subscriber.
    expect(() => queue.completeTask(task)).not.toThrow()
    await new Promise(r => setImmediate(r))
    expect(lifecycle.getStatus(task.id)).toBe('completed')
  })
})

describe('AgentStateMachine.handleBudgetDenied', () => {
  afterEach(() => {
    vi.restoreAllMocks()
  })

  it('delivers a budget error via responseCallback and drives the task to failed', async () => {
    const queue = new MessageQueue()
    const lifecycle = new TaskLifecycle()
    queue.setLifecycle(lifecycle) // queue.failTask must transition the SAME lifecycle
    const machine = new AgentStateMachine(queue, lifecycle)
    machine.setLLMProvider(stubProvider('openai'), 'gpt-4o')

    const responseCallback = vi.fn().mockResolvedValue(undefined)
    const task = queue.createInternalTask('hi')
    task.responseCallback = responseCallback
    lifecycle.register(task)
    lifecycle.transition(task.id, 'processing', 'dispatched')

    const failed: unknown[] = []
    machine.on('task:failed', e => failed.push(e))

    machine.handleBudgetDenied(task, 'monthly_cost_exceeded')
    await new Promise(r => setImmediate(r))

    expect(responseCallback).toHaveBeenCalledTimes(1)
    const payload = responseCallback.mock.calls[0][0]
    expect(payload.error.code).toBe('BUDGET_EXCEEDED')
    expect(payload.error.message).toMatch(/consumption budget/i)
    expect(payload.error.retryable).toBe(false)
    expect(payload.error.provider).toBe('openai')
    expect(lifecycle.getStatus(task.id)).toBe('failed')
    expect(failed).toHaveLength(1)
  })
})