agents 0.24.0 → 0.25.0

package/dist/chat/index.js

@@ -1,10 +1,11 @@
-import { isPlatformFailure, tryN } from "../retries.js";
-import { i as normalizeToolInput, n as getPartialStreamText, r as isReplayChunk, t as applyChunkToParts } from "../message-builder-BymO4N_D.js";
-import { i as interceptAgentToolBroadcast, n as applyAgentToolEvent, r as createAgentToolEventState, t as AgentToolProgressEmitter } from "../agent-tools-y7zLfw4Q.js";
+import { isPositionlessAgentToolChunk } from "../agent-tool-types.js";
+import { isDurableObjectResetError, isPlatformFailure, tryN } from "../retries.js";
+import { a as isReplayChunk, i as isLateToolInputChunk, n as applyLateToolInput, o as lateToolInputForwardChunks, r as getPartialStreamText, s as normalizeToolInput, t as applyChunkToParts } from "../message-builder-DAl9AhHH.js";
+import { a as interceptAgentToolBroadcast, i as createAgentToolEventState, r as applyAgentToolEvent, s as storedChunkBytes, t as AgentToolProgressEmitter } from "../agent-tools-CdJC-8Dc.js";
 import { t as TextSegmentJoiner } from "../text-segment-joiner-BtAFQSA_.js";
 import { n as sanitizeMessage, t as byteLength } from "../sanitize-D9TujEK8.js";
-import { i as StreamAccumulator, n as STREAM_RESUME_NONE_REASONS, r as transition, t as CHAT_MESSAGE_TYPES } from "../protocol-B0nh6KNf.js";
-import { n as Streams } from "../streams-CCPRV6dt.js";
+import { a as StreamAccumulator, i as transition, n as STREAM_RESUME_NONE_REASONS, t as CHAT_MESSAGE_TYPES } from "../protocol-kHsr-f0X.js";
+import { n as Streams } from "../streams-DW-UCOUc.js";
 import { t as MessageType } from "../wire-types-CnMt6_HR.js";
 import { jsonSchema, tool } from "ai";
 import { nanoid } from "nanoid";
@@ -262,6 +263,36 @@ var TurnQueue = class {
 	}
 };
 //#endregion
+//#region src/chat/origin-message-ids.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).
+*/
+function originMessageIds(messages) {
+	if (!Array.isArray(messages)) return void 0;
+	const ids = [];
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const message = messages[i];
+		if (message?.role !== "user") break;
+		if (typeof message.id === "string" && message.id) ids.unshift(message.id);
+	}
+	return ids.length > 0 ? ids : void 0;
+}
+/**
+* Return `frame` with `messageIds` added when it is a terminal
+* (`done` or `error`) frame that does not already carry them.
+*/
+function withOriginMessageIds(frame, messageIds) {
+	const fields = frame;
+	if (!messageIds || fields.messageIds !== void 0 || !(fields.done || fields.error)) return frame;
+	return {
+		...frame,
+		messageIds
+	};
+}
+//#endregion
 //#region src/chat/submit-concurrency.ts
 var SubmitConcurrencyController = class {
 	constructor(options) {
@@ -410,13 +441,15 @@ function isWebSocketClosedSendError(error) {
 * @returns False when the connection closed mid-replay — the caller leaves
 * its stream state untouched so the next reconnect can retry.
 */
-function sendReplayBodies(connection, requestId, bodies, continuation) {
+function sendReplayBodies(connection, requestId, bodies, continuation, firstSeq = 0) {
+	let seq = firstSeq;
 	for (const body of bodies) if (!sendIfOpen(connection, JSON.stringify({
 		body,
 		done: false,
 		id: requestId,
 		type: CHAT_MESSAGE_TYPES.USE_CHAT_RESPONSE,
 		replay: true,
+		seq: seq++,
 		...continuation && { continuation: true }
 	}))) return false;
 	return true;
@@ -435,7 +468,9 @@ function sendReplayControl(connection, requestId, options) {
 		type: CHAT_MESSAGE_TYPES.USE_CHAT_RESPONSE,
 		replay: true,
 		...options.replayComplete && { replayComplete: true },
-		...options.continuation && { continuation: true }
+		...options.continuation && { continuation: true },
+		...options.done && options.messageIds && { messageIds: options.messageIds },
+		...options.done && options.outcome && { outcome: options.outcome }
 	}));
 }
 //#endregion
@@ -496,16 +531,14 @@ const REPLAY_PAGE_SEGMENTS = 10;
 * the next {@link ResumableStream.start}.
 */
 const ABANDONED_STREAM_RETENTION_MS = 3600 * 1e3;
-/** Shared encoder for UTF-8 byte length measurement */
-const textEncoder = new TextEncoder();
+/** Deleted streams whose terminal details a late resume ACK can still read. */
+const MAX_REMEMBERED_DELETED_TERMINALS = 32;
 /**
 * Ceiling for one stored chat segment after JSON serialization, and the
 * `maxChunkBytes` the backing Streams capability must be constructed with.
 * Kept under the 2 MB SQLite row limit with headroom for escaping.
 */
 const CHAT_STREAM_MAX_CHUNK_BYTES = 19e5;
-/** Maximum serialized chunk body size before skipping storage (bytes). */
-const CHUNK_MAX_BYTES = 18e5;
 /**
 * Construct the Streams capability instance a chat host must install to back
 * its `ResumableStream`: identical to `new Streams()` except for the raised
@@ -548,10 +581,13 @@ var ResumableStream = class {
 		this._activeRequestId = null;
 		this._isLive = false;
 		this._activeIsContinuation = false;
+		this._nextChunkSeq = null;
 		this._chunkBuffer = [];
 		this._chunkBufferBytes = 0;
 		this._isFlushingChunks = false;
 		this._pendingCutover = null;
+		this._lastClosedStreamId = null;
+		this._deletedTerminals = /* @__PURE__ */ new Map();
 		this.ops = streams.__DO_NOT_USE_WILL_BREAK__sync();
 		this.ops.ensureTables();
 		this._sql = sql;
@@ -559,7 +595,10 @@ var ResumableStream = class {
 		this._ensureProgressTable();
 		deletionHooks.get(streams)?.();
 		deletionHooks.set(streams, this.ops.onDelete((row, cursor) => {
-			if (parseChatMetadata(row)) this._retire(cursor);
+			const chat = parseChatMetadata(row);
+			if (!chat) return;
+			this._retire(cursor);
+			this._rememberDeleted(row, chat);
 		}));
 		this._migrateLegacyTables(sql);
 		this.restore();
@@ -759,18 +798,34 @@ var ResumableStream = class {
 	*/
 	start(requestId, options = {}) {
 		this.flushBuffer();
+		const seqBase = this._nextSeqForRequest(requestId);
 		this.reclaim();
 		const streamId = nanoid();
 		this._activeStreamId = streamId;
 		this._activeRequestId = requestId;
 		this._isLive = true;
 		this._activeIsContinuation = options.continuation ?? false;
+		this._nextChunkSeq = seqBase;
 		const metadata = { cfChat: 1 };
 		if (options.messageId != null) metadata.messageId = options.messageId;
+		if (options.parentMessageId != null) metadata.parentMessageId = options.parentMessageId;
 		if (this._activeIsContinuation) metadata.isContinuation = 1;
+		if (seqBase > 0) metadata.seqBase = seqBase;
+		if (options.originMessageIds?.length) metadata.originMessageIds = options.originMessageIds;
 		this.ops.insertStream(streamId, requestId, metadata);
 		return streamId;
 	}
+	_nextSeqForRequest(requestId) {
+		const prior = this._latestChatRowByTag(requestId);
+		if (!prior) return 0;
+		let count = 0;
+		for (const _body of this._storedBodies(prior.stream_id)) count++;
+		return (parseChatMetadata(prior)?.seqBase ?? 0) + count;
+	}
+	_seqBase(streamId) {
+		const row = this.ops.getStream(streamId);
+		return row && parseChatMetadata(row)?.seqBase || 0;
+	}
 	/**
 	* The assistant message id an orphaned stream was producing — the same id the
 	* live path persists under, so recovery re-associates reconstructed chunks
@@ -783,13 +838,65 @@ var ResumableStream = class {
 		return parseChatMetadata(row)?.messageId ?? 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) {
+		const row = this.ops.getStream(streamId);
+		if (!row) return null;
+		return parseChatMetadata(row)?.parentMessageId ?? null;
+	}
+	/**
+	* The user message ids the request's latest chat stream was started for
+	* (#2280), or undefined when no stream recorded them.
+	*/
+	getOriginMessageIds(requestId) {
+		const row = this._latestChatRowByTag(requestId);
+		return (row ? parseChatMetadata(row)?.originMessageIds : void 0) ?? this._deletedTerminals.get(requestId)?.messageIds;
+	}
+	/**
+	* How the request's latest chat stream ended (recorded by {@link complete}
+	* or {@link finish}), or undefined for a normal completion.
+	*/
+	getOutcome(requestId) {
+		const row = this._latestChatRowByTag(requestId);
+		return (row ? parseChatMetadata(row)?.outcome : void 0) ?? this._deletedTerminals.get(requestId)?.outcome;
+	}
+	_rememberDeleted(row, chat) {
+		if (!row.tag || !chat.originMessageIds && !chat.outcome) return;
+		this._deletedTerminals.delete(row.tag);
+		this._deletedTerminals.set(row.tag, {
+			messageIds: chat.originMessageIds,
+			outcome: chat.outcome
+		});
+		if (this._deletedTerminals.size > MAX_REMEMBERED_DELETED_TERMINALS) {
+			const oldest = this._deletedTerminals.keys().next().value;
+			if (oldest !== void 0) this._deletedTerminals.delete(oldest);
+		}
+	}
+	_recordOutcome(streamId, outcome) {
+		if (outcome === void 0 || outcome === "completed") return;
+		const row = this.ops.getStream(streamId);
+		const chat = row ? parseChatMetadata(row) : null;
+		if (!chat) return;
+		this.ops.setMetadata(streamId, {
+			...chat,
+			outcome
+		});
+	}
+	/**
 	* 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) {
+	complete(streamId, outcome) {
 		this.flushBuffer();
+		const orphaned = streamId === this._activeStreamId && !this._isLive;
+		this._recordOutcome(streamId, outcome ?? (orphaned ? "aborted" : void 0));
 		this.ops.settle(streamId, "completed", null);
 		if (this._pendingCutover === streamId) this._pendingCutover = null;
+		this._lastClosedStreamId = streamId;
 		this._clearActive();
 	}
 	/**
@@ -799,9 +906,11 @@ var ResumableStream = class {
 	* live — exactly the evidence recovery rebuilds the message from. The
 	* host MUST follow with {@link cutover} or {@link finalizePending}.
 	*/
-	finish(streamId) {
+	finish(streamId, outcome) {
 		this.flushBuffer();
+		this._recordOutcome(streamId, outcome);
 		this._pendingCutover = streamId;
+		this._lastClosedStreamId = streamId;
 		this._clearActive();
 	}
 	/** The stream {@link finish}ed and awaiting its cutover, if any. */
@@ -856,6 +965,7 @@ var ResumableStream = class {
 		this.flushBuffer();
 		this.ops.settle(streamId, "errored", null);
 		if (this._pendingCutover === streamId) this._pendingCutover = null;
+		this._lastClosedStreamId = streamId;
 		this._clearActive();
 	}
 	/**
@@ -865,13 +975,17 @@ var ResumableStream = class {
 	* 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, body) {
-		const bodyBytes = textEncoder.encode(JSON.stringify(body)).byteLength;
-		if (bodyBytes > CHUNK_MAX_BYTES) {
+		const bodyBytes = storedChunkBytes(body);
+		if (bodyBytes > 18e5) {
 			console.warn(`[ResumableStream] Skipping oversized chunk (${bodyBytes} bytes) to prevent SQLite row limit crash. Live clients still receive it.`);
 			return;
 		}
+		const seq = streamId === this._activeStreamId && this._nextChunkSeq !== null ? this._nextChunkSeq++ : void 0;
 		if (this._chunkBuffer.length >= CHUNK_BUFFER_MAX_SIZE) this.flushBuffer();
 		if (this._chunkBuffer.length > 0 && this._chunkBufferBytes + bodyBytes > SEGMENT_MAX_BYTES) this.flushBuffer();
 		this._chunkBuffer.push({
@@ -880,6 +994,7 @@ var ResumableStream = class {
 		});
 		this._chunkBufferBytes += bodyBytes;
 		if (this._chunkBuffer.length >= CHUNK_BUFFER_SIZE) this.flushBuffer();
+		return seq;
 	}
 	/**
 	* Flush the buffered chunks to storage as a single packed segment.
@@ -950,13 +1065,16 @@ var ResumableStream = class {
 		if (!streamId) return null;
 		this.flushBuffer();
 		const continuation = this._activeIsContinuation;
-		if (!sendReplayBodies(connection, requestId, this._storedBodies(streamId), continuation)) return null;
+		if (!sendReplayBodies(connection, requestId, this._storedBodies(streamId), continuation, this._seqBase(streamId))) return null;
 		if (!this._isLive) {
+			const row = this.ops.getStream(streamId);
 			sendReplayControl(connection, requestId, {
 				done: true,
-				continuation
+				continuation,
+				messageIds: row ? parseChatMetadata(row)?.originMessageIds : void 0,
+				outcome: "aborted"
 			});
-			this.complete(streamId);
+			this.complete(streamId, "aborted");
 			return streamId;
 		}
 		sendReplayControl(connection, requestId, {
@@ -979,10 +1097,33 @@ var ResumableStream = class {
 		this.flushBuffer();
 		const row = this._latestChatRowByTag(requestId, "completed");
 		if (!row) return false;
-		const continuation = parseChatMetadata(row)?.isContinuation === 1;
-		if (!sendReplayBodies(connection, requestId, this._storedBodies(row.stream_id), continuation)) return false;
+		const chat = parseChatMetadata(row);
+		const continuation = chat?.isContinuation === 1;
+		if (!sendReplayBodies(connection, requestId, this._storedBodies(row.stream_id), continuation, chat?.seqBase)) return false;
 		return sendReplayControl(connection, requestId, {
 			done: true,
+			continuation,
+			messageIds: chat?.originMessageIds,
+			outcome: chat?.outcome
+		});
+	}
+	/**
+	* 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, requestId) {
+		this.flushBuffer();
+		const row = this._lastClosedStreamId !== null ? this.ops.getStream(this._lastClosedStreamId) : void 0;
+		const chat = row?.tag === requestId ? parseChatMetadata(row) : null;
+		const continuation = chat?.isContinuation === 1;
+		if (row && chat && !sendReplayBodies(connection, requestId, this._storedBodies(row.stream_id), continuation, chat.seqBase)) return false;
+		return sendReplayControl(connection, requestId, {
+			done: false,
+			replayComplete: true,
 			continuation
 		});
 	}
@@ -1004,7 +1145,8 @@ var ResumableStream = class {
 		this.flushBuffer();
 		const row = this._latestChatRowByTag(requestId, "errored");
 		if (!row) return true;
-		return sendReplayBodies(connection, requestId, this._storedBodies(row.stream_id), parseChatMetadata(row)?.isContinuation === 1);
+		const chat = parseChatMetadata(row);
+		return sendReplayBodies(connection, requestId, this._storedBodies(row.stream_id), chat?.isContinuation === 1, chat?.seqBase);
 	}
 	/**
 	* Latest chat stream row for a request regardless of status — the recovery
@@ -1053,6 +1195,7 @@ var ResumableStream = class {
 			this._activeStreamId = row.stream_id;
 			this._activeRequestId = row.tag;
 			this._activeIsContinuation = row.chat.isContinuation === 1;
+			this._nextChunkSeq = null;
 		}
 	}
 	/**
@@ -1063,6 +1206,8 @@ var ResumableStream = class {
 		this._chunkBuffer = [];
 		this._chunkBufferBytes = 0;
 		this._deleteRetiring(this._chatRows());
+		this._deletedTerminals.clear();
+		this._lastClosedStreamId = null;
 		this._activeStreamId = null;
 		this._activeRequestId = null;
 		this._activeIsContinuation = false;
@@ -2211,23 +2356,83 @@ function parseProtocolMessage(raw) {
 /**
 * 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
 */
 function reconcileMessages(incoming, serverMessages, sanitizeForContentKey) {
-	return reconcileAssistantIds(mergeServerToolOutputs(incoming, serverMessages), serverMessages, sanitizeForContentKey);
+	return dropStaleToolCopies(mergeServerToolOutputs(reconcileAssistantIds(incoming, serverMessages, sanitizeForContentKey), serverMessages), serverMessages, sanitizeForContentKey);
+}
+/**
+* Drop a stale client copy of an assistant that the same submit also echoes
+* under its stored ID. Kept, the copy persists as a second row carrying the
+* same toolCallIds and reaches the next prompt as a duplicate tool call, which
+* providers that issue unique IDs reject.
+*
+* A message is dropped only when it claimed no server row, is not the last
+* submitted message (a new call awaiting its result sits there), and consists
+* solely of `step-start` parts and pending tool parts each matching the same
+* call already settled on a server row this submit claimed. Anything else is
+* kept.
+*/
+function dropStaleToolCopies(reconciled, serverMessages, sanitize) {
+	const reconciledIds = new Set(reconciled.map((msg) => msg.id));
+	const serverIds = /* @__PURE__ */ new Set();
+	const settledOnClaimed = /* @__PURE__ */ new Map();
+	for (const msg of serverMessages) {
+		serverIds.add(msg.id);
+		if (msg.role !== "assistant" || !reconciledIds.has(msg.id)) continue;
+		for (const part of msg.parts) {
+			const record = part;
+			if (!isResolvedToolPart(record)) continue;
+			const toolCallId = record.toolCallId;
+			const settled = settledOnClaimed.get(toolCallId);
+			if (settled) settled.push(record);
+			else settledOnClaimed.set(toolCallId, [record]);
+		}
+	}
+	if (settledOnClaimed.size === 0) return reconciled;
+	const lastIndex = reconciled.length - 1;
+	const kept = reconciled.filter((msg, index) => {
+		if (index === lastIndex) return true;
+		if (msg.role !== "assistant" || serverIds.has(msg.id)) return true;
+		const comparable = sanitize ? sanitize(msg) : msg;
+		let hasToolPart = false;
+		for (const part of comparable.parts) {
+			const record = part;
+			if (record.type === "step-start") continue;
+			if (typeof record.toolCallId !== "string" || !(isPendingToolPart(record) || record.state === "input-streaming")) return true;
+			if (!settledOnClaimed.get(record.toolCallId)?.some((candidate) => sameToolCall(candidate, record))) return true;
+			hasToolPart = true;
+		}
+		return !hasToolPart;
+	});
+	return kept.length === reconciled.length ? reconciled : kept;
 }
 /**
 * 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`.
 */
 function resolveToolMergeId(message, serverMessages) {
 	if (message.role !== "assistant") return message;
@@ -2293,23 +2498,28 @@ function assistantContentKey(message, sanitize) {
 	return JSON.stringify(sanitized.parts);
 }
 function mergeServerToolOutputs(incoming, serverMessages) {
-	const serverResolvedParts = /* @__PURE__ */ new Map();
+	const serverResolvedPartsByMessage = /* @__PURE__ */ new Map();
 	for (const msg of serverMessages) {
 		if (msg.role !== "assistant") continue;
+		const resolvedParts = /* @__PURE__ */ new Map();
 		for (const part of msg.parts) {
 			const record = part;
-			if ("toolCallId" in record && "state" in record && (record.state === "output-available" || record.state === "output-error" || record.state === "output-denied")) serverResolvedParts.set(record.toolCallId, record);
+			if (isResolvedToolPart(record)) resolvedParts.set(record.toolCallId, record);
 		}
+		if (resolvedParts.size > 0) serverResolvedPartsByMessage.set(msg.id, resolvedParts);
 	}
-	if (serverResolvedParts.size === 0) return incoming;
+	if (serverResolvedPartsByMessage.size === 0) return incoming;
 	return incoming.map((msg) => {
 		if (msg.role !== "assistant") return msg;
+		const ownResolvedParts = serverResolvedPartsByMessage.get(msg.id);
+		if (!ownResolvedParts) return msg;
 		let hasChanges = false;
 		const updatedParts = msg.parts.map((part) => {
 			const record = part;
-			if ("toolCallId" in record && "state" in record && (record.state === "input-available" || record.state === "approval-requested" || record.state === "approval-responded") && serverResolvedParts.has(record.toolCallId)) {
+			if (!isPendingToolPart(record)) return part;
+			const server = ownResolvedParts.get(record.toolCallId);
+			if (server) {
 				hasChanges = true;
-				const server = serverResolvedParts.get(record.toolCallId);
 				const merged = {
 					...part,
 					state: server.state
@@ -2344,7 +2554,22 @@ function reconcileAssistantIds(incoming, serverMessages, sanitize) {
 	}
 	return incoming.map((incomingMessage, incomingIdx) => {
 		if (exactMatchMap.has(incomingIdx)) return incomingMessage;
-		if (incomingMessage.role !== "assistant" || hasToolCallPart(incomingMessage)) return incomingMessage;
+		if (incomingMessage.role !== "assistant") return incomingMessage;
+		const incomingToolParts = toolPartsByCallId(sanitize ? sanitize(incomingMessage) : incomingMessage);
+		if (incomingToolParts.size > 0) {
+			for (let i = 0; i < serverMessages.length; i++) {
+				if (claimedServerIndices.has(i)) continue;
+				const serverMessage = serverMessages[i];
+				if (serverMessage.role === "assistant" && carriesSameToolCalls(serverMessage, incomingToolParts)) {
+					claimedServerIndices.add(i);
+					return {
+						...incomingMessage,
+						id: serverMessage.id
+					};
+				}
+			}
+			return incomingMessage;
+		}
 		const incomingKey = assistantContentKey(incomingMessage, sanitize);
 		if (!incomingKey) return incomingMessage;
 		for (let i = 0; i < serverMessages.length; i++) {
@@ -2365,6 +2590,53 @@ function reconcileAssistantIds(incoming, serverMessages, sanitize) {
 function hasToolCallPart(message) {
 	return message.parts.some((part) => "toolCallId" in part);
 }
+/** A server-side tool part that has reached a terminal state. */
+function isResolvedToolPart(record) {
+	return "toolCallId" in record && "state" in record && (record.state === "output-available" || record.state === "output-error" || record.state === "output-denied");
+}
+/** A client-side tool part still waiting on a result. */
+function isPendingToolPart(record) {
+	return "toolCallId" in record && "state" in record && (record.state === "input-available" || record.state === "approval-requested" || record.state === "approval-responded");
+}
+/**
+* Whether `serverMessage` shares at least one toolCallId with the incoming
+* message and every shared toolCallId is the same call on both sides. A
+* provider that reuses a toolCallId for a new call carries a different tool
+* or input, so it cannot adopt the older row's ID.
+*/
+function carriesSameToolCalls(serverMessage, incomingToolParts) {
+	let shared = false;
+	for (const part of serverMessage.parts) {
+		const record = part;
+		if (typeof record.toolCallId !== "string") continue;
+		const incomingPart = incomingToolParts.get(record.toolCallId);
+		if (!incomingPart) continue;
+		if (!sameToolCall(record, incomingPart)) return false;
+		shared = true;
+	}
+	return shared;
+}
+/**
+* Same tool and structurally equal input (object key order ignored). Static
+* tool parts may omit `toolName`, so it is compared only when both carry it.
+*/
+function sameToolCall(a, b) {
+	return a.type === b.type && (a.toolName === void 0 || b.toolName === void 0 || a.toolName === b.toolName) && stableStringify(a.input) === stableStringify(b.input);
+}
+function stableStringify(value) {
+	if (value === null || typeof value !== "object") return JSON.stringify(value);
+	if (Array.isArray(value)) return `[${value.map((item) => stableStringify(item) ?? "null").join(",")}]`;
+	const record = value;
+	return `{${Object.keys(record).filter((key) => record[key] !== void 0).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`).join(",")}}`;
+}
+function toolPartsByCallId(message) {
+	const parts = /* @__PURE__ */ new Map();
+	for (const part of message.parts) {
+		const record = part;
+		if (typeof record.toolCallId === "string" && !parts.has(record.toolCallId)) parts.set(record.toolCallId, record);
+	}
+	return parts;
+}
 function findMessageByToolCallId(messages, toolCallId) {
 	for (const msg of messages) {
 		if (msg.role !== "assistant") continue;
@@ -2396,7 +2668,7 @@ function toolPartHasSettledResult(record) {
 *
 *   - 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
@@ -2415,7 +2687,8 @@ function repairInterruptedToolParts(messages, options) {
 	let normalizedInputs = 0;
 	const toolCallIds = [];
 	const repaired = [];
-	for (const message of messages) {
+	for (const [messageIndex, message] of messages.entries()) {
+		const isLastMessage = messageIndex === messages.length - 1;
 		const parts = [];
 		let messageChanged = false;
 		for (const part of message.parts) {
@@ -2427,8 +2700,23 @@ function repairInterruptedToolParts(messages, options) {
 			}
 			if (!isSettled(record)) {
 				if ((typeof record.state === "string" ? record.state : "") === "approval-responded") {
-					parts.push(part);
-					continue;
+					if (!options.repairApprovalResponded || isLastMessage) {
+						parts.push(part);
+						continue;
+					}
+					if (record.approval?.approved === false) {
+						const normalized = normalizeInput("input" in record ? record.input : void 0);
+						parts.push({
+							...part,
+							input: normalized.input,
+							state: "output-denied"
+						});
+						if (normalized.changed) normalizedInputs++;
+						removedToolCalls++;
+						messageChanged = true;
+						toolCallIds.push(toolCallId);
+						continue;
+					}
 				}
 				if (!shouldRepair(part)) {
 					parts.push(part);
@@ -2493,7 +2781,7 @@ async function persistReconstructedOrphan(chunks, options) {
 }
 //#endregion
 //#region src/chat/recovery.ts
-function createChatFiberSnapshot({ kind, requestId, recoveryRootRequestId, continuation, messages, lastBody, lastClientTools }) {
+function createChatFiberSnapshot({ kind, requestId, recoveryRootRequestId, continuation, messages, lastBody, lastClientTools, originMessageIds }) {
 	const latestMessage = messages.length > 0 ? messages[messages.length - 1] : void 0;
 	let latestUser;
 	for (let index = messages.length - 1; index >= 0; index--) if (messages[index].role === "user") {
@@ -2511,7 +2799,8 @@ function createChatFiberSnapshot({ kind, requestId, recoveryRootRequestId, conti
 		latestUserMessageId: latestUser?.id,
 		startedAt: Date.now(),
 		lastBody,
-		lastClientTools
+		lastClientTools,
+		...originMessageIds ? { originMessageIds } : {}
 	};
 }
 function wrapChatFiberSnapshot(key, snapshot, user) {
@@ -2703,13 +2992,20 @@ var ResumeHandshake = class {
 		if (resumableStream.hasActiveStream() && resumableStream.activeRequestId === requestId) {
 			const orphanedStreamId = resumableStream.replayChunks(connection, resumableStream.activeRequestId);
 			if (orphanedStreamId) await this.host.persistOrphanedStream(orphanedStreamId);
-		} else if (resumableStream.hasActiveStream()) {} else if (await this._replayTerminalOnAck(connection, requestId)) {} else if (!resumableStream.replayCompletedChunksByRequestId(connection, requestId)) sendIfOpen(connection, JSON.stringify({
-			body: "",
-			done: true,
-			id: requestId,
-			type: responseMessageType,
-			replay: true
-		}));
+		} else if (resumableStream.hasActiveStream()) {} else if (this.host.holdsTerminalFrames?.(requestId)) resumableStream.replayClosedStreamChunks(connection, requestId);
+		else if (await this._replayTerminalOnAck(connection, requestId)) {} else if (!resumableStream.replayCompletedChunksByRequestId(connection, requestId)) {
+			const messageIds = resumableStream.getOriginMessageIds(requestId);
+			const outcome = resumableStream.getOutcome(requestId);
+			sendIfOpen(connection, JSON.stringify({
+				body: "",
+				done: true,
+				id: requestId,
+				type: responseMessageType,
+				replay: true,
+				...messageIds && { messageIds },
+				...outcome && { outcome }
+			}));
+		}
 	}
 	/**
 	* Replay a pending terminal outcome (#1645) over the resume handshake so a
@@ -2741,12 +3037,14 @@ var ResumeHandshake = class {
 		const pending = await this.host.pendingChatTerminal();
 		if (!pending || pending.requestId !== requestId) return false;
 		if (!resumableStream.replayErroredChunksByRequestId(connection, pending.requestId)) return true;
+		const messageIds = pending.messageIds ?? resumableStream.getOriginMessageIds(pending.requestId);
 		sendIfOpen(connection, JSON.stringify({
 			body: pending.body,
 			done: true,
 			error: true,
 			id: pending.requestId,
-			type: responseMessageType
+			type: responseMessageType,
+			...messageIds && { messageIds }
 		}));
 		return true;
 	}
@@ -2786,7 +3084,7 @@ const CHAT_LAST_TERMINAL_KEY = "cf:chat:last-terminal";
 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
@@ -3026,11 +3324,13 @@ var StreamProgressCreditThrottle = class {
 * until a later turn supersedes it ({@link clearChatTerminal}); a single record
 * is sufficient because only the most recent terminal is relevant.
 */
-async function recordChatTerminal(storage, requestId, body) {
-	await storage.put(CHAT_LAST_TERMINAL_KEY, {
+async function recordChatTerminal(storage, requestId, body, messageIds) {
+	const record = {
 		requestId,
 		body
-	});
+	};
+	if (messageIds?.length) record.messageIds = messageIds;
+	await storage.put(CHAT_LAST_TERMINAL_KEY, record);
 }
 /** Clear the durable terminal record once a later turn supersedes it (#1645). */
 async function clearChatTerminal(storage) {
@@ -3127,10 +3427,12 @@ async function evaluateChatRecoveryIncident(input) {
 	const workBudgetExceeded = existing != null && Number.isFinite(config.maxRecoveryWork) && work > config.maxRecoveryWork;
 	const oomAttempts = existing?.oomAttempts ?? 0;
 	const oomBudgetExceeded = existing != null && !awaitingClientInteraction && oomAttempts > config.maxOomRetries;
+	const transientRetries = existing?.transientRetries ?? 0;
+	const transientBudgetExceeded = existing != null && !awaitingClientInteraction && transientRetries >= config.maxAttempts;
 	const debounced = existing != null && !madeProgress && now - existing.lastAttemptAt < 3e4;
 	const attempt = madeProgress ? 1 : debounced ? existing?.attempt ?? 1 : (existing?.attempt ?? 0) + 1;
 	let abortedByCaller = false;
-	if (existing != null && !awaitingClientInteraction && config.shouldKeepRecovering && !noProgressExceeded && !workBudgetExceeded && !oomBudgetExceeded && attempt <= config.maxAttempts) try {
+	if (existing != null && !awaitingClientInteraction && config.shouldKeepRecovering && !noProgressExceeded && !workBudgetExceeded && !oomBudgetExceeded && !transientBudgetExceeded && attempt <= config.maxAttempts) try {
 		const ctx = {
 			incidentId,
 			requestId: identity.requestId,
@@ -3145,7 +3447,7 @@ async function evaluateChatRecoveryIncident(input) {
 	} catch (error) {
 		input.onShouldKeepRecoveringError?.(error);
 	}
-	const exhausted = !awaitingClientInteraction && (oomBudgetExceeded || noProgressExceeded || workBudgetExceeded || abortedByCaller || attempt > config.maxAttempts);
+	const exhausted = !awaitingClientInteraction && (oomBudgetExceeded || noProgressExceeded || workBudgetExceeded || abortedByCaller || transientBudgetExceeded || attempt > config.maxAttempts);
 	const incident = {
 		incidentId,
 		requestId: identity.requestId,
@@ -3160,6 +3462,7 @@ async function evaluateChatRecoveryIncident(input) {
 		progress,
 		workBaseline,
 		...oomAttempts > 0 ? { oomAttempts } : {},
+		...transientRetries > 0 ? { transientRetries } : {},
 		...exhausted ? { reason: oomBudgetExceeded ? "out_of_memory" : workBudgetExceeded ? "work_budget_exceeded" : noProgressExceeded ? "no_progress_timeout" : abortedByCaller ? "recovery_aborted" : "max_attempts_exceeded" } : {}
 	};
 	const events = [];
@@ -3272,7 +3575,7 @@ var ChatRecoveryEngine = class {
 				options: void 0,
 				partial
 			})) await wake.persistOrphanedStream(streamId);
-			await adapter.exhaustChatRecovery(incident, config, partial, streamId, ctx.createdAt);
+			await adapter.exhaustChatRecovery(incident, config, partial, streamId, ctx.createdAt, snapshot?.originMessageIds);
 			return true;
 		}
 		try {
@@ -3386,7 +3689,7 @@ var ChatRecoveryEngine = class {
 			maxAttempts: incident.maxAttempts,
 			recoveryKind: input.recoveryKind
 		});
-		await this.adapter.scheduleRecovery(input.callback, input.data, input.reason ?? "initial", 0);
+		await this.adapter.scheduleRecovery(input.callback, input.data, input.reason ?? "initial", input.delaySeconds ?? 0);
 	}
 	/**
 	* Reschedule a recovery continuation/retry that timed out waiting for stable
@@ -3425,6 +3728,47 @@ var ChatRecoveryEngine = class {
 		return true;
 	}
 	/**
+	* 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.
+	*/
+	async recordTransientRetry(incidentId) {
+		const { adapter } = this;
+		const key = chatRecoveryIncidentKey(incidentId);
+		const incident = await adapter.getIncident(key);
+		if (!incident) return 1;
+		const transientRetries = (incident.transientRetries ?? 0) + 1;
+		await adapter.putIncident(key, {
+			...incident,
+			transientRetries
+		});
+		return transientRetries;
+	}
+	/**
+	* 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.
+	*/
+	async cancelScheduledRecovery(requestId) {
+		const incidents = await this.adapter.listActiveIncidents?.() ?? [];
+		let cancelled = false;
+		for (const incident of incidents) if (incident.status === "scheduled" && (incident.recoveryRootRequestId === requestId || incident.requestId === requestId)) {
+			await this.updateIncident(incident.incidentId, "skipped", CHAT_RECOVERY_CANCELLED_REASON);
+			cancelled = true;
+		}
+		return cancelled;
+	}
+	/** Whether the user cancelled this incident's scheduled recovery. */
+	async isRecoveryCancelled(incidentId) {
+		if (!incidentId) return false;
+		const incident = await this.adapter.getIncident(chatRecoveryIncidentKey(incidentId));
+		return incident?.status === "skipped" && incident.reason === "user_cancelled";
+	}
+	/**
 	* Record that a recovery callback observed a Durable Object memory-limit reset
 	* (the isolate exceeded its 128 MB limit — `isDurableObjectMemoryLimitReset`)
 	* and decide what to do next (#1825).
@@ -3591,6 +3935,47 @@ var ChatRecoveryEngine = class {
 		else if (status === "completed" || status === "skipped" || status === "failed") await adapter.setRecovering(false);
 	}
 };
+/** `incident.reason` for a scheduled recovery the user cancelled. */
+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}.
+*/
+function chatRecoveryBackoffSeconds(retries, retryAfterSeconds) {
+	const backoff = Math.min(2 ** (retries - 1), 30);
+	if (retryAfterSeconds === void 0) return backoff;
+	return Math.min(Math.max(backoff, retryAfterSeconds), 60);
+}
+/**
+* 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.
+*/
+function retryAfterSeconds(error, now = Date.now()) {
+	let current = error;
+	for (let depth = 0; depth < 8 && current != null; depth++) {
+		if (typeof current !== "object") return void 0;
+		const record = current;
+		const value = readRetryAfterHeader(record.responseHeaders) ?? readRetryAfterHeader(record.headers);
+		if (value !== void 0) return parseRetryAfter(value, now);
+		current = record.cause;
+	}
+}
+function readRetryAfterHeader(headers) {
+	if (headers == null || typeof headers !== "object") return void 0;
+	if (headers instanceof Headers) return headers.get("retry-after") ?? void 0;
+	for (const [name, value] of Object.entries(headers)) if (name.toLowerCase() === "retry-after" && typeof value === "string") return value;
+}
+function parseRetryAfter(value, now) {
+	const trimmed = value.trim();
+	if (/^\d+(\.\d+)?$/.test(trimmed)) return Math.ceil(Number(trimmed));
+	const date = Date.parse(trimmed);
+	if (Number.isNaN(date)) return void 0;
+	return Math.max(0, Math.ceil((date - now) / 1e3));
+}
 /**
 * Build the `ChatRecoveryExhaustedContext` delivered to `onExhausted` and the
 * `chat:recovery:exhausted` event. Pure field-mapping shared by both packages;
@@ -3750,20 +4135,14 @@ async function* iterateWithStallWatchdog(source, timeoutMs, onStall) {
 //#endregion
 //#region src/chat/truncate-older-messages.ts
 /**
-* Read-time context truncation.
-*
-* Truncates older tool outputs and long text before sending to the LLM.
-* Structured tool outputs keep their container shape so tool-specific
-* `toModelOutput` handlers can safely replay older results.
-* Does NOT mutate stored messages — operates on a copy.
-*/
-/**
 * Truncate tool outputs and long text in older messages.
 * Returns a new array — input messages are not mutated.
 *
 * 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
@@ -3778,6 +4157,7 @@ function truncateOlderMessages(messages, options) {
 	const keepRecent = options?.keepRecent ?? 4;
 	const maxToolOutput = options?.maxToolOutputChars ?? 500;
 	const maxText = options?.maxTextChars ?? 1e4;
+	const truncateToolOutputs = options?.toolOutputs ?? true;
 	if (messages.length <= keepRecent) return messages;
 	const cutoff = messages.length - keepRecent;
 	const result = [];
@@ -3789,7 +4169,7 @@ function truncateOlderMessages(messages, options) {
 		const msg = messages[i];
 		let changed = false;
 		const truncatedParts = msg.parts.map((part) => {
-			if ((part.type.startsWith("tool-") || part.type === "dynamic-tool") && "output" in part) {
+			if (truncateToolOutputs && isToolPart(part) && "output" in part && !isProviderExecuted(part)) {
 				const output = part.output;
 				if (output !== void 0) {
 					const truncated = truncateToolOutput(output, maxToolOutput);
@@ -3821,7 +4201,153 @@ function truncateOlderMessages(messages, options) {
 	}
 	return result;
 }
+/**
+* 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.
+*/
+function truncateOlderToolResults(modelMessages, messages, options) {
+	const keepRecent = options?.keepRecent ?? 4;
+	const maxChars = options?.maxToolOutputChars ?? 500;
+	const cutoff = messages.length - keepRecent;
+	if (cutoff <= 0) return modelMessages;
+	const resultsById = /* @__PURE__ */ new Map();
+	let hasOlderResult = false;
+	messages.forEach((message, index) => {
+		for (const part of message.parts) {
+			if (!isToolPart(part) || !producesToolResult(part)) continue;
+			const truncatable = index < cutoff && !isProviderExecuted(part);
+			const toolCallId = part.toolCallId;
+			const results = resultsById.get(toolCallId) ?? [];
+			results.push(truncatable);
+			resultsById.set(toolCallId, results);
+			hasOlderResult ||= truncatable;
+		}
+	});
+	if (!hasOlderResult) return modelMessages;
+	return modelMessages.map((message) => {
+		if (message.role !== "tool") return message;
+		let changed = false;
+		const content = message.content.map((part) => {
+			if (part.type !== "tool-result") return part;
+			if (!resultsById.get(part.toolCallId)?.shift()) return part;
+			const output = truncateModelOutput(part.output, maxChars);
+			if (output === part.output) return part;
+			changed = true;
+			return {
+				...part,
+				output
+			};
+		});
+		return changed ? {
+			...message,
+			content
+		} : message;
+	});
+}
+function truncateModelOutput(output, maxChars) {
+	switch (output.type) {
+		case "text":
+		case "error-text":
+		case "json":
+		case "error-json": {
+			const truncated = truncateToolOutput(output.value, maxChars);
+			return truncated.truncated ? {
+				...output,
+				value: truncated.output
+			} : output;
+		}
+		case "content": {
+			let changed = false;
+			const withoutBytes = output.value.map((item) => {
+				const mediaType = inlineBinaryMediaType(item);
+				if (mediaType === void 0) return item;
+				changed = true;
+				return {
+					type: "text",
+					text: omittedMediaMarker(mediaType)
+				};
+			});
+			const total = output.value.reduce((sum, item) => sum + (inlineText(item)?.length ?? 0), 0);
+			if (total <= maxChars) return changed ? {
+				...output,
+				value: withoutBytes
+			} : output;
+			const suffix = truncatedSuffix(total);
+			let remaining = Math.max(0, maxChars - suffix.length);
+			let truncated = false;
+			const value = output.value.flatMap((item, index) => {
+				const text = inlineText(item);
+				if (text === void 0) return [withoutBytes[index]];
+				if (truncated) return [];
+				if (text.length <= remaining) {
+					remaining -= text.length;
+					return [item];
+				}
+				truncated = true;
+				return [withInlineText(item, maxChars <= suffix.length ? suffix.slice(0, maxChars) : `${text.slice(0, remaining)}${suffix}`)];
+			});
+			return {
+				...output,
+				value
+			};
+		}
+		default: return output;
+	}
+}
+/** Text a content item carries inline: a text item, or a text file. */
+function inlineText(item) {
+	if (item.type === "text") return item.text;
+	if (item.type === "file" && item.data.type === "text") return item.data.text;
+}
+function withInlineText(item, text) {
+	if (item.type === "file" && item.data.type === "text") return {
+		...item,
+		data: {
+			...item.data,
+			text
+		}
+	};
+	return {
+		...item,
+		text
+	};
+}
+/** Media type of a content item that carries file or image bytes inline. */
+function inlineBinaryMediaType(item) {
+	if (item.type === "file-data" || item.type === "image-data") return item.mediaType;
+	if (item.type === "file" && item.data.type === "data") return item.mediaType;
+}
+function omittedMediaMarker(mediaType) {
+	return `[${mediaType} omitted from an older tool result]`;
+}
+/**
+* Whether `convertToModelMessages` turns this UI tool part into a result in a
+* `tool` message. Provider-executed results go in the assistant message
+* instead, unless the part is a denied approval.
+*/
+function producesToolResult(part) {
+	const { state, approval } = part;
+	if (state === "approval-responded") return approval?.approved === false;
+	if (isProviderExecuted(part)) return false;
+	return state === "output-available" || state === "output-error" || state === "output-denied";
+}
+function isToolPart(part) {
+	return part.type.startsWith("tool-") || part.type === "dynamic-tool";
+}
+function isProviderExecuted(part) {
+	return part.providerExecuted === true;
+}
 //#endregion
-export { AGENT_TOOL_STREAM_PROGRESS_BUMP_THROTTLE_MS, AbortRegistry, AgentToolProgressEmitter, AgentToolStreamProgressThrottle, AutoContinuationController, CHAT_LAST_TERMINAL_KEY, CHAT_MESSAGE_TYPES, CHAT_RECOVERING_FLAG_TTL_MS, CHAT_RECOVERING_KEY, CHAT_RECOVERY_ALARM_DEBOUNCE_MS, CHAT_RECOVERY_INCIDENT_KEY_PREFIX, CHAT_RECOVERY_INCIDENT_TTL_MS, CHAT_RECOVERY_PROGRESS_KEY, CHAT_RECOVERY_STABLE_RETRY_DELAY_SECONDS, CHAT_RECOVERY_TASK_NAME, CHAT_STREAM_PROGRESS_CREDIT_THROTTLE_MS, ChatRecoveryEngine, ChatStreamStalledError, ContinuationState, DEFAULT_CHAT_RECOVERY_MAX_ATTEMPTS, DEFAULT_CHAT_RECOVERY_MAX_OOM_RETRIES, DEFAULT_CHAT_RECOVERY_MAX_WORK, DEFAULT_CHAT_RECOVERY_NO_PROGRESS_TIMEOUT_MS, DEFAULT_CHAT_RECOVERY_STABLE_TIMEOUT_MS, DEFAULT_CHAT_RECOVERY_TERMINAL_MESSAGE, KV_DELETE_MAX_KEYS, MAX_BOUND_PARAMS, MessageType, PreStreamTurns, ROW_MAX_BYTES, ResumableStream, ResumeHandshake, STREAM_RESUME_NONE_REASONS, StreamAccumulator, StreamProgressCreditThrottle, SubmitConcurrencyController, TIMED_OUT, TextSegmentJoiner, TurnQueue, aiSdkRecoveryCodec, applyAgentToolEvent, applyChunkToParts, applyToolUpdate, awaitWithDeadline, transition as broadcastTransition, buildChatRecoveringFrame, buildInClauseStrings, bumpChatRecoveryProgress, byteLength, chatRecoveryTaskRunOptions, classifyAgentToolChildRecovery, clearChatTerminal, clientResolvableToolNames, createAgentToolEventState, createChatFiberSnapshot, createChatRecoveryTaskDefinition, createChatStreams, createChatTurnTaskDefinition, createToolsFromClientSchemas, crossMessageToolResultUpdate, dispatchChatRecoveryToHandoff, drainInteractionApplies, enforceRowSizeLimit, hasIncompleteToolBatch, interceptAgentToolBroadcast, isPlatformFailure, isReplayChunk, iterateWithStallWatchdog, listActiveChatRecoveryIncidents, normalizeToolInput, parseProtocolMessage, partAwaitsClientInteraction, pausedExecutionUpdate, pendingChatTerminal, persistReconstructedOrphan, readChatRecoveryProgress, reconcileMessages, reconcileOrphanPartial, recordChatTerminal, repairInterruptedToolParts, resolveChatRecoveryConfig, resolveToolMergeId, runChatRecoveryExhaustion, sanitizeMessage, sendIfOpen, setChatRecovering, shouldCreditStreamProgress, sweepStaleChatRecoveryIncidents, toolApprovalUpdate, toolPartHasSettledResult, toolResultUpdate, truncateOlderMessages, unwrapChatFiberSnapshot, wrapChatFiberSnapshot };
+export { AGENT_TOOL_STREAM_PROGRESS_BUMP_THROTTLE_MS, AbortRegistry, AgentToolProgressEmitter, AgentToolStreamProgressThrottle, AutoContinuationController, CHAT_LAST_TERMINAL_KEY, CHAT_MESSAGE_TYPES, 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, CHAT_RECOVERY_STABLE_RETRY_DELAY_SECONDS, CHAT_RECOVERY_TASK_NAME, CHAT_STREAM_PROGRESS_CREDIT_THROTTLE_MS, ChatRecoveryEngine, ChatStreamStalledError, ContinuationState, DEFAULT_CHAT_RECOVERY_MAX_ATTEMPTS, DEFAULT_CHAT_RECOVERY_MAX_OOM_RETRIES, DEFAULT_CHAT_RECOVERY_MAX_WORK, DEFAULT_CHAT_RECOVERY_NO_PROGRESS_TIMEOUT_MS, DEFAULT_CHAT_RECOVERY_STABLE_TIMEOUT_MS, DEFAULT_CHAT_RECOVERY_TERMINAL_MESSAGE, KV_DELETE_MAX_KEYS, MAX_BOUND_PARAMS, MessageType, PreStreamTurns, ROW_MAX_BYTES, ResumableStream, ResumeHandshake, STREAM_RESUME_NONE_REASONS, StreamAccumulator, StreamProgressCreditThrottle, SubmitConcurrencyController, TIMED_OUT, TextSegmentJoiner, TurnQueue, aiSdkRecoveryCodec, applyAgentToolEvent, applyChunkToParts, applyLateToolInput, applyToolUpdate, awaitWithDeadline, transition as broadcastTransition, buildChatRecoveringFrame, buildInClauseStrings, bumpChatRecoveryProgress, byteLength, chatRecoveryBackoffSeconds, chatRecoveryTaskRunOptions, classifyAgentToolChildRecovery, clearChatTerminal, clientResolvableToolNames, createAgentToolEventState, createChatFiberSnapshot, createChatRecoveryTaskDefinition, createChatStreams, createChatTurnTaskDefinition, createToolsFromClientSchemas, crossMessageToolResultUpdate, dispatchChatRecoveryToHandoff, drainInteractionApplies, enforceRowSizeLimit, hasIncompleteToolBatch, interceptAgentToolBroadcast, isDurableObjectResetError, isLateToolInputChunk, isPlatformFailure, isPositionlessAgentToolChunk, isReplayChunk, iterateWithStallWatchdog, lateToolInputForwardChunks, listActiveChatRecoveryIncidents, normalizeToolInput, originMessageIds, parseProtocolMessage, partAwaitsClientInteraction, partialHasSettledToolResults, pausedExecutionUpdate, pendingChatTerminal, persistReconstructedOrphan, readChatRecoveryProgress, reconcileMessages, reconcileOrphanPartial, recordChatTerminal, repairInterruptedToolParts, resolveChatRecoveryConfig, resolveToolMergeId, retryAfterSeconds, runChatRecoveryExhaustion, sanitizeMessage, sendIfOpen, setChatRecovering, shouldCreditStreamProgress, sweepStaleChatRecoveryIncidents, toolApprovalUpdate, toolPartHasSettledResult, toolResultUpdate, truncateOlderMessages, truncateOlderToolResults, unwrapChatFiberSnapshot, withOriginMessageIds, wrapChatFiberSnapshot };
 
 //# sourceMappingURL=index.js.map