Files
orca/src/main/runtime/structured-agent-session-codex-scripted-child.test.ts
T

217 lines
8.0 KiB
TypeScript

import { mkdtemp, rm } from 'node:fs/promises'
import { tmpdir } from 'node:os'
import { join } from 'node:path'
import { afterEach, expect, it, vi } from 'vitest'
import { codexScriptedChild } from '../codex/codex-scripted-child.test-fixture'
import { computeAgentSessionPayloadFingerprint } from '../../shared/agent-session-mutation-envelope'
import {
HOST_TEST_SESSION,
hostTestAttachParams,
hostTestMessage
} from '../native-chat/agent-session-wire/structured-agent-session-host-test-data'
import { createStructuredAgentSessionLogger } from '../native-chat/agent-session-wire/structured-agent-session-logger'
import type { ScriptedAgentChild } from './structured-agent-scripted-child.test-fixture'
import {
ensureStructuredAgentSessionHost,
stopStructuredAgentSessionRuntime
} from './structured-agent-session-runtime'
let root: string | undefined
const caller = { callerKey: 'scripted-codex-test' }
let operation = 0
function envelope(method: string, fence: number, fields: Record<string, unknown>) {
return {
sessionId: HOST_TEST_SESSION,
clientOperationId: `${Date.now()}-${(++operation).toString(16).padStart(32, '0')}`,
expectedRuntimeFence: fence,
payloadFingerprint: computeAgentSessionPayloadFingerprint({
method,
sessionId: HOST_TEST_SESSION,
fields
})
}
}
afterEach(async () => {
await stopStructuredAgentSessionRuntime()
if (root) {
await rm(root, { recursive: true, force: true })
}
})
async function attachedHost(child: ScriptedAgentChild) {
root = await mkdtemp(join(tmpdir(), 'orca-scripted-codex-'))
const host = await ensureStructuredAgentSessionHost({
logger: createStructuredAgentSessionLogger(),
stateDirectory: root,
hostId: 'local',
claimKeyId: 'key-1',
resolveWorkspacePath: async () => root ?? '',
resolveClaudeAuthPolicy: () => ({ account: 'managed' }),
resolveLaunchArgs: () => [],
...child.deps
})
const attach = hostTestAttachParams(null, { providerHandle: undefined })
attach.envelope.clientOperationId = `${Date.now()}-${'b'.repeat(32)}`
const attached = await host.attach(caller, attach)
if (!attached.ok) {
throw new Error(JSON.stringify(attached.refusal))
}
return { host, fence: attached.value.fence }
}
it('attaches at spawn and holds sends until the scripted Codex handshake answers', async () => {
const child = codexScriptedChild()
const { host, fence } = await attachedHost(child)
const body = hostTestMessage('held until Codex is ready')
const sent = await host.send(caller, {
envelope: envelope('agentSession.send', fence, { body }),
body
})
expect(sent.ok).toBe(true)
expect(child.spawns()).toBe(1)
expect(host.deps.store.getRecord(HOST_TEST_SESSION)?.lease.ownerProcess).toMatchObject({
pid: expect.any(Number),
spawnToken: expect.any(String)
})
expect(child.prompts()).toEqual([])
child.releaseHandshake()
await vi.waitFor(() => expect(child.prompts()).toEqual(['held until Codex is ready']))
})
it('ends a running Codex child on Stop and resumes its thread for the next send', async () => {
const child = codexScriptedChild()
child.holdHandshakes = false
child.completeTurns = false
const { host, fence } = await attachedHost(child)
const body = hostTestMessage('first turn')
expect(
(await host.send(caller, { envelope: envelope('agentSession.send', fence, { body }), body })).ok
).toBe(true)
await vi.waitFor(() => expect(child.prompts()).toEqual(['first turn']))
expect(
(await host.cancel(caller, { envelope: envelope('agentSession.cancel', fence, {}) })).ok
).toBe(true)
await host.collaboratorsForTests().serialize(HOST_TEST_SESSION, async () => {})
expect(child.closes()).toBe(1)
const next = hostTestMessage('next turn')
expect(
(
await host.send(caller, {
envelope: envelope('agentSession.send', fence, { body: next }),
body: next
})
).ok
).toBe(true)
await vi.waitFor(() => expect(child.prompts()).toEqual(['first turn', 'next turn']))
expect(child.spawns()).toBe(2)
expect(child.resumes()).toBe(1)
})
it('can Stop the scripted child during initialization and settle a held send as withdrawn', async () => {
const child = codexScriptedChild()
const { host, fence } = await attachedHost(child)
const body = hostTestMessage('never handed over')
const sent = await host.send(caller, {
envelope: envelope('agentSession.send', fence, { body }),
body
})
if (!sent.ok) {
throw new Error(JSON.stringify(sent.refusal))
}
expect(
(await host.cancel(caller, { envelope: envelope('agentSession.cancel', fence, {}) })).ok
).toBe(true)
await host.collaboratorsForTests().serialize(HOST_TEST_SESSION, async () => {})
expect(child.closes()).toBe(1)
expect(child.prompts()).toEqual([])
const { submissions } = await host.journalSnapshot(HOST_TEST_SESSION)
expect(
submissions.find((entry) => entry.clientMessageId === sent.value.clientMessageId)?.dispatchState
).toBe('rejected')
})
it('hands Codex a model and effort picked while it started before the first message', async () => {
const child = codexScriptedChild()
const { host, fence } = await attachedHost(child)
const picks = (
[
['model', 'scripted-alt-model'],
['effort', 'high']
] as const
).map(([key, value]) => {
const fields = { key, value }
return host.setOption(caller, {
envelope: envelope('agentSession.setOption', fence, fields),
...fields
})
})
const body = hostTestMessage('first message')
const sent = host.send(caller, { envelope: envelope('agentSession.send', fence, { body }), body })
child.releaseHandshake()
expect(await Promise.all(picks)).toEqual([
expect.objectContaining({ ok: true }),
expect.objectContaining({ ok: true })
])
expect((await sent).ok).toBe(true)
await vi.waitFor(() => expect(child.prompts()).toEqual(['first message']))
const turn = child.requests().find(({ method }) => method === 'turn/start')
expect(turn?.params).toMatchObject({ model: 'scripted-alt-model', effort: 'high' })
expect(host.deps.store.getRecord(HOST_TEST_SESSION)?.options).toMatchObject({
model: 'scripted-alt-model',
effort: 'high'
})
})
it('rejects a held send once when Codex initialization refuses and closes the child once', async () => {
const child = codexScriptedChild()
const { host, fence } = await attachedHost(child)
const body = hostTestMessage('never delivered')
const sent = await host.send(caller, {
envelope: envelope('agentSession.send', fence, { body }),
body
})
if (!sent.ok) {
throw new Error(JSON.stringify(sent.refusal))
}
await vi.waitFor(() =>
expect(child.requests().some((request) => request.method === 'initialize')).toBe(true)
)
child.failHandshake('Please sign in to Codex')
await vi.waitFor(async () => {
const { submissions } = await host.journalSnapshot(HOST_TEST_SESSION)
const rejected = submissions.filter(
(entry) => entry.clientMessageId === sent.value.clientMessageId
)
expect(rejected).toHaveLength(1)
expect(rejected[0]?.dispatchState).toBe('rejected')
})
expect(child.closes()).toBe(1)
expect(child.spawns()).toBe(1)
expect(child.prompts()).toEqual([])
})
it('stops while thread/start is held and never hands over the accepted send', async () => {
const thread = Promise.withResolvers<unknown>()
const child = codexScriptedChild({ 'thread/start': () => thread.promise })
child.holdHandshakes = false
const { host, fence } = await attachedHost(child)
const body = hostTestMessage('never delivered')
const sent = await host.send(caller, {
envelope: envelope('agentSession.send', fence, { body }),
body
})
expect(sent.ok).toBe(true)
await vi.waitFor(() =>
expect(child.requests().some((request) => request.method === 'thread/start')).toBe(true)
)
expect(
(await host.cancel(caller, { envelope: envelope('agentSession.cancel', fence, {}) })).ok
).toBe(true)
thread.resolve({ thread: { id: 'scripted-codex-thread' } })
await host.collaboratorsForTests().serialize(HOST_TEST_SESSION, async () => {})
expect(child.closes()).toBe(1)
expect(child.prompts()).toEqual([])
})