Add dedicated fork tool presentation and localized settlement outcomes. Simplify the subagent catalog, clarify team collaboration controls, and update documentation and replay expectations.
271 lines
14 KiB
TypeScript
271 lines
14 KiB
TypeScript
/** Keyless browser coverage of subagent task summaries and durable creation receipts. */
|
|
import { mkdir } from 'node:fs/promises'
|
|
import { join } from 'node:path'
|
|
import { fileURLToPath } from 'node:url'
|
|
import type { Agent, AssistantStreamFrame } from '@deepseek-ai/dsh-agent'
|
|
import {
|
|
AssistantStreamAccumulator, LlmAttemptId, ToolCallId,
|
|
createAssistantMessage, createToolResultMessage, createUserMessage,
|
|
type StreamChunk,
|
|
} from '@deepseek-ai/dsh-llm'
|
|
import type { SessionEvent } from '@deepseek-ai/dsh-session'
|
|
import type { Browser, Locator, Page } from 'playwright'
|
|
import { chromium } from 'playwright'
|
|
import { afterAll, beforeAll, describe, expect, it } from 'vitest'
|
|
import {
|
|
acknowledgeReloadConnectionLoss, assertFixtureInventory, captureStableAria, compareOrRefreshGolden,
|
|
launchWebScaffold, watchConsole, webSnapshotMode, type WebScaffold,
|
|
} from './scaffold.ts'
|
|
import { connectFreshWorkspace, expandOwningTurnProcess, newEnglishPage } from './support.ts'
|
|
|
|
const SNAPSHOT_DIR = fileURLToPath(new URL('./snapshots/subagent-summary/', import.meta.url))
|
|
const MODE = webSnapshotMode()
|
|
const DESCRIPTION = 'Review subagent task summaries'
|
|
const PROMPT = 'Inspect the subagent tool card across its lifecycle.\nCheck streaming arguments, creation receipts, and restored history.\nReturn findings without changing unrelated files.'
|
|
const SOURCE = { provider: 'deepseek-official', model: 'deepseek-v4-flash' }
|
|
|
|
async function snapshotGolden(name: string, actual: string): Promise<void> {
|
|
if (MODE === 'refresh') await mkdir(SNAPSHOT_DIR, { recursive: true })
|
|
await compareOrRefreshGolden(join(SNAPSHOT_DIR, `${name}.expected.md`), actual, MODE)
|
|
}
|
|
|
|
function startTurn(agent: Agent, turn: number): void {
|
|
agent.session.append('turn/start', { turn })
|
|
agent.session.append('user/message', createUserMessage({
|
|
content: [{ type: 'text', text: `Inspect subagent summary case ${turn}.` }], source: { kind: 'user' },
|
|
}), { surfaceOp: 'append' })
|
|
agent.session.append('step/start', { turn, step: 1 })
|
|
}
|
|
|
|
function appendCall(agent: Agent, turn: number, callId: ToolCallId, args: string, name = 'subagent'): SessionEvent<'tool/call'> {
|
|
agent.session.append('assistant/message', {
|
|
turn, step: 1, stream: [],
|
|
message: createAssistantMessage({
|
|
content: [{ type: 'tool-call', id: callId, name, arguments: args }], source: SOURCE,
|
|
}),
|
|
}, { surfaceOp: 'append' })
|
|
return agent.session.append('tool/call', { turn, step: 1, callId, name, arguments: args })
|
|
}
|
|
|
|
function finishCall(agent: Agent, call: SessionEvent<'tool/call'>, text: string, isError = false): void {
|
|
const { turn, step, callId } = call.data
|
|
agent.session.append('tool/result', {
|
|
turn, step, message: createToolResultMessage({ callId, content: [{ type: 'text', text }], isError }),
|
|
}, { surfaceOp: 'append', sourceEventSeqs: [call.seq] })
|
|
agent.session.append('step/end', { turn, step })
|
|
agent.session.append('turn/end', { turn, reason: { kind: 'completed' } })
|
|
}
|
|
|
|
function toolSelector(callId: ToolCallId): string {
|
|
return `[data-chat-call-id="${callId}"] [data-tool="subagent"]`
|
|
}
|
|
|
|
async function expectSummary(card: Locator, text: string): Promise<void> {
|
|
const header = card.locator('[data-disclosure-row]').first()
|
|
await expect.poll(() => header.textContent(), { timeout: 10_000 }).toBe(`Create subagent${text}`)
|
|
}
|
|
|
|
async function expandTask(card: Locator, prompt: string): Promise<void> {
|
|
await expandOwningTurnProcess(card.page(), card)
|
|
const toggle = card.locator('[data-expandable]').first()
|
|
if (await toggle.getAttribute('aria-expanded') !== 'true') await toggle.click()
|
|
const task = card.locator('details').filter({ has: card.page().locator('summary', { hasText: /^Task$/u }) })
|
|
await task.waitFor()
|
|
if (await task.getAttribute('open') === null) await task.locator('summary').click()
|
|
await expect.poll(() => task.locator('p').textContent()).toBe(prompt)
|
|
}
|
|
|
|
describe.skipIf(MODE === 'record')('web e2e: subagent task summary', () => {
|
|
let scaffold: WebScaffold
|
|
let browser: Browser
|
|
let page: Page
|
|
let tripwire: ReturnType<typeof watchConsole>
|
|
let agent: Agent
|
|
|
|
beforeAll(async () => {
|
|
scaffold = await launchWebScaffold()
|
|
browser = await chromium.launch()
|
|
page = await newEnglishPage(browser)
|
|
tripwire = watchConsole(page)
|
|
await page.goto(scaffold.authenticatedUrl, { waitUntil: 'load' })
|
|
await page.locator('[class*="frame"]').waitFor()
|
|
await connectFreshWorkspace(page, scaffold.workspaceCwd)
|
|
const connected = scaffold.ctx.agents.list()[0]
|
|
if (connected === undefined) throw new Error('Subagent summary fixture has no connected Agent')
|
|
agent = connected
|
|
})
|
|
|
|
afterAll(async () => {
|
|
try { await browser?.close() } finally { await scaffold?.close() }
|
|
})
|
|
|
|
it('streams the description and preserves it through creation and restored history', async () => {
|
|
const callId = ToolCallId('subagent-summary-described')
|
|
const selector = toolSelector(callId)
|
|
const card = page.locator(selector)
|
|
const snapshots: string[] = []
|
|
const capture = async (stage: string): Promise<void> => {
|
|
await expandOwningTurnProcess(page, card)
|
|
snapshots.push(`## ${stage}\n\n${await captureStableAria(page, selector, scaffold.workspaceCwd)}`)
|
|
}
|
|
startTurn(agent, 1)
|
|
await scaffold.ctx.sessions.flush(agent.session)
|
|
await page.locator('[data-chat-turn="1"]').getByText('Inspect subagent summary case 1.', { exact: true }).waitFor()
|
|
|
|
const attemptId = LlmAttemptId('subagent-summary-stream')
|
|
const stream = new AssistantStreamAccumulator()
|
|
let revision = 0
|
|
let index = 0
|
|
const emit = (frame: AssistantStreamFrame): void => { scaffold.ctx.emit('agent/assistant-stream', { agent, frame }) }
|
|
const push = (chunk: StreamChunk): void => {
|
|
const time = Date.now()
|
|
stream.push({ time, chunk })
|
|
emit({ type: 'chunk', attemptId, revision: ++revision, index: index++, time, chunk })
|
|
}
|
|
emit({ type: 'start', attemptId, revision: ++revision, turn: 1, step: 1 })
|
|
push({ type: 'block-start', index: 0, blockType: 'tool-call' })
|
|
push({ type: 'tool-call-delta', index: 0, id: callId, name: 'subagent', argumentsDelta: `{"prompt":${JSON.stringify(PROMPT)},` })
|
|
await card.waitFor({ state: 'attached' })
|
|
await expandOwningTurnProcess(page, card)
|
|
await expect.poll(() => card.getAttribute('data-state')).toBe('preparing')
|
|
await expectSummary(card, '')
|
|
await capture('Preparing without description')
|
|
push({ type: 'tool-call-delta', index: 0, id: callId, argumentsDelta: '"description":"Review subagent' })
|
|
await expectSummary(card, 'Review subagent')
|
|
push({ type: 'tool-call-delta', index: 0, id: callId, argumentsDelta: ' task summaries\\nAdditional description context' })
|
|
await expectSummary(card, DESCRIPTION)
|
|
await capture('Preparing with partial description')
|
|
push({ type: 'tool-call-delta', index: 0, id: callId, argumentsDelta: '"}' })
|
|
const args = JSON.stringify({ prompt: PROMPT, description: `${DESCRIPTION}\nAdditional description context` })
|
|
const block = { type: 'tool-call' as const, id: callId, name: 'subagent', arguments: args }
|
|
push({ type: 'block-end', index: 0, block })
|
|
push({ type: 'finish', reason: { kind: 'tool-calls' } })
|
|
const message = agent.session.append('assistant/message', {
|
|
turn: 1, step: 1, stream: [...stream.snapshot()],
|
|
message: createAssistantMessage({ content: [block], source: SOURCE }),
|
|
}, { surfaceOp: 'append' })
|
|
emit({ type: 'end', attemptId, revision: ++revision, index, outcome: { kind: 'committed', eventType: 'assistant/message', seq: message.seq } })
|
|
const call = agent.session.append('tool/call', { turn: 1, step: 1, callId, name: 'subagent', arguments: args })
|
|
await scaffold.ctx.sessions.flush(agent.session)
|
|
await expect.poll(() => card.getAttribute('data-state')).toBe('running')
|
|
await expectSummary(card, DESCRIPTION)
|
|
await capture('Running')
|
|
|
|
finishCall(agent, call, 'started subagent summary-worker\nname: lead/foo')
|
|
await scaffold.ctx.sessions.flush(agent.session)
|
|
await expect.poll(() => card.getAttribute('data-state')).toBe('ok')
|
|
await expectSummary(card, DESCRIPTION)
|
|
await capture('Created')
|
|
await expandTask(card, PROMPT)
|
|
await expectSummary(card, DESCRIPTION)
|
|
expect(await card.getByText('Agent response', { exact: true }).count()).toBe(0)
|
|
await card.getByText('Started', { exact: true }).waitFor()
|
|
expect(await card.locator('dt').allTextContents()).toEqual(['Agent ID', 'Agent name'])
|
|
expect(await card.locator('dd').allTextContents()).toEqual(['summary-worker', 'lead/foo'])
|
|
await capture('Creation receipt and complete task')
|
|
|
|
const beforeReload = tripwire.warnings.length
|
|
await page.reload({ waitUntil: 'load' })
|
|
await card.waitFor({ state: 'attached' })
|
|
await expandOwningTurnProcess(page, card)
|
|
await expectSummary(card, DESCRIPTION)
|
|
await expandTask(card, PROMPT)
|
|
await expectSummary(card, DESCRIPTION)
|
|
expect(await card.getByText('Agent response', { exact: true }).count()).toBe(0)
|
|
await capture('Restored creation receipt')
|
|
acknowledgeReloadConnectionLoss(tripwire, beforeReload)
|
|
await snapshotGolden('lifecycle', snapshots.join('\n\n'))
|
|
expect(tripwire.pageErrors).toEqual([])
|
|
expect(tripwire.warnings).toEqual([])
|
|
})
|
|
|
|
it('falls back to the prompt, keeps synchronous replies in details, and preserves errors', async () => {
|
|
const cases = [
|
|
{ id: 'fallback', args: { prompt: 'Review the fallback summary.\nKeep the complete task in details.' }, summary: 'Review the fallback summary.', result: 'started subagent fallback-worker\nname: lead/fallback' },
|
|
{ id: 'reply', args: { description: 'Check synchronous agent reply', prompt: 'Review the synchronous report.\nKeep every instruction available.' }, summary: 'Check synchronous agent reply', result: 'The synchronous agent found two issues.\nBoth are documented in the report.' },
|
|
{ id: 'title-only', args: {}, summary: '', result: 'started subagent empty-worker\nname: lead/empty' },
|
|
{ id: 'error', args: { description: 'Delegate a failing task', prompt: 'Attempt the requested delegation.' }, summary: 'Subagent capacity exceeded', result: 'Subagent capacity exceeded\nWait for an active agent to finish.', error: true },
|
|
]
|
|
const snapshots: string[] = []
|
|
for (const [index, fixture] of cases.entries()) {
|
|
const turn = index + 2
|
|
const callId = ToolCallId(`subagent-summary-${fixture.id}`)
|
|
const selector = toolSelector(callId)
|
|
const card = page.locator(selector)
|
|
startTurn(agent, turn)
|
|
const call = appendCall(agent, turn, callId, JSON.stringify(fixture.args))
|
|
await scaffold.ctx.sessions.flush(agent.session)
|
|
await card.waitFor({ state: 'attached' })
|
|
await expandOwningTurnProcess(page, card)
|
|
await expectSummary(card, fixture.args.description ?? fixture.args.prompt?.split('\n')[0] ?? '')
|
|
finishCall(agent, call, fixture.result, fixture.error)
|
|
await scaffold.ctx.sessions.flush(agent.session)
|
|
await expect.poll(() => card.getAttribute('data-state')).toBe(fixture.error === true ? 'error' : 'ok')
|
|
await expectSummary(card, fixture.summary)
|
|
if (fixture.args.prompt !== undefined && fixture.error !== true) {
|
|
await expandTask(card, fixture.args.prompt)
|
|
await expectSummary(card, fixture.summary)
|
|
if (fixture.id === 'reply') {
|
|
await card.getByText('Agent response', { exact: true }).waitFor()
|
|
await card.getByText('The synchronous agent found two issues.', { exact: false }).waitFor()
|
|
await card.getByText('Both are documented in the report.', { exact: false }).waitFor()
|
|
expect(await card.getByText('Started', { exact: true }).count()).toBe(0)
|
|
} else expect(await card.getByText('Agent response', { exact: true }).count()).toBe(0)
|
|
}
|
|
await expandOwningTurnProcess(page, card)
|
|
snapshots.push(`## ${fixture.id}\n\n${await captureStableAria(page, selector, scaffold.workspaceCwd)}`)
|
|
}
|
|
await snapshotGolden('variants', snapshots.join('\n\n'))
|
|
expect(tripwire.pageErrors).toEqual([])
|
|
expect(tripwire.warnings).toEqual([])
|
|
})
|
|
|
|
it('presents fork creation with a distinct title, task summary, and restored receipt', async () => {
|
|
const name = 'subagent_fork'
|
|
const callId = ToolCallId('subagent-fork-summary')
|
|
const selector = `[data-chat-call-id="${callId}"] [data-tool="${name}"]`
|
|
const card = page.locator(selector)
|
|
const description = 'Review inherited conversation context'
|
|
const prompt = 'Summarize the earlier agreed requirements.\nDo not modify files.'
|
|
const snapshots: string[] = []
|
|
const capture = async (stage: string): Promise<void> => {
|
|
snapshots.push(`## ${stage}\n\n${await captureStableAria(page, selector, scaffold.workspaceCwd)}`)
|
|
}
|
|
const expectForkSummary = async (): Promise<void> => {
|
|
await expect.poll(() => card.locator('[data-disclosure-row]').first().textContent())
|
|
.toBe(`Fork subagent${description}`)
|
|
}
|
|
startTurn(agent, 6)
|
|
const call = appendCall(agent, 6, callId, JSON.stringify({ description, prompt }), name)
|
|
await scaffold.ctx.sessions.flush(agent.session)
|
|
await card.waitFor({ state: 'attached' })
|
|
await expandOwningTurnProcess(page, card)
|
|
await expect.poll(() => card.getAttribute('data-state')).toBe('running')
|
|
await expectForkSummary()
|
|
await capture('Running')
|
|
finishCall(agent, call, 'started subagent fork-worker\nname: lead/context-reviewer')
|
|
await scaffold.ctx.sessions.flush(agent.session)
|
|
await expect.poll(() => card.getAttribute('data-state')).toBe('ok')
|
|
await expandTask(card, prompt)
|
|
await expectForkSummary()
|
|
expect(await card.locator('dt').allTextContents()).toEqual(['Agent ID', 'Agent name'])
|
|
expect(await card.locator('dd').allTextContents()).toEqual(['fork-worker', 'lead/context-reviewer'])
|
|
expect(await card.getByText('Agent response', { exact: true }).count()).toBe(0)
|
|
await capture('Creation receipt and complete task')
|
|
const beforeReload = tripwire.warnings.length
|
|
await page.reload({ waitUntil: 'load' })
|
|
await card.waitFor({ state: 'attached' })
|
|
await expandTask(card, prompt)
|
|
await expectForkSummary()
|
|
await capture('Restored creation receipt')
|
|
acknowledgeReloadConnectionLoss(tripwire, beforeReload)
|
|
await snapshotGolden('fork', snapshots.join('\n\n'))
|
|
expect(tripwire.pageErrors).toEqual([])
|
|
expect(tripwire.warnings).toEqual([])
|
|
})
|
|
|
|
it('keeps the fixture inventory closed', async () => {
|
|
await assertFixtureInventory(SNAPSHOT_DIR, ['lifecycle.expected.md', 'variants.expected.md', 'fork.expected.md'])
|
|
})
|
|
})
|