97 lines
4.2 KiB
TypeScript
97 lines
4.2 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 { STRUCTURED_OUTPUT_TOOL } from '@deepseek-ai/dsh-subagent-inprocess'
|
|
import { MockAdapter, textResponse, toolCallResponse } from '../../../core/agent-loop/tests/mock-adapter.ts'
|
|
import WorkerWorkflowEngine from '../src/index.ts'
|
|
|
|
type Script = ConstructorParameters<typeof MockAdapter>[0]
|
|
|
|
/**
|
|
* The whole in-process stack, keyless, with the script in a REAL worker
|
|
* thread: the engine drives the REAL spawn backend (with its
|
|
* structured runtime) on a real agent loop; the scripted mock MODEL is the
|
|
* only mocked boundary. This is the guard the unit suites structurally
|
|
* cannot give — the MessageChannel suite fakes the host, and the host suite
|
|
* stubs the subagent seam.
|
|
*/
|
|
async function setup(script: Script) {
|
|
const ctx = new Context()
|
|
const adapter = new MockAdapter(script)
|
|
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(WorkerWorkflowEngine, {})
|
|
ctx.llm.registerAdapter(['mock'], adapter)
|
|
const parent = ctx.agentLoop.create(AgentId('parent'), { model: 'mock' })
|
|
return { ctx, parent, adapter }
|
|
}
|
|
|
|
describe('dsh-workflow-workerthread over the real in-process stack', () => {
|
|
it('runs a two-stage workflow: a plain child, then a schema child through the structured runtime', async () => {
|
|
const { ctx, parent } = await setup([
|
|
textResponse('the file list is a.ts'),
|
|
toolCallResponse('c1', STRUCTURED_OUTPUT_TOOL, { verdict: 'real', confidence: 0.9 }),
|
|
])
|
|
const childIds: string[] = []
|
|
ctx.on('workflow/agent-start', (_info, agent) => {
|
|
// The workflow bridge must await asynchronous provider start: an observer
|
|
// sees the real spawn child already published, never a reserved id.
|
|
expect(ctx.agents.get(agent.childId)).toBeDefined()
|
|
childIds.push(agent.childId)
|
|
})
|
|
const run = ctx.workflows.start({
|
|
meta: { name: 'integration', description: 'plain + structured children' },
|
|
script: `phase('Read')
|
|
const prose = await agent('read the repo')
|
|
phase('Judge')
|
|
const judged = await agent('judge: ' + prose, {
|
|
schema: { type: 'object', properties: { verdict: { type: 'string', enum: ['real', 'bogus'] }, confidence: { type: 'number' } }, required: ['verdict'] },
|
|
})
|
|
return { prose, verdict: judged.verdict, confidence: judged.confidence }`,
|
|
parent,
|
|
})
|
|
const result = await run.result
|
|
expect(result.stopReason).toBe('completed')
|
|
expect(result.value).toEqual({ prose: 'the file list is a.ts', verdict: 'real', confidence: 0.9 })
|
|
expect(result.agentsStarted).toBe(2)
|
|
await run.dispose()
|
|
// Both children were disposed to quiescence — no live child agents remain.
|
|
expect(childIds.length).toBe(2)
|
|
for (const childId of childIds) {
|
|
expect(ctx.agents.get(AgentId(childId))).toBeUndefined()
|
|
}
|
|
})
|
|
|
|
it('a child that fails against its schema (nudges exhausted) reaches the script as null', async () => {
|
|
const { ctx, parent } = await setup([
|
|
textResponse('prose only'),
|
|
textResponse('still prose after the nudge'),
|
|
])
|
|
const run = ctx.workflows.start({
|
|
meta: { name: 'null-path', description: 'schema failure maps to null' },
|
|
script: `const judged = await agent('judge it', { schema: { type: 'object', properties: { v: { type: 'string' } } } })
|
|
return { got: judged === null ? 'null' : 'value' }`,
|
|
parent,
|
|
})
|
|
const result = await run.result
|
|
expect(result.stopReason).toBe('completed')
|
|
expect(result.value).toEqual({ got: 'null' })
|
|
await run.dispose()
|
|
})
|
|
})
|