Skip to content

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

TypeScript
18.6 KB
Raw Blame
import { beforeEach, describe, expect, it, vi } from 'vitest'
import { EventEmitter } from 'events'
import { buildConnectRequiredApproval } from '../core/extensions/mcpApprovalGateController'
import { TaskLifecycle } from '../lifecycle/taskLifecycle'
import { IncomingMessageHandler, PendingTaskEntry } from '../messageHandler'
import { progressReporterRegistry } from '../progress/sseProgressReporter'
import { MessageQueue } from '../queue/messageQueue'
import { ResultStore } from '../resultStore'
import type { IncomingMessage } from '../server'

function createTestMessage(content = 'Hello'): IncomingMessage {
  return {
    sender: 'user-1',
    content,
    channelType: 'telegram',
    channelId: 'test-channel',
    messageId: `msg-${Date.now()}`,
    timestamp: new Date().toISOString(),
    hostRef: 'test-host',
  }
}

function createMockDeps() {
  const messageQueue = new MessageQueue()
  const agent = new EventEmitter() as any
  const pendingTaskResults = new ResultStore<PendingTaskEntry>(10 * 60 * 1000, e => e.storedAt)
  const taskLifecycle = new TaskLifecycle()
  messageQueue.setLifecycle(taskLifecycle)
  return {
    messageQueue,
    agent,
    pendingTaskResults,
    getModel: () => 'test-model',
    sanitizeAttachments: (a: any) => a,
    timeoutMs: 500, // short timeout for tests
    taskLifecycle,
  }
}

describe('IncomingMessageHandler', () => {
  it('should resolve with completed response when task finishes normally', async () => {
    const deps = createMockDeps()
    const message = createTestMessage('Hi')
    const handler = new IncomingMessageHandler(message, deps)

    const resultPromise = handler.execute()

    // Simulate task completion: find the task and call its responseCallback
    await new Promise(r => setTimeout(r, 10))
    const task = deps.messageQueue.dequeue()
    expect(task).not.toBeNull()
    await task!.responseCallback!({ response: 'Hello back!' })

    const result = await resultPromise
    expect(result.success).toBe(true)
    expect(result.status).toBe('completed')
    expect(result.response).toBe('Hello back!')
    expect(result.model).toBe('test-model')
  })

  it('should resolve with error when task fails', async () => {
    const deps = createMockDeps()
    const handler = new IncomingMessageHandler(createTestMessage(), deps)

    const resultPromise = handler.execute()

    await new Promise(r => setTimeout(r, 10))
    const task = deps.messageQueue.dequeue()!
    // Simulate failure via queue event — no retries now
    deps.messageQueue.failTask(task, {
      code: 'LLM_API_CALL_FAILED',
      message: 'Something broke',
      retryable: false,
      provider: 'openai',
    })

    const result = await resultPromise
    expect(result.success).toBe(false)
    expect(result.error).toEqual({
      code: 'LLM_API_CALL_FAILED',
      message: 'Something broke',
      retryable: false,
      provider: 'openai',
    })
  })

  it('should resolve with timeout error after timeoutMs', async () => {
    const deps = createMockDeps()
    deps.timeoutMs = 50 // 50ms timeout
    const handler = new IncomingMessageHandler(createTestMessage(), deps)

    const result = await handler.execute()

    expect(result.success).toBe(false)
    expect(result.error).toEqual({
      code: 'LLM_API_CALL_FAILED',
      message: 'Task processing timeout',
      retryable: true,
      provider: 'unknown',
    })
  })

  it('should resolve with approval notification on first approval event', async () => {
    const deps = createMockDeps()
    const handler = new IncomingMessageHandler(createTestMessage(), deps)

    const resultPromise = handler.execute()

    await new Promise(r => setTimeout(r, 10))
    const task = deps.messageQueue.dequeue()!

    // Simulate approval event from agent
    deps.agent.emit('tool:approval_needed', {
      data: {
        taskId: task.id,
        requestId: 'req-1',
        userId: 'user-1',
        notification: 'Approve shell_exec?',
      },
    })

    const result = await resultPromise
    expect(result.success).toBe(true)
    expect(result.status).toBe('waiting_approval')
    expect(result.approval?.notification).toBe('Approve shell_exec?')
  })

  // U5 — a connect_required suspension must reach the polling wire with its
  // discriminator so the desktop renders "Connect <server>", matching the SSE
  // path. Event connect fields are taken from the REAL producer (T1).
  it('resolves waiting_approval carrying the connect_required discriminator (sync path)', async () => {
    const deps = createMockDeps()
    const handler = new IncomingMessageHandler(createTestMessage(), deps)

    const resultPromise = handler.execute()
    await new Promise(r => setTimeout(r, 10))
    const task = deps.messageQueue.dequeue()!

    const approval = buildConnectRequiredApproval(
      { id: 'tc_1', name: 'monday__list_boards', arguments: { limit: 5 } },
      { mcpServerName: 'monday' }
    )
    deps.agent.emit('tool:approval_needed', {
      data: {
        taskId: task.id,
        requestId: approval.request_id,
        userId: 'user-1',
        notification: 'Connect monday to continue',
        reason: approval.reason,
        mcpServerName: approval.mcpServerName,
      },
    })

    const result = await resultPromise
    expect(result.status).toBe('waiting_approval')
    expect(result.approval).toMatchObject({
      reason: 'connect_required',
      mcpServerName: 'monday',
    })
    expect(result.approval).not.toHaveProperty('provider')
  })

  it('resolves a generic waiting_approval without connect fields (back-compat, sync path)', async () => {
    const deps = createMockDeps()
    const handler = new IncomingMessageHandler(createTestMessage(), deps)

    const resultPromise = handler.execute()
    await new Promise(r => setTimeout(r, 10))
    const task = deps.messageQueue.dequeue()!

    deps.agent.emit('tool:approval_needed', {
      data: {
        taskId: task.id,
        requestId: 'req-generic',
        userId: 'user-1',
        notification: 'Approve shell_exec?',
      },
    })

    const result = await resultPromise
    expect(result.approval).toBeDefined()
    expect(result.approval).not.toHaveProperty('reason')
    expect(result.approval).not.toHaveProperty('mcpServerName')
    expect(result.approval).not.toHaveProperty('provider')
  })

  it('should store subsequent responses in pendingTaskResults', async () => {
    const deps = createMockDeps()
    const handler = new IncomingMessageHandler(createTestMessage(), deps)

    const resultPromise = handler.execute()

    await new Promise(r => setTimeout(r, 10))
    const task = deps.messageQueue.dequeue()!

    // First: approval event resolves the promise
    deps.agent.emit('tool:approval_needed', {
      data: {
        taskId: task.id,
        requestId: 'req-1',
        userId: 'user-1',
        notification: 'Approve?',
      },
    })
    await resultPromise // resolve first

    // Second: task completes after approval — should be stored, not resolve again
    await task.responseCallback!({ response: 'Final result' })

    const stored = deps.pendingTaskResults.get(task.id)
    expect(stored).toBeDefined()
    expect(stored!.status).toBe('completed')
    expect(stored!.response).toBe('Final result')
  })

  describe('executeAsync', () => {
    it('should return immediately with pending status and taskId', () => {
      const deps = createMockDeps()
      const handler = new IncomingMessageHandler(createTestMessage(), deps)

      const result = handler.executeAsync()

      expect(result.success).toBe(true)
      expect(result.status).toBe('pending')
      expect(result.taskId).toBeDefined()
      expect(typeof result.taskId).toBe('string')
    })

    it('should enqueue the task', () => {
      const deps = createMockDeps()
      const handler = new IncomingMessageHandler(createTestMessage(), deps)

      handler.executeAsync()

      const task = deps.messageQueue.dequeue()
      expect(task).not.toBeNull()
    })

    it('should store completed result in pendingTaskResults when task finishes', async () => {
      const deps = createMockDeps()
      const handler = new IncomingMessageHandler(createTestMessage(), deps)

      const result = handler.executeAsync()
      const taskId = result.taskId!

      // Dequeue and simulate completion via the overridden responseCallback
      const task = deps.messageQueue.dequeue()!
      await task.responseCallback!({ response: 'Async result' })

      const stored = deps.pendingTaskResults.get(taskId)
      expect(stored).toBeDefined()
      expect(stored!.status).toBe('completed')
      expect(stored!.response).toBe('Async result')
      expect(stored!.model).toBe('test-model')
    })

    it('should store approval notification in pendingTaskResults', async () => {
      const deps = createMockDeps()
      const handler = new IncomingMessageHandler(createTestMessage(), deps)

      const result = handler.executeAsync()
      const taskId = result.taskId!

      // Dequeue to get the task id for the approval event
      const task = deps.messageQueue.dequeue()!

      // Simulate approval event
      deps.agent.emit('tool:approval_needed', {
        data: {
          taskId: task.id,
          requestId: 'req-async-1',
          userId: 'user-1',
          notification: 'Approve async tool?',
        },
      })

      // Allow event to propagate
      await new Promise(r => setTimeout(r, 10))

      const stored = deps.pendingTaskResults.get(taskId)
      expect(stored).toBeDefined()
      expect(stored!.status).toBe('waiting_approval')
      expect(stored!.approval?.requestId).toBe('req-async-1')
      expect(stored!.approval?.notification).toBe('Approve async tool?')
    })

    // U5 — the stored async approval entry (polled via GET /tasks/:id/result →
    // handleTaskResult) must carry the connect_required discriminator so a
    // reconnecting desktop rebuilds the connect suspension. Event connect fields
    // taken from the REAL producer (T1).
    it('stores the connect_required discriminator in pendingTaskResults (async path)', async () => {
      const deps = createMockDeps()
      const handler = new IncomingMessageHandler(createTestMessage(), deps)

      const result = handler.executeAsync()
      const taskId = result.taskId!
      const task = deps.messageQueue.dequeue()!

      const approval = buildConnectRequiredApproval(
        { id: 'tc_1', name: 'monday__list_boards', arguments: { limit: 5 } },
        { mcpServerName: 'monday' }
      )
      deps.agent.emit('tool:approval_needed', {
        data: {
          taskId: task.id,
          requestId: approval.request_id,
          userId: 'user-1',
          notification: 'Connect monday to continue',
          reason: approval.reason,
          mcpServerName: approval.mcpServerName,
        },
      })

      await new Promise(r => setTimeout(r, 10))

      const stored = deps.pendingTaskResults.get(taskId)
      expect(stored).toBeDefined()
      expect(stored!.approval).toMatchObject({
        reason: 'connect_required',
        mcpServerName: 'monday',
      })
      expect(stored!.approval).not.toHaveProperty('provider')
    })

    it('stores a generic async approval without connect fields (back-compat)', async () => {
      const deps = createMockDeps()
      const handler = new IncomingMessageHandler(createTestMessage(), deps)

      const result = handler.executeAsync()
      const taskId = result.taskId!
      const task = deps.messageQueue.dequeue()!

      deps.agent.emit('tool:approval_needed', {
        data: {
          taskId: task.id,
          requestId: 'req-async-generic',
          userId: 'user-1',
          notification: 'Approve async tool?',
        },
      })

      await new Promise(r => setTimeout(r, 10))

      const stored = deps.pendingTaskResults.get(taskId)
      expect(stored!.approval).toBeDefined()
      expect(stored!.approval).not.toHaveProperty('reason')
      expect(stored!.approval).not.toHaveProperty('mcpServerName')
      expect(stored!.approval).not.toHaveProperty('provider')
    })
  })

  describe('approval cache invalidation', () => {
    it('clears the stored waiting_approval entry when approval is granted (executeAsync path)', async () => {
      const deps = createMockDeps()
      const handler = new IncomingMessageHandler(createTestMessage(), deps)

      const result = handler.executeAsync()
      const taskId = result.taskId!

      // Dequeue so the task is real
      deps.messageQueue.dequeue()

      // 1. Approval needed → entry stored
      deps.agent.emit('tool:approval_needed', {
        data: {
          taskId,
          requestId: 'req-stale-1',
          userId: 'user-1',
          notification: 'Approve thing?',
        },
      })
      await new Promise(r => setTimeout(r, 0))
      expect(deps.pendingTaskResults.get(taskId)?.status).toBe('waiting_approval')

      // 2. Approval granted → entry must be cleared, so that the next poll
      //    sees no entry (handleTaskResult returns 'pending' instead of stale
      //    waiting_approval).
      deps.agent.emit('tool:approval_granted', {
        data: {
          toolName: 'shell_exec',
          requestId: 'req-stale-1',
          userId: 'user-1',
          alwaysApprove: false,
          taskId,
        },
      })
      await new Promise(r => setTimeout(r, 0))
      expect(deps.pendingTaskResults.get(taskId)).toBeUndefined()
    })

    it('clears the stored waiting_approval entry when approval is denied (executeAsync path)', async () => {
      const deps = createMockDeps()
      const handler = new IncomingMessageHandler(createTestMessage(), deps)

      const result = handler.executeAsync()
      const taskId = result.taskId!
      deps.messageQueue.dequeue()

      deps.agent.emit('tool:approval_needed', {
        data: {
          taskId,
          requestId: 'req-stale-2',
          userId: 'user-1',
          notification: 'Approve thing?',
        },
      })
      await new Promise(r => setTimeout(r, 0))
      expect(deps.pendingTaskResults.get(taskId)?.status).toBe('waiting_approval')

      deps.agent.emit('tool:approval_denied', {
        data: {
          toolName: 'shell_exec',
          requestId: 'req-stale-2',
          userId: 'user-1',
          taskId,
        },
      })
      await new Promise(r => setTimeout(r, 0))
      expect(deps.pendingTaskResults.get(taskId)).toBeUndefined()
    })

    it('clears the entry stored after first resolve on the sync path (multi-approval staleness)', async () => {
      const deps = createMockDeps()
      const handler = new IncomingMessageHandler(createTestMessage(), deps)

      const resultPromise = handler.execute()
      await new Promise(r => setTimeout(r, 10))
      const task = deps.messageQueue.dequeue()!

      // First approval resolves the promise (sync path's first-resolve branch).
      deps.agent.emit('tool:approval_needed', {
        data: {
          taskId: task.id,
          requestId: 'req-sync-1',
          userId: 'user-1',
          notification: 'First approval?',
        },
      })
      await resultPromise

      // Second approval is stored to pendingTaskResults (this is the path that
      // the channel-reader's waitForTaskResult polls).
      deps.agent.emit('tool:approval_needed', {
        data: {
          taskId: task.id,
          requestId: 'req-sync-2',
          userId: 'user-1',
          notification: 'Second approval?',
        },
      })
      await new Promise(r => setTimeout(r, 0))
      expect(deps.pendingTaskResults.get(task.id)?.approval?.requestId).toBe('req-sync-2')

      // Granted → entry must be cleared so the next poll doesn't re-surface
      // the same notification.
      deps.agent.emit('tool:approval_granted', {
        data: {
          toolName: 'shell_exec',
          requestId: 'req-sync-2',
          userId: 'user-1',
          alwaysApprove: false,
          taskId: task.id,
        },
      })
      await new Promise(r => setTimeout(r, 0))
      expect(deps.pendingTaskResults.get(task.id)).toBeUndefined()
    })

    it('does not clear the entry for a different task (taskId routing)', async () => {
      const deps = createMockDeps()
      const handler = new IncomingMessageHandler(createTestMessage(), deps)

      const result = handler.executeAsync()
      const taskId = result.taskId!
      deps.messageQueue.dequeue()

      deps.agent.emit('tool:approval_needed', {
        data: {
          taskId,
          requestId: 'req-mine',
          userId: 'user-1',
          notification: 'Mine?',
        },
      })
      await new Promise(r => setTimeout(r, 0))

      // A granted event for a *different* task must not nuke our entry.
      deps.agent.emit('tool:approval_granted', {
        data: {
          toolName: 'shell_exec',
          requestId: 'req-someone-else',
          userId: 'user-2',
          alwaysApprove: false,
          taskId: 'some-other-task-id',
        },
      })
      await new Promise(r => setTimeout(r, 0))
      expect(deps.pendingTaskResults.get(taskId)?.status).toBe('waiting_approval')
    })
  })

  describe('SSE reporter ownership', () => {
    it('does not pre-register an SseProgressReporter — TaskExecutor owns construction', () => {
      // Single construction site: reporters are built by TaskExecutor.buildLoopConfig.
      // Any code path that pre-registers in messageHandler would drift from
      // taskExecutor's safety wiring (the bug fixed in 8919ec06 + the broader
      // soft-contract risk). Asserting NO pre-registration locks that in.
      const deps = createMockDeps()
      const handler = new IncomingMessageHandler(createTestMessage(), deps)
      const taskId = (handler as unknown as { task: { id: string } }).task.id
      expect(progressReporterRegistry.get(taskId)).toBeUndefined()
    })
  })
})

describe('interrupted attachment delivery', () => {
  it.each([false, true])(
    'keeps failure status and attachments in sync and async delivery (async=%s)',
    async asyncMode => {
      const deps = createMockDeps()
      const handler = new IncomingMessageHandler(createTestMessage(), deps)
      const pending = asyncMode ? Promise.resolve(handler.executeAsync()) : handler.execute()
      const task = deps.messageQueue.dequeue()!
      expect(task).not.toBeNull()
      const attachment = {
        id: 'result',
        kind: 'image' as const,
        mimeType: 'image/png',
        encoding: 'base64' as const,
        dataBase64: 'eA==',
      }
      const error = {
        code: 'TASK_ITERATION_LIMIT',
        message: 'Work interrupted',
        retryable: false,
        provider: 'openai',
      }
      await task.responseCallback!({ error, attachments: [attachment] })
      const inline = await pending
      const stored = deps.pendingTaskResults.get(task.id)
      expect(stored).toMatchObject({ status: 'failed', error, attachments: [attachment] })
      if (!asyncMode)
        expect(inline).toMatchObject({ success: false, error, attachments: [attachment] })
    }
  )
})