refactor(agent-loop): simplify observable state machine

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

@@ -1,13 +1,13 @@
 /**
- * Bounded transient model-request retry policy on the agent loop's closed-step
- * recovery seam. Each scheduled retry is durable before its cancellable wait.
+ * Bounded transient model-request retry policy on the agent request-recovery
+ * seam. Each scheduled retry is durable before its cancellable wait.
  *
  * @module @deepseek-ai/dsh-llm-retry
  */
 
 import type { Context } from 'cordis'
 import z from 'schemastery'
-import type { Agent, RequestError, RequestErrorDecision } from '@deepseek-ai/dsh-agent'
+import type { Agent, RequestError } from '@deepseek-ai/dsh-agent'
 import type { LlmFailure } from '@deepseek-ai/dsh-llm'
 import type {} from '@deepseek-ai/dsh-session'
 import { MAX_TIMER_DELAY_MS } from '@deepseek-ai/dsh-timeout'
@@ -145,7 +145,8 @@ export function apply(ctx: Context, config: Config = {}, internals: RetryInterna
   const resolved = resolveConfig(config)
   const random = internals.random ?? Math.random
   const lifetime = new AbortController()
-  const active = new Set<Promise<RequestErrorDecision>>()
+  const active = new Set<Promise<void>>()
+  const retries = new WeakMap<Agent, number>()
 
   async function backoff(
     agent: Agent,
@@ -155,9 +156,9 @@ export function apply(ctx: Context, config: Config = {}, internals: RetryInterna
     retry: number,
     delayMs: number,
     signal: AbortSignal,
-  ): Promise<RequestErrorDecision> {
+  ): Promise<void> {
     const fusedSignal = AbortSignal.any([signal, lifetime.signal])
-    if (fusedSignal.aborted) return { action: 'fail' }
+    if (fusedSignal.aborted) return
     agent.session.append('llm/retry', {
       turn,
       step,
@@ -166,29 +167,33 @@ export function apply(ctx: Context, config: Config = {}, internals: RetryInterna
       delayMs,
       failure,
     })
-    if (!await cancellableDelay(delayMs, fusedSignal)) return { action: 'fail' }
-    return { action: 'retry' }
+    retries.set(agent, retry)
+    if (!await cancellableDelay(delayMs, fusedSignal)) return
+    agent.retry()
   }
 
+  ctx.on('agent/idle', (agent) => {
+    retries.delete(agent)
+  })
+
   const disposeListener = ctx.on('agent/request-error', (
     agent: Agent,
     turn: number,
     step: number,
     _error: RequestError,
     failure: LlmFailure,
-    priorFailures: readonly LlmFailure[],
     signal: AbortSignal,
-    next: () => Promise<RequestErrorDecision>,
+    next: () => Promise<void>,
   ) => {
     // A waterfall may have captured this callback before its registration was
     // removed. Lifetime cancellation must prevent that stale callback from
     // entering a downstream policy after disposal.
-    if (lifetime.signal.aborted) return Promise.resolve<RequestErrorDecision>({ action: 'fail' })
+    if (lifetime.signal.aborted) return Promise.resolve()
     if (!resolved.retryableCodes.has(failure.code)) return next()
-    const priorTransientFailures = priorFailures.filter(item => resolved.retryableCodes.has(item.code)).length
-    if (priorTransientFailures >= resolved.maxTransientRetries) return next()
+    const priorRetries = retries.get(agent) ?? 0
+    if (priorRetries >= resolved.maxTransientRetries) return next()
 
-    const retry = priorTransientFailures + 1
+    const retry = priorRetries + 1
     let delayMs: number
     if (failure.providerRetryAfterMs !== undefined
       && Number.isFinite(failure.providerRetryAfterMs)

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

@@ -13,6 +13,34 @@ export const name = 'llm-retry-invariant'
 /** Service required before the companion can reserve package ownership. */
 export const inject = ['invariants']
 
+/** 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[],
@@ -59,14 +87,15 @@ function validateRetry(
     fail(`llm/retry names step ${step}, but the latest closed step is ${String(closedStep)}`)
   }
 
-  const priorRetries = currentTurnEvents
+  const chainStart = retryChainStart(history, turn)
+  const chainRetries = history.slice(Math.max(chainStart, 0))
     .filter((prior): prior is SessionEvent<'llm/retry'> => prior.type === 'llm/retry')
-  if (priorRetries.some(prior => prior.data.step === step)) {
+  if (chainRetries.some(prior => prior.data.turn === turn && prior.data.step === step)) {
     fail(`llm/retry duplicates the retry record for turn ${turn}/step ${step}`)
   }
-  const priorRetry = priorRetries[0]
-  if (priorRetry !== undefined && retry <= priorRetry.data.retry) {
-    fail(`llm/retry retry ${retry} must increase after retry ${priorRetry.data.retry}`)
+  const expectedRetry = chainRetries.length + 1
+  if (retry !== expectedRetry) {
+    fail(`llm/retry retry ${retry} must equal retry-chain position ${expectedRetry}`)
   }
 }