Skip to content

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

TypeScript
19.8 KB
Raw Blame
/**
 * Gap 3 Resolution: Agent-layer event bridge tests.
 *
 * Verifies that events originating at the agent layer (AgentStateMachine)
 * are properly bridged to the core SimpleEventEmitter via getCoreEvents().
 *
 * Events tested:
 *   1. tool:approval_granted  - emitted on handleApproval()
 *   2. tool:approval_denied   - emitted on handleDenial()
 *   3. state:changed          - bridged from setState() via emitEvent()
 *   4. task:completed         - bridged from handleLoopResult() via emitEvent()
 */
import { beforeEach, describe, expect, it, vi } from 'vitest'
import { runToolUseLoop } from '../../core/orchestration/toolUseLoop'
import type { AgentEvent, AgentEventType } from '../../core/types'
import { TaskLifecycle } from '../../lifecycle/taskLifecycle'
import { MessageQueue } from '../../queue/messageQueue'
import { Task } from '../../queue/types'
import { AgentStateMachine } from '../stateMachine'

// Mock config to avoid CLERUM_HOST_NAME requirement
vi.mock('../../config', () => ({
  config: {
    devMode: true,
    contextMaxTokens: 100_000,
    enableApproval: true,
    enableNudge: false,
    nudgeMaxIterations: 3,
    devModelName: 'test-model',
    devModelProvider: 'openai',
    nativeTool: {
      workspacePath: '/tmp',
      shellTimeout: 5000,
      httpAllowlist: [],
      envAllowlist: ['PATH'],
      memoryMaxSize: 1048576,
    },
  },
}))

// Mock the orchestration module
vi.mock('../../core/orchestration/toolUseLoop', () => ({
  runToolUseLoop: vi.fn(),
  validateToolLinkages: vi.fn(),
}))

function createTestTask(sender: string = 'user-1'): Task {
  return {
    id: `task-${Date.now()}`,
    source: 'channel',
    sourceMessage: {
      sender,
      content: 'Do something',
      channelType: 'telegram',
      channelId: 'test-channel',
      messageId: 'msg-1',
      timestamp: new Date().toISOString(),
      hostRef: 'test-host',
    },
    priority: 'normal',
    status: 'pending',
    conversationHistory: [
      {
        role: 'user',
        content: 'Do something',
        timestamp: new Date(),
      },
    ],
    responseCallback: vi.fn(async () => {}),
    createdAt: new Date(),
  }
}

describe('Gap 3 — tool:approval_granted via core SimpleEventEmitter', () => {
  let agent: AgentStateMachine
  let queue: MessageQueue

  beforeEach(() => {
    vi.clearAllMocks()
    queue = new MessageQueue()
    agent = new AgentStateMachine(queue, new TaskLifecycle(), { autoStart: false })
    const mockProvider = {
      completeSingleTurn: vi.fn(),
      completeSingleTurnWithTools: vi.fn(),
      getProviderType: () => 'openai' as const,
    }
    agent.setLLMProvider(mockProvider as any)
    agent.setMcpManager({ getAllTools: () => [], callTool: vi.fn() } as any)
    agent.start() // Required for getState() to aggregate executor states
  })

  it('should emit tool:approval_granted through coreEvents on handleApproval', async () => {
    const coreEvents = agent.getCoreEvents()
    const collected: AgentEvent[] = []
    coreEvents.on('tool:approval_granted', event => collected.push(event))

    // Mock loop returning need_approval, then response on resume
    ;(runToolUseLoop as ReturnType<typeof vi.fn>)
      .mockResolvedValueOnce({
        type: 'need_approval',
        approval: {
          request_id: 'req-grant-1',
          tool_name: 'shell_exec',
          parameters: { command: 'ls' },
          description: 'Shell command',
          tool_call_id: 'tc_1',
          context_snapshot: [],
        },
      })
      .mockResolvedValueOnce({
        type: 'response',
        content: 'Done',
        usage: { input_tokens: 5, output_tokens: 5, total_tokens: 10 },
      })

    const task = createTestTask('user-1')
    await agent.executeTask(task)

    expect(agent.getState()).toBe('waiting_approval')

    await agent.handleApproval('user-1', 'req-grant-1', false)

    expect(collected.length).toBe(1)
    expect(collected[0].type).toBe('tool:approval_granted')
    expect((collected[0].data as Record<string, unknown>).toolName).toBe('shell_exec')
    expect((collected[0].data as Record<string, unknown>).requestId).toBe('req-grant-1')
    expect((collected[0].data as Record<string, unknown>).userId).toBe('user-1')
    expect((collected[0].data as Record<string, unknown>).alwaysApprove).toBe(false)
    expect(collected[0].timestamp).toBeInstanceOf(Date)
  })

  it('should include alwaysApprove=true in tool:approval_granted data', async () => {
    const coreEvents = agent.getCoreEvents()
    const collected: AgentEvent[] = []
    coreEvents.on('tool:approval_granted', event => collected.push(event))
    ;(runToolUseLoop as ReturnType<typeof vi.fn>)
      .mockResolvedValueOnce({
        type: 'need_approval',
        approval: {
          request_id: 'req-always-1',
          tool_name: 'shell_exec',
          parameters: { command: 'ls' },
          description: 'Shell command',
          tool_call_id: 'tc_1',
          context_snapshot: [],
        },
      })
      .mockResolvedValueOnce({
        type: 'response',
        content: 'Done',
        usage: { input_tokens: 5, output_tokens: 5, total_tokens: 10 },
      })

    const task = createTestTask('user-1')
    await agent.executeTask(task)

    expect(agent.getState()).toBe('waiting_approval')

    await agent.handleApproval('user-1', 'req-always-1', true)

    expect(collected.length).toBe(1)
    expect((collected[0].data as Record<string, unknown>).alwaysApprove).toBe(true)
  })
})

describe('Gap 3 — tool:approval_denied via core SimpleEventEmitter', () => {
  let agent: AgentStateMachine
  let queue: MessageQueue

  beforeEach(() => {
    vi.clearAllMocks()
    queue = new MessageQueue()
    agent = new AgentStateMachine(queue, new TaskLifecycle(), { autoStart: false })
    const mockProvider = {
      completeSingleTurn: vi.fn(),
      completeSingleTurnWithTools: vi.fn(),
      getProviderType: () => 'openai' as const,
    }
    agent.setLLMProvider(mockProvider as any)
    agent.setMcpManager({ getAllTools: () => [], callTool: vi.fn() } as any)
    agent.start() // Required for getState() to aggregate executor states
  })

  it('should emit tool:approval_denied through coreEvents on handleDenial', async () => {
    const coreEvents = agent.getCoreEvents()
    const collected: AgentEvent[] = []
    coreEvents.on('tool:approval_denied', event => collected.push(event))
    ;(runToolUseLoop as ReturnType<typeof vi.fn>).mockResolvedValueOnce({
      type: 'need_approval',
      approval: {
        request_id: 'req-deny-1',
        tool_name: 'shell_exec',
        parameters: { command: 'rm -rf /' },
        description: 'Dangerous command',
        tool_call_id: 'tc_1',
        context_snapshot: [],
      },
    })

    const task = createTestTask('user-1')
    await agent.executeTask(task)

    expect(agent.getState()).toBe('waiting_approval')

    await agent.handleDenial('user-1', 'req-deny-1')

    expect(collected.length).toBe(1)
    expect(collected[0].type).toBe('tool:approval_denied')
    expect((collected[0].data as Record<string, unknown>).toolName).toBe('shell_exec')
    expect((collected[0].data as Record<string, unknown>).requestId).toBe('req-deny-1')
    expect((collected[0].data as Record<string, unknown>).userId).toBe('user-1')
    expect(collected[0].timestamp).toBeInstanceOf(Date)
  })
})

describe('Gap 3 — state:changed via core SimpleEventEmitter', () => {
  let agent: AgentStateMachine
  let queue: MessageQueue

  beforeEach(() => {
    vi.clearAllMocks()
    queue = new MessageQueue()
    agent = new AgentStateMachine(queue, new TaskLifecycle(), { autoStart: false })
    const mockProvider = {
      completeSingleTurn: vi.fn(),
      completeSingleTurnWithTools: vi.fn(),
      getProviderType: () => 'openai' as const,
    }
    agent.setLLMProvider(mockProvider as any)
    agent.setMcpManager({ getAllTools: () => [], callTool: vi.fn() } as any)
  })

  it('should emit state:changed through coreEvents when state transitions', async () => {
    const coreEvents = agent.getCoreEvents()
    const collected: AgentEvent[] = []
    coreEvents.on('state:changed', event => collected.push(event))

    // State:changed fires for lifecycle transitions (pause/resume).
    // SessionProcessor now drives task dispatch — idle→processing via setState() no longer
    // fires on executeTask(); use agent lifecycle methods to trigger state:changed.
    agent.start()
    collected.length = 0 // clear any start events

    agent.pause()
    agent.resume()

    // Should have at least 2 state transitions: idle→paused, paused→idle
    const stateChanges = collected.filter(e => e.type === 'state:changed')
    expect(stateChanges.length).toBeGreaterThanOrEqual(2)

    // Verify data shape
    for (const event of stateChanges) {
      const data = event.data as Record<string, unknown>
      expect(data).toHaveProperty('oldState')
      expect(data).toHaveProperty('newState')
      expect(event.timestamp).toBeInstanceOf(Date)
    }

    await agent.stop()
  })

  it('should emit state:changed for pause/resume transitions', async () => {
    const coreEvents = agent.getCoreEvents()
    const collected: AgentEvent[] = []
    coreEvents.on('state:changed', event => collected.push(event))

    agent.start()
    collected.length = 0 // Clear start events

    agent.pause()
    expect(collected.length).toBe(1)
    expect((collected[0].data as Record<string, unknown>).newState).toBe('paused')

    agent.resume()
    expect(collected.length).toBe(2)
    expect((collected[1].data as Record<string, unknown>).newState).toBe('idle')

    await agent.stop()
  })
})

describe('Gap 3 — task:completed via core SimpleEventEmitter', () => {
  let agent: AgentStateMachine
  let queue: MessageQueue

  beforeEach(() => {
    vi.clearAllMocks()
    queue = new MessageQueue()
    agent = new AgentStateMachine(queue, new TaskLifecycle(), { autoStart: false })
    const mockProvider = {
      completeSingleTurn: vi.fn(),
      completeSingleTurnWithTools: vi.fn(),
      getProviderType: () => 'openai' as const,
    }
    agent.setLLMProvider(mockProvider as any)
    agent.setMcpManager({ getAllTools: () => [], callTool: vi.fn() } as any)
  })

  it('should emit task:completed through coreEvents on successful task', async () => {
    const coreEvents = agent.getCoreEvents()
    const collected: AgentEvent[] = []
    coreEvents.on('task:completed', event => collected.push(event))
    ;(runToolUseLoop as ReturnType<typeof vi.fn>).mockResolvedValueOnce({
      type: 'response',
      content: 'Task done',
      usage: { input_tokens: 5, output_tokens: 5, total_tokens: 10 },
    })

    // Use executeTask directly — SessionProcessor now drives queue-based dispatch.
    agent.start()
    const task = createTestTask('user-1')
    await agent.executeTask(task)

    expect(collected.length).toBe(1)
    expect(collected[0].type).toBe('task:completed')
    const data = collected[0].data as Record<string, unknown>
    expect(data).toHaveProperty('task')
    expect(collected[0].timestamp).toBeInstanceOf(Date)

    await agent.stop()
  })

  it('should emit task:completed through coreEvents on denial', async () => {
    agent.start() // Required for getState() to aggregate executor states

    const coreEvents = agent.getCoreEvents()
    const collected: AgentEvent[] = []
    coreEvents.on('task:completed', event => collected.push(event))

    // Reset mock impl queue to avoid leakage from prior tests that enqueue without dispatch.
    ;(runToolUseLoop as ReturnType<typeof vi.fn>).mockReset()
    ;(runToolUseLoop as ReturnType<typeof vi.fn>).mockResolvedValueOnce({
      type: 'need_approval',
      approval: {
        request_id: 'req-deny-tc-1',
        tool_name: 'shell_exec',
        parameters: { command: 'rm' },
        description: 'Shell command',
        tool_call_id: 'tc_1',
        context_snapshot: [],
      },
    })

    const task = createTestTask('user-1')
    await agent.executeTask(task)

    expect(agent.getState()).toBe('waiting_approval')

    await agent.handleDenial('user-1', 'req-deny-tc-1')

    // task:completed should fire on denial (task is considered completed with denial response)
    expect(collected.length).toBe(1)
    expect(collected[0].type).toBe('task:completed')
    const data = collected[0].data as Record<string, unknown>
    expect(data).toHaveProperty('task')

    await agent.stop()
  })

  it('should emit task:failed through coreEvents on exhaustion', async () => {
    const coreEvents = agent.getCoreEvents()
    const collected: AgentEvent[] = []
    coreEvents.on('task:failed', event => collected.push(event))
    ;(runToolUseLoop as ReturnType<typeof vi.fn>).mockResolvedValueOnce({
      type: 'exhaustion',
      message: 'Max iterations reached',
      iterations: 10,
    })

    // Use executeTask directly — SessionProcessor now drives queue-based dispatch.
    agent.start()
    const task = createTestTask('user-1')
    await agent.executeTask(task)

    expect(collected.length).toBe(1)
    expect(collected[0].type).toBe('task:failed')

    await agent.stop()
  })
})

describe('Gap 3 — complete AgentEventType coverage via getCoreEvents()', () => {
  it('should expose getCoreEvents() method that returns a SimpleEventEmitter', () => {
    const queue = new MessageQueue()
    const agent = new AgentStateMachine(queue, new TaskLifecycle(), { autoStart: false })
    const coreEvents = agent.getCoreEvents()

    expect(coreEvents).toBeDefined()
    expect(typeof coreEvents.emit).toBe('function')
    expect(typeof coreEvents.on).toBe('function')
    expect(typeof coreEvents.off).toBe('function')
  })

  it('should accept subscriptions for all 14 AgentEventType values', () => {
    const queue = new MessageQueue()
    const agent = new AgentStateMachine(queue, new TaskLifecycle(), { autoStart: false })
    const coreEvents = agent.getCoreEvents()

    const allTypes: AgentEventType[] = [
      'state:changed',
      'task:started',
      'task:failed',
      'task:failed',
      'tool:called',
      'tool:completed',
      'tool:approval_needed',
      'tool:approval_granted',
      'tool:approval_denied',
      'loop:iteration',
      'loop:completed',
      'safety:input_blocked',
      'safety:output_sanitized',
      'context:compacted',
    ]

    // Should not throw for any event type
    for (const type of allTypes) {
      const handler = vi.fn()
      coreEvents.on(type, handler)
      coreEvents.off(type, handler)
    }
  })
})

/**
 * Regression — PR #291 follow-up: tool:approval_granted and tool:approval_denied
 * MUST reach Node EventEmitter subscribers (agent.on(...)), not only the
 * SimpleEventEmitter (coreEvents).
 *
 * Why: PR #291 wired messageHandler.onApprovalConsumed via `this.deps.agent.on(...)`
 * to clear pendingTaskResults after approval is consumed, but the events were
 * emitted via `this.coreEvents.emit(...)` only. The two emitters are isolated,
 * so the listener never fired in production — channel-reader kept polling and
 * surfacing stale `waiting_approval` notifications to the user.
 *
 * These tests exercise the real `agent.handleApproval()` / `agent.handleDenial()`
 * code path (no mocked emit) and assert delivery on BOTH emitters.
 */
describe('PR #291 follow-up — approval events reach Node EE subscribers', () => {
  let agent: AgentStateMachine
  let queue: MessageQueue

  beforeEach(() => {
    vi.clearAllMocks()
    queue = new MessageQueue()
    agent = new AgentStateMachine(queue, new TaskLifecycle(), { autoStart: false })
    const mockProvider = {
      completeSingleTurn: vi.fn(),
      completeSingleTurnWithTools: vi.fn(),
      getProviderType: () => 'openai' as const,
    }
    agent.setLLMProvider(mockProvider as any)
    agent.setMcpManager({ getAllTools: () => [], callTool: vi.fn() } as any)
    agent.start()
  })

  it('handleApproval emits tool:approval_granted on the Node EventEmitter', async () => {
    const nodeEvents: AgentEvent[] = []
    const coreCollected: AgentEvent[] = []
    agent.on('tool:approval_granted', event => nodeEvents.push(event as AgentEvent))
    agent.getCoreEvents().on('tool:approval_granted', event => coreCollected.push(event))
    ;(runToolUseLoop as ReturnType<typeof vi.fn>)
      .mockResolvedValueOnce({
        type: 'need_approval',
        approval: {
          request_id: 'req-nodeee-grant-1',
          tool_name: 'shell_exec',
          parameters: { command: 'ls' },
          description: 'Shell command',
          tool_call_id: 'tc_1',
          context_snapshot: [],
        },
      })
      .mockResolvedValueOnce({
        type: 'response',
        content: 'Done',
        usage: { input_tokens: 5, output_tokens: 5, total_tokens: 10 },
      })

    const task = createTestTask('user-1')
    await agent.executeTask(task)
    expect(agent.getState()).toBe('waiting_approval')

    await agent.handleApproval('user-1', 'req-nodeee-grant-1', false)

    // Node EE subscriber MUST receive the event (was broken pre-fix).
    expect(nodeEvents.length).toBe(1)
    expect(nodeEvents[0].type).toBe('tool:approval_granted')
    const ndata = nodeEvents[0].data as Record<string, unknown>
    expect(ndata.requestId).toBe('req-nodeee-grant-1')
    expect(ndata.userId).toBe('user-1')
    expect(ndata.taskId).toBe(task.id)
    expect(ndata.toolName).toBe('shell_exec')
    expect(ndata.alwaysApprove).toBe(false)

    // coreEvents subscriber MUST also still receive it (eventWiring depends on this).
    expect(coreCollected.length).toBe(1)
    expect(coreCollected[0].type).toBe('tool:approval_granted')
    expect((coreCollected[0].data as Record<string, unknown>).requestId).toBe('req-nodeee-grant-1')
  })

  it('handleDenial emits tool:approval_denied on the Node EventEmitter', async () => {
    const nodeEvents: AgentEvent[] = []
    const coreCollected: AgentEvent[] = []
    agent.on('tool:approval_denied', event => nodeEvents.push(event as AgentEvent))
    agent.getCoreEvents().on('tool:approval_denied', event => coreCollected.push(event))
    ;(runToolUseLoop as ReturnType<typeof vi.fn>).mockResolvedValueOnce({
      type: 'need_approval',
      approval: {
        request_id: 'req-nodeee-deny-1',
        tool_name: 'shell_exec',
        parameters: { command: 'rm -rf /' },
        description: 'Dangerous command',
        tool_call_id: 'tc_1',
        context_snapshot: [],
      },
    })

    const task = createTestTask('user-1')
    await agent.executeTask(task)
    expect(agent.getState()).toBe('waiting_approval')

    await agent.handleDenial('user-1', 'req-nodeee-deny-1')

    expect(nodeEvents.length).toBe(1)
    expect(nodeEvents[0].type).toBe('tool:approval_denied')
    const ndata = nodeEvents[0].data as Record<string, unknown>
    expect(ndata.requestId).toBe('req-nodeee-deny-1')
    expect(ndata.userId).toBe('user-1')
    expect(ndata.taskId).toBe(task.id)
    expect(ndata.toolName).toBe('shell_exec')

    expect(coreCollected.length).toBe(1)
    expect(coreCollected[0].type).toBe('tool:approval_denied')
  })

  it('Node EE subscriber observes taskId so cross-task routing works', async () => {
    const granted: AgentEvent[] = []
    agent.on('tool:approval_granted', event => granted.push(event as AgentEvent))
    ;(runToolUseLoop as ReturnType<typeof vi.fn>)
      .mockResolvedValueOnce({
        type: 'need_approval',
        approval: {
          request_id: 'req-routing-1',
          tool_name: 'shell_exec',
          parameters: { command: 'ls' },
          description: 'Shell command',
          tool_call_id: 'tc_1',
          context_snapshot: [],
        },
      })
      .mockResolvedValueOnce({
        type: 'response',
        content: 'Done',
        usage: { input_tokens: 5, output_tokens: 5, total_tokens: 10 },
      })

    const task = createTestTask('user-1')
    await agent.executeTask(task)
    await agent.handleApproval('user-1', 'req-routing-1', false)

    // taskId is what messageHandler.onApprovalConsumed routes on:
    //   `if (data.taskId !== this.task.id) return`
    // Without it, the listener early-exits on every call.
    expect(granted.length).toBe(1)
    expect((granted[0].data as Record<string, unknown>).taskId).toBe(task.id)
  })
})