Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure
TypeScript
import { beforeEach, describe, expect, it, vi } from 'vitest'
import express, { type NextFunction, type Request, type Response } from 'express'
import request from 'supertest'
import {
GrokProviderAttemptFinalizeError,
type GrokProviderAttemptFinalizeErrorCode,
} from '../src/services/grokProviderAttemptFinalization.js'
import {
GrokProviderAttemptRedeemError,
type GrokProviderAttemptRedeemErrorCode,
} from '../src/services/grokProviderAttemptRedemption.js'
import { LlmProviderAttemptRedeemError } from '../src/services/llmProviderAttemptRedemption.js'
const services = vi.hoisted(() => ({
redeemGrok: vi.fn(),
finalizeGrok: vi.fn(),
redeemCodex: vi.fn(),
finalizeCodex: vi.fn(),
}))
vi.mock('../src/services/grokProviderAttemptRedemption.js', async () => ({
...(await vi.importActual('../src/services/grokProviderAttemptRedemption.js')),
redeemGrokProviderAttempt: services.redeemGrok,
}))
vi.mock('../src/services/grokProviderAttemptFinalization.js', async () => ({
...(await vi.importActual('../src/services/grokProviderAttemptFinalization.js')),
finalizeGrokProviderAttempt: services.finalizeGrok,
}))
vi.mock('../src/services/llmProviderAttemptRedemption.js', async () => ({
...(await vi.importActual('../src/services/llmProviderAttemptRedemption.js')),
redeemLlmProviderAttempt: services.redeemCodex,
}))
vi.mock('../src/services/llmProviderAttemptFinalization.js', async () => ({
...(await vi.importActual('../src/services/llmProviderAttemptFinalization.js')),
finalizeLlmProviderAttempt: services.finalizeCodex,
}))
vi.mock('../src/db.js', () => ({ pool: { query: vi.fn() }, withTransaction: vi.fn() }))
const { createInternalLlmProviderAttemptRoutes } =
await import('../src/routes/internal/llmProviderAttempts.js')
const REDEEM = '/internal/llm/grok/provider-attempts/redeem'
const FINALIZE = '/internal/llm/grok/provider-attempts/finalize'
/** The ConfigMap writer the gateway hands the routes; the cluster is outside this process. */
const materializer = { materialize: vi.fn(async () => {}) }
/** Stand-in for internalServiceAuth: the header names the authenticated caller. */
function makeApp() {
const app = express()
app.use(express.json())
app.use((req: Request, _res: Response, next: NextFunction) => {
const service = req.header('x-test-service')
if (service) {
;(req as Request & { internalService?: { name: string } }).internalService = {
name: service,
}
}
next()
})
app.use(createInternalLlmProviderAttemptRoutes(materializer))
app.use((err: unknown, _req: Request, res: Response, _next: NextFunction) => {
res.status(500).json({ error: 'internal', name: (err as Error)?.name })
})
return app
}
describe('internal Grok provider-attempt routes', () => {
beforeEach(() => {
for (const fn of Object.values(services)) fn.mockReset()
materializer.materialize.mockClear()
})
describe('service identity', () => {
it.each([
[REDEEM, undefined],
[REDEEM, 'codex-llm-proxy'],
[FINALIZE, undefined],
[FINALIZE, 'codex-llm-proxy'],
])('rejects %s for caller %s', async (path, service) => {
const req = request(makeApp()).post(path).send({})
const res = await (service ? req.set('x-test-service', service) : req)
expect(res.status).toBe(401)
expect(services.redeemGrok).not.toHaveBeenCalled()
expect(services.finalizeGrok).not.toHaveBeenCalled()
})
it('does not let the Grok proxy reach the Codex redeem route', async () => {
const res = await request(makeApp())
.post('/internal/llm/provider-attempts/redeem')
.set('x-test-service', 'grok-llm-proxy')
.send({ executionTicket: 't', requestHash: 'h' })
expect(res.status).toBe(401)
expect(services.redeemCodex).not.toHaveBeenCalled()
})
})
describe('redeem', () => {
it('passes only typed fields and defaults the operation', async () => {
services.redeemGrok.mockResolvedValue({ accessToken: 'access', attemptReceipt: 'r' })
const res = await request(makeApp())
.post(REDEEM)
.set('x-test-service', 'grok-llm-proxy')
.send({
executionTicket: 'ticket',
requestHash: 'a'.repeat(64),
model: 'grok-4.6',
hostRef: 7,
operation: 'drop_tables',
})
expect(res.status).toBe(200)
expect(services.redeemGrok).toHaveBeenCalledWith(
{
executionTicket: 'ticket',
requestHash: 'a'.repeat(64),
model: 'grok-4.6',
hostRef: undefined,
operation: 'completion_stream',
},
expect.objectContaining({ publishAllowlist: expect.any(Function) })
)
expect(services.redeemCodex).not.toHaveBeenCalled()
})
it.each([
['grok-llm-proxy', REDEEM, services.redeemGrok],
['codex-llm-proxy', '/internal/llm/provider-attempts/redeem', services.redeemCodex],
] as const)(
'R9-19 hands the %s redemption a publish bound to the gateway ConfigMap writer',
async (service, path, redeem) => {
redeem.mockResolvedValue({ accessToken: 'access', attemptReceipt: 'r' })
const res = await request(makeApp())
.post(path)
.set('x-test-service', service)
.send({ executionTicket: 'ticket', requestHash: 'h' })
expect(res.status).toBe(200)
expect(redeem).toHaveBeenCalledTimes(1)
const deps = redeem.mock.calls[0]?.[1] as { publishAllowlist: () => Promise<void> }
expect(materializer.materialize).not.toHaveBeenCalled()
await deps.publishAllowlist()
expect(materializer.materialize).toHaveBeenCalledTimes(1)
}
)
const redeemStatus: Array<[GrokProviderAttemptRedeemErrorCode, number]> = [
['disabled', 404],
['ticket_invalid', 403],
['ticket_replayed', 409],
['ticket_expired', 403],
['request_hash_mismatch', 403],
['connection_unavailable', 503],
['no_grant', 403],
['provider_unavailable', 503],
]
it.each(redeemStatus)('maps redeem error %s to %i', async (code, status) => {
services.redeemGrok.mockRejectedValue(
new GrokProviderAttemptRedeemError(code, 'detail with access-secret')
)
const res = await request(makeApp())
.post(REDEEM)
.set('x-test-service', 'grok-llm-proxy')
.send({ executionTicket: 'ticket', requestHash: 'h' })
expect(res.status).toBe(status)
expect(res.body).toEqual({ error: code })
})
it('does not translate a Codex redeem error thrown on the Grok route', async () => {
services.redeemGrok.mockRejectedValue(new LlmProviderAttemptRedeemError('no_grant', 'codex'))
const res = await request(makeApp())
.post(REDEEM)
.set('x-test-service', 'grok-llm-proxy')
.send({ executionTicket: 'ticket', requestHash: 'h' })
expect(res.status).toBe(500)
})
})
describe('finalize', () => {
const finalizeStatus: Array<[GrokProviderAttemptFinalizeErrorCode, number]> = [
['disabled', 404],
['ticket_invalid', 403],
['request_hash_mismatch', 403],
['invalid_receipt', 400],
['conflict', 409],
]
it.each(finalizeStatus)('maps finalize error %s to %i', async (code, status) => {
services.finalizeGrok.mockRejectedValue(new GrokProviderAttemptFinalizeError(code, 'detail'))
const res = await request(makeApp())
.post(FINALIZE)
.set('x-test-service', 'grok-llm-proxy')
.send({ attemptReceipt: 'a'.repeat(64), receipt: {} })
expect(res.status).toBe(status)
expect(res.body).toEqual({ error: code })
expect(services.finalizeCodex).not.toHaveBeenCalled()
})
it('forwards a non-string attemptReceipt as empty and returns the result', async () => {
services.finalizeGrok.mockResolvedValue({
providerAttemptId: 'attempt-1',
outcome: 'success',
duplicate: false,
})
const receipt = { schemaVersion: 'grok-attempt-receipt.v1' }
const res = await request(makeApp())
.post(FINALIZE)
.set('x-test-service', 'grok-llm-proxy')
.send({ attemptReceipt: 42, receipt })
expect(res.status).toBe(200)
expect(res.body).toEqual({
providerAttemptId: 'attempt-1',
outcome: 'success',
duplicate: false,
})
expect(services.finalizeGrok).toHaveBeenCalledWith({ attemptReceipt: '', receipt })
})
})
})