agents 0.24.0 → 0.26.0

package/dist/chat/index.d.ts

@@ -1,18 +1,29 @@
-import { o as isPlatformFailure } from "../retries-D9B2UCq3.js";
+import {
+  i as isDurableObjectResetError,
+  s as isPlatformFailure
+} from "../retries-CV6AkXmQ.js";
 import {
   I as AgentToolEvent,
-  J as AgentToolRunState,
-  L as AgentToolEventMessage,
-  R as AgentToolEventState,
-  _ as FiberRecoveryContext$1
-} from "../agent-routing-B2XLNMxq.js";
-import { _ as TaskStep, m as TaskRunOptions } from "../tasks-V2lCT8ZV.js";
+  R as AgentToolEventMessage,
+  Y as AgentToolRunState,
+  _ as FiberRecoveryContext$1,
+  at as isPositionlessAgentToolChunk,
+  z as AgentToolEventState
+} from "../agent-routing-0DR0Tk2v.js";
+import { _ as TaskStep, m as TaskRunOptions } from "../tasks-9YxYtByh.js";
 import {
-  n as ClientToolSchema,
-  r as createToolsFromClientSchemas,
-  t as ClientToolExecutor
-} from "../client-tools-aIBO0Fk7.js";
-import { n as Streams } from "../streams-BcE8JP2X.js";
+  a as CHAT_MESSAGE_TYPES,
+  c as ClientToolExecutor,
+  i as OutgoingMessage,
+  l as ClientToolSchema,
+  n as IncomingMessage,
+  o as STREAM_RESUME_NONE_REASONS,
+  r as MessageType,
+  s as StreamResumeNoneReason,
+  t as ChatTurnOutcome,
+  u as createToolsFromClientSchemas
+} from "../wire-types-CrjKvDyi.js";
+import { n as Streams } from "../streams-Cmkj9QfW.js";
 import {
   a as applyAgentToolEvent,
   i as AgentToolProgressEmitter,
@@ -21,9 +32,9 @@ import {
   r as AgentToolProgressEmitResult,
   s as interceptAgentToolBroadcast,
   t as AgentToolBroadcastHooks
-} from "../agent-tools-Dj5Mzlw7.js";
+} from "../agent-tools-YrATZJu2.js";
 import { l as SessionMessage } from "../types-B7LojTe4.js";
-import { JSONSchema7, UIMessage } from "ai";
+import { ModelMessage, UIMessage } from "ai";
 import { Connection, FiberRecoveryContext } from "agents";
 
 //#region src/chat/message-builder.d.ts
@@ -90,6 +101,44 @@ declare function normalizeToolInput(raw: unknown): {
   input: unknown;
   changed: boolean;
 };
+/**
+ * Whether `chunk` is a `tool-input-available` for a tool part that has
+ * already reached an approval state. Stream builders apply it server-side
+ * (see {@link applyLateToolInput}) but must not forward it: the AI SDK client
+ * would move its part back to `input-available` and drop the approval UI.
+ */
+declare function isLateToolInputChunk(
+  parts: MessagePart[],
+  chunk: StreamChunkData
+): boolean;
+/**
+ * Fill an approval part's input from a `tool-input-available` that arrived
+ * after its `tool-approval-request`, without changing the approval state.
+ * Only replaces input that is missing or was reconstructed from deltas, so
+ * a complete input the user has already seen is never swapped out.
+ *
+ * @returns `true` when the part's input changed.
+ */
+declare function applyLateToolInput(
+  parts: MessagePart[],
+  chunk: StreamChunkData
+): boolean;
+/**
+ * The chunks a stream builder forwards and stores for a late
+ * `tool-input-available` (see {@link isLateToolInputChunk}) so clients and
+ * stream replay see the input without losing the approval: the input chunk,
+ * then the part's approval request again. The AI SDK client moves the part
+ * to `input-available` on the first and back to `approval-requested` on the
+ * second.
+ *
+ * Returns `[]` unless the part is still awaiting approval: once the user has
+ * responded, re-sending the request would reopen it.
+ */
+declare function lateToolInputForwardChunks(
+  parts: MessagePart[],
+  chunk: StreamChunkData,
+  approvalRequest?: StreamChunkData
+): StreamChunkData[];
 /**
  * Applies a stream chunk to a mutable parts array, building up the message
  * incrementally. Returns true if the chunk was handled, false if it was
@@ -329,6 +378,23 @@ declare class TurnQueue {
   private _decrementCount;
 }
 //#endregion
+//#region src/chat/origin-message-ids.d.ts
+/**
+ * IDs of the user messages a chat request originated from: the trailing run of
+ * user messages in its `messages` (one for a plain send or a regenerate,
+ * several when queued sends arrive together). Terminal response frames echo
+ * them as `messageIds` (#2280).
+ */
+declare function originMessageIds$1(messages: unknown): string[] | undefined;
+/**
+ * Return `frame` with `messageIds` added when it is a terminal
+ * (`done` or `error`) frame that does not already carry them.
+ */
+declare function withOriginMessageIds<T extends object>(
+  frame: T,
+  messageIds: string[] | undefined
+): T;
+//#endregion
 //#region src/chat/text-segment-joiner.d.ts
 /** @internal A parsed structured-stream chunk accepted by the joiner. */
 interface TextSegmentChunk {
@@ -380,6 +446,11 @@ type ChatResponseResult = {
     | "error"
     | "aborted" /** Error message when `status` is `"error"`. */;
   error?: string;
+  /**
+   * `true` when the hook is delivered by recovery after a restart, because
+   * the turn's message was persisted but the hook had not run yet.
+   */
+  recovered?: boolean;
   /**
    * Advisory reply attachments recorded during the turn (best-effort,
    * producing-attempt only — not re-applied on a ledger replay).
@@ -534,10 +605,11 @@ type ChatRecoveryProgressContext = {
   maxAttempts: number;
   recoveryKind: "retry" | "continue";
   /**
-   * Recovery work units produced since this incident began — a durable,
-   * monotonic, reconnect-immune count of produced content/tool segments (not
-   * tokens). The signal that distinguishes a healthy long turn from a runaway
-   * loop.
+   * Recovery work produced since this incident began — a durable, monotonic,
+   * reconnect-immune count of flushed stream segments (roughly ten packed
+   * streaming chunks, one settled tool result, or one forwarded sub-agent
+   * credit each; not tokens). The signal that distinguishes a healthy long turn
+   * from a runaway loop, in the same unit as `maxRecoveryWork`.
    */
   work: number /** Wall-clock ms since the incident's first interruption. */;
   ageMs: number;
@@ -573,9 +645,9 @@ type ChatRecoveryConfig =
        */
       noProgressTimeoutMs?: number;
       /**
-       * Runaway-loop guard. Maximum recovery WORK — produced content/tool units
-       * since the incident began — before a still-progressing turn is sealed
-       * with `reason="work_budget_exceeded"`. Defaults to `1000`: a generous
+       * Runaway-loop guard. Maximum recovery WORK since the incident began
+       * before a still-progressing turn is sealed with
+       * `reason="work_budget_exceeded"`. Defaults to `10000`: a generous
        * backstop that bounds wasted re-run cost when a turn keeps emitting a
        * little content but never converges (e.g. an isolate that OOMs mid-stream
        * on every recovery — #1825 — which otherwise resets the attempt cap and
@@ -585,6 +657,14 @@ type ChatRecoveryConfig =
        * that legitimately needs more can raise this (or set `Infinity` to
        * disable the framework cap and bound the runaway via `shouldKeepRecovering`
        * instead).
+       *
+       * The unit is one durably flushed stream segment: roughly ten packed
+       * streaming chunks, one settled tool result (flushed on its own), or one
+       * explicit credit for forwarded sub-agent output. It is not tokens,
+       * messages, or chunks. The unit changed from "credited chunk" in #2223
+       * (and the default moved from `1000` to `10000`); an explicit value
+       * carried over from an earlier release is not recalibrated, so measure
+       * `ctx.work` for a healthy interrupted turn before choosing a cap.
        */
       maxRecoveryWork?: number;
       /**
@@ -800,6 +880,12 @@ declare class ResumableStream {
    * restored from SQLite after hibernation in restore().
    */
   private _activeIsContinuation;
+  /**
+   * Index the next stored chunk of the active stream gets, which is also its
+   * position in a replay. `null` for a stream restored from SQLite, whose
+   * count is not tracked.
+   */
+  private _nextChunkSeq;
   private _chunkBuffer;
   private _chunkBufferBytes;
   private _isFlushingChunks;
@@ -809,6 +895,8 @@ declare class ResumableStream {
    * write, or {@link finalizePending} it when there is nothing to persist.
    */
   private _pendingCutover;
+  /** The stream most recently closed by complete, finish, or markError. */
+  private _lastClosedStreamId;
   private readonly ops;
   constructor(
     streams: Streams,
@@ -911,9 +999,13 @@ declare class ResumableStream {
     requestId: string,
     options?: {
       messageId?: string;
+      parentMessageId?: string;
       continuation?: boolean;
+      originMessageIds?: string[];
     }
   ): string;
+  private _nextSeqForRequest;
+  private _seqBase;
   /**
    * The assistant message id an orphaned stream was producing — the same id the
    * live path persists under, so recovery re-associates reconstructed chunks
@@ -921,11 +1013,36 @@ declare class ResumableStream {
    * predates message-id tracking.
    */
   getStreamMessageId(streamId: string): string | null;
+  /**
+   * The message an orphaned stream's assistant message is a child of, or null
+   * when the stream appends to the latest leaf or predates parent tracking.
+   */
+  getStreamParentMessageId(streamId: string): string | null;
+  /**
+   * The user message ids the request's latest chat stream was started for
+   * (#2280), or undefined when no stream recorded them.
+   */
+  getOriginMessageIds(requestId: string): string[] | undefined;
+  /**
+   * How the request's latest chat stream ended (recorded by {@link complete}
+   * or {@link finish}), or undefined for a normal completion.
+   */
+  getOutcome(requestId: string): ChatTurnOutcome | undefined;
+  /**
+   * Origin ids and outcome of recently deleted streams (cutover, reclaim),
+   * so a resume ACK that arrives after the rows are gone still gets them on
+   * its replay terminal.
+   */
+  private readonly _deletedTerminals;
+  private _rememberDeleted;
+  private _recordOutcome;
   /**
    * Mark a stream as completed and flush any pending chunks.
    * @param streamId - The stream to mark as completed
+   * @param outcome - How the request ended, when not a normal completion.
+   *   Defaults to `aborted` for a stream restored without a live reader.
    */
-  complete(streamId: string): void;
+  complete(streamId: string, outcome?: ChatTurnOutcome): void;
   /**
    * The producer finished, but leave the row `streaming` for the cutover:
    * the host persists the message and settles the stream in one
@@ -933,7 +1050,7 @@ declare class ResumableStream {
    * live — exactly the evidence recovery rebuilds the message from. The
    * host MUST follow with {@link cutover} or {@link finalizePending}.
    */
-  finish(streamId: string): void;
+  finish(streamId: string, outcome?: ChatTurnOutcome): void;
   /** The stream {@link finish}ed and awaiting its cutover, if any. */
   get pendingCutoverId(): string | null;
   /**
@@ -972,8 +1089,11 @@ declare class ResumableStream {
    * but will be missing from replay on reconnection.
    * @param streamId - The stream this chunk belongs to
    * @param body - The serialized chunk body
+   * @returns The chunk's index in a replay of the stream, for the live
+   *   broadcast to carry as `seq`; `undefined` when the chunk is not stored
+   *   or the stream's count is not tracked.
    */
-  storeChunk(streamId: string, body: string): void;
+  storeChunk(streamId: string, body: string): number | undefined;
   /**
    * Flush the buffered chunks to storage as a single packed segment.
    * Uses a lock to prevent concurrent flush operations.
@@ -1025,6 +1145,15 @@ declare class ResumableStream {
     connection: Connection,
     requestId: string
   ): boolean;
+  /**
+   * Replay the request's just-closed stream (finished and awaiting its
+   * cutover, completed for a recovery, or errored), ending in
+   * `replayComplete` rather than `done`: the host has not sent the request's
+   * terminal frame yet and delivers it live once the message is persisted.
+   * After the cutover deleted the rows, only the `replayComplete` is sent.
+   * @returns False when the connection closed mid-replay.
+   */
+  replayClosedStreamChunks(connection: Connection, requestId: string): boolean;
   /**
    * Replay the stored chunks of an errored stream for a request, WITHOUT a
    * terminal frame — the caller follows up with the `done: true, error: true`
@@ -1192,7 +1321,8 @@ type ChatFiberSnapshot<Kind extends string = string> = {
   latestUserMessageId?: string;
   startedAt: number;
   lastBody?: Record<string, unknown>;
-  lastClientTools?: ClientToolSchema[];
+  lastClientTools?: ClientToolSchema[] /** User message ids the turn's request originated from, if any. */;
+  originMessageIds?: string[];
 };
 declare function createChatFiberSnapshot<Kind extends string>({
   kind,
@@ -1201,7 +1331,8 @@ declare function createChatFiberSnapshot<Kind extends string>({
   continuation,
   messages,
   lastBody,
-  lastClientTools
+  lastClientTools,
+  originMessageIds
 }: {
   kind: Kind;
   requestId: string;
@@ -1210,6 +1341,7 @@ declare function createChatFiberSnapshot<Kind extends string>({
   messages: ReadonlyArray<SnapshotMessage>;
   lastBody?: Record<string, unknown>;
   lastClientTools?: ClientToolSchema[];
+  originMessageIds?: string[];
 }): ChatFiberSnapshot<Kind>;
 declare function wrapChatFiberSnapshot<Kind extends string>(
   key: string,
@@ -1293,6 +1425,14 @@ type ChatRecoveryIncident = {
    * incident with `reason="out_of_memory"` (#1825). Optional for backward-compat.
    */
   oomAttempts?: number;
+  /**
+   * Recoveries scheduled for this incident after a transient or rate-limited
+   * stream error. Drives the retry backoff and is capped by `maxAttempts`.
+   * Unlike `attempt`, it is not debounced and does not reset on progress: a
+   * provider that fails every retry within seconds must still back off and
+   * run out of attempts. Bumped by `ChatRecoveryEngine.recordTransientRetry`.
+   */
+  transientRetries?: number;
 };
 declare const CHAT_RECOVERY_INCIDENT_KEY_PREFIX = "cf:chat-recovery:incident:";
 /**
@@ -1327,7 +1467,7 @@ declare const CHAT_LAST_TERMINAL_KEY = "cf:chat:last-terminal";
 declare const DEFAULT_CHAT_RECOVERY_MAX_ATTEMPTS = 10;
 /**
  * Runaway-loop guard default — the framework-imposed backstop on cumulative
- * recovery WORK (produced content/tool units) since an incident opened.
+ * recovery WORK (durable stream segments, see below) since an incident opened.
  *
  * Originally `Infinity` (rfc-chat-recovery-work-budget): the SDK shipped the
  * *mechanism* but no default cap, so a progressing turn was never terminated on
@@ -1510,7 +1650,8 @@ declare class StreamProgressCreditThrottle {
 /** Durable record of the last turn that ended in a terminal error (#1645). */
 type ChatTerminalRecord = {
   requestId: string;
-  body: string;
+  body: string /** The request's originating user message ids (#2280). */;
+  messageIds?: string[];
 };
 /**
  * Persist a durable record of the last terminal turn so a client that
@@ -1521,7 +1662,8 @@ type ChatTerminalRecord = {
 declare function recordChatTerminal(
   storage: Pick<DurableObjectStorage, "put">,
   requestId: string,
-  body: string
+  body: string,
+  messageIds?: string[]
 ): Promise<void>;
 /** Clear the durable terminal record once a later turn supersedes it (#1645). */
 declare function clearChatTerminal(
@@ -1639,8 +1781,15 @@ type ChatRecoveryScheduleCallback =
  *   settles only AFTER the callback returns, so an idempotent reschedule would
  *   dedup onto the doomed attempt and settle with it — the retry would never
  *   fire. A fresh (non-idempotent) delayed attempt survives.
+ *
+ * - `"chained_retry"` — the next attempt, scheduled from inside an executing
+ *   recovery attempt that was interrupted again. Non-idempotent for the same
+ *   reason as `"stable_timeout_retry"`.
  */
-type ChatRecoveryScheduleReason = "initial" | "stable_timeout_retry";
+type ChatRecoveryScheduleReason =
+  | "initial"
+  | "stable_timeout_retry"
+  | "chained_retry";
 /**
  * A reconstructed orphaned-stream partial. The engine seam is deliberately
  * **wire-vocabulary-agnostic**: `text` is the accumulated assistant text and
@@ -1719,6 +1868,12 @@ interface ChatRecoveryAdapter {
    * fixture) omits it and the engine treats the turn as never parked (`false`).
    */
   isAwaitingClientInteraction?(): boolean;
+  /**
+   * Optional: list the live (not yet terminalized) incidents. Required for
+   * {@link ChatRecoveryEngine.cancelScheduledRecovery}; a host that omits it
+   * cannot cancel a scheduled recovery.
+   */
+  listActiveIncidents?(): Promise<ChatRecoveryIncident[]>;
   /** Persist the evaluated incident under `key`. */
   putIncident(key: string, incident: ChatRecoveryIncident): Promise<void>;
   /**
@@ -1771,7 +1926,13 @@ interface ChatRecoveryAdapter {
     config: ResolvedChatRecoveryConfig,
     partial: RecoveryPartial,
     streamId: string,
-    createdAt: number
+    createdAt: number,
+    /**
+     * The fiber snapshot's origin ids (#2280). A restored pre-stream turn has
+     * no stream row or live request to recover them from otherwise.
+     */
+
+    originMessageIds?: string[]
   ): Promise<void>;
   /**
    * Resolve the orphaned stream identity for a (recovery-root) request id —
@@ -2016,6 +2177,7 @@ declare class ChatRecoveryEngine {
     callback: ChatRecoveryScheduleCallback;
     data: Record<string, unknown>;
     reason?: ChatRecoveryScheduleReason;
+    delaySeconds?: number;
   }): Promise<void>;
   /**
    * Reschedule a recovery continuation/retry that timed out waiting for stable
@@ -2041,6 +2203,24 @@ declare class ChatRecoveryEngine {
     data: Record<string, unknown> | undefined;
     fallbackMaxAttempts: number;
   }): Promise<boolean>;
+  /**
+   * Bump the incident's durable `transientRetries` counter before scheduling a
+   * recovery for a transient or rate-limited stream error, and return the new
+   * count so the caller can derive its backoff. Returns `1` when the incident
+   * record is gone.
+   */
+  recordTransientRetry(incidentId: string): Promise<number>;
+  /**
+   * The user cancelled `requestId` while its recovery was scheduled but not
+   * yet running (e.g. during a transient-error backoff). Marks every
+   * `scheduled` incident whose recovery root or current attempt is
+   * `requestId` as `skipped` with {@link CHAT_RECOVERY_CANCELLED_REASON}, so
+   * the queued callback bails when it fires (see {@link isRecoveryCancelled}).
+   * Returns whether any incident was cancelled.
+   */
+  cancelScheduledRecovery(requestId: string): Promise<boolean>;
+  /** Whether the user cancelled this incident's scheduled recovery. */
+  isRecoveryCancelled(incidentId: string | undefined): Promise<boolean>;
   /**
    * Record that a recovery callback observed a Durable Object memory-limit reset
    * (the isolate exceeded its 128 MB limit — `isDurableObjectMemoryLimitReset`)
@@ -2138,6 +2318,28 @@ declare class ChatRecoveryEngine {
     reason?: string
   ): Promise<void>;
 }
+/** `incident.reason` for a scheduled recovery the user cancelled. */
+declare const CHAT_RECOVERY_CANCELLED_REASON = "user_cancelled";
+/**
+ * Delay before the `retries`-th transient-error recovery: exponential backoff
+ * capped at {@link CHAT_RECOVERY_MAX_BACKOFF_SECONDS}. A provider
+ * `retryAfterSeconds` (rate limits) extends it, capped at
+ * {@link CHAT_RECOVERY_MAX_RETRY_AFTER_SECONDS}.
+ */
+declare function chatRecoveryBackoffSeconds(
+  retries: number,
+  retryAfterSeconds?: number
+): number;
+/**
+ * The `Retry-After` an error carries, in whole seconds. Reads
+ * `responseHeaders` (AI SDK `APICallError`) or `headers` on the error or its
+ * `cause` chain; accepts delta-seconds or an HTTP date. `undefined` when absent
+ * or unparseable.
+ */
+declare function retryAfterSeconds(
+  error: unknown,
+  now?: number
+): number | undefined;
 /**
  * The complete give-up choreography from a single call: build the exhausted
  * context, fire the shared notification ({@link notifyChatRecoveryExhausted}),
@@ -2193,7 +2395,11 @@ type ChatRecoveryTaskInput = {
   readonly delaySeconds: number;
 };
 /** Why a recovery attempt is being enqueued. */
-type ChatRecoveryTaskReason = "initial" | "stable_timeout_retry" | "redefer";
+type ChatRecoveryTaskReason =
+  | "initial"
+  | "stable_timeout_retry"
+  | "chained_retry"
+  | "redefer";
 /** The host's bounded entry point for each continuation callback. */
 type ChatRecoveryTaskHooks = Record<
   ChatRecoveryScheduleCallback,
@@ -2286,202 +2492,6 @@ declare function buildInClauseStrings(
   count: number
 ): TemplateStringsArray;
 //#endregion
-//#region src/chat/protocol.d.ts
-/**
- * Wire protocol message type constants for the cf_agent_chat_* protocol.
- *
- * These are the string values used on the wire between agent servers and
- * clients. Both @cloudflare/ai-chat (via its MessageType enum) and
- * @cloudflare/think use these values.
- */
-declare const STREAM_RESUME_NONE_REASONS: {
-  /** No active, pending, or terminal stream exists for this agent. */ readonly IDLE: "idle" /** An active tool continuation is owned by another live connection. */;
-  readonly CONTINUATION_OWNED: "continuation-owned";
-};
-type StreamResumeNoneReason =
-  (typeof STREAM_RESUME_NONE_REASONS)[keyof typeof STREAM_RESUME_NONE_REASONS];
-declare const CHAT_MESSAGE_TYPES: {
-  readonly CHAT_MESSAGES: "cf_agent_chat_messages";
-  readonly USE_CHAT_REQUEST: "cf_agent_use_chat_request";
-  readonly USE_CHAT_RESPONSE: "cf_agent_use_chat_response";
-  readonly CHAT_CLEAR: "cf_agent_chat_clear";
-  readonly CHAT_REQUEST_CANCEL: "cf_agent_chat_request_cancel";
-  readonly STREAM_RESUMING: "cf_agent_stream_resuming";
-  readonly STREAM_RESUME_ACK: "cf_agent_stream_resume_ack";
-  readonly STREAM_RESUME_REQUEST: "cf_agent_stream_resume_request";
-  readonly STREAM_RESUME_NONE: "cf_agent_stream_resume_none";
-  readonly STREAM_PENDING: "cf_agent_stream_pending";
-  readonly TOOL_RESULT: "cf_agent_tool_result";
-  readonly TOOL_APPROVAL: "cf_agent_tool_approval";
-  readonly MESSAGE_UPDATED: "cf_agent_message_updated";
-  readonly CHAT_RECOVERING: "cf_agent_chat_recovering";
-};
-//#endregion
-//#region src/chat/wire-types.d.ts
-/**
- * Enum for message types to improve type safety and maintainability
- */
-declare enum MessageType {
-  CF_AGENT_CHAT_MESSAGES = "cf_agent_chat_messages",
-  CF_AGENT_USE_CHAT_REQUEST = "cf_agent_use_chat_request",
-  CF_AGENT_USE_CHAT_RESPONSE = "cf_agent_use_chat_response",
-  CF_AGENT_CHAT_CLEAR = "cf_agent_chat_clear",
-  CF_AGENT_CHAT_REQUEST_CANCEL = "cf_agent_chat_request_cancel",
-  /** Sent by server when client connects and there's an active stream to resume */
-  CF_AGENT_STREAM_RESUMING = "cf_agent_stream_resuming",
-  /** Sent by client to acknowledge stream resuming notification and request chunks */
-  CF_AGENT_STREAM_RESUME_ACK = "cf_agent_stream_resume_ack",
-  /** Sent by client after message handler is ready, requesting stream resume check */
-  CF_AGENT_STREAM_RESUME_REQUEST = "cf_agent_stream_resume_request",
-  /** Sent by server when client requests resume but no active stream exists */
-  CF_AGENT_STREAM_RESUME_NONE = "cf_agent_stream_resume_none",
-  /**
-   * Sent by server when a turn is accepted but its resumable stream has not
-   * started yet (queued / debouncing / waiting on MCP / async setup). Tells a
-   * reconnecting client to keep waiting rather than resolve its resume probe to
-   * "no stream". Resolved by a later `CF_AGENT_STREAM_RESUMING` (stream started)
-   * or `CF_AGENT_STREAM_RESUME_NONE` (settled without streaming). See #1784.
-   */
-  CF_AGENT_STREAM_PENDING = "cf_agent_stream_pending",
-  /** Client sends tool result to server (for client-side tools) */
-  CF_AGENT_TOOL_RESULT = "cf_agent_tool_result",
-  /** Server notifies client that a message was updated (e.g., tool result applied) */
-  CF_AGENT_MESSAGE_UPDATED = "cf_agent_message_updated",
-  /** Client sends tool approval response to server (for tools with needsApproval) */
-  CF_AGENT_TOOL_APPROVAL = "cf_agent_tool_approval",
-  /**
-   * Server→client progress hint: a durable chat turn is being recovered
-   * (interrupted by a deploy/eviction or a stream-stall watchdog abort and now
-   * resuming). Sent when a recovery continuation is scheduled and cleared on
-   * every terminal outcome. (`@cloudflare/think` also replays it on connect;
-   * `@cloudflare/ai-chat` broadcasts the live signal only — see #1645.)
-   * Backward-compatible — clients that don't understand it ignore it. See #1620.
-   */
-  CF_AGENT_CHAT_RECOVERING = "cf_agent_chat_recovering"
-}
-/**
- * Types of messages sent from the Agent to clients
- */
-type OutgoingMessage<ChatMessage extends UIMessage = UIMessage> =
-  | {
-      /** Indicates this message is a command to clear chat history */ type: MessageType.CF_AGENT_CHAT_CLEAR;
-    }
-  | {
-      /** Indicates this message contains updated chat messages */ type: MessageType.CF_AGENT_CHAT_MESSAGES /** Array of chat messages */;
-      messages: readonly ChatMessage[];
-    }
-  | {
-      /** Indicates this message is a response to a chat request */ type: MessageType.CF_AGENT_USE_CHAT_RESPONSE /** Unique ID of the request this response corresponds to */;
-      id: string /** Content body of the response */;
-      body: string /** Whether this is the final chunk of the response */;
-      done: boolean /** Whether this response contains an error */;
-      error?: boolean /** Whether this is a continuation (append to last assistant message) */;
-      continuation?: boolean /** Whether this chunk is being replayed from storage (stream resumption) */;
-      replay?: boolean /** Signals that replay of stored chunks is complete (stream is still active) */;
-      replayComplete?: boolean;
-    }
-  | {
-      /** Indicates the server is resuming an active stream */ type: MessageType.CF_AGENT_STREAM_RESUMING /** The request ID of the stream being resumed */;
-      id: string /** Present when this offer directly answers a client resume probe. */;
-      probeId?: string;
-    }
-  | {
-      /** Server notifies client that a message was updated (e.g., tool result applied) */ type: MessageType.CF_AGENT_MESSAGE_UPDATED /** The updated message */;
-      message: ChatMessage;
-    }
-  | {
-      /** Server responds to a resume request with no stream for this client. */ type: MessageType.CF_AGENT_STREAM_RESUME_NONE;
-      /**
-       * Why no stream was offered. Only `idle` proves global inactivity;
-       * omitted by older servers and by non-authoritative delayed releases.
-       */
-      reason?: StreamResumeNoneReason /** Correlates an authoritative response to its client resume probe. */;
-      probeId?: string;
-    }
-  | {
-      /**
-       * Server signals an accepted turn whose resumable stream has not started
-       * yet — the client should keep waiting for `STREAM_RESUMING` (or a later
-       * `STREAM_RESUME_NONE`) rather than give up. See #1784.
-       */
-      type: MessageType.CF_AGENT_STREAM_PENDING /** The accepted request id, when known. */;
-      id?: string /** Correlates a direct keep-waiting response to its client probe. */;
-      probeId?: string;
-    }
-  | {
-      /**
-       * Progress hint: a durable chat turn is being recovered (`recovering:
-       * true`) or recovery has resolved (`recovering: false`). Purely advisory;
-       * a client renders a "recovering…" indicator while true.
-       */
-      type: MessageType.CF_AGENT_CHAT_RECOVERING /** Whether recovery is in progress (true) or has resolved (false). */;
-      recovering: boolean /** The recovery-root request id of the turn being recovered, if known. */;
-      id?: string;
-    };
-/**
- * Types of messages sent from clients to the Agent
- */
-type IncomingMessage<ChatMessage extends UIMessage = UIMessage> =
-  | {
-      /** Indicates this message is a command to clear chat history */ type: MessageType.CF_AGENT_CHAT_CLEAR;
-    }
-  | {
-      /** Indicates this message is a request to the chat API */ type: MessageType.CF_AGENT_USE_CHAT_REQUEST /** Unique ID for this request */;
-      id: string /** Request initialization options */;
-      init: Pick<
-        RequestInit,
-        | "method"
-        | "keepalive"
-        | "headers"
-        | "body"
-        | "redirect"
-        | "integrity"
-        | "credentials"
-        | "mode"
-        | "referrer"
-        | "referrerPolicy"
-        | "window"
-      >;
-    }
-  | {
-      /** Indicates this message contains updated chat messages */ type: MessageType.CF_AGENT_CHAT_MESSAGES /** Array of chat messages */;
-      messages: ChatMessage[];
-    }
-  | {
-      /** Indicates the user wants to stop generation of this message */ type: MessageType.CF_AGENT_CHAT_REQUEST_CANCEL;
-      id: string;
-    }
-  | {
-      /** Client acknowledges stream resuming notification and is ready to receive chunks */ type: MessageType.CF_AGENT_STREAM_RESUME_ACK /** The request ID of the stream being resumed */;
-      id: string;
-    }
-  | {
-      /** Client requests stream resume check after message handler is registered */ type: MessageType.CF_AGENT_STREAM_RESUME_REQUEST /** Opaque correlation id echoed by direct server responses. */;
-      probeId?: string;
-    }
-  | {
-      /** Client sends tool result to server (for client-side tools) */ type: MessageType.CF_AGENT_TOOL_RESULT /** The tool call ID this result is for */;
-      toolCallId: string /** The name of the tool */;
-      toolName: string /** The output from the tool execution */;
-      output: unknown /** Override the tool part state (e.g. "output-error" for custom denial) */;
-      state?:
-        | "output-available"
-        | "output-error" /** Error message when state is "output-error" */;
-      errorText?: string /** Whether server should auto-continue the conversation after applying result */;
-      autoContinue?: boolean /** Client tool schemas for continuation (client is source of truth) */;
-      clientTools?: Array<{
-        name: string;
-        description?: string;
-        parameters?: JSONSchema7;
-      }>;
-    }
-  | {
-      /** Client sends tool approval response to server (for tools with needsApproval) */ type: MessageType.CF_AGENT_TOOL_APPROVAL /** The tool call ID this approval is for */;
-      toolCallId: string /** Whether the tool execution was approved */;
-      approved: boolean /** Whether server should auto-continue the conversation after applying approval */;
-      autoContinue?: boolean;
-    };
-//#endregion
 //#region src/chat/connection.d.ts
 /**
  * Connection I/O — shared WebSocket send guard for chat agents.
@@ -3131,14 +3141,22 @@ declare function parseProtocolMessage(raw: string): ChatProtocolEvent | null;
 /**
  * Reconcile incoming client messages against server state.
  *
- * 1. Merges server-known tool outputs into incoming messages that still
- *    show stale states (input-available, approval-requested, approval-responded)
- * 2. Reconciles assistant IDs: exact match → content-key match → toolCallId match
+ * 1. Reconciles assistant IDs: exact match → same tool call → content-key
+ *    match. Each server row is claimed at most once, and a tool-call match
+ *    requires the same toolCallId, tool and input, since providers may reuse
+ *    toolCallIds across turns.
+ * 2. Merges server-known tool outputs into incoming messages that still
+ *    show stale states (input-available, approval-requested, approval-responded).
+ *    Outputs come only from the server row the message resolved to.
+ * 3. Drops a stale copy of an assistant the same submit also echoes under its
+ *    stored ID (see {@link dropStaleToolCopies}).
  *
  * @param incoming - Messages from the client
  * @param serverMessages - Current server-side messages (source of truth)
  * @param sanitizeForContentKey - Function to sanitize a message before computing
- *   its content key (typically strips ephemeral provider metadata)
+ *   its content key or comparing its tool calls against stored rows
+ *   (typically the host's persistence sanitizer, so a tool input the host
+ *   truncates on write compares equal to its stored form)
  * @returns Reconciled messages ready for persistence
  */
 declare function reconcileMessages(
@@ -3149,7 +3167,13 @@ declare function reconcileMessages(
 /**
  * For a single message, resolve its ID by matching toolCallId against server state.
  * Prevents duplicate DB rows when client IDs differ from server IDs.
- * Tool call IDs are unique per conversation, so matching is safe regardless of state.
+ *
+ * @deprecated Unsafe when a provider reuses a toolCallId across turns. This
+ * scans the whole conversation and claims nothing, so a later assistant can
+ * adopt an earlier row's ID and overwrite it on upsert (#1992). Use
+ * {@link reconcileMessages}, which claims server rows one-to-one over the
+ * whole transcript. Retained only for backwards compatibility; no longer used
+ * by `@cloudflare/ai-chat` or `@cloudflare/think`.
  */
 declare function resolveToolMergeId(
   message: UIMessage,
@@ -3237,6 +3261,16 @@ interface RepairInterruptedToolPartsOptions {
    * with an error. Skipped parts are not counted in `removedToolCalls`.
    */
   shouldRepair?: (part: UIMessage["parts"][number]) => boolean;
+  /**
+   * Also repair `approval-responded` parts in any message a later message
+   * follows. Pass `true` only when no continuation will execute them: a turn
+   * that is not itself a continuation, with no continuation waiting to run.
+   * Parts in the last message are always kept, because the AI SDK executes a
+   * trailing approval response when the transcript is submitted as-is. A
+   * denied approval settles as `output-denied`; an approved one is handed to
+   * `repairPart`. Defaults to `false`.
+   */
+  repairApprovalResponded?: boolean;
 }
 interface RepairInterruptedToolPartsResult {
   /** A new messages array; unchanged messages keep their original reference. */
@@ -3255,7 +3289,7 @@ interface RepairInterruptedToolPartsResult {
  *
  *   - a tool part with NO settled result and state `approval-responded` is kept
  *     verbatim (an approved server tool waiting for its continuation to run
- *     `execute()` — not abandoned);
+ *     `execute()` — not abandoned), unless `repairApprovalResponded` is set;
  *   - a tool part with NO settled result for which `shouldRepair` returns false
  *     is kept verbatim (a part still awaiting a CLIENT interaction; see option);
  *   - any other tool part with no settled result is normalized then handed to
@@ -3327,6 +3361,22 @@ declare function persistReconstructedOrphan<
 ): Promise<boolean>;
 //#endregion
 //#region src/chat/recovery-codec.d.ts
+/**
+ * Whether a reconstructed AI SDK `UIMessage` parts array carries any settled
+ * (provider-accepted) tool result — the completed, often non-idempotent work
+ * that a `{ persist: false }` recovery return would otherwise silently discard
+ * (#1631). A part counts as settled when it is a tool part (`tool-*` /
+ * `dynamic-tool`) carrying an `output`/`result`, or whose state reached a
+ * terminal `output-{available,error,denied}`.
+ *
+ * This is the AI SDK codec's implementation of the per-vocabulary "did this
+ * partial settle a tool?" question. It lives with {@link AISDKRecoveryCodec}
+ * (not in the engine) because the codec owns the part vocabulary — the engine
+ * only ever reads the precomputed `RecoveryPartial.hasSettledToolResults`
+ * boolean and never names a part type. Foreign codecs (e.g. AG-UI) compute the
+ * same boolean from their own chunk vocabulary without producing AI SDK parts.
+ */
+declare function partialHasSettledToolResults(parts: MessagePart[]): boolean;
 /**
  * Reconstructs the partial assistant state of an interrupted turn from its
  * stored `ResumableStream` chunk bodies (oldest-first).
@@ -3409,6 +3459,7 @@ declare const aiSdkRecoveryCodec: AISDKRecoveryCodec;
 interface PendingChatTerminal {
   requestId: string;
   body: string;
+  messageIds?: string[];
 }
 /**
  * The host-owned surface the resume handshake threads. `pendingResumeConnections`
@@ -3446,6 +3497,14 @@ interface ResumeHandshakeHost {
    * resumed by the replacement connection (#1784).
    */
   isConnectionPresent?(connectionId: string): boolean;
+  /**
+   * Whether the host still holds the request's terminal frames and will
+   * broadcast them once its message is persisted. Optional: hosts that send
+   * the terminal frame with the stream's end omit it. While true, a resume
+   * ACK gets the stored chunks without a terminal, so the connection learns
+   * the outcome from the live frame that follows the transcript.
+   */
+  holdsTerminalFrames?(requestId: string): boolean;
 }
 /**
  * Drives the server side of the stream-resume protocol over a
@@ -3551,6 +3610,12 @@ interface TruncateOptions {
   maxToolOutputChars?: number;
   /** Max chars for text parts in older messages (default: 10000) */
   maxTextChars?: number;
+  /**
+   * Truncate tool outputs in older messages (default: true). Set to `false`
+   * to leave them intact and truncate the converted model messages with
+   * {@link truncateOlderToolResults} instead.
+   */
+  toolOutputs?: boolean;
 }
 /**
  * Truncate tool outputs and long text in older messages.
@@ -3559,6 +3624,8 @@ interface TruncateOptions {
  * Recent messages (last `keepRecent`) are left intact.
  * Older messages get tool outputs and long text truncated. Structured tool
  * outputs are truncated in place instead of being replaced by raw strings.
+ * Provider-executed tool outputs are never truncated: the provider parses
+ * them against its own schema when they are replayed.
  *
  * Use in assembleContext() before sending to the LLM:
  * ```typescript
@@ -3573,6 +3640,31 @@ declare function truncateOlderMessages(
   messages: SessionMessage[],
   options?: TruncateOptions
 ): SessionMessage[];
+interface TruncateToolResultsOptions {
+  /** Number of recent UI messages whose tool results stay intact (default: 4) */
+  keepRecent?: number;
+  /** Max chars for each older tool result (default: 500) */
+  maxToolOutputChars?: number;
+}
+/**
+ * Truncate the tool results of older messages after `convertToModelMessages`.
+ * `messages` are the UI messages that were converted, so "older" means the
+ * same messages {@link truncateOlderMessages} treats as older.
+ *
+ * The converted result is what the model reads, after any `toModelOutput`, so
+ * no tool schema applies to it. Provider-executed results are left intact.
+ * Inline file and image bytes in an older `content` result are replaced by a
+ * short text marker.
+ *
+ * Tool call ids are not unique across turns, so each converted result is
+ * matched to the UI tool part it came from by order: the Nth result for an id
+ * belongs to the Nth UI part with that id that converts to a tool result.
+ */
+declare function truncateOlderToolResults<M extends ModelMessage>(
+  modelMessages: M[],
+  messages: readonly SessionMessage[],
+  options?: TruncateToolResultsOptions
+): M[];
 //#endregion
 export {
   AGENT_TOOL_STREAM_PROGRESS_BUMP_THROTTLE_MS,
@@ -3598,6 +3690,7 @@ export {
   CHAT_RECOVERING_FLAG_TTL_MS,
   CHAT_RECOVERING_KEY,
   CHAT_RECOVERY_ALARM_DEBOUNCE_MS,
+  CHAT_RECOVERY_CANCELLED_REASON,
   CHAT_RECOVERY_INCIDENT_KEY_PREFIX,
   CHAT_RECOVERY_INCIDENT_TTL_MS,
   CHAT_RECOVERY_PROGRESS_KEY,
@@ -3630,6 +3723,7 @@ export {
   type ChatStreamStatus,
   type ChatTerminalRecord,
   type ChatTurnClosureEntry,
+  type ChatTurnOutcome,
   type ChatTurnTaskHooks,
   type ChunkAction,
   type ChunkResult,
@@ -3696,11 +3790,13 @@ export {
   TextSegmentJoiner,
   type ToolPartUpdate,
   type TruncateOptions,
+  type TruncateToolResultsOptions,
   TurnQueue,
   type TurnResult,
   aiSdkRecoveryCodec,
   applyAgentToolEvent,
   applyChunkToParts,
+  applyLateToolInput,
   applyToolUpdate,
   awaitWithDeadline,
   transition as broadcastTransition,
@@ -3708,6 +3804,7 @@ export {
   buildInClauseStrings,
   bumpChatRecoveryProgress,
   byteLength,
+  chatRecoveryBackoffSeconds,
   chatRecoveryTaskRunOptions,
   classifyAgentToolChildRecovery,
   clearChatTerminal,
@@ -3724,13 +3821,19 @@ export {
   enforceRowSizeLimit,
   hasIncompleteToolBatch,
   interceptAgentToolBroadcast,
+  isDurableObjectResetError,
+  isLateToolInputChunk,
   isPlatformFailure,
+  isPositionlessAgentToolChunk,
   isReplayChunk,
   iterateWithStallWatchdog,
+  lateToolInputForwardChunks,
   listActiveChatRecoveryIncidents,
   normalizeToolInput,
+  originMessageIds$1 as originMessageIds,
   parseProtocolMessage,
   partAwaitsClientInteraction,
+  partialHasSettledToolResults,
   pausedExecutionUpdate,
   pendingChatTerminal,
   persistReconstructedOrphan,
@@ -3741,6 +3844,7 @@ export {
   repairInterruptedToolParts,
   resolveChatRecoveryConfig,
   resolveToolMergeId,
+  retryAfterSeconds,
   runChatRecoveryExhaustion,
   sanitizeMessage,
   sendIfOpen,
@@ -3751,7 +3855,9 @@ export {
   toolPartHasSettledResult,
   toolResultUpdate,
   truncateOlderMessages,
+  truncateOlderToolResults,
   unwrapChatFiberSnapshot,
+  withOriginMessageIds,
   wrapChatFiberSnapshot
 };
 //# sourceMappingURL=index.d.ts.map