Tianyi Cui
7aabd2a3df
The second PR of the subagent seam: the two in-process backends that run a
child agent on the same cordis context, reusing the agent factory's quiescent
AgentHandle teardown. Both register on ctx.subagents (PR1's named-provider
registry) and share one run driver.
- dsh-subagent-spawn: a FRESH child via ctx.agents.create — own session, the
parent's model by default (overridable), zero inherited conversation. Also
exports the shared in-process run driver (startInProcessRun): mint ids, stamp
cwd/parentSession-lineage/depth, drive the one-shot (send → whenIdle), read
the last assistant/message + turn/end reason, dispose to quiescence.
- dsh-subagent-fork: a child SEEDED with the parent's balanced completed-turn
prefix (the log up to and including its last turn/end), so the child inherits
context. The in-flight unbalanced turn is excluded — a raw seed would fail the
invariants replay. Proven: a regression test goes red if the boundary seeds
the open turn.
- Seam extension: CreateAgentOptions.seed, threaded through AgentLoop.createAgent
→ ctx.sessions.prepare({ seed }) (the primitive resume already used). This is
the fork-lineage path the TODO(sub-agents) markers anticipated.
- Depth: a merge-extensible AgentOptions.subagentDepth (0 top-level, parent+1 for
a child); the depthLimit capability refuses a spawn past request.maxDepth.
Tests: real-loop unit tests for both backends (mock MODEL only, real loop +
invariants), a multi-subagent test (one parent drives a fork AND a spawn child
then keeps working), and a with-key e2e (a real parent delegates via the
`subagent` tool to a real child that writes a file on disk — world-verified).
100% per-file coverage. The coding-agent demo wires the spawn backend + tool.
Snapshot coverage of nested agents is deferred to a stacked follow-up
(TODO(subagent-snapshots)): dsh-llm-replay is a single global positional cursor
that cannot route calls to a parent vs. a child on one context. Recorded in the
RFC's deferrals and a new AGENTS.md rule: designing a subsystem must design its
test infrastructure END TO END up front, verifying the snapshot/e2e harness can
express the new shape — a gap this plan hit.
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)
|
|
})
|
|
})
|