refactor(agent-loop): simplify observable state machine

packages/core/agent-loop/tests/request-error.spec.ts

@@ -0,0 +1,149 @@
+import { describe, expect, it } from 'vitest'
+import { Context } from 'cordis'
+import AgentRegistry from '@deepseek-ai/dsh-agent'
+import AgentLoop from '@deepseek-ai/dsh-agent-loop'
+import LlmService, { LlmError } from '@deepseek-ai/dsh-llm'
+import type { LlmFailure } from '@deepseek-ai/dsh-llm'
+import SessionStore, { SessionId } from '@deepseek-ai/dsh-session'
+import SystemPrompt from '@deepseek-ai/dsh-system-prompt'
+import ToolRegistry from '@deepseek-ai/dsh-tools'
+import { MockAdapter, textResponse } from './mock-adapter.ts'
+
+async function harness(adapter: MockAdapter): Promise<Context> {
+  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 fail(message: string, code: string): () => never {
+  return () => {
+    throw new LlmError(message, code)
+  }
+}
+
+describe('agent/request-error', () => {
+  it('does not offer middleware failures to request recovery', async () => {
+    const adapter = new MockAdapter([textResponse('unused')])
+    const ctx = await harness(adapter)
+    const agent = ctx.agentLoop.create(SessionId('request-error-narrow'), { provider: 'mock', model: 'mock' })
+    let recoveries = 0
+    ctx.on('agent/request', () => {
+      throw new LlmError('middleware failed', 'MIDDLEWARE')
+    })
+    ctx.on('agent/request-error', async () => {
+      recoveries += 1
+    })
+
+    agent.followup([{ type: 'text', text: 'go' }])
+    await agent.whenIdle()
+
+    expect(recoveries).toBe(0)
+    expect(adapter.requests).toHaveLength(0)
+  })
+
+  it('lets each failed request schedule a retry before its turn closes', async () => {
+    const adapter = new MockAdapter([
+      fail('busy', 'RATE_LIMIT'),
+      fail('unavailable', 'SERVICE_UNAVAILABLE'),
+      textResponse('ok'),
+    ])
+    const ctx = await harness(adapter)
+    const agent = ctx.agentLoop.create(SessionId('request-error-retry'), { provider: 'mock', model: 'mock' })
+    const seen: { turn: number; step: number; failure: LlmFailure }[] = []
+    const statuses: string[] = []
+    const idleTurns: number[] = []
+    ctx.on('agent/status', (subject, status) => {
+      if (subject === agent) statuses.push(status)
+    })
+    ctx.on('agent/idle', (subject, turn) => {
+      if (subject === agent) idleTurns.push(turn)
+    })
+    ctx.on('agent/request-error', async (subject, turn, step, _error, failure) => {
+      expect(subject).toBe(agent)
+      expect(agent.session.events.at(-1)).toMatchObject({
+        type: 'step/end',
+        data: { turn, step },
+      })
+      seen.push({ turn, step, failure })
+      subject.retry()
+      subject.retry()
+    })
+
+    agent.followup([{ type: 'text', text: 'go' }])
+    await agent.whenIdle()
+
+    expect(seen.map(item => ({
+      turn: item.turn,
+      step: item.step,
+      code: item.failure.code,
+    }))).toEqual([
+      {
+        turn: 1,
+        step: 1,
+        code: 'RATE_LIMIT',
+      },
+      {
+        turn: 2,
+        step: 1,
+        code: 'SERVICE_UNAVAILABLE',
+      },
+    ])
+    expect(agent.session.events.filter(event => event.type === 'turn/start').map(event => event.data.trigger))
+      .toEqual([
+        { kind: 'message', source: { kind: 'user' } },
+        { kind: 'retry' },
+        { kind: 'retry' },
+      ])
+    expect(statuses).toEqual(['running', 'idle'])
+    expect(idleTurns).toEqual([3])
+  })
+
+  it('lets cancellation win over a retry request', async () => {
+    const adapter = new MockAdapter([fail('busy', 'RATE_LIMIT'), textResponse('unused')])
+    const ctx = await harness(adapter)
+    const agent = ctx.agentLoop.create(SessionId('request-error-cancel'), { provider: 'mock', model: 'mock' })
+    ctx.on('agent/request-error', async (subject) => {
+      subject.retry()
+      subject.cancel({ kind: 'user' })
+    })
+
+    agent.followup([{ type: 'text', text: 'go' }])
+    await agent.whenIdle()
+
+    expect(adapter.requests).toHaveLength(1)
+    expect(agent.session.events.filter(event => event.type === 'turn/start')).toHaveLength(1)
+    expect(agent.session.events.find(event => event.type === 'turn/end')).toMatchObject({
+      type: 'turn/end',
+      data: { reason: { kind: 'aborted' } },
+    })
+  })
+
+  it('does not honor a retry requested by a failing recovery listener', async () => {
+    const adapter = new MockAdapter([fail('busy', 'RATE_LIMIT'), textResponse('unused')])
+    const ctx = await harness(adapter)
+    const agent = ctx.agentLoop.create(SessionId('request-error-recovery-failed'), {
+      provider: 'mock',
+      model: 'mock',
+    })
+    ctx.on('agent/request-error', async (subject) => {
+      subject.retry()
+      throw new Error('recovery failed')
+    })
+
+    agent.followup([{ type: 'text', text: 'go' }])
+    await agent.whenIdle()
+
+    expect(adapter.requests).toHaveLength(1)
+    expect(agent.session.events.filter(event => event.type === 'turn/start')).toHaveLength(1)
+    expect(agent.session.events.find(event => event.type === 'turn/end')).toMatchObject({
+      type: 'turn/end',
+      data: { reason: { kind: 'error' } },
+    })
+  })
+})