Skip to content

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

TypeScript
3.6 KB
Raw Blame
import { describe, expect, it, vi } from 'vitest'
import type { AddressInfo } from 'net'
import type { RPCServer } from '../server'
import type { HostActivityEvent } from '../server/types'

async function startServer(
  configure: (server: RPCServer) => void
): Promise<{ server: RPCServer; baseUrl: string }> {
  process.env.CLERUM_ENABLE_AUTH = 'false'
  process.env.CLERUM_HOST_NAME = 'chatllm'
  vi.resetModules()
  // config reads auth settings at module load, so import after the test env is set.
  const { RPCServer } = await import('../server')
  const server = new RPCServer(0)
  configure(server)
  await server.start()
  const address = (server as any).server.address() as AddressInfo
  return { server, baseUrl: `http://127.0.0.1:${address.port}` }
}

const rpcEdgeHeaders = {
  'x-clerum-edge-caller': 'rpc-proxy',
  'x-clerum-edge-host-ref': 'chatllm',
  'x-clerum-edge-user-id': 'user-1',
}

describe('RPCServer activity routes', () => {
  it('serves activity snapshot with limit/sinceEventId', async () => {
    const events: HostActivityEvent[] = [
      {
        version: '1.0',
        eventId: 'evt_0000000001',
        hostRef: 'chatllm',
        ts: new Date().toISOString(),
        type: 'task.queued',
        title: 'queued',
        severity: 'info',
        meta: {},
        redactions: [],
      },
      {
        version: '1.0',
        eventId: 'evt_0000000002',
        hostRef: 'chatllm',
        ts: new Date().toISOString(),
        type: 'task.started',
        title: 'started',
        severity: 'info',
        meta: {},
        redactions: [],
      },
    ]

    const { server, baseUrl } = await startServer(rpcServer => {
      rpcServer.onActivitySnapshot(async (limit, sinceEventId) => ({
        hostRef: 'chatllm',
        version: '1.0',
        items: events.filter(event => !sinceEventId || event.eventId > sinceEventId).slice(-limit),
        nextCursor: 'evt_0000000002',
      }))
    })

    try {
      const response = await fetch(
        `${baseUrl}/v1/runtime/activity?limit=1&sinceEventId=evt_0000000001`,
        { headers: rpcEdgeHeaders }
      )
      expect(response.status).toBe(200)
      const body = (await response.json()) as { items: HostActivityEvent[] }
      expect(body.items).toHaveLength(1)
      expect(body.items[0]?.eventId).toBe('evt_0000000002')
    } finally {
      await server.stop()
    }
  })

  it('streams open/activity/closed SSE events', async () => {
    let subscriber: ((event: HostActivityEvent) => void) | null = null
    const { server, baseUrl } = await startServer(rpcServer => {
      rpcServer.onActivityStream(onEvent => {
        subscriber = onEvent
        return { hostRef: 'chatllm', unsubscribe: () => undefined }
      })
    })

    try {
      const response = await fetch(`${baseUrl}/v1/runtime/activity/stream`, {
        headers: rpcEdgeHeaders,
      })
      expect(response.status).toBe(200)
      const streamCallback = subscriber as ((event: HostActivityEvent) => void) | null
      if (streamCallback) {
        streamCallback({
          version: '1.0',
          eventId: 'evt_0000000003',
          hostRef: 'chatllm',
          ts: new Date().toISOString(),
          type: 'task.completed',
          title: 'done',
          severity: 'info',
          meta: {},
          redactions: [],
        })
      }
      const reader = response.body?.getReader()
      expect(reader).toBeTruthy()
      const first = await reader!.read()
      const chunk = new TextDecoder().decode(first.value || new Uint8Array())
      expect(chunk.includes('event: open') || chunk.includes('event: activity')).toBe(true)
      await reader?.cancel()
    } finally {
      await server.stop()
    }
  })
})