mirror of
https://github.com/deepseek-ai/deepseek-harness
synced 2026-08-15 21:04:50 +00:00
dafb81be7b
The seam vocabulary (SubagentStartRequest.outputSchema, SubagentResult .structured) existed but no in-process backend honored it — spawn/fork advertised outputSchema: false. This lands the missing half: - dsh-tools gains a structured-output JSON Schema subset (json-schema.ts): StructuredOutputSchema, assertSupportedOutputSchema (rejects loud outside the enforced subset, every violation listed), validateStructuredValue (path-qualified issues, total). outputSchema's seam type becomes this raw JSON-Schema subset instead of the author-facing SchemaSpec DSL — the schema travels verbatim to the model as a forced tool's parameters. - dsh-subagent-inprocess gains the shared structured runtime: one global structured_output capture tool (placeholder parameters) + a prepend:true agent/request listener doing FINAL-REQUEST enforcement (strip for plain agents, per-run schema for structured children — survives downstream request-replacing listeners) + an agent/turn-continuation veto that stops a child's turn once captured (no wasted extra model step). Lifetime is refcounted by backends (plugin lifetime) AND live runs (start→settle). - startInProcessRun drives the capture: subset asserted before the child exists, instruction appended to the child's system prompt, clean-finish nudge loop (structuredNudgeRetries, backend Config, default 1), captured value on result.structured; a clean finish without a capture settles 'error' (never a silent success with a missing field). - spawn + fork flip outputSchema: true and inject 'tools'.
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', structuredNudgeRetries: 1 })
|
|
await ctx.plugin(fork, { providerName: 'fork', structuredNudgeRetries: 1 })
|
|
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)
|
|
})
|
|
})
|