experimental-a2 0.16.0 → 0.16.1

package/dist/ai.d.ts

@@ -1,2 +1,2 @@
-import { $ as reduceAIState, A as MessageInterruptedPayload, B as SessionCreatedPayload, C as GenerationUsage, D as LanguageModelUsage, E as JSONValue, F as PendingApproval, G as UIMessageChunk, H as ToolCalledPayload, I as PendingInput, J as createReducer, K as agent, L as RetryGenerationOptions, M as ModelMetadataRequestedPayload, N as ModelMetadataResolvedPayload, O as MessageCompletedPayload, P as ModelMetadataState, Q as inputs, R as RetryRequestedPayload, S as GenerationStartedPayload, T as InputRespondedPayload, U as ToolResultPayload, V as ToolActivity, W as UIMessage, X as events, Y as deriveUIMessages, Z as handlerContext, _ as GenerationCompletedPayload, a as ActiveGenerationProjection, at as ControlReceipt, b as GenerationReason, c as AgentStatus, d as ApprovalRequestedPayload, et as AIStoredReducer, f as ApprovalRespondedPayload, g as FinishReason, h as CompactionState, i as ActiveGeneration, it as ControlCommand, j as ModelLimits, k as MessageCreatedPayload, l as AgentToolContext, m as CompactionRequestedPayload, n as AIInputs, nt as PendingQueueCommand, o as AgentDefinition, ot as InboxItem, p as CompactionCompletedPayload, q as createEvents, r as AIState, rt as ActiveTurn, s as AgentOptions, t as AIEventDefs, tt as AIStoredState, u as AgentToolEventDefs, v as GenerationFailedPayload, w as InputRequestedPayload, x as GenerationRequestedPayload, y as GenerationProgressPayload, z as SessionClosedPayload } from "./ai-HJ9fHfYI.js";
+import { $ as reduceAIState, A as MessageInterruptedPayload, B as SessionCreatedPayload, C as GenerationUsage, D as LanguageModelUsage, E as JSONValue, F as PendingApproval, G as UIMessageChunk, H as ToolCalledPayload, I as PendingInput, J as createReducer, K as agent, L as RetryGenerationOptions, M as ModelMetadataRequestedPayload, N as ModelMetadataResolvedPayload, O as MessageCompletedPayload, P as ModelMetadataState, Q as inputs, R as RetryRequestedPayload, S as GenerationStartedPayload, T as InputRespondedPayload, U as ToolResultPayload, V as ToolActivity, W as UIMessage, X as events, Y as deriveUIMessages, Z as handlerContext, _ as GenerationCompletedPayload, a as ActiveGenerationProjection, at as ControlReceipt, b as GenerationReason, c as AgentStatus, d as ApprovalRequestedPayload, et as AIStoredReducer, f as ApprovalRespondedPayload, g as FinishReason, h as CompactionState, i as ActiveGeneration, it as ControlCommand, j as ModelLimits, k as MessageCreatedPayload, l as AgentToolContext, m as CompactionRequestedPayload, n as AIInputs, nt as PendingQueueCommand, o as AgentDefinition, ot as InboxItem, p as CompactionCompletedPayload, q as createEvents, r as AIState, rt as ActiveTurn, s as AgentOptions, t as AIEventDefs, tt as AIStoredState, u as AgentToolEventDefs, v as GenerationFailedPayload, w as InputRequestedPayload, x as GenerationRequestedPayload, y as GenerationProgressPayload, z as SessionClosedPayload } from "./ai-CrEf6p_W.js";
 export { AIEventDefs, AIInputs, AIState, type AIStoredReducer, type AIStoredState, ActiveGeneration, ActiveGenerationProjection, type ActiveTurn, AgentDefinition, AgentOptions, AgentStatus, AgentToolContext, AgentToolEventDefs, ApprovalRequestedPayload, ApprovalRespondedPayload, CompactionCompletedPayload, CompactionRequestedPayload, CompactionState, type ControlCommand, type ControlReceipt, type FinishReason, GenerationCompletedPayload, GenerationFailedPayload, GenerationProgressPayload, GenerationReason, GenerationRequestedPayload, GenerationStartedPayload, GenerationUsage, type InboxItem, InputRequestedPayload, InputRespondedPayload, type JSONValue, type LanguageModelUsage, MessageCompletedPayload, MessageCreatedPayload, MessageInterruptedPayload, ModelLimits, ModelMetadataRequestedPayload, ModelMetadataResolvedPayload, ModelMetadataState, PendingApproval, PendingInput, type PendingQueueCommand, RetryGenerationOptions, RetryRequestedPayload, SessionClosedPayload, SessionCreatedPayload, ToolActivity, ToolCalledPayload, ToolResultPayload, type UIMessage, type UIMessageChunk, agent, createEvents, createReducer, deriveUIMessages, events, handlerContext, inputs, reduceAIState };

package/dist/ai.js

@@ -1,2 +1,2 @@
-import { a as events, c as reduceAIState, i as deriveUIMessages, n as createEvents, o as handlerContext, r as createReducer, s as inputs, t as agent } from "./ai-CrLYwNEx.js";
+import { a as events, c as reduceAIState, i as deriveUIMessages, n as createEvents, o as handlerContext, r as createReducer, s as inputs, t as agent } from "./ai-DgOBltJ_.js";
 export { agent, createEvents, createReducer, deriveUIMessages, events, handlerContext, inputs, reduceAIState };

package/docs/guides/06-ai-agents.mdx

@@ -728,8 +728,10 @@ export function StopButton() {
 }
 ```
 
-The accepted command ends the turn and reaches A2's cancellation channel. `lastSeenIndex` is the exact confirmed log frontier visible when the
-user clicked. The reducer rewinds the indexed generation projection to that
+The client immediately previews Stop for the observed turn. `lastSeenIndex` is the exact confirmed log frontier visible when the
+user clicked. While that generation's indexed projection is retained, the client freezes the response at that
+frontier through the request echo and controller decision. A rejected push or decision removes the preview.
+The reducer rewinds the indexed generation projection to that
 frontier and keeps the partial text the user actually saw. Tool parts whose
 arguments are still streaming are drafts: interruption removes them from the
 conversation and subsequent model prompts, even if their current JSON parses.
@@ -740,6 +742,13 @@ input, and compaction events remain in raw history but cannot reactivate it or
 alter the projection.
 Completed tool results at or before the visible frontier remain completed.
 
+Once Stop is persisted, A2's existing cancellation stream aborts running model
+and tool work for that turn without waiting for the control handler. Startup
+checks also skip matching jobs created while Stop is pending. Cancellation is
+cooperative: tools must honor their abort signal. The control handler remains
+responsible for recording the interruption and advancing the inbox; a Stop for
+an older turn cannot cancel its successor.
+
 For the lower-level `inputs.interrupt()` builder, between
 `ai.generation.requested` and `ai.generation.started`, copy
 `activeRequestId` as `requestId` and `activeResponseMessageId` as `messageId`.
@@ -1219,8 +1228,9 @@ With `agent().reducer` or `createReducer()`, the client state is already optimis
 An idle, unpaused send appears in `state.messages` immediately, with
 `state.starting: true`. Another send waits in `state.inbox.items` while that
 optimistic turn or a confirmed turn is active. Paused sessions keep new sends in
-the inbox. Render the conversation and queue from `state`; `state.active` and
-execution controls remain server-confirmed.
+the inbox. Render the conversation and queue from `state`. A pending Stop clears
+the displayed `state.active` turn immediately; rejection restores it. New active
+turn identities still come from accepted control decisions.
 Steering appears immediately in `state.messages`, after the current response,
 and stays there while that step finishes. Send now has the same display when
 an active turn is targeted. These inputs are omitted from the client inbox,
@@ -1267,7 +1277,7 @@ A custom reducer can keep normalized AI state by nesting `agent.reducer.fold()`
 and derive its view with `agent.reducer.view()`. It does not inherit the built-in
 optimistic client display. `reduceAIState()` remains a pure transition over the
 confirmed `AIState` view for applications that project raw event histories.
-`state.pendingQueueCommands` tracks unresolved queue commands incrementally, so
+`state.pendingQueueCommands` tracks unresolved queue commands and Stops incrementally, so
 the client does not scan raw history. Pending edits apply in order, so the latest
 local edit stays visible while earlier commands are confirmed. Editing and Send
 now can remain available while an edit awaits its receipt. Close an editor as

package/docs/reference/01-api.mdx

@@ -1234,7 +1234,7 @@ message type. Both are isomorphic.
 
 Clients using `agent().reducer` or `createReducer()` expose `state.messages`,
 `state.inbox`, and `state.starting` with pending send, edit, move, remove,
-Send now, steer, pause, and resume commands applied for display. Idle, unpaused
+Send now, steer, pause, resume, and Stop commands applied for display. Idle, unpaused
 sends appear in the conversation immediately. A generating input occupies the
 optimistic turn, so subsequent sends queue. Busy or paused sessions queue new
 sends. `starting` indicates a speculative turn awaiting acceptance; it does not
@@ -1245,7 +1245,12 @@ inbox. This display survives receipt and hydration, including while paused.
 They remain pending server inputs until admission and do not enter the model
 prompt early. Multiple steering inputs follow inbox admission order.
 
-`state.active` and model execution stay confirmed.
+New active turn identities come from accepted control decisions. A pending Stop
+for that turn clears the displayed `state.active`, generation, and pending
+approvals/inputs, and previews an idle status (or paused when the inbox is paused). With
+`lastSeenIndex`, its retained generation projection freezes at the observed
+frontier. The preview lasts through the request echo until the controller's
+decision; rejected requests restore the confirmed active turn and output.
 Server reads and reducer folds retain confirmed messages and inbox entries;
 `state.starting` is false there. Custom reducers that call `reduceAIState()` or
 nest the AI fold do not inherit the client display behavior. Repeat editing and
@@ -1313,7 +1318,7 @@ Checkpoint size and serialization cost still grow with retained progress.
 Tool-input deltas update `input-streaming` parts with best-effort partial JSON
 for display. The state stays `input-streaming` until a completed input arrives;
 partial parsing does not authorize execution or change interruption handling.
-Extension events are ignored. The default reducer name is `a2.ai.state.v21:records-v2`.
+Extension events are ignored. The default reducer name is `a2.ai.state.v22:records-v2`.
 
 ### `deriveUIMessages(history)` and `reduceAIState(state, event)`
 

package/examples/playground/package.json

@@ -22,7 +22,7 @@
     "@vercel/sandbox": "^3.0.0",
     "ai": "^7.0.58",
     "codemirror": "^6.0.2",
-    "experimental-a2": "0.16.0",
+    "experimental-a2": "0.16.1",
     "ioredis": "^5.9.0",
     "next": "^16.3.0",
     "pg": "^8.16.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "experimental-a2",
-  "version": "0.16.0",
+  "version": "0.16.1",
   "description": "Durable sync and reactions for things with a lifecycle: one event log, derived state, and live client per session.",
   "license": "MIT",
   "type": "module",

package/src/ai-client-state.ts

@@ -1,6 +1,7 @@
 import type { UIMessage } from 'ai'
 import type { AIState } from './ai.ts'
 import type { ControlCommand, InboxItem } from './ai-control.ts'
+import { interruptGenerationProjection } from './ai-message-projection.ts'
 
 export type QueueCommand<M extends UIMessage> = Extract<
   ControlCommand<M>,
@@ -14,6 +15,7 @@ export type QueueCommand<M extends UIMessage> = Extract<
       | 'steer'
       | 'pause'
       | 'resume'
+      | 'stop'
   }
 >
 export type PendingQueueCommand<M extends UIMessage> = {
@@ -31,7 +33,8 @@ export const isQueueCommand = <M extends UIMessage>(
   command.action === 'send-now' ||
   command.action === 'steer' ||
   command.action === 'pause' ||
-  command.action === 'resume'
+  command.action === 'resume' ||
+  command.action === 'stop'
 
 const moveItem = <M extends UIMessage>({
   items,
@@ -166,6 +169,8 @@ export function projectAIClientState<M extends UIMessage>(
         paused = false
         suspended = false
         break
+      case 'stop':
+        continue
     }
     admit()
   }
@@ -174,10 +179,39 @@ export function projectAIClientState<M extends UIMessage>(
     show(item.message)
     return false
   })
-  return {
+  const displayed = {
     ...state,
     messages,
     inbox: { items, paused },
     starting: starting && !suspended,
   }
+  const stop = pending.find(
+    ({ command }) =>
+      command.action === 'stop' && command.turnId === state.active?.turnId,
+  )?.command
+  if (stop?.action !== 'stop') return displayed
+  const projection = state.activeProjection
+  const stopped =
+    projection === null
+      ? displayed
+      : (interruptGenerationProjection(
+          displayed,
+          projection.generationId,
+          projection.responseMessageId,
+          stop.lastSeenIndex ?? Number.POSITIVE_INFINITY,
+        ) ?? displayed)
+  return {
+    ...stopped,
+    active: null,
+    status: paused ? 'paused' : 'idle',
+    starting: false,
+    activeGeneration: null,
+    activeRequestId: null,
+    activeRequestReason: null,
+    activeRequestSourceGenerationId: null,
+    activeResponseMessageId: null,
+    pendingApprovals: [],
+    pendingInputs: [],
+    error: null,
+  }
 }

package/src/ai-control-server.ts

@@ -73,17 +73,36 @@ export const createControlRuntime = <
 }): AIControlRuntime<M, D> => {
   const reducer = options.agent.contract
     .reducer({
-      name: 'a2.ai.control.v4',
+      name: 'a2.ai.control.v5',
       initialState: initialControlState<M>(),
     })
-    .fold((state, event) =>
-      event.type === 'ai.control.committed'
+    .fold((state, event) => {
+      if (event.type === 'ai.control.requested') {
+        const command = event.payload as ControlCommand<M>
+        if (command.action === 'stop')
+          return {
+            ...state,
+            pendingStops: {
+              ...state.pendingStops,
+              [event.id]: command.turnId,
+            },
+          }
+      }
+      if (event.type === 'ai.control.decided') {
+        const receipt = event.payload as ControlReceipt
+        if (Object.hasOwn(state.pendingStops, receipt.commandId)) {
+          const pendingStops = { ...state.pendingStops }
+          delete pendingStops[receipt.commandId]
+          return { ...state, pendingStops }
+        }
+      }
+      return event.type === 'ai.control.committed'
         ? applyControlChanges({
             state,
             changes: (event.payload as ControlCommit).changes,
           })
-        : state,
-    )
+        : state
+    })
   const coordinator = aiCoordinatorReducer(options.agent.contract)
 
   const handler = async (

package/src/ai-control.ts

@@ -77,6 +77,7 @@ export type ControlWork = {
 }
 
 export type AIControlState<M extends UIMessage = UIMessage> = {
+  pendingStops: Record<string, string>
   inbox: { paused: boolean; items: InboxItem<M>[] }
   active:
     | (ActiveTurn<M> & {
@@ -109,6 +110,7 @@ export type ToolExecutionRequest = {
 export const initialControlState = <
   M extends UIMessage,
 >(): AIControlState<M> => ({
+  pendingStops: {},
   inbox: { paused: false, items: [] },
   active: null,
   coordinator: { closed: false, queued: [] },

package/src/ai-message-projection.ts

@@ -1,13 +1,18 @@
 import type { UIMessage, UIMessageChunk } from 'ai'
 import type {
   ActiveGenerationProjection,
+  AIState,
   ApprovalRequestedPayload,
   ApprovalRespondedPayload,
   ToolCalledPayload,
   ToolResultPayload,
   ToolActivity,
 } from './ai.ts'
-import { type UIMessageCursor, projectUIMessageStream } from './ai-projector.ts'
+import {
+  type UIMessageCursor,
+  projectUIMessageStream,
+  interruptUIMessage,
+} from './ai-projector.ts'
 import {
   flattenProgressBatches,
   appendProgressBatch,
@@ -346,3 +351,124 @@ export const advanceProjection = <M extends UIMessage>({
     },
   }
 }
+
+export const projectedTools = <M extends UIMessage>(
+  projection: ActiveGenerationProjection<M>,
+): ToolActivity[] =>
+  projection.toolEvents.reduce(
+    (tools, event) => reduceToolActivity(tools, event),
+    projection.baseTools,
+  )
+
+export const restoreGenerationBase = <M extends UIMessage>(
+  state: AIState<M>,
+  generationId: string,
+  responseMessageId: string,
+  reason: 'interrupted' | 'superseded' | 'failed',
+): AIState<M> => {
+  const projection =
+    state.activeProjection?.generationId === generationId
+      ? state.activeProjection
+      : null
+  return {
+    ...state,
+    messages:
+      projection?.baseMessage === undefined
+        ? state.messages.filter((message) => message.id !== responseMessageId)
+        : upsertMessage(state.messages, projection.baseMessage),
+    tools:
+      projection === null
+        ? state.tools.filter(
+            (activity) => activity.generationId !== generationId,
+          )
+        : projection.baseTools,
+    pendingApprovals: state.pendingApprovals.filter(
+      (approval) => approval.generationId !== generationId,
+    ),
+    pendingInputs: state.pendingInputs.filter(
+      (input) => input.generationId !== generationId,
+    ),
+    activeGeneration: null,
+    activeProjection: null,
+    terminalGenerations: {
+      ...state.terminalGenerations,
+      [generationId]: reason,
+    },
+    compaction:
+      projection === null
+        ? state.compaction?.generationId === generationId
+          ? null
+          : state.compaction
+        : (projection.baseCompaction ?? null),
+  }
+}
+
+export const stopGenerationTools = (
+  tools: ToolActivity[],
+  generationId: string | undefined,
+  responseMessageId: string,
+  error: string,
+): ToolActivity[] =>
+  tools.map((activity) =>
+    activity.status === 'running' &&
+    (generationId === undefined
+      ? activity.messageId === responseMessageId
+      : activity.generationId === generationId)
+      ? { ...activity, status: 'failed', error, preliminary: false }
+      : activity,
+  )
+
+export const interruptGenerationProjection = <M extends UIMessage>(
+  state: AIState<M>,
+  generationId: string,
+  responseMessageId: string,
+  cutoff: number,
+): AIState<M> | null => {
+  const projection =
+    state.activeProjection?.generationId === generationId
+      ? state.activeProjection
+      : null
+  if (projection === null) return null
+  const retained: ActiveGenerationProjection<M> = {
+    ...projection,
+    batches: progressBatches(
+      flattenProgressBatches(projection.batches).filter(
+        (batch) => batch.index <= cutoff,
+      ),
+    ),
+    toolEvents: projection.toolEvents.filter(
+      (toolEvent) => toolEvent.index <= cutoff,
+    ),
+    approvalEvents: projection.approvalEvents.filter(
+      (approvalEvent) => approvalEvent.index <= cutoff,
+    ),
+  }
+  const shouldProject =
+    retained.baseMessage !== undefined || retained.batches.length > 0
+  const restored = restoreGenerationBase(
+    state,
+    generationId,
+    responseMessageId,
+    'interrupted',
+  )
+  return {
+    ...restored,
+    messages: shouldProject
+      ? upsertMessage(
+          state.messages,
+          interruptUIMessage(projectedMessage(retained)),
+        )
+      : restored.messages,
+    tools: stopGenerationTools(
+      projectedTools(retained),
+      generationId,
+      responseMessageId,
+      'Tool execution was interrupted.',
+    ),
+    usage:
+      projection.completionIndex === undefined ||
+      projection.completionIndex <= cutoff
+        ? restored.usage
+        : restored.usage.filter((entry) => entry.generationId !== generationId),
+  }
+}

package/src/ai-server.ts

@@ -1219,6 +1219,7 @@ export function createHandlers<
       )
       if (
         state.active?.turnId !== request.turnId ||
+        Object.values(state.pendingStops).includes(request.turnId) ||
         state.active.suspended ||
         state.active.version !== request.version ||
         state.coordinator.response?.failure !== undefined ||
@@ -1256,9 +1257,15 @@ export function createHandlers<
       snapshot.state.authority?.phase === 'pausing'
     )
       return
-    const coordinatorState = (
-      await ctx.session.state(coordinator, { through: snapshot.index })
+    const controlState = (
+      await ctx.session.state(control.reducer, { through: snapshot.index })
     ).state
+    if (
+      request.control !== undefined &&
+      Object.values(controlState.pendingStops).includes(request.control.turnId)
+    )
+      return
+    const coordinatorState = controlState.coordinator
     if (
       coordinatorState.closed ||
       coordinatorState.response?.activeRequestId !== requestId
@@ -1876,6 +1883,9 @@ export function createHandlers<
     'ai.generation.requested': {
       lane: 'a2.ai.model',
       abortOn: {
+        'ai.control.requested': (event, trigger) =>
+          event.payload.action === 'stop' &&
+          event.payload.turnId === trigger.payload.control?.turnId,
         'ai.control.committed': (event, trigger) => {
           const active = (event.payload as ControlCommit).view
           return (
@@ -1897,6 +1907,9 @@ export function createHandlers<
     },
     'ai.tool.execution.requested': {
       abortOn: {
+        'ai.control.requested': (event, trigger) =>
+          event.payload.action === 'stop' &&
+          event.payload.turnId === trigger.payload.turnId,
         'ai.generation.failed': (event, trigger) =>
           event.payload.generationId === trigger.payload.call.generationId,
         'ai.control.committed': (event, trigger) => {

package/src/ai.ts

@@ -53,6 +53,10 @@ import {
   approvalRequestedChunk,
   toolResultChunk,
   advanceProjection,
+  projectedTools,
+  restoreGenerationBase,
+  stopGenerationTools,
+  interruptGenerationProjection,
   projectedMessage,
   reduceToolActivity,
 } from './ai-message-projection.ts'
@@ -1027,127 +1031,6 @@ const projectedResponse = <M extends UIMessage>(options: {
     : message
 }
 
-const projectedTools = <M extends UIMessage>(
-  projection: ActiveGenerationProjection<M>,
-): ToolActivity[] =>
-  projection.toolEvents.reduce(
-    (tools, event) => reduceToolActivity(tools, event),
-    projection.baseTools,
-  )
-
-const restoreGenerationBase = <M extends UIMessage>(
-  state: AIState<M>,
-  generationId: string,
-  responseMessageId: string,
-  reason: 'interrupted' | 'superseded' | 'failed',
-): AIState<M> => {
-  const projection =
-    state.activeProjection?.generationId === generationId
-      ? state.activeProjection
-      : null
-  return {
-    ...state,
-    messages:
-      projection?.baseMessage === undefined
-        ? state.messages.filter((message) => message.id !== responseMessageId)
-        : upsertMessage(state.messages, projection.baseMessage),
-    tools:
-      projection === null
-        ? state.tools.filter(
-            (activity) => activity.generationId !== generationId,
-          )
-        : projection.baseTools,
-    pendingApprovals: state.pendingApprovals.filter(
-      (approval) => approval.generationId !== generationId,
-    ),
-    pendingInputs: state.pendingInputs.filter(
-      (input) => input.generationId !== generationId,
-    ),
-    activeGeneration: null,
-    activeProjection: null,
-    terminalGenerations: {
-      ...state.terminalGenerations,
-      [generationId]: reason,
-    },
-    compaction:
-      projection === null
-        ? state.compaction?.generationId === generationId
-          ? null
-          : state.compaction
-        : (projection.baseCompaction ?? null),
-  }
-}
-
-const stopGenerationTools = (
-  tools: ToolActivity[],
-  generationId: string | undefined,
-  responseMessageId: string,
-  error: string,
-): ToolActivity[] =>
-  tools.map((activity) =>
-    activity.status === 'running' &&
-    (generationId === undefined
-      ? activity.messageId === responseMessageId
-      : activity.generationId === generationId)
-      ? { ...activity, status: 'failed', error, preliminary: false }
-      : activity,
-  )
-
-const interruptGenerationProjection = <M extends UIMessage>(
-  state: AIState<M>,
-  generationId: string,
-  responseMessageId: string,
-  cutoff: number,
-): AIState<M> | null => {
-  const projection =
-    state.activeProjection?.generationId === generationId
-      ? state.activeProjection
-      : null
-  if (projection === null) return null
-  const retained: ActiveGenerationProjection<M> = {
-    ...projection,
-    batches: progressBatches(
-      flattenProgressBatches(projection.batches).filter(
-        (batch) => batch.index <= cutoff,
-      ),
-    ),
-    toolEvents: projection.toolEvents.filter(
-      (toolEvent) => toolEvent.index <= cutoff,
-    ),
-    approvalEvents: projection.approvalEvents.filter(
-      (approvalEvent) => approvalEvent.index <= cutoff,
-    ),
-  }
-  const shouldProject =
-    retained.baseMessage !== undefined || retained.batches.length > 0
-  const restored = restoreGenerationBase(
-    state,
-    generationId,
-    responseMessageId,
-    'interrupted',
-  )
-  return {
-    ...restored,
-    messages: shouldProject
-      ? upsertMessage(
-          state.messages,
-          interruptUIMessage(projectedMessage(retained)),
-        )
-      : restored.messages,
-    tools: stopGenerationTools(
-      projectedTools(retained),
-      generationId,
-      responseMessageId,
-      'Tool execution was interrupted.',
-    ),
-    usage:
-      projection.completionIndex === undefined ||
-      projection.completionIndex <= cutoff
-        ? restored.usage
-        : restored.usage.filter((entry) => entry.generationId !== generationId),
-  }
-}
-
 const terminalGenerationReason = <M extends UIMessage>(
   state: AIState<M>,
   generationId: string,
@@ -2306,7 +2189,7 @@ export function createReducer<D extends EventDefs>(options: {
   type M = AIMessageFrom<D>
   const reducer = options.contract
     .reducer({
-      name: options.name ?? 'a2.ai.state.v21',
+      name: options.name ?? 'a2.ai.state.v22',
       initialState: initialState<M>(),
       ...(options.stateSchema === undefined
         ? {}
@@ -2505,7 +2388,7 @@ export function agent<
   })
   const reducer = agentContract
     .reducer({
-      name: options.reducerName ?? 'a2.ai.state.v21',
+      name: options.reducerName ?? 'a2.ai.state.v22',
       initialState: initialState<M>(),
     })
     .fold((state, event) => reduceAIState(state, event))