Tianyi Cui
a3cb678875
Integrate the observed master checkpoint 7ab215e23e5d977aae7eb5d4fb91782d39969dbb without rewriting the earlier published checkpoints. Master adds current-directory events, directory-aware consumers, and retained Git worktrees; its old subagent startup paths overlapped the unified activation implementation. Resolve directory selection within managed startup after acquiring parent ownership. Preserve the original Session origin while setting each new local child directory, retain persisted directory state on cold resume, and pass a required absolute cwd to external providers. Keep unified local/external ownership, full completion notices, parked-input host completion, SDK wait/error/shutdown behavior, and ACP cancellation semantics. Retain removal of the old in-process driver and continuation managers. Combine SDK wait with the new directory requests, preserve the new master directory/worktree fixtures, regenerate derived catalogs from the combined sources, and refresh only the four stale prompt/schema sidecars. Preserve every protected historical schema, archived note, catalog-v2 acknowledgement, and recorded predecessor input. Validation: full build; 59 CI static gates; 855 subagent tests with 100% coverage on changed core/external sources; affected consumer suites including 119 repaired-fixture tests; SDK 11 and headless 16 recorded scenarios; two local headless expected cases; six built nested SDK/ACP cases; lint, strict cast inventory, workspace constraints, and whitespace checks. Native Windows worker diagnostics remain additive and require the next CI run to classify the original crash.
96 lines
4.9 KiB
TypeScript
96 lines
4.9 KiB
TypeScript
import { mountWorkingDirectoryFixture } from '../../subagent/tests/working-directory-fixture.ts'
|
|
import { mountLocalActivations, startTestActivation as start } from '../../subagent/tests/local-activation.ts'
|
|
import { createUserMessage } from '@deepseek-ai/dsh-llm'
|
|
import { describe, expect, it } from 'vitest'
|
|
import { Context } from '@deepseek-ai/cordis'
|
|
import { SessionId } from '@deepseek-ai/dsh-session'
|
|
import AgentLoop from '@deepseek-ai/dsh-agent-loop'
|
|
import { mountAgentLoopTestDependencies } from '@deepseek-ai/dsh-agent-loop-testkit'
|
|
import SubagentRuntime from '@deepseek-ai/dsh-subagent'
|
|
import * as Spawn from '@deepseek-ai/dsh-subagent-spawn-in-process'
|
|
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 mountAgentLoopTestDependencies(ctx)
|
|
await mountLocalActivations(ctx)
|
|
await ctx.plugin(AgentLoop, { agents: [] })
|
|
await mountWorkingDirectoryFixture(ctx)
|
|
await ctx.plugin(SubagentRuntime)
|
|
await ctx.plugin(Spawn, { providerName: 'spawn' })
|
|
await ctx.plugin(fork, { providerName: 'fork' })
|
|
ctx.llm.registerAdapter(['mock'], new MockAdapter(script))
|
|
const parent = await ctx.agentLoop.create(SessionId('parent'), { provider: 'mock', model: 'mock' })
|
|
return { ctx, parent }
|
|
}
|
|
|
|
function text(blocks: readonly { 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.followup(createUserMessage({ content: [{ type: 'text', text: 'parent q1' }], source: { kind: 'user' } }))
|
|
await parent.whenIdle()
|
|
const parentPrefixLen = parent.session.snapshotEvents().length
|
|
|
|
// Delegate to a fresh spawn child.
|
|
const spawnRun = await start(ctx, '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 = await start(ctx, '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 = spawnRun.localAgent
|
|
const forkChild = forkRun.localAgent
|
|
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.snapshotEvents().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.followup(createUserMessage({ content: [{ type: 'text', text: 'parent q2' }], source: { kind: 'user' } }))
|
|
await parent.whenIdle()
|
|
const lastParentMessage = parent.session.snapshotEvents().findLast(e => e.type === 'assistant/message')
|
|
expect(lastParentMessage?.type === 'assistant/message' && text(lastParentMessage.data.message.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.snapshotEvents().filter(e => e.type === 'turn/end')).toHaveLength(2)
|
|
})
|
|
})
|