Skip to content

The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.

6.0 KB
Raw Blame
// The backend router client.
//
// Two things are pinned hard here. First, that EVERY failure comes back as null rather than throwing:
// this sits in front of a fallback ladder, and a router that can throw turns a backend hiccup into a
// lost turn. Second, that a 404 is one of those failures — the CLI self-updates from GCS while the
// backend ships on its own tags, so a machine will hold this build before the endpoint exists, and
// that machine must route exactly as it did yesterday.
import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest'

const readAuthSession = vi.hoisted(() => vi.fn())
const accessToken = vi.hoisted(() => vi.fn())
vi.mock('./authSession.js', () => ({
  readAuthSession,
  AuthSessionManager: class {
    accessToken = accessToken
  },
}))

import { rankAgents, routeApiBase, ROUTE_API_PATH } from './routeApi.js'

const agents = [
  { id: 'a1', name: 'Phones', prompts: ['iphone 17 gia bao nhieu'] },
  { id: 'a2', name: 'Frontend', prompts: [] },
]

const ask = (over: Partial<Parameters<typeof rankAgents>[0]> = {}) =>
  rankAgents({ task: 'so sanh iphone vs samsung', agents, budgetMs: 12_000, ...over })

/** One backend reply in the `{success, data}` envelope every route uses. */
const replies = (ranking: unknown, status = 200) =>
  vi.fn(async (_url: string, _init?: RequestInit) =>
    new Response(JSON.stringify({ success: status === 200, data: { ranking } }), {
      status,
      headers: { 'content-type': 'application/json' },
    }))

/** The RequestInit of the nth fetch this test made. */
const sent = (spy: ReturnType<typeof replies>, at = 0): RequestInit => spy.mock.calls[at][1] as RequestInit

describe('rankAgents', () => {
  beforeEach(() => {
    readAuthSession.mockReturnValue({ accessToken: 'raw', autonomousEnv: 'prod', computerId: 'c1' })
    accessToken.mockResolvedValue('fresh-token')
  })
  afterEach(() => vi.restoreAllMocks())

  it('returns the ranking', async () => {
    vi.stubGlobal('fetch', replies([
      { agentId: 'a1', score: 0.91, reason: 'phones' },
      { agentId: 'a2', score: 0.12, reason: 'no' },
    ]))
    expect(await ask()).toEqual([
      { agentId: 'a1', score: 0.91, reason: 'phones' },
      { agentId: 'a2', score: 0.12, reason: 'no' },
    ])
  })

  it('sends the REFRESHED token, not the one on disk', async () => {
    // A daemon that has been up for a week is holding an expired access token in its session file.
    const spy = replies([{ agentId: 'a1', score: 1 }])
    vi.stubGlobal('fetch', spy)
    await ask()
    const headers = sent(spy).headers as Record<string, string>
    expect(headers.authorization).toBe('Bearer fresh-token')
    expect(headers['x-autonomous-env']).toBe('prod')
  })

  it('sends the prompts as sent, empty list included', async () => {
    const spy = replies([{ agentId: 'a1', score: 1 }])
    vi.stubGlobal('fetch', spy)
    await ask()
    const body = JSON.parse(sent(spy).body as string)
    expect(body.agents).toEqual(agents)
    expect(body.task).toBe('so sanh iphone vs samsung')
  })

  it('asks the backend for LESS time than the caller has', async () => {
    // Equal deadlines make it a coin toss which fires first, and if the caller's wins the fallback
    // ladder never runs at all.
    const spy = replies([{ agentId: 'a1', score: 1 }])
    vi.stubGlobal('fetch', spy)
    await ask({ budgetMs: 12_000 })
    const body = JSON.parse(sent(spy).body as string)
    expect(body.budgetMs).toBeLessThan(12_000)
  })

  it('passes continuity only when it was given', async () => {
    const spy = replies([{ agentId: 'a1', score: 1 }])
    vi.stubGlobal('fetch', spy)
    await ask({ continuity: { agentId: 'a2', agoMs: 4_000 } })
    expect(JSON.parse(sent(spy).body as string).continuity)
      .toEqual({ agentId: 'a2', agoMs: 4_000 })
    vi.stubGlobal('fetch', spy)
    await ask()
    expect(JSON.parse(sent(spy, 1).body as string).continuity).toBeUndefined()
  })

  it('is null on 404 — the endpoint may simply not be deployed yet', async () => {
    vi.stubGlobal('fetch', replies(null, 404))
    expect(await ask()).toBeNull()
  })

  it('is null on 500', async () => {
    vi.stubGlobal('fetch', replies(null, 500))
    expect(await ask()).toBeNull()
  })

  it('is null when the machine is offline, and does not throw', async () => {
    vi.stubGlobal('fetch', vi.fn(async () => { throw new Error('ENOTFOUND') }))
    await expect(ask()).resolves.toBeNull()
  })

  it('is null when nobody is signed in', async () => {
    readAuthSession.mockReturnValue(null)
    const spy = replies([{ agentId: 'a1', score: 1 }])
    vi.stubGlobal('fetch', spy)
    expect(await ask()).toBeNull()
    expect(spy).not.toHaveBeenCalled()
  })

  it('is null when the token cannot be refreshed', async () => {
    accessToken.mockRejectedValue(new Error('refresh refused'))
    vi.stubGlobal('fetch', replies([{ agentId: 'a1', score: 1 }]))
    await expect(ask()).resolves.toBeNull()
  })

  it('drops a row naming an agent this daemon does not have', async () => {
    // The endpoint filters too, but THIS process is the one that will dispatch on the answer.
    vi.stubGlobal('fetch', replies([
      { agentId: 'ghost', score: 0.99 },
      { agentId: 'a2', score: 0.4 },
    ]))
    expect(await ask()).toEqual([{ agentId: 'a2', score: 0.4, reason: '' }])
  })

  it('is null when every row was dropped', async () => {
    vi.stubGlobal('fetch', replies([{ agentId: 'ghost', score: 0.99 }]))
    expect(await ask()).toBeNull()
  })

  it('is null when the body is not a ranking at all', async () => {
    vi.stubGlobal('fetch', vi.fn(async () => new Response('not json', { status: 200 })))
    expect(await ask()).toBeNull()
  })

  it('clamps a score outside 0..1 rather than trusting it', async () => {
    vi.stubGlobal('fetch', replies([{ agentId: 'a1', score: 7 }]))
    expect((await ask())?.[0].score).toBe(1)
  })
})

describe('routeApiBase', () => {
  it('is the websocket host over https', () => {
    expect(routeApiBase()).toMatch(/^https?:\/\//)
    expect(routeApiBase()).not.toMatch(/\/$/)
  })
  it('names the agreed path', () => expect(ROUTE_API_PATH).toBe('/api/route/agents'))
})