experimental-a2 0.18.0 → 0.19.0

package/src/ai.ts

@@ -23,7 +23,8 @@ import {
 } from './ai-client-state.ts'
 export type { PendingQueueCommand } from './ai-client-state.ts'
 import { applyControlChanges } from './ai-control-state.ts'
-import { initialControlState } from './ai-control.ts'
+import { STEERED_REASON, unexplainedAdmission } from './ai-control.ts'
+import { isJSONCompatible, isRecord, isUIMessage } from './ai-message-shape.ts'
 import { AI_EVENT_ID_PREFIX } from './ai-id.ts'
 import type {
   ControlCommit,
@@ -31,6 +32,7 @@ import type {
   ControlCommand,
   ControlReceipt,
   InboxItem,
+  InputRef,
   ToolExecutionRequest,
   WorkReport,
 } from './ai-control.ts'
@@ -39,6 +41,7 @@ export type {
   ControlCommand,
   ControlReceipt,
   InboxItem,
+  InputRef,
 } from './ai-control.ts'
 import { contract as createContract } from './contract.ts'
 import type { Contract, ContractEvent, EventDefs } from './contract.ts'
@@ -139,10 +142,15 @@ export type TranscriptMessage<M extends UIMessage> = Omit<M, 'parts'> & {
 
 export type SessionCreatedPayload = { metadata?: JSONValue }
 export type SessionClosedPayload = { reason?: string }
-export type MessageCreatedPayload<M extends UIMessage> = {
-  message: M
-  /** For user messages, false records passive context. Omission or true schedules. */
-  generate?: boolean
+/**
+ * A message entering the transcript. Its content is the command's that brought
+ * it in, which every reader of the transcript has already folded.
+ */
+export type MessageCreatedPayload = {
+  messageId: string
+  role: UIMessage['role']
+  /** For user messages, false records passive context. Omission schedules. */
+  generate?: false
 }
 export type MessageCompletedPayload = { messageId: string }
 type MessageInterruption = {
@@ -312,7 +320,7 @@ export type AIEventDefs<M extends UIMessage = UIMessage> = {
   }>
   'ai.session.created': StandardSchemaV1<SessionCreatedPayload>
   'ai.session.closed': StandardSchemaV1<SessionClosedPayload>
-  'ai.message.created': StandardSchemaV1<MessageCreatedPayload<M>>
+  'ai.message.created': StandardSchemaV1<MessageCreatedPayload>
   'ai.message.completed': StandardSchemaV1<MessageCompletedPayload>
   'ai.message.interrupted': StandardSchemaV1<MessageInterruptedPayload>
   'ai.generation.requested': StandardSchemaV1<GenerationRequestedPayload>
@@ -402,7 +410,7 @@ export type GenerationUsage = {
 export type AIState<M extends UIMessage = UIMessage> = {
   inbox: { paused: boolean; items: InboxItem<M>[] }
   pendingQueueCommands?: PendingQueueCommand<M>[]
-  active: ActiveTurn<M> | null
+  active: ActiveTurn | null
   starting: boolean
   receipt: ControlReceipt | null
   pausedGenerationIds?: Record<string, true>
@@ -433,13 +441,13 @@ export type AIState<M extends UIMessage = UIMessage> = {
   error: string | null
 }
 
-/** The `UIMessage` type a contract's `ai.message.created` schema carries. */
+/** The `UIMessage` type a contract's input commands carry. */
 export type AIMessageOf<D> = D extends {
-  readonly 'ai.message.created': infer S extends StandardSchemaV1
+  readonly 'ai.control.requested': infer S extends StandardSchemaV1
 }
-  ? StandardSchemaV1.InferOutput<S> extends MessageCreatedPayload<
-      infer M extends UIMessage
-    >
+  ? Extract<StandardSchemaV1.InferOutput<S>, { action: 'send' }> extends {
+      message: infer M extends UIMessage
+    }
     ? M
     : UIMessage
   : UIMessage
@@ -529,33 +537,6 @@ const schema = <T>(
   },
 })
 
-const isRecord = (value: unknown): value is Record<string, unknown> =>
-  typeof value === 'object' && value !== null && !Array.isArray(value)
-
-const isJSONCompatible = (
-  value: unknown,
-  seen: Set<object> = new Set(),
-): boolean => {
-  if (
-    value === null ||
-    typeof value === 'string' ||
-    typeof value === 'boolean'
-  ) {
-    return true
-  }
-  if (typeof value === 'number') return Number.isFinite(value)
-  if (typeof value === 'undefined') return true
-  if (typeof value !== 'object') return false
-  if (seen.has(value)) return false
-  seen.add(value)
-  const valid = Array.isArray(value)
-    ? value.every((item) => isJSONCompatible(item, seen))
-    : Object.getPrototypeOf(value) === Object.prototype &&
-      Object.values(value).every((item) => isJSONCompatible(item, seen))
-  seen.delete(value)
-  return valid
-}
-
 const jsonObject = <T extends object>(
   label: string,
   check: (value: Record<string, unknown>) => boolean,
@@ -584,45 +565,39 @@ const optionalStringField = (
   key: string,
 ): boolean => value[key] === undefined || typeof value[key] === 'string'
 
-const messageValue = (value: unknown): value is UIMessage =>
-  isRecord(value) &&
-  typeof value['id'] === 'string' &&
-  (value['role'] === 'user' ||
-    value['role'] === 'assistant' ||
-    value['role'] === 'system') &&
-  Array.isArray(value['parts']) &&
-  value['parts'].every(
-    (part) => isRecord(part) && typeof part['type'] === 'string',
-  ) &&
-  isJSONCompatible(value)
-
 const validateMessage = <M extends UIMessage>(
   value: unknown,
   messageSchema?: StandardSchemaV1<M>,
 ): SchemaResult<M> => {
-  if (!messageValue(value)) return issue('invalid AI SDK UIMessage')
+  if (!isUIMessage(value)) return issue('invalid AI SDK UIMessage')
   if (!messageSchema) return { value: value as M }
   return validateSync(messageSchema, value, 'the AI message')
 }
 
-const messagePayloadSchema = <M extends UIMessage>(
-  messageSchema?: StandardSchemaV1<M>,
-): StandardSchemaV1<MessageCreatedPayload<M>> =>
-  schema('ai.message.created', (value) => {
-    if (!isRecord(value)) return issue('invalid ai.message.created payload')
-    const message = validateMessage(value['message'], messageSchema)
-    if (message.issues) return { issues: message.issues }
-    const generate = value['generate']
-    if (generate !== undefined && typeof generate !== 'boolean') {
-      return issue('invalid ai.message.created generate flag')
-    }
+const messageCreatedSchema: StandardSchemaV1<MessageCreatedPayload> = schema(
+  'ai.message.created',
+  (value) => {
+    if (
+      !isRecord(value) ||
+      Object.keys(value).some(
+        (key) => key !== 'messageId' && key !== 'role' && key !== 'generate',
+      ) ||
+      !stringField(value, 'messageId') ||
+      (value['role'] !== 'user' &&
+        value['role'] !== 'assistant' &&
+        value['role'] !== 'system') ||
+      (value['generate'] !== undefined && value['generate'] !== false)
+    )
+      return issue('invalid ai.message.created payload')
     return {
       value: {
-        message: message.value,
-        ...(generate === false ? { generate: false } : {}),
+        messageId: value['messageId'] as string,
+        role: value['role'],
+        ...(value['generate'] === false ? { generate: false as const } : {}),
       },
     }
-  })
+  },
+)
 
 const progressPayloadSchema: StandardSchemaV1<GenerationProgressPayload> =
   schema('ai.generation.progress', (value) => {
@@ -731,6 +706,14 @@ export function createEvents<M extends UIMessage = UIMessage>(options?: {
           'AI command',
         )
         if (payload.issues) return { issues: payload.issues }
+        if (
+          action === 'interrupt' &&
+          isRecord(payload.value) &&
+          payload.value['reason'] === STEERED_REASON
+        )
+          return issue(
+            `the interruption reason "${STEERED_REASON}" is reserved for steering`,
+          )
         return { value: { action, [key]: payload.value } as ControlCommand<M> }
       }
       if (action === 'send' || action === 'edit' || action === 'steer') {
@@ -857,7 +840,7 @@ export function createEvents<M extends UIMessage = UIMessage>(options?: {
     'ai.session.closed': jsonObject('ai.session.closed', (value) =>
       optionalStringField(value, 'reason'),
     ),
-    'ai.message.created': messagePayloadSchema(messageSchema),
+    'ai.message.created': messageCreatedSchema,
     'ai.message.completed': jsonObject('ai.message.completed', (value) =>
       stringField(value, 'messageId'),
     ),
@@ -1036,7 +1019,7 @@ export function createEvents<M extends UIMessage = UIMessage>(options?: {
 export const events: AIEventDefs<UIMessage> = createEvents()
 
 const initialState = <M extends UIMessage>(): AIState<M> => ({
-  inbox: initialControlState<M>().inbox,
+  inbox: { paused: false, items: [] },
   pendingQueueCommands: [],
   active: null,
   starting: false,
@@ -1153,6 +1136,22 @@ export function reduceAIState<M extends UIMessage>(
   )
 }
 
+/**
+ * An input's content, while it is queued or about to enter the transcript:
+ * its inbox item's, or its pending send's or steer's, whose command id is the
+ * input's id.
+ */
+function inputContent<M extends UIMessage>(state: AIState<M>, id: string): M {
+  const queued = state.inbox.items.find((item) => item.id === id)?.message
+  if (queued !== undefined) return queued
+  const command = state.pendingQueueCommands?.find(
+    (item) => item.commandId === id,
+  )?.command
+  if (command?.action === 'send' || command?.action === 'steer')
+    return command.message
+  throw unexplainedAdmission(id)
+}
+
 function reduceAIEvent<M extends UIMessage>(
   state: AIState<M>,
   event: { type: string; payload: unknown; index: number; id?: string },
@@ -1177,12 +1176,35 @@ function reduceAIEvent<M extends UIMessage>(
     }
     case 'ai.control.committed': {
       const commit = event.payload as ControlCommit
-      const visible = applyControlChanges({
-        state: { inbox: state.inbox, active: state.active },
-        changes: commit.changes.filter(
-          (change) => change.path[0] === 'inbox' || change.path[0] === 'active',
-        ),
-      })
+      const changes = commit.changes.filter(
+        (change) => change.path[0] === 'inbox' || change.path[0] === 'active',
+      )
+      let { inbox, active } = state
+      if (changes.length > 0) {
+        // A commit holds inputs by reference; their content is the commands'.
+        const visible = applyControlChanges({
+          state: {
+            inbox: {
+              ...inbox,
+              items: inbox.items.map(
+                ({ message: _, ...input }): InputRef => input,
+              ),
+            },
+            active,
+          },
+          changes,
+        })
+        const queued = new Map(inbox.items.map((item) => [item.id, item]))
+        inbox = {
+          ...visible.inbox,
+          items: visible.inbox.items.map((input) => ({
+            ...input,
+            message:
+              queued.get(input.id)?.message ?? inputContent(state, input.id),
+          })),
+        }
+        active = visible.active
+      }
       const { phase } = commit.view
       const status: AgentStatus = commit.view.closed
         ? 'closed'
@@ -1199,7 +1221,8 @@ function reduceAIEvent<M extends UIMessage>(
                 : 'idle'
       return {
         ...state,
-        ...visible,
+        inbox,
+        active,
         status,
         activeRequestId: commit.view.requestId,
         activeRequestReason: commit.view.requestReason,
@@ -1214,9 +1237,24 @@ function reduceAIEvent<M extends UIMessage>(
       const settled = pending.find(
         (item) => item.commandId === receipt.commandId,
       )
+      // An edit's content takes effect at its receipt.
+      const edited =
+        receipt.outcome === 'applied' && settled?.command.action === 'edit'
+          ? settled.command.message
+          : undefined
       return {
         ...state,
         receipt,
+        ...(edited === undefined
+          ? {}
+          : {
+              inbox: {
+                ...state.inbox,
+                items: state.inbox.items.map((item) =>
+                  item.id === edited.id ? { ...item, message: edited } : item,
+                ),
+              },
+            }),
         ...(settled === undefined
           ? {}
           : {
@@ -1329,7 +1367,8 @@ function reduceAIEvent<M extends UIMessage>(
         activeProjection: null,
       }
     case 'ai.message.created': {
-      const { message } = event.payload as MessageCreatedPayload<M>
+      const { messageId } = event.payload as MessageCreatedPayload
+      const message = inputContent(state, messageId)
       return {
         ...state,
         messages: upsertMessage(state.messages, message),
@@ -2516,7 +2555,7 @@ export function handlerContext<D extends AgentToolEventDefs = AIEventDefs>(
 }
 
 /** The built-in AI reducer's name, and so its checkpoint identity. */
-export const AI_STATE_REDUCER = 'a2.ai.state.v26'
+export const AI_STATE_REDUCER = 'a2.ai.state.v27'
 
 /**
  * The built-in AI protocol plus application events, as a core contract whose

package/src/internal.ts

@@ -274,12 +274,18 @@ export const DRAIN_TIMINGS: {
   watchdogGraceMs: number
   /** Maximum time a top-level append waits for its initial scheduler arm. */
   schedulerArmTimeoutMs: number
+  /** First retry delay after a caught failure, doubling per failure. */
+  failureRetryBaseMs: number
+  /** Ceiling of the caught-failure retry delay. */
+  failureRetryMaxMs: number
 } = {
   claimTtlMs: 5_000,
   claimHeartbeatMs: 2_000,
   renewRetryMs: 400,
   watchdogGraceMs: 1_000,
   schedulerArmTimeoutMs: 2_000,
+  failureRetryBaseMs: 1_000,
+  failureRetryMaxMs: 30_000,
 }
 
 /**

package/src/libfx.d.ts

@@ -14,8 +14,15 @@ declare module 'libfx' {
     cancel(): void
   }
 
+  export type FxPromptBlock =
+    | { type: 'text'; text: string }
+    | { type: 'image'; data: string; mimeType: string }
+
   export type FxAgent = {
-    prompt(input: string, options?: { signal?: AbortSignal }): FxTurn
+    prompt(
+      input: string | FxPromptBlock[],
+      options?: { signal?: AbortSignal },
+    ): FxTurn
     checkpoint(): Promise<Uint8Array>
     close(): Promise<void>
   }

package/src/scheduler-qstash.ts

@@ -912,7 +912,7 @@ export function qstash(options: QStashSchedulerOptions = {}): A2Scheduler {
         }
         if (result.settled) return response.ok()
 
-        if (result.outcome === 'busy') {
+        if (result.outcome === 'busy' || result.outcome === 'stalled') {
           if (result.schedulerArm) await result.schedulerArm
           else {
             await sendTask({
@@ -926,10 +926,10 @@ export function qstash(options: QStashSchedulerOptions = {}): A2Scheduler {
           return response.ok()
         }
 
-        // QStash's per-message retry default can be lower than A2's failure
-        // budget. Hand stalled work to a fresh durable message so recovery
-        // continues until the store reports success or dead-letter. If this
-        // publish fails, the throw keeps the current delivery retryable.
+        // A drain whose outcome is unknown hands its work to a fresh durable
+        // message: QStash's per-message retry default can be lower than A2's
+        // failure budget. If this publish fails, the throw keeps the current
+        // delivery retryable.
         await sendTask({
           version: 1,
           kind: 'drain',

package/src/scheduler-vercel.ts

@@ -14,8 +14,7 @@
  *   the configured deployment scope for sending and receiving.
  * - `handler(...servers)` is the delivery route: look up the server for
  *   the contract named in the message and drain it. Settled drains ack;
- *   contention arms a later watchdog before acking; handler failure keeps
- *   the current message and redelivers with backoff.
+ *   contention and handler failure arm a later watchdog before acking.
  *
  * `@vercel/queue` is an optional peer dependency, imported lazily. The
  * `transport` option is the injection seam — tests run a real little
@@ -44,12 +43,12 @@ import {
 } from './server.ts'
 
 /**
- * The "not settled yet" signal for a stalled handler — an expected state,
- * not a transport failure. The default transport classifies it in
- * `@vercel/queue`'s `retry` option and reschedules the delivery quietly
+ * The "not settled yet" signal for a drain whose outcome is unknown — an
+ * expected state, not a transport failure. The default transport classifies
+ * it in `@vercel/queue`'s `retry` option and reschedules the delivery quietly
  * (`{ afterSeconds }` → visibility change → 200 response, no error log)
- * instead of letting it surface as a thrown 500. Busy deliveries use a
- * fresh watchdog instead. Custom transports should treat this class the
+ * instead of letting it surface as a thrown 500. Busy and stalled deliveries
+ * use a fresh watchdog instead. Custom transports should treat this class the
  * same way when their protocol has a polite reschedule.
  */
 export class DrainUnsettled extends Error {}
@@ -101,12 +100,9 @@ export type VercelQueuesOptions = {
 /** Vercel Queues rejects shorter visibility changes. */
 const MIN_VISIBILITY_SECONDS = 30
 
-/** Vercel Queues' maximum message retention and delivery delay. */
+/** Vercel Queues' maximum message retention; its default is a day. */
 const MAX_RETENTION_SECONDS = 7 * 24 * 60 * 60
 
-/** Leave the final retention day for delivery and retries. */
-const MAX_DELAY_SECONDS = 6 * 24 * 60 * 60
-
 const TOPIC_PATTERN = /^[A-Za-z0-9_-]+$/
 const RETRYABLE_HTTP_CLIENT_STATUSES = new Set([408, 409, 425, 429])
 /** The SDK's send path maps these statuses to name-only error instances. */
@@ -258,14 +254,6 @@ export function vercelQueues(options: VercelQueuesOptions = {}): A2Scheduler {
       0,
       Math.ceil((deliveryTargetAt - nowMs) / 1_000),
     )
-    if (deliveryDelaySeconds > MAX_DELAY_SECONDS) {
-      throw classifySchedulerSendFailure(
-        new RangeError(
-          'vercelQueues() tasks cannot be delayed more than 6 days',
-        ),
-        'terminal',
-      )
-    }
     const message: SchedulerTask = { ...task, dueAt }
     const idempotencyKey =
       task.kind === 'drain'
@@ -354,11 +342,12 @@ export function vercelQueues(options: VercelQueuesOptions = {}): A2Scheduler {
               }
           if (result.settled) return
 
-          if (result.outcome === 'busy') {
-            // The live owner normally arms its own claim windows.
-            // Ensure a later slot here as well before relinquishing this
-            // durable delivery. If the queue is down, the throw leaves the
-            // current message unacked for visibility-timeout redelivery.
+          if (result.outcome === 'busy' || result.outcome === 'stalled') {
+            // The live owner arms its own claim windows, and the store holds
+            // a failed event until its retry time. Ensure a later slot here
+            // as well before relinquishing this durable delivery. If the queue is down, the
+            // throw leaves the current message unacked for visibility-timeout
+            // redelivery.
             if (result.schedulerArm) await result.schedulerArm
             else {
               await sendTask({
@@ -372,9 +361,8 @@ export function vercelQueues(options: VercelQueuesOptions = {}): A2Scheduler {
             return
           }
 
-          // Handler failure keeps the current durable message and uses the
-          // transport retry path. Dead-lettered sessions count as settled
-          // above, so retries stop there.
+          // A drain whose outcome is unknown keeps the current durable message
+          // and uses the transport retry path.
           throw new DrainUnsettled(
             `a2 scheduler: session '${task.sessionId}' of '${task.contract}' not settled yet (${result.outcome}) — rescheduled for redelivery`,
           )

package/src/server.ts

@@ -205,9 +205,15 @@ export type DeadLetter<D extends EventDefs> = ContractEvent<D> & {
   lane: string | null
   /** Durable dispatch claims, including claims abandoned by hard kills. */
   attemptCount: number
-  /** Caught handler failures since the event was appended or last retried. */
+  /**
+   * Failed attempts since the event was appended or last retried: caught
+   * handler failures, and attempts that ended before they finished.
+   */
   failureCount: number
-  /** The last handler failure, stringified. */
+  /**
+   * The last error a handler threw, stringified; null when every failed
+   * attempt ended before it finished.
+   */
   lastError: string | null
   failedAt: Date
 }
@@ -499,6 +505,13 @@ export type ServerOptions<
 
 const MAX_FAILURES = 10
 
+/** How long an event waits after its `failureCount`th failed attempt. */
+const failureRetryDelayMs = (failureCount: number): number =>
+  Math.min(
+    DRAIN_TIMINGS.failureRetryBaseMs * 2 ** Math.max(failureCount - 1, 0),
+    DRAIN_TIMINGS.failureRetryMaxMs,
+  )
+
 /** Abort a lost attempt's handler and release its drain slot. */
 function endSuperseded(
   entry: {
@@ -527,6 +540,7 @@ type ClaimWindow = {
   expiresAtMs: number
   watchdogAtMs: number
   deadlineCapped: boolean
+  pastDeadline: boolean
 }
 
 type DrainSignal = {
@@ -601,9 +615,11 @@ function pruneAbortHub(hub: AbortHub): void {
 }
 
 /**
- * Deadlines tighten the claim/watchdog window; they never decide whether a
- * handler starts. A platform timeout therefore follows the same path as any
- * other process death: the in-flight event remains pending and is retried.
+ * Deadlines tighten the claim/watchdog window, and a passed deadline ends
+ * claiming: a claim then could not run, only lapse and be claimed again until
+ * the platform ends the process. A platform timeout otherwise follows the
+ * same path as any other process death: the in-flight event remains pending
+ * and a fresh invocation retries it.
  */
 function nextClaimWindow(): ClaimWindow {
   const nowMs = Date.now()
@@ -619,6 +635,7 @@ function nextClaimWindow(): ClaimWindow {
     expiresAtMs,
     watchdogAtMs: expiresAtMs + DRAIN_TIMINGS.watchdogGraceMs,
     deadlineCapped,
+    pastDeadline: deadlineMs !== null && deadlineTtlMs <= 0,
   }
 }
 
@@ -3068,6 +3085,25 @@ export function createServer<
           return tracked
         }
 
+        /** Records an event the store dead-lettered on takeover; it never runs. */
+        const reportExhausted = (event: StoredEvent): Promise<void> =>
+          telemetry.span(
+            'a2.event',
+            {
+              'a2.contract': name,
+              'a2.session_id': sessionId,
+              'a2.event.type': event.type,
+              'a2.event.index': event.index,
+              'a2.event.id': event.id,
+              'a2.event.attempt': event.attemptCount,
+              'a2.event.handled': handlers.has(event.type),
+              ...(event.lane === null ? {} : { 'a2.event.lane': event.lane }),
+            },
+            async (eventSpan) => {
+              eventSpan.setAttribute('a2.event.outcome', 'dead_lettered')
+            },
+          )
+
         const runEvent = async (
           event: StoredEvent,
           supersedeSignal: AbortSignal,
@@ -3127,9 +3163,8 @@ export function createServer<
                 if (supersedeSignal.aborted && err === supersedeSignal.reason) {
                   // The handler surrendered to its own abort — identity, not
                   // code, so it cannot arrive from another context. A lapse
-                  // is not a handler failure: no completion, no failure
-                  // budget spent; the claim simply expires and recovery
-                  // retries.
+                  // is not a handler failure: no completion; the claim simply
+                  // expires, and the claim that takes it over counts it.
                   eventSpan.setAttribute('a2.event.outcome', 'surrendered')
                   return {
                     status: 'surrendered',
@@ -3162,6 +3197,7 @@ export function createServer<
                       // budget before dead-lettering.
                       maxFailures:
                         err instanceof NonRetriableError ? 1 : MAX_FAILURES,
+                      retryAfterMs: failureRetryDelayMs(event.failureCount + 1),
                     })
                     commitSpan.setAttribute('a2.commit.outcome', result.outcome)
                     return result
@@ -3293,6 +3329,10 @@ export function createServer<
             let claim: StoreClaimAvailableResult | undefined
             if (shouldClaim) {
               const window = nextClaimWindow()
+              if (window.pastDeadline) {
+                outcome = 'busy'
+                break
+              }
               claim = await telemetry.span(
                 'a2.claim',
                 { 'a2.contract': name, 'a2.session_id': sessionId },
@@ -3301,6 +3341,7 @@ export function createServer<
                     sessionId: ns,
                     holder,
                     ttlMs: window.ttlMs,
+                    maxFailures: MAX_FAILURES,
                     ...(window.deadlineCapped
                       ? { expiresAtMs: window.expiresAtMs }
                       : {}),
@@ -3317,11 +3358,16 @@ export function createServer<
                 },
               )
               if (claim.outcome === 'claimed') {
-                requestWatchdog(window.watchdogAtMs)
+                // A takeover that spent the last failed attempt comes back
+                // dead-lettered instead of claimed.
+                const runnable = claim.events.filter(
+                  (event) => event.failedAt === null,
+                )
+                for (const event of claim.events)
+                  if (event.failedAt !== null) await reportExhausted(event)
+                if (runnable.length > 0) requestWatchdog(window.watchdogAtMs)
                 if (window.deadlineCapped) stopRenewing = true
-                for (const event of claim.events) {
-                  start(event, window.expiresAtMs)
-                }
+                for (const event of runnable) start(event, window.expiresAtMs)
                 shouldClaim = false
               }
             }