Tianyi Cui
b907c20213
Two human review directives: - No re-prompt. A structured child that finishes a turn cleanly without calling structured_output settles error to the parent immediately — readResult already carried that mapping; the nudge loop only delayed it. Deletes the loop, its cancellation-window guard, STRUCTURED_OUTPUT_NUDGE, and the structuredNudgeRetries Config on both backends. - FIXME in the structured module doc: per-agent/per-session tool registry and prompt assembly would dissolve the final-assembly enforcement dance (the placeholder tool, the swap, the strip, the global-registration lifetime).
100 lines
4.7 KiB
TypeScript
100 lines
4.7 KiB
TypeScript
import { describe, expect, it } from 'vitest'
|
|
import { Context } 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 } 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 * as Spawn from '@deepseek-ai/dsh-subagent-spawn'
|
|
import { MockAdapter, textResponse } from '../../../core/agent-loop/tests/mock-adapter.ts'
|
|
import * as fork from '../src/index.ts'
|
|
|
|
type Script = ConstructorParameters<typeof MockAdapter>[0]
|
|
|
|
/**
|
|
* The two in-process backends coexist on one context: the SAME parent agent
|
|
* delegates to a `spawn` child (fresh) and a `fork` child (seeded with its log),
|
|
* and keeps working itself. This is the multi-provider coexistence the seam
|
|
* exists for — the named registry lets one runtime hold both transports.
|
|
*/
|
|
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)
|
|
await ctx.plugin(Spawn, { providerName: 'spawn' })
|
|
await ctx.plugin(fork, { providerName: 'fork' })
|
|
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('multi-subagent coexistence (spawn + fork on one context)', () => {
|
|
it('both providers register and coexist', async () => {
|
|
const { ctx } = await setup([])
|
|
expect(ctx.subagents.list().sort()).toEqual(['fork', 'spawn'])
|
|
})
|
|
|
|
it('the same parent drives a spawn child AND a fork child, then keeps working', async () => {
|
|
// Script order: parent turn 1, spawn child, fork child, parent turn 2.
|
|
const { ctx, parent } = await setup([
|
|
textResponse('parent turn one'),
|
|
textResponse('spawn child reply'),
|
|
textResponse('fork child reply'),
|
|
textResponse('parent turn two'),
|
|
])
|
|
|
|
// Parent does one real turn first, so the fork has a completed turn to seed.
|
|
parent.send([{ type: 'text', text: 'parent q1' }])
|
|
await parent.whenIdle()
|
|
const parentPrefixLen = parent.session.events.length
|
|
|
|
// Delegate to a fresh spawn child.
|
|
const spawnRun = ctx.subagents.start('spawn', { prompt: [{ type: 'text', text: 'spawn task' }], parent })
|
|
const spawnResult = await spawnRun.result
|
|
expect(spawnResult.stopReason).toBe('completed')
|
|
expect(text(spawnResult.output)).toBe('spawn child reply')
|
|
|
|
// Delegate to a fork child (seeded with the parent's turn-1 prefix).
|
|
const forkRun = ctx.subagents.start('fork', { prompt: [{ type: 'text', text: 'fork task' }], parent })
|
|
const forkResult = await forkRun.result
|
|
expect(forkResult.stopReason).toBe('completed')
|
|
expect(text(forkResult.output)).toBe('fork child reply')
|
|
|
|
// The two children are distinct sessions, both lineage-stamped to the parent.
|
|
const spawnChild = ctx.agents.get(spawnRun.id)!
|
|
const forkChild = ctx.agents.get(forkRun.id)!
|
|
expect(spawnChild.session.header.id).not.toBe(forkChild.session.header.id)
|
|
expect(spawnChild.session.header.parentSession).toBe(parent.session.header.id)
|
|
expect(forkChild.session.header.parentSession).toBe(parent.session.header.id)
|
|
// The fork child inherited the parent's prefix; the spawn child did not.
|
|
expect(forkChild.session.events.slice(0, parentPrefixLen).some(e => e.type === 'user/message')).toBe(true)
|
|
|
|
await spawnRun.dispose()
|
|
await forkRun.dispose()
|
|
|
|
// The parent is unaffected and keeps working after both delegations.
|
|
parent.send([{ type: 'text', text: 'parent q2' }])
|
|
await parent.whenIdle()
|
|
const lastParentMessage = parent.session.events.findLast(e => e.type === 'assistant/message')
|
|
expect(lastParentMessage?.type === 'assistant/message' && text(lastParentMessage.data.content)).toBe('parent turn two')
|
|
// The parent's OWN log never recorded the children's internal steps — its
|
|
// only subagent-related entries would be tool/call+tool/result IF it had
|
|
// used the tool, but here we called the service directly, so the parent log
|
|
// is purely its own two turns.
|
|
expect(parent.session.events.filter(e => e.type === 'turn/end')).toHaveLength(2)
|
|
})
|
|
})
|