mirror of
https://github.com/deepseek-ai/deepseek-harness
synced 2026-08-15 21:04:50 +00:00
4535bfab75
Session.append pushes the event BEFORE notifying session/event listeners,
so a throwing listener leaves the event in the log while the line after
the append (a boolean flag) never runs. Both turn-balance decisions were
gated on such flags, so a throwing listener could strand an open turn or
skip a durability checkpoint.
- loop.ts: the outer catch decided "turn/end owed" from `turnStarted`.
A throwing listener on the turn/start append left turn/start logged but
the flag false → catch rethrew and skipped turn/end → permanently open
turn (violating ADR 0017). Now decided from the log (this turn's
turn/start present), so the turn is always balanced; only a genuine
pre-push failure (non-serializable trigger — turn/start never logged) is
rethrown to the runLoop backstop. Removed the now-dead `turnStarted`.
- agent.ts inject(): the idle one-shot-turn flush was gated on a
`turnRecorded` flag set after append('turn/end'); a throwing turn/end
listener skipped the flush, losing the balanced in-memory injection turn
on crash. Now the flush decision is read from the log, the synthetic
turn/end append contains a throwing listener (turn stays balanced), and
a failing idle flush is reported via agent/error (step 0 convention) AND
the logger — mirroring the loop's post-turn/end flush path — with a
throwing agent/error listener contained.
Rewrote the test that encoded the old (buggy) "turn/start listener throw
is rethrown, no turn/end" semantics to assert the balanced-turn contract,
and added regressions for the throwing-turn/end-listener flush and the
agent/error report. Updated Agent.inject JSDoc.
273 lines
12 KiB
TypeScript
273 lines
12 KiB
TypeScript
import { describe, expect, it, vi } from 'vitest'
|
|
import { Context } from 'cordis'
|
|
import { AgentId } from '@deepseek-ai/dsh-agent'
|
|
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 from '@deepseek-ai/dsh-agent'
|
|
import AgentLoop, { LoopAgent } from '@deepseek-ai/dsh-agent-loop'
|
|
import { MockAdapter, textResponse } from './mock-adapter.ts'
|
|
|
|
async function harness(adapter: MockAdapter) {
|
|
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(AgentLoop, { agents: [] })
|
|
ctx.llm.registerAdapter(['mock'], adapter)
|
|
return ctx
|
|
}
|
|
|
|
function waitForIdle(ctx: Context, agent: LoopAgent): Promise<void> {
|
|
return new Promise((resolve) => {
|
|
const dispose = ctx.on('agent/status', (subject, status) => {
|
|
if (subject === agent && status === 'idle') {
|
|
dispose()
|
|
resolve()
|
|
}
|
|
})
|
|
})
|
|
}
|
|
|
|
function send(agent: LoopAgent, text: string) {
|
|
agent.send([{ type: 'text', text }])
|
|
}
|
|
|
|
describe('LoopAgent', () => {
|
|
it('send() throws after disposal', async () => {
|
|
const adapter = new MockAdapter(['hang'])
|
|
const ctx = await harness(adapter)
|
|
let agent!: LoopAgent
|
|
const fiber = await ctx.plugin(Object.assign((inner: Context) => {
|
|
agent = inner.agentLoop.create('scoped', { model: 'mock' })
|
|
}, { inject: ['agentLoop'] }))
|
|
send(agent, 'go')
|
|
await new Promise(r => setTimeout(r, 30))
|
|
await fiber.dispose()
|
|
await agent.done
|
|
|
|
expect(() => { agent.send([{ type: 'text', text: 'too late' }]) }).toThrow('disposed')
|
|
})
|
|
|
|
it('steer() throws after disposal', async () => {
|
|
const adapter = new MockAdapter(['hang'])
|
|
const ctx = await harness(adapter)
|
|
let agent!: LoopAgent
|
|
const fiber = await ctx.plugin(Object.assign((inner: Context) => {
|
|
agent = inner.agentLoop.create('scoped', { model: 'mock' })
|
|
}, { inject: ['agentLoop'] }))
|
|
send(agent, 'go')
|
|
await new Promise(r => setTimeout(r, 30))
|
|
await fiber.dispose()
|
|
await agent.done
|
|
|
|
expect(() => { agent.steer([{ type: 'text', text: 'too late' }]) }).toThrow('disposed')
|
|
})
|
|
|
|
it('inject() throws after disposal', async () => {
|
|
const adapter = new MockAdapter(['hang'])
|
|
const ctx = await harness(adapter)
|
|
let agent!: LoopAgent
|
|
const fiber = await ctx.plugin(Object.assign((inner: Context) => {
|
|
agent = inner.agentLoop.create('scoped', { model: 'mock' })
|
|
}, { inject: ['agentLoop'] }))
|
|
send(agent, 'go')
|
|
await new Promise(r => setTimeout(r, 30))
|
|
await fiber.dispose()
|
|
await agent.done
|
|
|
|
expect(() => { agent.inject([{ type: 'text', text: 'too late' }]) }).toThrow('disposed')
|
|
})
|
|
|
|
it('inject() decides enclosure from the LOG (open turn), not agent status', async () => {
|
|
const adapter = new MockAdapter([textResponse('ok')])
|
|
const ctx = await harness(adapter)
|
|
const agent = ctx.agentLoop.create('a1', { model: 'mock' })
|
|
|
|
// Simulate an OPEN turn in the log while the agent is idle (status is not a
|
|
// reliable open-turn signal). inject must append into that open turn, NOT
|
|
// wrap a new one.
|
|
agent.session.append('turn/start', { turn: 1, trigger: { kind: 'message', source: { kind: 'user' } } })
|
|
agent.inject([{ type: 'text', text: 'mid' }], { source: { kind: 'plugin', plugin: 'p' } })
|
|
expect(agent.session.events.filter(e => e.type === 'turn/start')).toHaveLength(1)
|
|
expect(agent.session.events.at(-1)!.type).toBe('context/message')
|
|
|
|
// Close the turn; now inject must wrap its own one-shot injection turn.
|
|
agent.session.append('turn/end', { turn: 1, reason: { kind: 'completed' } })
|
|
agent.inject([{ type: 'text', text: 'after' }], { source: { kind: 'plugin', plugin: 'p' } })
|
|
const starts = agent.session.events.filter(e => e.type === 'turn/start')
|
|
expect(starts).toHaveLength(2)
|
|
const last = starts[1]!
|
|
expect(last.type === 'turn/start' && last.data.trigger.kind).toBe('injection')
|
|
expect(agent.session.events.at(-1)!.type).toBe('turn/end') // turn-enclosed
|
|
})
|
|
|
|
it('idle inject() contains a failing flush (logs, does not throw into the caller)', async () => {
|
|
const adapter = new MockAdapter([textResponse('ok')])
|
|
const ctx = await harness(adapter)
|
|
// A persistence-like listener whose flush rejects.
|
|
ctx.on('session/flush', () => { throw new Error('disk gone') })
|
|
const warn = vi.spyOn(ctx.logger, 'warn').mockImplementation(() => undefined)
|
|
const agent = ctx.agentLoop.create('a1', { model: 'mock' })
|
|
|
|
// inject() is synchronous and fires a fire-and-forget flush; a rejecting
|
|
// flush must be contained (logged), never thrown into the caller.
|
|
expect(() => { agent.inject([{ type: 'text', text: 'notice' }], { source: { kind: 'plugin', plugin: 'p' } }) }).not.toThrow()
|
|
await new Promise(r => setTimeout(r, 20)) // let the contained flush settle
|
|
expect(warn).toHaveBeenCalledWith(expect.stringContaining('flush after idle injection failed'))
|
|
warn.mockRestore()
|
|
})
|
|
|
|
it('idle inject() closes its one-shot turn AND still checkpoints even if the append throws', async () => {
|
|
const adapter = new MockAdapter([textResponse('ok')])
|
|
const ctx = await harness(adapter)
|
|
const agent = ctx.agentLoop.create('a1', { model: 'mock' })
|
|
let flushes = 0
|
|
ctx.on('session/flush', () => { flushes += 1 })
|
|
|
|
// Non-serializable injected content makes Session.append throw AFTER
|
|
// turn/start was recorded. The turn/end must still be appended (finally),
|
|
// AND the durability checkpoint must still fire — the balanced turn is in
|
|
// memory and a crash before the next turn/dispose would otherwise lose it.
|
|
expect(() => {
|
|
agent.inject([{ type: 'text', text: 'x', bad: 1n } as never], { source: { kind: 'plugin', plugin: 'p' } })
|
|
}).toThrow(/non-JSON-serializable/)
|
|
const types = agent.session.events.map(e => e.type)
|
|
expect(types).toEqual(['turn/start', 'turn/end']) // balanced, no open turn
|
|
await new Promise(r => setTimeout(r, 10)) // let the fire-and-forget flush run
|
|
expect(flushes).toBe(1) // checkpoint fired despite the throw
|
|
})
|
|
|
|
it('idle inject() still checkpoints when a listener throws on the synthetic turn/end', async () => {
|
|
const adapter = new MockAdapter([textResponse('ok')])
|
|
const ctx = await harness(adapter)
|
|
const agent = ctx.agentLoop.create('a1', { model: 'mock' })
|
|
let flushes = 0
|
|
ctx.on('session/flush', () => { flushes += 1 })
|
|
// A session/event listener that throws on the synthetic turn/end. Append
|
|
// pushes before notifying, so turn/end is in the log (turn balanced) but the
|
|
// throw must NOT skip the durability checkpoint — the flush decision is made
|
|
// from the log, not a flag set after the (throwing) append.
|
|
let threw = false
|
|
ctx.on('session/event', (_s, event) => {
|
|
if (!threw && event.type === 'turn/end') { threw = true; throw new Error('boom turn/end') }
|
|
})
|
|
|
|
expect(() => { agent.inject([{ type: 'text', text: 'notice' }], { source: { kind: 'plugin', plugin: 'p' } }) }).not.toThrow()
|
|
const types = agent.session.events.map(e => e.type)
|
|
expect(types).toEqual(['turn/start', 'context/message', 'turn/end']) // balanced
|
|
await new Promise(r => setTimeout(r, 10))
|
|
expect(flushes).toBe(1) // checkpoint fired despite the throwing turn/end listener
|
|
})
|
|
|
|
it('idle inject() reports a failing flush via agent/error (step 0) AND the logger', async () => {
|
|
const adapter = new MockAdapter([textResponse('ok')])
|
|
const ctx = await harness(adapter)
|
|
// A non-Error rejection exercises the String() normalization branch.
|
|
ctx.on('session/flush', () => { throw 'disk gone' })
|
|
const warn = vi.spyOn(ctx.logger, 'warn').mockImplementation(() => undefined)
|
|
const agent = ctx.agentLoop.create('a1', { model: 'mock' })
|
|
const errors: { turn: number; step: number; message: string }[] = []
|
|
ctx.on('agent/error', (_a, turn, step, error) => void errors.push({ turn, step, message: error.message }))
|
|
|
|
agent.inject([{ type: 'text', text: 'notice' }], { source: { kind: 'plugin', plugin: 'p' } })
|
|
await new Promise(r => setTimeout(r, 20)) // let the contained flush settle
|
|
|
|
// Reported via agent/error (step 0 — the idle-injection convention) so
|
|
// plugins monitoring agent/error see idle-injection persistence failures,
|
|
// mirroring the loop's post-turn/end flush path. A non-Error throw is
|
|
// normalized to an Error.
|
|
expect(errors).toEqual([{ turn: 1, step: 0, message: 'disk gone' }])
|
|
expect(warn).toHaveBeenCalledWith(expect.stringContaining('flush after idle injection failed'))
|
|
warn.mockRestore()
|
|
})
|
|
|
|
it('idle inject() with a non-serializable source opens no turn (nothing to close)', async () => {
|
|
const adapter = new MockAdapter([textResponse('ok')])
|
|
const ctx = await harness(adapter)
|
|
const agent = ctx.agentLoop.create('a1', { model: 'mock' })
|
|
|
|
// A non-serializable source makes the turn/start append throw BEFORE the
|
|
// event is pushed (Session.append validates before push), so NO turn opens.
|
|
// The finally's isTurnOpen() guard sees no open turn and appends nothing —
|
|
// the log stays empty, not left with a dangling turn/start.
|
|
expect(() => {
|
|
agent.inject([{ type: 'text', text: 'x' }], { source: { kind: 'plugin', plugin: 'p', bad: 1n } as never })
|
|
}).toThrow(/non-JSON-serializable/)
|
|
expect(agent.session.events).toHaveLength(0)
|
|
})
|
|
|
|
it('steer() when idle falls through to send() and starts a turn', async () => {
|
|
const adapter = new MockAdapter([textResponse('ok')])
|
|
const ctx = await harness(adapter)
|
|
const agent = ctx.agentLoop.create('a1', { model: 'mock' })
|
|
|
|
// steer while idle delegates to send
|
|
agent.steer([{ type: 'text', text: 'steer idle' }], { source: { kind: 'plugin', plugin: 'test' } })
|
|
await waitForIdle(ctx, agent)
|
|
|
|
// The message was recorded as a user-level message (send path)
|
|
expect(agent.session.events.some(e => e.type === 'user/message')).toBe(true)
|
|
expect(adapter.requests).toHaveLength(1)
|
|
})
|
|
|
|
it('disposer is idempotent (double-stop)', async () => {
|
|
// Create a bare LoopAgent and call start() directly to get the disposer.
|
|
// Then call it twice — the second call hits the early-return branch.
|
|
const ctx = new Context()
|
|
await ctx.plugin(SessionStore)
|
|
const session = ctx.sessions.create('test')
|
|
const agent = new LoopAgent(ctx, AgentId('bare'), { model: 'mock' }, session)
|
|
|
|
// Start the loop to get the disposer; the agent waits for messages
|
|
// (idle, never-resolving cancel), so it will stay idle.
|
|
const dispose = agent.start()
|
|
|
|
// First dispose
|
|
dispose()
|
|
expect(agent.status).toBe('disposed')
|
|
|
|
// Second dispose — idempotent, no throw
|
|
expect(() => { dispose() }).not.toThrow()
|
|
expect(agent.status).toBe('disposed')
|
|
})
|
|
|
|
it('setting the same status does not emit agent/status again', async () => {
|
|
const adapter = new MockAdapter([textResponse('ok')])
|
|
const ctx = await harness(adapter)
|
|
const agent = ctx.agentLoop.create('a1', { model: 'mock' })
|
|
|
|
const statuses: string[] = []
|
|
ctx.on('agent/status', (subject, status) => {
|
|
if (subject === agent) statuses.push(status)
|
|
})
|
|
|
|
send(agent, 'hi')
|
|
await waitForIdle(ctx, agent)
|
|
|
|
// After the turn, agent is idle. Send again to trigger another attempt
|
|
// to go idle — but it's already idle, so no emission.
|
|
const idleTransitionCount = statuses.filter(s => s === 'idle').length
|
|
expect(idleTransitionCount).toBe(1) // only the final transition from running
|
|
})
|
|
|
|
it('abort() resolves reason to "aborted" when no reason provided', async () => {
|
|
const adapter = new MockAdapter(['hang'])
|
|
const ctx = await harness(adapter)
|
|
const agent = ctx.agentLoop.create('a1', { model: 'mock' })
|
|
|
|
const reasons: { kind: string; reason?: string }[] = []
|
|
ctx.on('agent/turn-end', (_agent, _turn, reason) => void reasons.push(reason))
|
|
|
|
send(agent, 'go')
|
|
await new Promise(r => setTimeout(r, 30))
|
|
agent.abort() // no reason string
|
|
await waitForIdle(ctx, agent)
|
|
|
|
expect(reasons[0]).toMatchObject({ kind: 'aborted', reason: 'aborted' })
|
|
})
|
|
})
|