259 lines
10 KiB
TypeScript
259 lines
10 KiB
TypeScript
import { describe, expect, it, vi } from 'vitest'
|
|
import { Context, type Fiber } from 'cordis'
|
|
import LlmService from '@deepseek-ai/dsh-llm'
|
|
import SessionStore from '@deepseek-ai/dsh-session'
|
|
import SystemPrompt from '@deepseek-ai/dsh-system-prompt'
|
|
import ToolRegistry from '@deepseek-ai/dsh-tools'
|
|
import AgentRegistry, { AgentId, type Agent } from '@deepseek-ai/dsh-agent'
|
|
import AgentLoop from '@deepseek-ai/dsh-agent-loop'
|
|
import * as Invariants from '@deepseek-ai/dsh-invariants'
|
|
import SubagentService from '@deepseek-ai/dsh-subagent'
|
|
import { MockAdapter, textResponse } from '../../../core/agent-loop/tests/mock-adapter.ts'
|
|
import { depthOf, SubagentDepthError, startInProcessRun } from '../src/index.ts'
|
|
|
|
type Script = ConstructorParameters<typeof MockAdapter>[0]
|
|
|
|
/**
|
|
* Drives the shared in-process run driver DIRECTLY (no provider package), so the
|
|
* driver's own contract — depth read/cap, the one-shot drive, the result read —
|
|
* is covered independently of which backend (spawn/fork) calls it. The only
|
|
* mocked boundary is the model; the real agent loop, SubagentService, and
|
|
* dsh-invariants are mounted, so a malformed child session log fails the test.
|
|
*/
|
|
async function setup(script: Script) {
|
|
const ctx = new Context()
|
|
await ctx.plugin(LlmService)
|
|
await ctx.plugin(SessionStore)
|
|
await ctx.plugin(SystemPrompt)
|
|
await ctx.plugin(ToolRegistry)
|
|
await ctx.plugin(AgentRegistry)
|
|
await ctx.plugin(Invariants)
|
|
await ctx.plugin(AgentLoop, { agents: [] })
|
|
await ctx.plugin(SubagentService)
|
|
ctx.llm.registerAdapter(['mock'], new MockAdapter(script))
|
|
const parent = ctx.agentLoop.create(AgentId('parent'), { model: 'mock' })
|
|
return { ctx, parent }
|
|
}
|
|
|
|
function text(blocks: { type: string; text?: string }[]): string {
|
|
return blocks.filter(b => b.type === 'text').map(b => b.text).join('')
|
|
}
|
|
|
|
describe('depthOf', () => {
|
|
it('reads 0 for an agent with no subagentDepth, the set value otherwise', async () => {
|
|
const { parent } = await setup([])
|
|
expect(depthOf(parent)).toBe(0)
|
|
const withDepth = { options: { subagentDepth: 3 } } as unknown as Agent
|
|
expect(depthOf(withDepth)).toBe(3)
|
|
})
|
|
})
|
|
|
|
describe('startInProcessRun', () => {
|
|
it('rejects a non-JSON prompt before acquiring any run ownership', async () => {
|
|
const { ctx, parent } = await setup([])
|
|
expect(() => startInProcessRun(ctx, {
|
|
prompt: [{ type: 'text', text: Number.NaN as unknown as string }],
|
|
parent,
|
|
}, {})).toThrow('subagent prompt must be losslessly JSON-serializable')
|
|
})
|
|
|
|
it('rejects a prompt whose getter becomes non-JSON while it is snapshotted', async () => {
|
|
const { ctx, parent } = await setup([])
|
|
let reads = 0
|
|
const prompt = [{
|
|
type: 'text' as const,
|
|
get text(): string {
|
|
reads += 1
|
|
return reads === 1 ? 'valid during pre-check' : Number.NaN as unknown as string
|
|
},
|
|
}]
|
|
|
|
expect(() => startInProcessRun(ctx, { prompt, parent }, {}))
|
|
.toThrow('subagent prompt must be stable losslessly JSON-serializable data')
|
|
expect(reads).toBe(2)
|
|
})
|
|
|
|
it('rejects when the run-owner fiber settles without installing its context', async () => {
|
|
const { ctx, parent } = await setup([])
|
|
function inertOwner(): void {}
|
|
const inertFiber = ctx.plugin(inertOwner)
|
|
await inertFiber
|
|
const parentWithoutOwnerContext = {
|
|
options: parent.options,
|
|
session: parent.session,
|
|
ctx: { plugin: () => inertFiber },
|
|
} as unknown as Agent
|
|
|
|
const run = startInProcessRun(ctx, {
|
|
prompt: [{ type: 'text', text: 'must never start' }],
|
|
parent: parentWithoutOwnerContext,
|
|
}, {})
|
|
await expect(run.result).rejects.toThrow('subagent run owner became inactive before child creation')
|
|
await run.dispose()
|
|
})
|
|
|
|
it('normalizes a non-Error thrown while installing the run-owner fiber', async () => {
|
|
const { ctx, parent } = await setup([])
|
|
const setupFailure = 'non-Error owner setup failure'
|
|
const parentWithFailingOwnerSetup = {
|
|
options: parent.options,
|
|
session: parent.session,
|
|
ctx: { plugin: () => { throw setupFailure } },
|
|
} as unknown as Agent
|
|
|
|
const run = startInProcessRun(ctx, {
|
|
prompt: [{ type: 'text', text: 'must never start' }],
|
|
parent: parentWithFailingOwnerSetup,
|
|
}, {})
|
|
await expect(run.result).rejects.toMatchObject({
|
|
message: 'subagent run owner setup failed with a non-Error value',
|
|
cause: setupFailure,
|
|
})
|
|
await run.dispose()
|
|
})
|
|
|
|
it('normalizes a non-Error rejected by asynchronous child creation', async () => {
|
|
const { ctx, parent } = await setup([])
|
|
const creationFailure = 'non-Error child creation failure'
|
|
function inertOwner(): void {}
|
|
const ownerFiber = ctx.plugin(inertOwner)
|
|
await ownerFiber
|
|
const rejectWithNonError = (): Promise<never> => {
|
|
// Deliberately violate the promise contract to exercise boundary normalization.
|
|
// eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
|
|
return Promise.reject(creationFailure)
|
|
}
|
|
const rejectingOwnerCtx = {
|
|
agents: { create: rejectWithNonError },
|
|
} as unknown as Context
|
|
const parentWithRejectingFactory = {
|
|
options: parent.options,
|
|
session: parent.session,
|
|
ctx: {
|
|
plugin(plugin: (inner: Context) => void) {
|
|
plugin(rejectingOwnerCtx)
|
|
return ownerFiber
|
|
},
|
|
},
|
|
} as unknown as Agent
|
|
|
|
const run = startInProcessRun(ctx, {
|
|
prompt: [{ type: 'text', text: 'must never start' }],
|
|
parent: parentWithRejectingFactory,
|
|
}, {})
|
|
await expect(run.result).rejects.toMatchObject({
|
|
message: 'subagent child creation failed with a non-Error value',
|
|
cause: creationFailure,
|
|
})
|
|
await run.dispose()
|
|
})
|
|
|
|
it('follows owner-fiber inertia when raw teardown was already in flight', async () => {
|
|
const { ctx, parent } = await setup([])
|
|
const gate = Promise.withResolvers<undefined>()
|
|
let inertia: Promise<undefined> | undefined = gate.promise
|
|
const fakeFiber = {
|
|
dispose: vi.fn(() => undefined),
|
|
get inertia() { return inertia },
|
|
} as unknown as Fiber & PromiseLike<Fiber>
|
|
const rejectingOwnerCtx = {
|
|
agents: { create: () => Promise.reject(new Error('creation stopped by teardown')) },
|
|
} as unknown as Context
|
|
const parentWithDisposingOwner = {
|
|
options: parent.options,
|
|
session: parent.session,
|
|
ctx: {
|
|
plugin(plugin: (inner: Context) => void) {
|
|
plugin(rejectingOwnerCtx)
|
|
return fakeFiber
|
|
},
|
|
},
|
|
} as unknown as Agent
|
|
const run = startInProcessRun(ctx, {
|
|
prompt: [{ type: 'text', text: 'must never start' }],
|
|
parent: parentWithDisposingOwner,
|
|
}, {})
|
|
|
|
let settled = false
|
|
const disposing = run.dispose().then(() => { settled = true })
|
|
await Promise.resolve()
|
|
await Promise.resolve()
|
|
expect(fakeFiber.dispose).toHaveBeenCalledOnce()
|
|
expect(settled).toBe(false)
|
|
|
|
inertia = undefined
|
|
gate.resolve(undefined)
|
|
await disposing
|
|
await expect(run.result).resolves.toEqual({ output: [], stopReason: 'aborted' })
|
|
})
|
|
|
|
it('does not attach an abort listener when provider ownership is already inactive', async () => {
|
|
const { ctx, parent } = await setup([])
|
|
let providerCtx: Context | undefined
|
|
function provider(inner: Context): void { providerCtx = inner }
|
|
const providerFiber = await ctx.plugin(provider)
|
|
await providerFiber.dispose()
|
|
if (providerCtx === undefined) throw new Error('provider context was not captured')
|
|
const inactiveProviderCtx = providerCtx
|
|
|
|
const controller = new AbortController()
|
|
const addListener = vi.spyOn(controller.signal, 'addEventListener')
|
|
expect(() => startInProcessRun(inactiveProviderCtx, {
|
|
prompt: [{ type: 'text', text: 'must never start' }],
|
|
parent,
|
|
signal: controller.signal,
|
|
}, {})).toThrow(/inactive context/)
|
|
expect(addListener).not.toHaveBeenCalled()
|
|
})
|
|
|
|
it('drives a fresh child (no seed) to completion and returns its output', async () => {
|
|
const { ctx, parent } = await setup([textResponse('driver child answer')])
|
|
const run = startInProcessRun(ctx, { prompt: [{ type: 'text', text: 'do X' }], parent }, {})
|
|
const result = await run.result
|
|
expect(result.stopReason).toBe('completed')
|
|
expect(text(result.output)).toBe('driver child answer')
|
|
expect(depthOf(ctx.agents.get(run.id)!)).toBe(1)
|
|
await run.dispose()
|
|
})
|
|
|
|
it('snapshots the prompt before asynchronous child creation', async () => {
|
|
const { ctx, parent } = await setup([textResponse('done')])
|
|
const prompt = [{ type: 'text' as const, text: 'original prompt' }]
|
|
const run = startInProcessRun(ctx, { prompt, parent }, {})
|
|
|
|
prompt[0]!.text = 'mutated after start'
|
|
prompt.push({ type: 'text', text: 'also injected' })
|
|
await run.result
|
|
|
|
const child = ctx.agents.get(run.id)!
|
|
const userMessage = child.session.events.find(event => event.type === 'user/message')
|
|
expect(userMessage?.type === 'user/message' && userMessage.data.content)
|
|
.toEqual([{ type: 'text', text: 'original prompt' }])
|
|
await run.dispose()
|
|
})
|
|
|
|
it('throws SubagentDepthError when the child would exceed maxDepth', async () => {
|
|
const { ctx, parent } = await setup([])
|
|
expect(() => startInProcessRun(ctx, { prompt: [{ type: 'text', text: 'p' }], parent, maxDepth: 0 }, {}))
|
|
.toThrow(SubagentDepthError)
|
|
})
|
|
|
|
it('seeds the child session when a seed is supplied', async () => {
|
|
// Drive the parent through one real turn, then seed the child with that
|
|
// completed-turn prefix — the child must SEE the parent's history but its
|
|
// result is scoped to its OWN events (not the seeded parent message).
|
|
const { ctx, parent } = await setup([textResponse('parent turn'), textResponse('seeded child reply')])
|
|
parent.send([{ type: 'text', text: 'parent q' }])
|
|
await parent.whenIdle()
|
|
const seed = parent.session.events.slice()
|
|
const run = startInProcessRun(ctx, { prompt: [{ type: 'text', text: 'child q' }], parent }, { seed })
|
|
const result = await run.result
|
|
expect(result.stopReason).toBe('completed')
|
|
expect(text(result.output)).toBe('seeded child reply')
|
|
const child = ctx.agents.get(run.id)!
|
|
// The child inherited the parent's prefix.
|
|
expect(child.session.events.slice(0, seed.length).some(e => e.type === 'user/message')).toBe(true)
|
|
await run.dispose()
|
|
})
|
|
})
|