refactor(agent-loop): simplify message machine

packages/llm/llm-retry/src/index.ts

@@ -1,5 +1,5 @@
 /**
- * Provider-routed model-request retry policy on the agent loop's closed-step
+ * Provider-routed model-request retry policy on the agent loop's request
  * recovery seam. Each scheduled retry is durable before its cancellable wait.
  *
  * @module @deepseek-ai/dsh-llm-retry
@@ -7,14 +7,13 @@
 
 import type { Context } from 'cordis'
 import z from 'schemastery'
-import type { Agent, RequestError, RequestErrorAction } from '@deepseek-ai/dsh-agent'
+import type { Agent, RequestErrorAction, RequestFailureContext } from '@deepseek-ai/dsh-agent'
 import type { LlmFailure, ResolvedRetryPolicy } from '@deepseek-ai/dsh-llm'
 import type { SessionEvent } from '@deepseek-ai/dsh-session'
-import { providerForClosedStep } from './history.ts'
 
 declare module '@deepseek-ai/dsh-session' {
   interface SessionEventMap {
-    /** Durable, non-surface record of one provider-routed retry scheduled after a closed failed step. */
+    /** Durable, non-surface record of one provider-routed retry scheduled after a failed request attempt. */
     'llm/retry': {
       turn: number
       step: number
@@ -172,24 +171,12 @@ export function apply(ctx: Context, config: Config = {}, internals: RetryInterna
 
   async function recover(
     agent: Agent,
-    turn: number,
-    step: number,
-    _error: RequestError,
-    failure: LlmFailure,
-    priorFailures: readonly LlmFailure[],
-    policy: ResolvedRetryPolicy | undefined,
+    context: RequestFailureContext,
     signal: AbortSignal,
     next: () => Promise<RequestErrorAction>,
   ): Promise<RequestErrorAction> {
+    const { turn, step, provider, failure, retryPolicy: policy } = context
     if (policy === undefined) return next()
-    // The call-local policy belongs to the registration that served this
-    // failure. Recover only the durable provider identity from the header;
-    // downstream recovery may append later state before an always fallback.
-    const provider = providerForClosedStep(agent.session.events, turn, step)
-    /* v8 ignore next 3 -- agent-loop closes only steps whose request header was recorded */
-    if (provider === undefined) {
-      throw new Error(`llm-retry: no request provider for closed turn ${turn}/step ${step}`)
-    }
     if (policy.mode === 'always') {
       if (signal.aborted || lifetime.signal.aborted) return
       const fusedSignal = AbortSignal.any([signal, lifetime.signal])
@@ -211,11 +198,10 @@ export function apply(ctx: Context, config: Config = {}, internals: RetryInterna
     }
 
     const policyKey = retryPolicyKey(policy)
-    const firstPriorTurn = turn - priorFailures.length
     const priorPolicyRetry = agent.session.events.findLast((event): event is SessionEvent<'llm/retry'> =>
       event.type === 'llm/retry'
-      && event.data.turn >= firstPriorTurn
-      && event.data.turn < turn
+      && event.data.turn === turn
+      && event.data.step === step
       && event.data.provider === provider
       && event.data.policyKey === policyKey,
     )
@@ -241,12 +227,7 @@ export function apply(ctx: Context, config: Config = {}, internals: RetryInterna
 
   const disposeListener = ctx.on('agent/request-error', (
     agent: Agent,
-    turn: number,
-    step: number,
-    error: RequestError,
-    failure: LlmFailure,
-    priorFailures: readonly LlmFailure[],
-    policy: ResolvedRetryPolicy | undefined,
+    context: RequestFailureContext,
     signal: AbortSignal,
     next: () => Promise<RequestErrorAction>,
   ) => {
@@ -254,7 +235,7 @@ export function apply(ctx: Context, config: Config = {}, internals: RetryInterna
     // removed. Lifetime cancellation must prevent that stale callback from
     // entering a downstream policy after disposal.
     if (lifetime.signal.aborted) return Promise.resolve<RequestErrorAction>(undefined)
-    return track(recover(agent, turn, step, error, failure, priorFailures, policy, signal, next))
+    return track(recover(agent, context, signal, next))
   })
 
   ctx.effect(() => async () => {

packages/llm/llm-retry/src/invariant.ts

@@ -41,34 +41,6 @@ function validateFailure(value: unknown, fail: InvariantFailure): asserts value
   }
 }
 
-/** Find the first turn in the structured-failure retry chain containing `turn`. */
-function retryChainStart(history: readonly SessionEvent[], turn: number): number {
-  let startIndex = history.findLastIndex(
-    event => event.type === 'turn/start' && event.data.turn === turn,
-  )
-  while (startIndex >= 0) {
-    const start = history[startIndex]
-    if (start?.type !== 'turn/start' || start.data.trigger.kind !== 'retry') break
-
-    let endIndex = startIndex - 1
-    while (endIndex >= 0 && history[endIndex]?.type !== 'turn/end') endIndex -= 1
-    const end = history[endIndex]
-    if (end?.type !== 'turn/end'
-      || end.data.reason.kind !== 'error'
-      || end.data.reason.failure === undefined) break
-
-    const previousStart = history.findLastIndex(
-      (event, index) =>
-        index < endIndex
-        && event.type === 'turn/start'
-        && event.data.turn === end.data.turn,
-    )
-    if (previousStart < 0) break
-    startIndex = previousStart
-  }
-  return startIndex
-}
-
 /** Validate one retry record against the open turn and most recently closed step. */
 function validateRetry(
   history: readonly SessionEvent[],
@@ -139,7 +111,9 @@ function validateRetry(
     fail(`llm/retry provider ${provider} does not match the failed request provider ${String(routedProvider)}`)
   }
 
-  const chainStart = retryChainStart(history, turn)
+  const chainStart = history.findLastIndex(
+    prior => prior.type === 'turn/start' && prior.data.turn === turn,
+  )
   const chain = history.slice(Math.max(chainStart, 0))
   const lastSuccess = chain.findLastIndex(prior => prior.type === 'assistant/message')
   const chainRetries = chain.slice(lastSuccess + 1)