Files
deepseek-harness/packages/llm/llm-retry/tests/initialization.spec.ts
T

83 lines
3.8 KiB
TypeScript

/** Provider recovery overlapping retry projection registration. */
import { Context } from '@deepseek-ai/cordis'
import AgentLoop from '@deepseek-ai/dsh-agent-loop'
import { mountAgentLoopTestDependencies } from '@deepseek-ai/dsh-agent-loop-testkit'
import { createUserMessage, resolveRetryPolicy } from '@deepseek-ai/dsh-llm'
import type { ResolvedRetryPolicy } from '@deepseek-ai/dsh-llm'
import * as retry from '@deepseek-ai/dsh-llm-retry'
import { SessionId } from '@deepseek-ai/dsh-session'
import { describe, expect, it, onTestFinished, vi } from 'vitest'
import { MockAdapter, textResponse } from '../../../core/agent-loop/tests/mock-adapter.ts'
class RetryAdapter extends MockAdapter {
override providerRetryPolicy(): ResolvedRetryPolicy {
return resolveRetryPolicy({
mode: 'normal', maxRetries: 1,
backoff: { initialDelayMs: 1, maxDelayMs: 1, jitterRatio: 0 },
}, 'initialization test')
}
}
describe('retry activation', () => {
it.each(['ready', 'cancelled', 'disposed', 'failed'] as const)('handles a %s registration before settling the first provider failure', async (outcome) => {
const ctx = new Context()
const registered = Promise.withResolvers<undefined>()
const release = Promise.withResolvers<undefined>()
onTestFinished(async () => {
release.resolve(undefined)
await ctx.fiber.dispose()
})
await mountAgentLoopTestDependencies(ctx)
await ctx.plugin(AgentLoop, { agents: [] })
const adapter = new RetryAdapter([
[{ type: 'finish', reason: { kind: 'error', failure: { code: 'SERVER', message: 'temporary failure' } } }],
textResponse('recovered'),
])
ctx.llm.registerAdapter(['mock'], adapter)
const agent = await ctx.agentLoop.create(SessionId('initial-retry'), { provider: 'mock', model: 'mock' })
const register = ctx.sessionProjections.register.bind(ctx.sessionProjections)
const spy = vi.spyOn(ctx.sessionProjections, 'register').mockImplementation(async (definition) => {
const handle = await register(definition)
if (definition.key === 'llmRetry') {
registered.resolve(undefined)
await release.promise
}
return handle
})
onTestFinished(() => { spy.mockRestore() })
const fiber = ctx.plugin(retry)
await registered.promise
const recovering = Promise.withResolvers<undefined>()
ctx.on('agent/request-error', (_payload, next) => {
recovering.resolve(undefined)
return next()
}, { prepend: true })
const errors: unknown[] = []
ctx.on('agent/error', ({ error }) => { errors.push(error) })
agent.followup(createUserMessage({ content: [{ type: 'text', text: 'recover this request' }], source: { kind: 'user' } }))
await recovering.promise
if (outcome === 'cancelled') agent.cancel({ kind: 'user' })
const disposal = outcome === 'disposed' ? fiber.dispose() : undefined
if (outcome === 'failed') {
const rejected = expect(Promise.resolve(fiber)).rejects.toThrow('retry registration failed')
release.reject(new Error('retry registration failed'))
await rejected
} else {
release.resolve(undefined)
await (disposal ?? fiber)
}
await agent.whenIdle()
expect(adapter.requests).toHaveLength(outcome === 'ready' ? 2 : 1)
const log = agent.session.snapshotEvents()
expect(log.filter(event => event.type === 'llm/retry')).toHaveLength(outcome === 'ready' ? 1 : 0)
expect(log.filter(event => event.type === 'llm/retry-started')).toHaveLength(outcome === 'ready' ? 1 : 0)
if (outcome === 'ready') {
expect(adapter.requests[1]?.messages).toEqual(adapter.requests[0]?.messages)
expect(agent.session.deriveMessages().at(-1)?.content).toEqual([{ type: 'text', text: 'recovered' }])
}
if (outcome === 'failed') expect(errors).toContainEqual(new Error('retry registration failed'))
})
})