mirror of
https://github.com/deepseek-ai/deepseek-harness
synced 2026-08-15 21:04:50 +00:00
1d43ea3cd5
A new capability family at packages/workflow/ in the bash seam shape,
modeled on Claude Code's dynamic workflows: the model writes a JavaScript
orchestration script (export const meta = {...} + plain-JS body), a runtime
executes it, and the script — not the conversation — holds the loop, the
branching, and the intermediate results.
- dsh-workflow (ctx.workflows): abstract WorkflowService + run vocabulary
(WorkflowRun whose result NEVER rejects) + observe-only workflow/* events
carrying data snapshots (id + meta, never the live run), per-listener
contained like subagent/*.
- dsh-workflow-vm: in-process node:vm engine. Meta extraction via a
string/comment-aware scanner (template interpolation rejected; literal
evaluated alone in an empty timed context; statement blanked line-
preservingly so stacks keep script line numbers). Hooks: agent(prompt,
{label, phase, schema, model}) over ctx.subagents, parallel(), pipeline()
(no cross-stage barrier), phase(), log(), args. Fatal-vs-null discipline:
hook misuse (unknown/deferred options, bad arguments, unsupported
schemas, tripped caps, seam start failures, cancellation) throws fatal
WorkflowErrors the combinators RE-THROW — never dissolved into the
per-item null reserved for child failures. Realm boundary: inbound values
materialized by descriptor walks that never invoke accessors (defineProperty
copies, __proto__-safe); outbound values rebuilt in-realm via the
context's own JSON.parse. Determinism bans (Date.now/Math.random/argless
new Date) kept so future resume support cannot break scripts. Caps and
timeouts are validated Config. Every hook promise carries a no-op
rejection consumer (app-boot exits on unhandled rejections).
- dsh-tool-workflow: the model-facing workflow tool, synchronous like
dsh-tool-subagent (start → await → try/finally dispose; abort bridged;
non-completed → isError). Generic render card titled by a textual
meta.name sniff. The tool description carries the authoring contract.
Wired into examples/{coding-agent,acp-agent} with explicit-ask-only
guidance. Coverage at every tier: unit (meta scanner, materializer incl.
counting-getter and __proto__ regressions, combinator semantics,
concurrency ceiling, caps, cancellation, no-unhandled-rejection abandon),
integration over the real spawn stack, with-key e2e (real two-phase run +
the tool through the registry pipeline), and a recorded ACP snapshot
scenario (workflow-run, 1 child session). RFC:
docs/rfc/implemented/feature/2026-07-05-dynamic-workflows.md (deferred
work explicitly listed). AGENTS.md budget 1575 → 1590 for the new group's
layout line.
90 lines
4.0 KiB
TypeScript
90 lines
4.0 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 VmWorkflowEngine from '../src/index.ts'
|
|
|
|
type Script = ConstructorParameters<typeof MockAdapter>[0]
|
|
|
|
/**
|
|
* The whole in-process stack, keyless: the vm 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 integration guard the
|
|
* per-hook unit tests (which stub the subagent seam) structurally cannot give.
|
|
*/
|
|
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', structuredNudgeRetries: 1 })
|
|
await ctx.plugin(VmWorkflowEngine, {})
|
|
ctx.llm.registerAdapter(['mock'], adapter)
|
|
const parent = ctx.agentLoop.create(AgentId('parent'), { model: 'mock' })
|
|
return { ctx, parent, adapter }
|
|
}
|
|
|
|
describe('dsh-workflow-vm 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) => { childIds.push(agent.childId) })
|
|
const run = ctx.workflows.start({
|
|
script: `export const meta = { name: 'integration', description: 'plain + structured children' }
|
|
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({
|
|
script: `export const meta = { name: 'null-path', description: 'schema failure maps to null' }
|
|
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()
|
|
})
|
|
})
|