agents 0.22.0 → 0.24.0

package/dist/chat/index.js

@@ -1,67 +1,111 @@
-import { i as _classPrivateFieldInitSpec, n as _classPrivateFieldSet2, r as _assertClassBrand, t as _classPrivateFieldGet2 } from "../classPrivateFieldGet2-DZBYAB34.js";
-import { t as _classPrivateMethodInitSpec } from "../classPrivateMethodInitSpec-qMjJ6sHQ.js";
+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 { t as truncateToolOutput } from "../tool-output-truncation-CNnnGZQ3.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 { t as MessageType } from "../wire-types-CnMt6_HR.js";
 import { jsonSchema, tool } from "ai";
 import { nanoid } from "nanoid";
-//#region src/chat/sanitize.ts
-const textEncoder$1 = new TextEncoder();
-/** Maximum serialized message size before compaction (bytes). 1.8MB with headroom below SQLite's 2MB limit. */
-const ROW_MAX_BYTES = 18e5;
-/** Measure UTF-8 byte length of a string. */
-function byteLength(s) {
-	return textEncoder$1.encode(s).byteLength;
-}
-/**
-* Sanitize a message for persistence by removing ephemeral provider-specific
-* data that should not be stored or sent back in subsequent requests.
-*
-* 1. Strips OpenAI ephemeral fields (itemId, reasoningEncryptedContent)
-* 2. Filters truly empty reasoning parts (no text, no remaining providerMetadata)
-*/
-function sanitizeMessage(message) {
-	const sanitizedParts = message.parts.map((part) => {
-		let sanitizedPart = part;
-		if ("providerMetadata" in sanitizedPart && sanitizedPart.providerMetadata && typeof sanitizedPart.providerMetadata === "object" && "openai" in sanitizedPart.providerMetadata) sanitizedPart = stripOpenAIMetadata(sanitizedPart, "providerMetadata");
-		if ("callProviderMetadata" in sanitizedPart && sanitizedPart.callProviderMetadata && typeof sanitizedPart.callProviderMetadata === "object" && "openai" in sanitizedPart.callProviderMetadata) sanitizedPart = stripOpenAIMetadata(sanitizedPart, "callProviderMetadata");
-		return sanitizedPart;
-	}).filter((part) => {
-		if (part.type === "reasoning") {
-			const reasoningPart = part;
-			if (!reasoningPart.text || reasoningPart.text.trim() === "") {
-				if ("providerMetadata" in reasoningPart && reasoningPart.providerMetadata && typeof reasoningPart.providerMetadata === "object" && Object.keys(reasoningPart.providerMetadata).length > 0) return true;
-				return false;
-			}
-		}
-		return true;
-	});
+//#region src/chat/tool-output-truncation.ts
+const DEFAULT_MAX_DEPTH = 8;
+const TRUNCATED_FLAG = "__truncated";
+const TRUNCATED_CHARS = "__truncatedChars";
+function truncateToolOutput(output, maxChars) {
+	const original = stringifyForLength(output);
+	if (original.length <= maxChars) return {
+		output,
+		truncated: false,
+		originalLength: original.length
+	};
 	return {
-		...message,
-		parts: sanitizedParts
+		output: truncateValue(output, maxChars, original.length, 0),
+		truncated: true,
+		originalLength: original.length
 	};
 }
-function stripOpenAIMetadata(part, metadataKey) {
-	const metadata = part[metadataKey];
-	if (!metadata?.openai) return part;
-	const { itemId: _itemId, reasoningEncryptedContent: _rec, ...restOpenai } = metadata.openai;
-	const hasOtherOpenaiFields = Object.keys(restOpenai).length > 0;
-	const { openai: _openai, ...restMetadata } = metadata;
-	let newMetadata;
-	if (hasOtherOpenaiFields) newMetadata = {
-		...restMetadata,
-		openai: restOpenai
+function truncatedSuffix(originalLength) {
+	return `... [truncated ${originalLength} chars]`;
+}
+function truncateValue(value, maxChars, originalLength, depth) {
+	if (typeof value === "string") return truncateString(value, maxChars, value.length);
+	if (value === null || typeof value !== "object") return value;
+	if (depth >= DEFAULT_MAX_DEPTH) return `[Nested output omitted ${truncatedSuffix(originalLength)}]`;
+	if (Array.isArray(value)) return truncateArray(value, maxChars, originalLength, depth);
+	return truncateObject(value, maxChars, originalLength, depth);
+}
+function truncateArray(value, maxChars, originalLength, depth) {
+	const childBudget = childMaxChars(maxChars, value.length);
+	const result = value.map((item) => truncateValue(item, childBudget, stringifyForLength(item).length, depth + 1));
+	while (result.length > 1 && stringifyForLength(result).length > maxChars) result.pop();
+	if (result.length < value.length) result.push(`Array output truncated ${truncatedSuffix(originalLength)}`);
+	if (stringifyForLength(result).length > maxChars) return compactArrayMarker(maxChars, originalLength);
+	return result;
+}
+function truncateObject(value, maxChars, originalLength, depth) {
+	const entries = Object.entries(value);
+	const childBudget = childMaxChars(maxChars, entries.length);
+	const result = {};
+	for (const [key, entryValue] of entries) result[key] = truncateValue(entryValue, childBudget, stringifyForLength(entryValue).length, depth + 1);
+	const resultLength = stringifyForLength(result).length;
+	if (resultLength <= maxChars) return result;
+	shrinkStringFields(result, maxChars);
+	if (stringifyForLength(result).length > maxChars) {
+		result[TRUNCATED_FLAG] = true;
+		result[TRUNCATED_CHARS] = resultLength;
+	}
+	if (stringifyForLength(result).length > maxChars) return compactObjectMarker(maxChars, originalLength);
+	return result;
+}
+function shrinkStringFields(value, maxChars) {
+	const stringEntries = Object.entries(value).filter((entry) => typeof entry[1] === "string").sort((a, b) => b[1].length - a[1].length);
+	for (const [key, str] of stringEntries) {
+		if (stringifyForLength(value).length <= maxChars) return;
+		value[key] = truncateString(str, Math.max(0, Math.floor(maxChars / 4)), str.length);
+	}
+}
+function truncateString(value, maxChars, originalLength) {
+	if (value.length <= maxChars) return value;
+	const suffix = truncatedSuffix(originalLength);
+	if (maxChars <= suffix.length) return suffix.slice(0, maxChars);
+	return `${value.slice(0, maxChars - suffix.length)}${suffix}`;
+}
+function compactObjectMarker(maxChars, originalLength) {
+	const marker = {
+		[TRUNCATED_FLAG]: true,
+		[TRUNCATED_CHARS]: originalLength,
+		note: "Tool output omitted because it was too large to preserve structurally."
 	};
-	else if (Object.keys(restMetadata).length > 0) newMetadata = restMetadata;
-	const { [metadataKey]: _oldMeta, ...restPart } = part;
-	if (newMetadata) return {
-		...restPart,
-		[metadataKey]: newMetadata
+	if (stringifyForLength(marker).length <= maxChars) return marker;
+	return {
+		[TRUNCATED_FLAG]: true,
+		[TRUNCATED_CHARS]: originalLength
 	};
-	return restPart;
 }
+function compactArrayMarker(maxChars, originalLength) {
+	const structuredMarker = compactObjectMarker(maxChars, originalLength);
+	if (stringifyForLength([structuredMarker]).length <= maxChars) return [structuredMarker];
+	const marker = [`Array output omitted because it was too large to preserve structurally ${truncatedSuffix(originalLength)}`];
+	if (stringifyForLength(marker).length <= maxChars) return marker;
+	return [truncatedSuffix(originalLength).slice(0, maxChars)];
+}
+function childMaxChars(maxChars, childCount) {
+	if (childCount <= 1) return maxChars;
+	return Math.max(80, Math.floor(maxChars / Math.min(childCount, 10)));
+}
+function stringifyForLength(value) {
+	try {
+		if (typeof value === "string") return value;
+		return JSON.stringify(value) ?? String(value);
+	} catch {
+		return String(value);
+	}
+}
+//#endregion
+//#region src/chat/sanitize.ts
+/** Maximum serialized message size before compaction (bytes). 1.8MB with headroom below SQLite's 2MB limit. */
+const ROW_MAX_BYTES = 18e5;
 /**
 * Enforce SQLite row size limits by compacting tool outputs and text parts
 * when a serialized message exceeds the safety threshold (1.8MB). Shared by
@@ -218,58 +262,6 @@ var TurnQueue = class {
 	}
 };
 //#endregion
-//#region src/chat/text-segment-joiner.ts
-var _hasText = /* @__PURE__ */ new WeakMap();
-var _lastTextEndedWithWhitespace = /* @__PURE__ */ new WeakMap();
-var _needsBoundarySpace = /* @__PURE__ */ new WeakMap();
-var _TextSegmentJoiner_brand = /* @__PURE__ */ new WeakSet();
-/**
-* @internal Converts structured stream chunks into text and boundary events
-* without gluing words across non-text chunks. Sibling-package support for
-* `@cloudflare/voice` and `@cloudflare/think`, not a public API.
-*/
-var TextSegmentJoiner = class {
-	constructor() {
-		_classPrivateMethodInitSpec(this, _TextSegmentJoiner_brand);
-		_classPrivateFieldInitSpec(this, _hasText, false);
-		_classPrivateFieldInitSpec(this, _lastTextEndedWithWhitespace, false);
-		_classPrivateFieldInitSpec(this, _needsBoundarySpace, false);
-	}
-	pushChunk(chunk) {
-		if (chunk.type === "text-delta") {
-			const text = textFromChunk(chunk);
-			return text ? _assertClassBrand(_TextSegmentJoiner_brand, this, _pushText).call(this, text) : [];
-		}
-		if (typeof chunk.type !== "string" || !_assertClassBrand(_TextSegmentJoiner_brand, this, _markBoundary).call(this)) return [];
-		return [{ type: "boundary" }];
-	}
-};
-function _markBoundary() {
-	if (!_classPrivateFieldGet2(_hasText, this) || _classPrivateFieldGet2(_needsBoundarySpace, this)) return false;
-	_classPrivateFieldSet2(_needsBoundarySpace, this, true);
-	return true;
-}
-function _pushText(text) {
-	const events = [];
-	if (_classPrivateFieldGet2(_needsBoundarySpace, this) && !_classPrivateFieldGet2(_lastTextEndedWithWhitespace, this) && !/^\s/.test(text)) events.push({
-		type: "text",
-		text: " "
-	});
-	events.push({
-		type: "text",
-		text
-	});
-	_classPrivateFieldSet2(_hasText, this, true);
-	_classPrivateFieldSet2(_lastTextEndedWithWhitespace, this, /\s$/.test(text));
-	_classPrivateFieldSet2(_needsBoundarySpace, this, false);
-	return events;
-}
-function textFromChunk(chunk) {
-	if (typeof chunk.text === "string") return chunk.text;
-	if (typeof chunk.delta === "string") return chunk.delta;
-	return null;
-}
-//#endregion
 //#region src/chat/submit-concurrency.ts
 var SubmitConcurrencyController = class {
 	constructor(options) {
@@ -411,132 +403,337 @@ function isWebSocketClosedSendError(error) {
 	return error instanceof TypeError && error.message.includes("WebSocket send() after close");
 }
 //#endregion
+//#region src/chat/replay-frames.ts
+/**
+* Send stored chunk bodies to a connection as replay frames.
+*
+* @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) {
+	for (const body of bodies) if (!sendIfOpen(connection, JSON.stringify({
+		body,
+		done: false,
+		id: requestId,
+		type: CHAT_MESSAGE_TYPES.USE_CHAT_RESPONSE,
+		replay: true,
+		...continuation && { continuation: true }
+	}))) return false;
+	return true;
+}
+/**
+* Send one replay control frame: `done: true` ends the replayed stream;
+* `replayComplete` tells a live client to flush accumulated parts and keep
+* listening. Replay frames must mirror what a live client observed,
+* including the continuation flag (#1733).
+*/
+function sendReplayControl(connection, requestId, options) {
+	return sendIfOpen(connection, JSON.stringify({
+		body: "",
+		done: options.done,
+		id: requestId,
+		type: CHAT_MESSAGE_TYPES.USE_CHAT_RESPONSE,
+		replay: true,
+		...options.replayComplete && { replayComplete: true },
+		...options.continuation && { continuation: true }
+	}));
+}
+//#endregion
 //#region src/chat/resumable-stream.ts
 /**
-* ResumableStream: Standalone class for buffering, persisting, and replaying
-* stream chunks in SQLite. Extracted from AIChatAgent to separate concerns.
+* ResumableStream: chat's producer-side coalescing and wire-protocol replay
+* adapter over the `agents/streams` capability. Chat's in-flight output
+* lives in the shared durable chunk log (`cf_agents_streams` /
+* `cf_agents_stream_blocks`), one stream per turn, tagged with the turn's
+* request id so replay-by-request rides the capability's indexed lookup.
 *
 * Handles:
-* - Chunk buffering (batched writes to SQLite for performance)
-* - Stream lifecycle (start, complete, error)
-* - Chunk replay for reconnecting clients
-* - Stale stream cleanup
+* - Chunk buffering (packed segments — batched writes for storage-op economy)
+* - Stream lifecycle (start, complete, error) mapped onto Streams settlement
+* - Chunk replay for reconnecting clients (framing in `replay-frames.ts`)
+* - Stale stream cleanup (row-level retention; at most one indexed
+*   chunk-tail read per stale live candidate, never a chunk-table scan)
 * - Active stream restoration after agent restart
-*/
-/** Number of chunks to pack into a single SQLite row before flushing */
+* - One-time migration of legacy `cf_ai_chat_stream_*` tables
+*
+* The adapter's public surface is synchronous and may be constructed before
+* the Lifecycle starts, so it runs on the Streams internal sync aperture; the
+* invariant-bearing writes (append fence, settlement, wakeups, events) go
+* through the capability, so live `streams.read()` consumers and diagnostics
+* observe chat streams like any other stream. The host `sql` handle is used
+* only for chat's own legacy tables during migration.
+*/
+/** Number of chunks to pack into a single stored segment before flushing */
 const CHUNK_BUFFER_SIZE = 10;
 /** Maximum buffer size to prevent memory issues on rapid reconnections */
 const CHUNK_BUFFER_MAX_SIZE = 100;
 /**
-* Max accumulated raw chunk bytes packed into one row before forcing a flush.
-* The SQLite row limit is 2 MB; packing serializes bodies into a JSON array,
-* which re-escapes their contents (quotes/backslashes), so we keep the raw
-* total well under the limit to leave generous headroom for escaping overhead.
-* A chunk larger than this is flushed as its own (unwrapped) row.
+* Max accumulated raw chunk bytes packed into one segment before forcing a
+* flush. The SQLite row limit is 2 MB; packing serializes bodies into a JSON
+* array, which re-escapes their contents (quotes/backslashes), so we keep the
+* raw total well under the limit to leave generous headroom for escaping
+* overhead. A chunk larger than this is flushed as its own (unwrapped)
+* segment.
 */
 const SEGMENT_MAX_BYTES = 512e3;
-/** Default cleanup interval for old streams (ms) - every 10 minutes */
-const CLEANUP_INTERVAL_MS = 600 * 1e3;
 /**
-* Retention for completed/errored stream buffers, measured from completion.
-*
-* The assistant message is persisted separately (`cf_ai_chat_agent_messages`),
-* so once a stream completes its buffer is no longer the source of truth — it
-* is only a brief reconnect-and-replay grace window: long enough to cover a
-* client that dropped at the completion boundary and reconnects to replay the
-* just-finished stream, and to deliver a pending terminal error frame on a
-* resumed stream (#1645). It is deliberately short (not the chat's lifetime)
-* so idle/one-off chat DOs don't accumulate stale buffers (#1706).
+* Stored segments per page when replaying a stream's chunk log. Bounds
+* replay memory to one page of segment bodies rather than the whole turn.
 */
-const COMPLETED_RETENTION_MS = 600 * 1e3;
+const REPLAY_PAGE_SEGMENTS = 10;
 /**
 * Retention for abandoned `streaming` rows, measured from LAST chunk activity.
 *
-* Generous relative to {@link COMPLETED_RETENTION_MS}: an interrupted turn must
-* have ample time to be resumed by a reconnecting client or healed by fiber
-* recovery before its buffer is reaped. Only a stream that has produced no
-* chunk for this long is treated as truly dead. Keyed off last activity (not
-* start time) so a long but still-active stream is never swept mid-flight.
+* An interrupted turn must have ample time to be resumed by a reconnecting
+* client or healed by task replay before its buffer is reaped. Only a stream
+* that has produced no chunk for this long is treated as truly dead. Last
+* activity is decided in two phases — a coarse cutoff on the stream row's
+* `updated_at` (stamped at open, not per append), then one indexed read of
+* the newest chunk's timestamp for rows past it — so a long but still-active
+* stream is never reclaimed mid-flight. Terminal rows carry no such window:
+* a stream that finished is redundant with its persisted message, and the
+* cutover deletes it in the same transaction; leftovers are reclaimed by
+* the next {@link ResumableStream.start}.
 */
 const ABANDONED_STREAM_RETENTION_MS = 3600 * 1e3;
 /** Shared encoder for UTF-8 byte length measurement */
 const textEncoder = new TextEncoder();
 /**
-* How far ahead (seconds) to schedule the resumable-stream buffer cleanup
-* alarm. Set to the short completion-grace window ({@link COMPLETED_RETENTION_MS},
-* 10m) so a finished buffer is reclaimed promptly. The re-arm-while-reclaimable
-* loop (see {@link cleanupStreamBuffers}) revisits any longer-lived rows — e.g.
-* an abandoned in-flight buffer on its 1h window — by waking again each interval
-* until they age out, then stops. Driving cleanup from an alarm (rather than
-* only piggybacking on the next stream completion) ensures idle/one-off chat
-* DOs still reclaim their buffers without waking forever (#1706). Shared by
-* `AIChatAgent` and `Think`.
+* 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 STREAM_CLEANUP_DELAY_SECONDS = 600;
+const CHAT_STREAM_MAX_CHUNK_BYTES = 19e5;
+/** Maximum serialized chunk body size before skipping storage (bytes). */
+const CHUNK_MAX_BYTES = 18e5;
 /**
-* A stored row body is either a single chunk body (a JSON object string —
-* legacy per-chunk rows and single-chunk segments) or a packed segment (a JSON
-* array of chunk body strings). Unpack to the individual chunk bodies in order.
-*
-* Stored chunk bodies are always serialized JSON *objects*, never arrays, so
-* `Array.isArray` reliably distinguishes a packed segment from a single body.
+* Construct the Streams capability instance a chat host must install to back
+* its `ResumableStream`: identical to `new Streams()` except for the raised
+* per-chunk ceiling that chat's packed segments require.
 */
-function unpackSegmentBody(rowBody) {
+function createChatStreams() {
+	return new Streams({ maxChunkBytes: CHAT_STREAM_MAX_CHUNK_BYTES });
+}
+function toPublicStatus(state) {
+	return state === "errored" ? "error" : state;
+}
+function parseChatMetadata(row) {
+	if (row.metadata === null) return null;
 	try {
-		const parsed = JSON.parse(rowBody);
-		if (Array.isArray(parsed)) return parsed;
+		const parsed = JSON.parse(row.metadata);
+		if (parsed && parsed.cfChat === 1) return parsed;
 	} catch {}
-	return [rowBody];
+	return null;
 }
-function isMissingMetadataColumnError(error) {
-	const message = error instanceof Error ? error.message : String(error);
-	return (message.includes("message_id") || message.includes("is_continuation")) && (message.toLowerCase().includes("no such column") || message.toLowerCase().includes("has no column named"));
+/**
+* A stored segment is either a single chunk body (a JSON string value) or a
+* packed segment (a JSON array of chunk body strings). Unpack to the
+* individual chunk bodies in order.
+*/
+function unpackSegment(rawChunkJson) {
+	const parsed = JSON.parse(rawChunkJson);
+	if (Array.isArray(parsed)) return parsed;
+	return [parsed];
 }
-var ResumableStream = class ResumableStream {
-	constructor(sql) {
-		this.sql = sql;
+/**
+* The deletion hook each adapter holds on its Streams capability. One
+* adapter per capability: a host whose startup retried constructs the
+* adapter again on the same capability, and the earlier hook must go, or a
+* deleted stream's segments would be retired once per construction.
+*/
+const deletionHooks = /* @__PURE__ */ new WeakMap();
+var ResumableStream = class {
+	constructor(streams, sql, options = {}) {
 		this._activeStreamId = null;
 		this._activeRequestId = null;
-		this._segmentIndex = 0;
 		this._isLive = false;
 		this._activeIsContinuation = false;
 		this._chunkBuffer = [];
 		this._chunkBufferBytes = 0;
 		this._isFlushingChunks = false;
-		this._lastCleanupTime = 0;
-		this.sql`create table if not exists cf_ai_chat_stream_chunks (
-      id text primary key,
-      stream_id text not null,
-      body text not null,
-      chunk_index integer not null,
-      created_at integer not null
-    )`;
-		this.sql`create table if not exists cf_ai_chat_stream_metadata (
-      id text primary key,
-      request_id text not null,
-      status text not null,
-      created_at integer not null,
-      completed_at integer,
-      message_id text,
-      is_continuation integer
-    )`;
-		this.sql`create index if not exists idx_stream_chunks_stream_id 
-      on cf_ai_chat_stream_chunks(stream_id, chunk_index)`;
+		this._pendingCutover = null;
+		this.ops = streams.__DO_NOT_USE_WILL_BREAK__sync();
+		this.ops.ensureTables();
+		this._sql = sql;
+		this._onProgress = options.onProgress;
+		this._ensureProgressTable();
+		deletionHooks.get(streams)?.();
+		deletionHooks.set(streams, this.ops.onDelete((row, cursor) => {
+			if (parseChatMetadata(row)) this._retire(cursor);
+		}));
+		this._migrateLegacyTables(sql);
 		this.restore();
 	}
 	/**
-	* Add metadata columns for rows created before they existed. Constructors
-	* intentionally do not run this: most wakes never start a stream, so paying a
-	* schema-introspection read every time is wasteful. New tables include these
-	* columns in CREATE TABLE; legacy tables migrate lazily only if a write/read
-	* discovers the columns are missing.
+	* Tell the host the durable part of the marker moved. Called after the
+	* write that moved it has left any transaction, never inside one: the
+	* host's mirror is an async KV put, which a synchronous transaction
+	* would reject.
+	*/
+	_notifyProgress() {
+		this._onProgress?.(this._retiredSegments());
+	}
+	/**
+	* One row: `retired` accumulates the segments of deleted streams and
+	* explicit credits; `legacy` holds the pre-derivation KV counter, folded
+	* in once. They are separate columns so a seed can never swallow
+	* segments retired before it landed, and a repeated seed is idempotent.
+	*/
+	_ensureProgressTable() {
+		this._sql`
+      CREATE TABLE IF NOT EXISTS cf_agents_chat_progress (
+        key TEXT PRIMARY KEY,
+        retired INTEGER NOT NULL,
+        legacy INTEGER NOT NULL DEFAULT 0
+      ) WITHOUT ROWID
+    `;
+	}
+	_retiredSegments() {
+		const row = this._sql`
+      SELECT retired, legacy FROM cf_agents_chat_progress WHERE key = 'chat'
+    `[0];
+		return row ? row.retired + row.legacy : 0;
+	}
+	/** Add `segments` to the retired total. One row write; a no-op for zero. */
+	_retire(segments) {
+		if (segments <= 0) return;
+		this._sql`
+      INSERT INTO cf_agents_chat_progress (key, retired, legacy)
+      VALUES ('chat', ${segments}, 0)
+      ON CONFLICT(key) DO UPDATE SET retired = retired + excluded.retired
+    `;
+	}
+	/**
+	* Segments a row still accounts for: a live stream's log tail, a settled
+	* stream's final cursor (stamped exact at settlement).
+	*/
+	_segmentsOf(row) {
+		return row.state === "streaming" ? this.ops.cursor(row.stream_id) : row.chunk_count;
+	}
+	/**
+	* Monotonic count of durably flushed chat segments on this Durable
+	* Object, plus explicit credits (see {@link creditProgress}): the recovery
+	* engine's forward-progress marker. Advances only when a segment lands in
+	* the log — never on a reconnect replay or a recovery re-persist, which
+	* read the log without appending — and is untouched by compaction, which
+	* rewrites the transcript, not the log. Reads the stream rows plus one
+	* log-tail row per live stream: called at incident evaluation, not on the
+	* hot path.
+	*
+	* A chat row leaving the table by any path — this adapter's cutover,
+	* reclaim and clear, or the capability's own `delete()` — passes through
+	* the deletion hook, so its segments are retired before they are gone
+	* and the marker never moves on a deletion.
+	*/
+	progressMarker() {
+		let live = 0;
+		for (const row of this._chatRows()) live += this._segmentsOf(row);
+		return this._retiredSegments() + live;
+	}
+	/**
+	* Credit one unit of forward progress that the log cannot see: a parent
+	* forwarding a sub-agent's output (N9) produces no chunks of its own, yet
+	* that output is the parent turn advancing. One row write; callers
+	* throttle.
+	*/
+	creditProgress() {
+		this._retire(1);
+		this._notifyProgress();
+	}
+	/**
+	* Carry the pre-derivation KV counter forward: the marker must not read
+	* lower after the upgrade than the high-water mark an in-flight incident
+	* already recorded, or a progressing turn would look stuck until the log
+	* caught up. The counter is never written again, so its value is a
+	* constant this folds into its own column by max — idempotent across
+	* isolates, and never touching segments retired before the seed landed.
+	* A no-op for zero, so a fresh object never writes.
+	*
+	* The counter already credited a stream that was in flight at the
+	* upgrade, and that stream's live segments count again here, so the
+	* first read after the upgrade can exceed the counter by those segments.
+	* That reads as progress once, and hands an in-flight incident one extra
+	* no-progress window; it cannot recur.
 	*/
-	_migrateMetadataColumns() {
-		const columns = this.sql`
-        select name from pragma_table_info('cf_ai_chat_stream_metadata')
-      ` ?? [];
-		if (!columns.some((column) => column.name === "message_id")) this.sql`alter table cf_ai_chat_stream_metadata add column message_id text`;
-		if (!columns.some((column) => column.name === "is_continuation")) this.sql`alter table cf_ai_chat_stream_metadata add column is_continuation integer`;
+	seedProgress(legacyTotal) {
+		if (legacyTotal <= 0) return;
+		this._sql`
+      INSERT INTO cf_agents_chat_progress (key, retired, legacy)
+      VALUES ('chat', 0, ${legacyTotal})
+      ON CONFLICT(key) DO UPDATE
+        SET legacy = MAX(legacy, excluded.legacy)
+    `;
+	}
+	/**
+	* Delete chat rows. The deletion hook folds each row's segments into the
+	* retired total in the same synchronous block, retire before delete, so
+	* a partial commit could only ever count a stream twice, never lose it.
+	*/
+	_deleteRetiring(rows) {
+		if (rows.length === 0) return;
+		this.ops.deleteMany(rows.map((row) => row.stream_id));
+		this._notifyProgress();
+	}
+	/**
+	* One-time migration of the pre-capability `cf_ai_chat_stream_*` tables
+	* into the Streams tables, preserving in-flight resumability across the
+	* upgrade (an active stream keeps its id, chunks, and last-activity), then
+	* dropping the legacy tables. Tolerates the pre-#1691/#1733 metadata
+	* schema (no `message_id` / `is_continuation` columns). The host `sql`
+	* handle touches only these chat-owned legacy tables.
+	*/
+	_migrateLegacyTables(sql) {
+		const legacyTables = sql`
+      SELECT name FROM sqlite_master WHERE type = 'table'
+      AND name IN ('cf_ai_chat_stream_metadata', 'cf_ai_chat_stream_chunks')
+    `.map((row) => row.name);
+		if (legacyTables.length === 0) return;
+		if (legacyTables.includes("cf_ai_chat_stream_metadata")) {
+			const columns = sql`
+        SELECT name FROM pragma_table_info('cf_ai_chat_stream_metadata')
+      `.map((row) => row.name);
+			const hasMessageId = columns.includes("message_id");
+			const hasContinuation = columns.includes("is_continuation");
+			const hasChunks = legacyTables.includes("cf_ai_chat_stream_chunks");
+			const rows = sql`SELECT * FROM cf_ai_chat_stream_metadata`;
+			for (const row of rows) {
+				const streamId = String(row.id);
+				if (this.ops.getStream(streamId)) continue;
+				const metadata = { cfChat: 1 };
+				if (hasMessageId && row.message_id != null) metadata.messageId = String(row.message_id);
+				if (hasContinuation && row.is_continuation === 1) metadata.isContinuation = 1;
+				const chunkRows = hasChunks ? sql`
+              SELECT body, created_at FROM cf_ai_chat_stream_chunks
+              WHERE stream_id = ${streamId} ORDER BY chunk_index ASC
+            ` : [];
+				const status = String(row.status);
+				const state = status === "error" ? "errored" : status === "completed" ? "completed" : "streaming";
+				const createdAt = Number(row.created_at);
+				const closedAt = row.completed_at != null ? Number(row.completed_at) : null;
+				const lastChunkAt = chunkRows.reduce((max, chunk) => Math.max(max, Number(chunk.created_at)), createdAt);
+				this.ops.importStream({
+					streamId,
+					state,
+					tag: String(row.request_id),
+					metadata,
+					chunkCount: chunkRows.length,
+					createdAt,
+					updatedAt: closedAt ?? lastChunkAt,
+					closedAt
+				});
+				for (const chunk of chunkRows) {
+					const body = String(chunk.body);
+					let value = body;
+					try {
+						const parsed = JSON.parse(body);
+						if (Array.isArray(parsed)) value = parsed;
+					} catch {}
+					this.ops.importChunk(streamId, value, Number(chunk.created_at));
+				}
+			}
+		}
+		sql`DROP TABLE IF EXISTS cf_ai_chat_stream_chunks`;
+		sql`DROP TABLE IF EXISTS cf_ai_chat_stream_metadata`;
 	}
 	get activeStreamId() {
 		return this._activeStreamId;
@@ -556,53 +753,34 @@ var ResumableStream = class ResumableStream {
 	}
 	/**
 	* Start tracking a new stream for resumable streaming.
-	* Creates metadata entry in SQLite and sets up tracking state.
+	* Creates the backing stream row and sets up tracking state.
 	* @param requestId - The unique ID of the chat request
 	* @returns The generated stream ID
 	*/
 	start(requestId, options = {}) {
 		this.flushBuffer();
+		this.reclaim();
 		const streamId = nanoid();
 		this._activeStreamId = streamId;
 		this._activeRequestId = requestId;
-		this._segmentIndex = 0;
 		this._isLive = true;
 		this._activeIsContinuation = options.continuation ?? false;
-		const messageId = options.messageId ?? null;
-		try {
-			this.sql`
-        insert into cf_ai_chat_stream_metadata (id, request_id, status, created_at, message_id, is_continuation)
-        values (${streamId}, ${requestId}, 'streaming', ${Date.now()}, ${messageId}, ${this._activeIsContinuation ? 1 : 0})
-      `;
-		} catch (error) {
-			if (!isMissingMetadataColumnError(error)) throw error;
-			this._migrateMetadataColumns();
-			this.sql`
-        insert into cf_ai_chat_stream_metadata (id, request_id, status, created_at, message_id, is_continuation)
-        values (${streamId}, ${requestId}, 'streaming', ${Date.now()}, ${messageId}, ${this._activeIsContinuation ? 1 : 0})
-      `;
-		}
+		const metadata = { cfChat: 1 };
+		if (options.messageId != null) metadata.messageId = options.messageId;
+		if (this._activeIsContinuation) metadata.isContinuation = 1;
+		this.ops.insertStream(streamId, requestId, metadata);
 		return streamId;
 	}
 	/**
 	* The assistant message id an orphaned stream was producing — the same id the
 	* live path persists under, so recovery re-associates reconstructed chunks
 	* with the correct message (#1691). Returns null when the row is missing or
-	* is a legacy row written before the `message_id` column existed.
+	* predates message-id tracking.
 	*/
 	getStreamMessageId(streamId) {
-		let rows;
-		try {
-			rows = this.sql`
-        select message_id from cf_ai_chat_stream_metadata
-        where id = ${streamId}
-      `;
-		} catch (error) {
-			if (!isMissingMetadataColumnError(error)) throw error;
-			return null;
-		}
-		if (!rows || rows.length === 0) return null;
-		return rows[0].message_id ?? null;
+		const row = this.ops.getStream(streamId);
+		if (!row) return null;
+		return parseChatMetadata(row)?.messageId ?? null;
 	}
 	/**
 	* Mark a stream as completed and flush any pending chunks.
@@ -610,17 +788,65 @@ var ResumableStream = class ResumableStream {
 	*/
 	complete(streamId) {
 		this.flushBuffer();
-		this.sql`
-      update cf_ai_chat_stream_metadata 
-      set status = 'completed', completed_at = ${Date.now()} 
-      where id = ${streamId}
-    `;
+		this.ops.settle(streamId, "completed", null);
+		if (this._pendingCutover === streamId) this._pendingCutover = null;
+		this._clearActive();
+	}
+	/**
+	* The producer finished, but leave the row `streaming` for the cutover:
+	* the host persists the message and settles the stream in one
+	* transaction with {@link cutover}. Until then a crash leaves the stream
+	* live — exactly the evidence recovery rebuilds the message from. The
+	* host MUST follow with {@link cutover} or {@link finalizePending}.
+	*/
+	finish(streamId) {
+		this.flushBuffer();
+		this._pendingCutover = streamId;
+		this._clearActive();
+	}
+	/** The stream {@link finish}ed and awaiting its cutover, if any. */
+	get pendingCutoverId() {
+		return this._pendingCutover;
+	}
+	/**
+	* The cutover: settle the stream, run `persist` (synchronous writes — the
+	* message), and delete the stream's rows in one SQLite transaction. A
+	* crash leaves either the live stream or the finished message, never
+	* neither; nothing is left to sweep. `discard: false` keeps the settled
+	* rows (an agent-tool child whose parent still tails them); they are
+	* reclaimed by the next {@link start}. The settlement and `persist`
+	* writes commit or roll back together.
+	*/
+	cutover(streamId, persist, options = {}) {
+		this.flushBuffer();
+		const discard = options.discard ?? true;
+		const commit = persist;
+		const settled = this.ops.settle(streamId, "completed", null, {
+			commit,
+			discard
+		});
+		if (settled && discard) this._notifyProgress();
+		if (!settled) commit();
+		if (this._pendingCutover === streamId) this._pendingCutover = null;
+		this._clearActive();
+	}
+	/**
+	* Settle a {@link finish}ed stream that had nothing to persist (no parts,
+	* a persist that threw). Idempotent; a no-op when nothing is pending.
+	* The pending marker clears only once settlement succeeds, so a caller
+	* may retry after a settlement failure — matching {@link cutover}.
+	*/
+	finalizePending() {
+		const streamId = this._pendingCutover;
+		if (streamId === null) return;
+		this.ops.settle(streamId, "completed", null);
+		this._pendingCutover = null;
+	}
+	_clearActive() {
 		this._activeStreamId = null;
 		this._activeRequestId = null;
-		this._segmentIndex = 0;
 		this._isLive = false;
 		this._activeIsContinuation = false;
-		this._maybeCleanupOldStreams();
 	}
 	/**
 	* Mark a stream as errored and clean up state.
@@ -628,19 +854,12 @@ var ResumableStream = class ResumableStream {
 	*/
 	markError(streamId) {
 		this.flushBuffer();
-		this.sql`
-      update cf_ai_chat_stream_metadata 
-      set status = 'error', completed_at = ${Date.now()} 
-      where id = ${streamId}
-    `;
-		this._activeStreamId = null;
-		this._activeRequestId = null;
-		this._segmentIndex = 0;
-		this._isLive = false;
-		this._activeIsContinuation = false;
+		this.ops.settle(streamId, "errored", null);
+		if (this._pendingCutover === streamId) this._pendingCutover = null;
+		this._clearActive();
 	}
 	/**
-	* Buffer a stream chunk for batch write to SQLite.
+	* Buffer a stream chunk for batch write to storage.
 	* Chunks exceeding the row size limit are skipped to prevent crashes.
 	* The chunk is still broadcast to live clients (caller handles that),
 	* but will be missing from replay on reconnection.
@@ -648,8 +867,8 @@ var ResumableStream = class ResumableStream {
 	* @param body - The serialized chunk body
 	*/
 	storeChunk(streamId, body) {
-		const bodyBytes = textEncoder.encode(body).byteLength;
-		if (bodyBytes > ResumableStream.CHUNK_MAX_BYTES) {
+		const bodyBytes = textEncoder.encode(JSON.stringify(body)).byteLength;
+		if (bodyBytes > CHUNK_MAX_BYTES) {
 			console.warn(`[ResumableStream] Skipping oversized chunk (${bodyBytes} bytes) to prevent SQLite row limit crash. Live clients still receive it.`);
 			return;
 		}
@@ -663,13 +882,14 @@ var ResumableStream = class ResumableStream {
 		if (this._chunkBuffer.length >= CHUNK_BUFFER_SIZE) this.flushBuffer();
 	}
 	/**
-	* Flush the buffered chunks to SQLite as a single packed row.
+	* Flush the buffered chunks to storage as a single packed segment.
 	* Uses a lock to prevent concurrent flush operations.
 	*
-	* The whole buffer becomes one row: a single-chunk segment is stored
-	* unwrapped (legacy object format) so a large chunk avoids array-escaping
-	* inflation, while a multi-chunk segment stores a JSON array of bodies. This
-	* collapses N chunk rows into one, cutting rows written / stored / scanned.
+	* The whole buffer becomes one stored chunk on the backing stream: a
+	* single-chunk segment is stored unwrapped so a large chunk avoids
+	* array-escaping inflation, while a multi-chunk segment stores a JSON
+	* array of bodies. This collapses N chunk writes into one fenced append,
+	* cutting rows written / stored / scanned.
 	*/
 	flushBuffer() {
 		if (this._isFlushingChunks || this._chunkBuffer.length === 0) return;
@@ -679,17 +899,33 @@ var ResumableStream = class ResumableStream {
 			this._chunkBuffer = [];
 			this._chunkBufferBytes = 0;
 			const streamId = chunks[0].streamId;
-			const segmentBody = chunks.length === 1 ? chunks[0].body : JSON.stringify(chunks.map((chunk) => chunk.body));
-			this.sql`
-        insert into cf_ai_chat_stream_chunks (id, stream_id, body, chunk_index, created_at)
-        values (${nanoid()}, ${streamId}, ${segmentBody}, ${this._segmentIndex}, ${Date.now()})
-      `;
-			this._segmentIndex++;
+			const segment = chunks.length === 1 ? chunks[0].body : chunks.map((chunk) => chunk.body);
+			try {
+				this.ops.append(streamId, segment);
+			} catch {}
 		} finally {
 			this._isFlushingChunks = false;
 		}
 	}
 	/**
+	* Stored chunk bodies for one stream, packed segments expanded, in order.
+	* A generator over paged reads, so replaying a large turn holds one page
+	* of segments in memory instead of the whole stored stream; iteration is
+	* synchronous end to end (WebSocket sends don't await), so the pages see
+	* a consistent log.
+	*/
+	*_storedBodies(streamId) {
+		let next = 0;
+		for (;;) {
+			const rows = this.ops.readChunks(streamId, next, REPLAY_PAGE_SEGMENTS);
+			for (const row of rows) {
+				next = row.seq + 1;
+				yield* unpackSegment(row.chunk);
+			}
+			if (rows.length < REPLAY_PAGE_SEGMENTS) return;
+		}
+	}
+	/**
 	* Send stored stream chunks to a connection for replay.
 	* Chunks are marked with replay: true so the client can batch-apply them.
 	*
@@ -699,11 +935,10 @@ var ResumableStream = class ResumableStream {
 	* - **Orphaned stream** (restored from SQLite after hibernation, no reader):
 	*   sends chunks + `done` and completes the stream. The caller should
 	*   reconstruct and persist the partial message from the stored chunks.
-	* - **Completed during replay** (defensive): sends chunks + `done`.
 	*
-	* All sends use {@link sendIfOpen}, so a WebSocket closing mid-replay
-	* does not throw. If the connection drops while iterating chunks the
-	* stream is left active so the next reconnect can retry.
+	* All sends tolerate a WebSocket closing mid-replay. If the connection
+	* drops while iterating chunks the stream is left active so the next
+	* reconnect can retry.
 	*
 	* @param connection - The WebSocket connection
 	* @param requestId - The original request ID
@@ -715,66 +950,41 @@ var ResumableStream = class ResumableStream {
 		if (!streamId) return null;
 		this.flushBuffer();
 		const continuation = this._activeIsContinuation;
-		const chunks = this.sql`
-      select * from cf_ai_chat_stream_chunks 
-      where stream_id = ${streamId} 
-      order by chunk_index asc
-    `;
-		for (const chunk of chunks || []) for (const body of unpackSegmentBody(chunk.body)) if (!sendIfOpen(connection, JSON.stringify({
-			body,
-			done: false,
-			id: requestId,
-			type: CHAT_MESSAGE_TYPES.USE_CHAT_RESPONSE,
-			replay: true,
-			...continuation && { continuation: true }
-		}))) return null;
-		if (this._activeStreamId !== streamId) {
-			sendIfOpen(connection, JSON.stringify({
-				body: "",
-				done: true,
-				id: requestId,
-				type: CHAT_MESSAGE_TYPES.USE_CHAT_RESPONSE,
-				replay: true,
-				...continuation && { continuation: true }
-			}));
-			return null;
-		}
+		if (!sendReplayBodies(connection, requestId, this._storedBodies(streamId), continuation)) return null;
 		if (!this._isLive) {
-			sendIfOpen(connection, JSON.stringify({
-				body: "",
+			sendReplayControl(connection, requestId, {
 				done: true,
-				id: requestId,
-				type: CHAT_MESSAGE_TYPES.USE_CHAT_RESPONSE,
-				replay: true,
-				...continuation && { continuation: true }
-			}));
+				continuation
+			});
 			this.complete(streamId);
 			return streamId;
 		}
-		sendIfOpen(connection, JSON.stringify({
-			body: "",
+		sendReplayControl(connection, requestId, {
 			done: false,
-			id: requestId,
-			type: CHAT_MESSAGE_TYPES.USE_CHAT_RESPONSE,
-			replay: true,
 			replayComplete: true,
-			...continuation && { continuation: true }
-		}));
+			continuation
+		});
 		return null;
 	}
+	/**
+	* Latest CHAT-owned row carrying a request tag. The stream table is
+	* shared with application producers and tags are non-unique, so the
+	* newest row by tag alone could be an unrelated stream masking chat's
+	* recovery evidence — ownership is the `cfChat` metadata marker.
+	*/
+	_latestChatRowByTag(requestId, state) {
+		return this.ops.rowsByTag(requestId, state).find((row) => parseChatMetadata(row) !== null);
+	}
 	replayCompletedChunksByRequestId(connection, requestId) {
-		const stream = this._latestStreamForRequest(requestId, "completed");
-		if (!stream) return false;
-		const continuation = stream.is_continuation === 1;
-		if (!this._replayStoredChunks(connection, stream.id, requestId, continuation)) return false;
-		return sendIfOpen(connection, JSON.stringify({
-			body: "",
+		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;
+		return sendReplayControl(connection, requestId, {
 			done: true,
-			id: requestId,
-			type: CHAT_MESSAGE_TYPES.USE_CHAT_RESPONSE,
-			replay: true,
-			...continuation && { continuation: true }
-		}));
+			continuation
+		});
 	}
 	/**
 	* Replay the stored chunks of an errored stream for a request, WITHOUT a
@@ -782,9 +992,7 @@ var ResumableStream = class ResumableStream {
 	* frame carrying the durable terminal record's error text, mirroring what a
 	* live client observed (content chunks, then the error). Without this, a
 	* client that missed broadcast frames while disconnected has no other
-	* channel to the pre-error partial content: the server does not push
-	* messages on connect, and {@link replayCompletedChunksByRequestId} only
-	* serves `completed` streams (#1575).
+	* channel to the pre-error partial content (#1575).
 	*
 	* Returns true when the caller should proceed to send its terminal frame:
 	* either no errored stream existed (nothing to replay) or its chunks were
@@ -793,40 +1001,46 @@ var ResumableStream = class ResumableStream {
 	* and the next reconnect retries the whole sequence.
 	*/
 	replayErroredChunksByRequestId(connection, requestId) {
-		const stream = this._latestStreamForRequest(requestId, "error");
-		if (!stream) return true;
-		return this._replayStoredChunks(connection, stream.id, requestId, stream.is_continuation === 1);
-	}
-	/** Latest stream row for a request with the given terminal status. */
-	_latestStreamForRequest(requestId, status) {
 		this.flushBuffer();
-		return this.sql`
-      select * from cf_ai_chat_stream_metadata
-      where request_id = ${requestId}
-      and status = ${status}
-      order by created_at desc
-      limit 1
-    `[0];
+		const row = this._latestChatRowByTag(requestId, "errored");
+		if (!row) return true;
+		return sendReplayBodies(connection, requestId, this._storedBodies(row.stream_id), parseChatMetadata(row)?.isContinuation === 1);
 	}
 	/**
-	* Send a finished stream's stored chunks to a connection as replay frames.
-	* Returns false if the connection closed mid-replay.
+	* Latest chat stream row for a request regardless of status — the recovery
+	* engines' stream-evidence lookup.
 	*/
-	_replayStoredChunks(connection, streamId, requestId, continuation = false) {
-		const chunks = this.sql`
-      select * from cf_ai_chat_stream_chunks
-      where stream_id = ${streamId}
-      order by chunk_index asc
-    `;
-		for (const chunk of chunks || []) for (const body of unpackSegmentBody(chunk.body)) if (!sendIfOpen(connection, JSON.stringify({
-			body,
-			done: false,
-			id: requestId,
-			type: CHAT_MESSAGE_TYPES.USE_CHAT_RESPONSE,
-			replay: true,
-			...continuation && { continuation: true }
-		}))) return false;
-		return true;
+	latestStreamInfoForRequest(requestId) {
+		const row = this._latestChatRowByTag(requestId);
+		if (!row) return null;
+		return {
+			id: row.stream_id,
+			status: toPublicStatus(row.state),
+			createdAt: row.created_at
+		};
+	}
+	/**
+	* Latest in-flight chat stream for a request — recoverable-turn evidence.
+	*/
+	latestActiveStreamInfoForRequest(requestId) {
+		const row = this._latestChatRowByTag(requestId, "streaming");
+		if (!row) return null;
+		return {
+			id: row.stream_id,
+			createdAt: row.created_at
+		};
+	}
+	/** Every chat-owned stream row, newest first. */
+	_chatRows() {
+		const rows = [];
+		for (const row of this.ops.listRows()) {
+			const chat = parseChatMetadata(row);
+			if (chat) rows.push({
+				...row,
+				chat
+			});
+		}
+		return rows;
 	}
 	/**
 	* Restore active stream state if the agent was restarted during streaming.
@@ -834,192 +1048,268 @@ var ResumableStream = class ResumableStream {
 	* lazily in _maybeCleanupOldStreams after recovery has had its chance.
 	*/
 	restore() {
-		const activeStreams = this.sql`
-      select * from cf_ai_chat_stream_metadata 
-      where status = 'streaming' 
-      order by created_at desc 
-      limit 1
-    `;
-		if (activeStreams && activeStreams.length > 0) {
-			const stream = activeStreams[0];
-			this._activeStreamId = stream.id;
-			this._activeRequestId = stream.request_id;
-			this._activeIsContinuation = stream.is_continuation === 1;
-			const lastChunk = this.sql`
-        select max(chunk_index) as max_index 
-        from cf_ai_chat_stream_chunks 
-        where stream_id = ${this._activeStreamId}
-      `;
-			this._segmentIndex = lastChunk && lastChunk[0]?.max_index != null ? lastChunk[0].max_index + 1 : 0;
+		const row = this._chatRows().find((r) => r.state === "streaming");
+		if (row) {
+			this._activeStreamId = row.stream_id;
+			this._activeRequestId = row.tag;
+			this._activeIsContinuation = row.chat.isContinuation === 1;
 		}
 	}
 	/**
-	* Clear all stream data (called on chat history clear).
+	* Clear all chat stream data (called on chat history clear). Streams other
+	* producers opened on the same Durable Object are untouched.
 	*/
 	clearAll() {
 		this._chunkBuffer = [];
 		this._chunkBufferBytes = 0;
-		this.sql`delete from cf_ai_chat_stream_chunks`;
-		this.sql`delete from cf_ai_chat_stream_metadata`;
+		this._deleteRetiring(this._chatRows());
 		this._activeStreamId = null;
 		this._activeRequestId = null;
-		this._segmentIndex = 0;
 		this._activeIsContinuation = false;
 	}
 	/**
-	* Drop all stream tables (called on destroy).
+	* Remove all chat stream data (called on destroy). The backing tables
+	* belong to the Streams capability and are shared with other producers,
+	* so this deletes chat's rows rather than dropping tables. Buffered
+	* chunks are dropped (clearAll resets the buffer), not flushed: they
+	* belong to a chat-owned stream this very call deletes, so writing them
+	* first would only pay row writes for rows that die in the same
+	* synchronous block.
 	*/
 	destroy() {
-		this.flushBuffer();
-		this.sql`drop table if exists cf_ai_chat_stream_chunks`;
-		this.sql`drop table if exists cf_ai_chat_stream_metadata`;
-		this._activeStreamId = null;
-		this._activeRequestId = null;
-		this._activeIsContinuation = false;
+		this.clearAll();
 	}
 	/**
-	* Force a sweep of aged stream buffers now, bypassing the lazy interval
-	* gate used by {@link _maybeCleanupOldStreams}. Intended to be driven by an
-	* alarm so idle/hibernated chat DOs still reclaim buffers even when no
-	* further stream ever completes to trigger the lazy path.
-	*/
-	cleanup(now = Date.now()) {
-		this._lastCleanupTime = now;
-		this._sweepOldStreams(now);
-	}
-	/**
-	* True if any stream rows remain at all. Used by alarm-driven cleanup to
-	* decide whether to re-arm: once no rows remain there is nothing left to
-	* sweep, so the DO can stop waking itself.
-	*/
-	hasReclaimableStreams() {
-		return (this.sql`
-      select count(*) as n from cf_ai_chat_stream_metadata
-    `?.[0]?.n ?? 0) > 0;
-	}
-	_maybeCleanupOldStreams() {
-		const now = Date.now();
-		if (now - this._lastCleanupTime < CLEANUP_INTERVAL_MS) return;
-		this._lastCleanupTime = now;
-		this._sweepOldStreams(now);
-	}
-	/** Delete completed/errored buffers past the completion grace window, plus
-	*  abandoned "streaming" rows past the stale-in-flight window. The two use
-	*  different retentions: a completed buffer is redundant with the persisted
-	*  message and needs only a brief replay grace, whereas an in-flight buffer
-	*  must outlive resume/recovery before it is presumed dead. */
-	_sweepOldStreams(now) {
-		const completedCutoff = now - COMPLETED_RETENTION_MS;
-		this.sql`
-      delete from cf_ai_chat_stream_chunks 
-      where stream_id in (
-        select id from cf_ai_chat_stream_metadata 
-        where status in ('completed', 'error') and completed_at < ${completedCutoff}
-      )
-    `;
-		this.sql`
-      delete from cf_ai_chat_stream_metadata 
-      where status in ('completed', 'error') and completed_at < ${completedCutoff}
-    `;
+	* Delete every chat stream row this Durable Object no longer needs:
+	* finished streams (their messages are persisted; the cutover normally
+	* deletes them in the same transaction, so these are crash leftovers) and
+	* in-flight rows abandoned past {@link ABANDONED_STREAM_RETENTION_MS} by
+	* last chunk activity. Runs on every {@link start}, so nothing needs an
+	* alarm to be reclaimed; a Durable Object that never starts another turn
+	* keeps at most one turn's rows. Streams other producers opened on the
+	* same object are untouched.
+	* @returns How many rows were reclaimed.
+	*/
+	reclaim(now = Date.now()) {
 		const abandonedCutoff = now - ABANDONED_STREAM_RETENTION_MS;
-		this.sql`
-      delete from cf_ai_chat_stream_chunks
-      where stream_id in (
-        select m.id from cf_ai_chat_stream_metadata m
-        where m.status = 'streaming'
-          and coalesce(
-            (select max(c.created_at) from cf_ai_chat_stream_chunks c
-             where c.stream_id = m.id),
-            m.created_at
-          ) < ${abandonedCutoff}
-      )
-    `;
-		this.sql`
-      delete from cf_ai_chat_stream_metadata
-      where id in (
-        select m.id from cf_ai_chat_stream_metadata m
-        where m.status = 'streaming'
-          and coalesce(
-            (select max(c.created_at) from cf_ai_chat_stream_chunks c
-             where c.stream_id = m.id),
-            m.created_at
-          ) < ${abandonedCutoff}
-      )
-    `;
+		const reclaimable = this._chatRows().filter((row) => row.state === "streaming" ? row.stream_id !== this._activeStreamId && row.updated_at < abandonedCutoff && (this.ops.lastChunkAt(row.stream_id) ?? row.updated_at) < abandonedCutoff : true);
+		this._deleteRetiring(reclaimable);
+		return reclaimable.length;
 	}
 	/**
 	* Return the stored chunks for a stream as individual chunk bodies in order,
-	* unpacking packed segment rows. The returned `chunk_index` is a running
-	* per-chunk sequence (0, 1, 2, …) — stable across calls because rows are
-	* append-only — so callers can use it as a monotonic chunk sequence.
+	* unpacking packed segments. The returned `chunk_index` is a running
+	* per-chunk sequence (0, 1, 2, …) — stable across calls because segments
+	* are append-only — so callers can use it as a monotonic chunk sequence.
 	*/
 	getStreamChunks(streamId) {
-		const rows = this.sql`
-        select body from cf_ai_chat_stream_chunks 
-        where stream_id = ${streamId} 
-        order by chunk_index asc
-      ` || [];
-		const out = [];
-		let index = 0;
-		for (const row of rows) for (const body of unpackSegmentBody(row.body)) {
-			out.push({
-				body,
-				chunk_index: index
-			});
-			index++;
-		}
-		return out;
+		return [...this._storedBodies(streamId)].map((body, chunk_index) => ({
+			body,
+			chunk_index
+		}));
 	}
 	/** @internal For testing only */
 	getStreamMetadata(streamId) {
-		const result = this.sql`
-      select status, request_id from cf_ai_chat_stream_metadata 
-      where id = ${streamId}
-    `;
-		return result && result.length > 0 ? result[0] : null;
+		const row = this.ops.getStream(streamId);
+		if (!row || !parseChatMetadata(row)) return null;
+		return {
+			status: toPublicStatus(row.state),
+			request_id: row.tag ?? ""
+		};
 	}
 	/** @internal For testing only */
 	getAllStreamMetadata() {
-		return this.sql`select id, status, request_id, created_at from cf_ai_chat_stream_metadata` || [];
+		return this._chatRows().map((row) => ({
+			id: row.stream_id,
+			status: toPublicStatus(row.state),
+			request_id: row.tag ?? "",
+			created_at: row.created_at,
+			message_id: row.chat.messageId ?? null
+		}));
 	}
 	/** @internal For testing only */
 	insertStaleStream(streamId, requestId, ageMs) {
 		const createdAt = Date.now() - ageMs;
-		this.sql`
-      insert into cf_ai_chat_stream_metadata (id, request_id, status, created_at)
-      values (${streamId}, ${requestId}, 'streaming', ${createdAt})
-    `;
+		this.ops.importStream({
+			streamId,
+			state: "streaming",
+			tag: requestId,
+			metadata: { cfChat: 1 },
+			chunkCount: 0,
+			createdAt,
+			updatedAt: createdAt,
+			closedAt: null
+		});
 	}
 	/**
-	* Append a chunk to a stream dated `ageMs` in the past. Used to exercise the
-	* last-activity sweep threshold: a long-running streaming row with a *recent*
-	* chunk must survive even when its start time is older than the cutoff.
+	* Append a chunk to a stream dated `ageMs` in the past. Used to exercise
+	* reclaim's phase-2 verification: a long-running streaming row with a
+	* *recent* chunk must survive even when its row `updated_at` (stamped at
+	* open, not per append) is older than the coarse cutoff.
 	* @internal For testing only
 	*/
 	insertChunkAt(streamId, body, ageMs) {
-		const createdAt = Date.now() - ageMs;
-		this.sql`
-      insert into cf_ai_chat_stream_chunks (id, stream_id, body, chunk_index, created_at)
-      values (${nanoid()}, ${streamId}, ${body}, 0, ${createdAt})
-    `;
+		this.ops.importChunk(streamId, body, Date.now() - ageMs);
 	}
 };
-ResumableStream.CHUNK_MAX_BYTES = 18e5;
+//#endregion
+//#region src/chat/turn-task.ts
+/** Durable snapshot key for one chat turn's stash envelope. */
+function turnSnapshotKey(runId) {
+	return `__cf_chat_turn_snapshot:${runId}`;
+}
+/**
+* Build the chat-turn Task handler for one host. Registered under the
+* host's `CHAT_FIBER_NAME` via `Tasks#register`.
+*/
+function createChatTurnTaskDefinition(hooks) {
+	return async (input, step) => {
+		const { requestId, nonce } = input;
+		await step.do("model-turn", {
+			retries: { limit: 1 },
+			timeout: "1 day"
+		}, async ({ signal }) => {
+			const runId = `chat_${nonce}`;
+			const snapshotKey = turnSnapshotKey(runId);
+			const entry = hooks.getLiveClosure(nonce);
+			if (!entry) {
+				const persisted = await hooks.storage.get(snapshotKey);
+				const createdAt = await hooks.getRunCreatedAt(runId) ?? Date.now();
+				await hooks.handleRecovery({
+					id: runId,
+					name: `${hooks.definitionName}:${requestId}`,
+					snapshot: persisted ?? null,
+					createdAt,
+					recoveryReason: "interrupted"
+				});
+				await hooks.storage.delete(snapshotKey);
+				return;
+			}
+			await hooks.storage.put(snapshotKey, entry.initial);
+			try {
+				const value = await hooks.keepAliveWhile(() => hooks.withStash({
+					id: nonce,
+					signal,
+					stash: (data) => void hooks.storage.put(snapshotKey, entry.wrap(data)).catch(() => {})
+				}, () => entry.run()));
+				entry.settle.resolve(value);
+			} catch (error) {
+				entry.settle.reject(error);
+				throw error;
+			} finally {
+				hooks.storage.delete(snapshotKey).catch(() => {});
+			}
+		});
+	};
+}
+//#endregion
+//#region src/chat/recovery-task.ts
 /**
-* The buffer-cleanup alarm body: sweep aged stream buffers, then re-arm only
-* while rows remain so a fully-swept DO stops waking itself. `rearm` schedules
-* the next sweep — it MUST schedule a non-idempotent alarm, because this runs
-* INSIDE the currently-executing one-shot schedule row, which `alarm()` deletes
-* only after it returns; an idempotent reschedule would dedup onto that row and
-* be deleted with it, so the re-arm would silently never fire and buffers that
-* survived this sweep (e.g. a younger turn) would go uncollected. A fresh
-* delayed row survives the deletion. Shared by `AIChatAgent` and `Think`.
+* Chat recovery transport on the Tasks capability.
+*
+* Each continuation attempt is one short Task run. The Task waits for any
+* requested backoff, dispatches the bounded host callback through model
+* handoff, then disappears after terminal settlement. The durable recovery
+* incident remains the source of truth for attempt and work budgets.
 *
-* `@internal`
+* @internal Sibling-package support for AI Chat and Think.
 */
-async function cleanupStreamBuffers(stream, rearm) {
-	stream.cleanup();
-	if (stream.hasReclaimableStreams()) await rearm();
+/** Reserved Task definition shared by the chat hosts. */
+const CHAT_RECOVERY_TASK_NAME = "__cf_internal_chat_recovery";
+/**
+* Run a queue-driven recovery callback up to its model handoff, then return.
+*
+* The recovered turn can legitimately run for a long time, and awaiting it
+* would hold the Lifecycle job loop, starving every other job on the object.
+* A failure before the handoff rejects here, so the executing Task run (or
+* compatibility schedule row) keeps ownership and the driver's
+* platform-failure deferral applies (#1730). After the handoff the turn is
+* detached alarm work: a platform failure enqueues one replacement attempt,
+* retried a few times since the completed Task no longer owns this incident
+* and a failure here would otherwise abandon it silently, and any other
+* failure belongs to the turn's own incident bookkeeping.
+*/
+async function dispatchChatRecoveryToHandoff(handoff) {
+	let handedOff = false;
+	let signalHandoff = () => {};
+	const reachedTurn = new Promise((resolve) => {
+		signalHandoff = () => {
+			handedOff = true;
+			resolve();
+		};
+	});
+	const turn = handoff.detached(signalHandoff);
+	const tracked = reachedTurn.then(() => handoff.track(turn));
+	turn.catch((error) => {
+		if (!handedOff) return;
+		if (isPlatformFailure(error)) {
+			const dedupeKey = crypto.randomUUID();
+			tryN(3, () => handoff.redefer(dedupeKey), {
+				baseDelayMs: 50,
+				maxDelayMs: 500
+			}).catch((redeferError) => handoff.onDetachedError(redeferError));
+			return;
+		}
+		handoff.onDetachedError(error);
+	});
+	await Promise.race([turn, tracked]);
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseChatRecoveryTaskInput(input) {
+	if (!isRecord(input)) throw new Error("Chat recovery Task input must be an object");
+	const callback = input.callback;
+	if (callback !== "_chatRecoveryContinue" && callback !== "_chatRecoveryRetry") throw new Error("Chat recovery Task input has an unknown callback");
+	if (!isRecord(input.data)) throw new Error("Chat recovery Task input data must be an object");
+	const delaySeconds = input.delaySeconds;
+	if (typeof delaySeconds !== "number" || !Number.isFinite(delaySeconds) || delaySeconds < 0) throw new Error("Chat recovery Task delaySeconds must be a finite non-negative number");
+	return {
+		callback,
+		data: input.data,
+		delaySeconds
+	};
+}
+/**
+* Build run options for one recovery attempt.
+*
+* Initial detection joins an existing in-flight attempt for the same incident
+* and callback. Chained retries are otherwise unkeyed because each one is
+* enqueued while the preceding run still exists — a genuinely new attempt,
+* not a retry of this same enqueue. `dedupeKey`, when supplied, keys this
+* specific enqueue call by `runId` instead: every retry of one failed
+* `redefer` (see {@link dispatchChatRecoveryToHandoff}) reuses the same key,
+* so a rejected-but-already-inserted attempt is joined rather than
+* duplicated. Non-retention releases the initial key when the run settles.
+*/
+function chatRecoveryTaskRunOptions(input, reason, dedupeKey) {
+	const incidentId = typeof input.data.incidentId === "string" ? input.data.incidentId : void 0;
+	const recoveredRequestId = typeof input.data.recoveredRequestId === "string" ? input.data.recoveredRequestId : void 0;
+	return {
+		retain: false,
+		...dedupeKey !== void 0 ? { runId: dedupeKey } : {},
+		...reason === "initial" && incidentId ? { idempotencyKey: `chat-recovery:${input.callback}:${incidentId}` } : {},
+		metadata: {
+			callback: input.callback,
+			...incidentId ? { incidentId } : {},
+			...recoveredRequestId ? { recoveredRequestId } : {}
+		}
+	};
+}
+/** Build the shared recovery Task handler for one chat host. */
+function createChatRecoveryTaskDefinition(hooks) {
+	return async (unknownInput, step) => {
+		const input = parseChatRecoveryTaskInput(unknownInput);
+		if (input.delaySeconds > 0) await step.sleep("backoff", input.delaySeconds * 1e3);
+		await step.do("continuation", {
+			retries: {
+				limit: 3,
+				delay: 100,
+				backoff: "exponential"
+			},
+			timeout: "15 minutes"
+		}, () => hooks[input.callback](input.data));
+	};
 }
 //#endregion
 //#region src/chat/sql-batch.ts
@@ -2293,11 +2583,12 @@ function partialHasSettledToolResults(parts) {
 	});
 }
 /**
-* The single, host-agnostic rule for crediting recovery forward progress from a
-* stored stream chunk — the convergence of what `AIChatAgent` and `Think`
-* previously each decided on their own (ai-chat keyed on chunk type only; Think
-* keyed on its flush cadence). Both hosts now call this at chunk-store time so
-* the bump TIMING is identical:
+* The host-agnostic rule for crediting recovery forward progress from a stored
+* stream chunk, from when the marker was a counter bumped per chunk. Neither
+* host bumps a counter any more: the marker is derived from the stream log
+* (`ResumableStream.progressMarker`), so a chunk counts once its segment is
+* durably flushed. The rule stays exported for consumers that still keep a
+* counter of their own:
 *
 *  - a **milestone** ({@link ChatRecoveryCodec.isProgressChunk}) always credits;
 *  - **streaming content** ({@link ChatRecoveryCodec.isStreamingContentChunk})
@@ -2464,10 +2755,14 @@ var ResumeHandshake = class {
 //#region src/chat/recovery-incident.ts
 const CHAT_RECOVERY_INCIDENT_KEY_PREFIX = "cf:chat-recovery:incident:";
 /**
-* Durable, monotonic forward-progress counter for recovery budget resets.
-* Bumped at production time when new content is streamed, so it reflects
-* genuinely new content and is immune to reconnects/re-persists; never
-* recomputed from the (compactable) transcript.
+* The pre-derivation forward-progress counter: a KV integer bumped per
+* credited chunk. The marker is now derived from the stream log
+* (`ResumableStream.progressMarker`), and this key is only read — once per
+* isolate, to seed the derived marker so it never reads lower than the
+* high-water mark an incident recorded before the upgrade. Current code
+* writes it only as a mirror of the derived marker's durable part — one put
+* per stream retired, none per chunk — so a build rolled back to the
+* counter never reads a marker lower than an incident recorded here.
 */
 const CHAT_RECOVERY_PROGRESS_KEY = "cf:chat-recovery:progress";
 /**
@@ -2511,8 +2806,17 @@ const DEFAULT_CHAT_RECOVERY_MAX_ATTEMPTS = 10;
 * the incident is deleted). A very long agentic turn under heavy interruption
 * that legitimately needs more should raise `maxRecoveryWork` (or set it to
 * `Infinity` to restore the pre-#1825 unbounded behavior).
+*
+* The unit is one durable stream segment — about ten packed streaming chunks,
+* or one settled tool result, which is flushed on its own — plus one per
+* explicit credit for forwarded sub-agent output. The marker is derived from
+* the stream log (`ResumableStream.progressMarker`), so that is what it can
+* count. The earlier KV counter credited per milestone chunk and per five
+* seconds of deltas, a coarser measure of streamed text; 10 000 segments
+* (on the order of 100 000 chunks of re-run output) keeps the budget as
+* generous as 1 000 credits was for delta-heavy turns, and still finite.
 */
-const DEFAULT_CHAT_RECOVERY_MAX_WORK = 1e3;
+const DEFAULT_CHAT_RECOVERY_MAX_WORK = 1e4;
 /**
 * Tight, OOM-specific retry budget (#1825). A Durable Object memory-limit reset
 * (`isDurableObjectMemoryLimitReset`) is usually deterministic — the turn's
@@ -2655,9 +2959,13 @@ async function readChatRecoveryProgress(storage) {
 	return await storage.get("cf:chat-recovery:progress") ?? 0;
 }
 /**
-* Advance the durable recovery-progress counter by one. Called when genuinely new
-* content is durably flushed (real, reconnect-immune forward progress); shared by
-* `AIChatAgent` and `Think`.
+* Advance the KV progress counter by one.
+*
+* @deprecated Hosts no longer bump a counter per credited chunk: the marker
+* is derived from the stream log (`ResumableStream.progressMarker`) and
+* explicit credits go through `ResumableStream.creditProgress`. Kept for
+* code that still maintains the KV counter; a value written here is folded
+* into the derived marker on the next seed.
 */
 async function bumpChatRecoveryProgress(storage) {
 	const current = await storage.get("cf:chat-recovery:progress") ?? 0;
@@ -2880,18 +3188,6 @@ async function evaluateChatRecoveryIncident(input) {
 //#endregion
 //#region src/chat/recovery-engine.ts
 /**
-* Resolve the `schedule()` idempotency option for a recovery schedule. Single
-* source of truth for both packages; see {@link ChatRecoveryScheduleReason} for
-* the rationale behind each case.
-*
-* This is a cutover invariant: flipping either case silently breaks deploy-storm
-* dedup (initial) or stalls stable-timeout retries (reschedule), and neither is
-* caught by a type error — only by the recovery suites.
-*/
-function chatRecoverySchedulePolicy(reason) {
-	return { idempotent: reason === "initial" };
-}
-/**
 * Drives the shared recovery orchestration over a {@link ChatRecoveryAdapter}.
 * The incident *budget math* lives in the pure `evaluateChatRecoveryIncident`;
 * this class owns the surrounding sequence and its ordering invariants.
@@ -3069,7 +3365,8 @@ var ChatRecoveryEngine = class {
 	* 1. transition the incident to `scheduled` (persist + drive the #1620
 	*    "recovering…" status) via {@link updateIncident};
 	* 2. emit `chat:recovery:scheduled`; and
-	* 3. enqueue the callback through the adapter's idempotent schedule.
+	* 3. enqueue the callback through the adapter's transport — a Task run on
+	*    a root agent, an idempotent schedule on the routed fallback.
 	*
 	* `recoveryKind` is passed explicitly (not read off the incident) because a
 	* caller can legitimately report a different kind than the incident was opened
@@ -3093,12 +3390,14 @@ var ChatRecoveryEngine = class {
 	}
 	/**
 	* Reschedule a recovery continuation/retry that timed out waiting for stable
-	* state, INSIDE the currently-executing one-shot schedule row. Reads the
+	* state, from INSIDE the currently-executing recovery attempt (a
+	* `__cf_internal_chat_recovery` Task run for a root agent, the routed
+	* one-shot schedule row for a dynamic agent). Reads the
 	* incident; if it is still under the attempt cap, bumps `attempt`, marks it
-	* `scheduled` with `reason:"stable_timeout_retry"`, and issues a delayed,
-	* NON-idempotent schedule (`alarm()` deletes the executing row only after this
-	* returns, so an idempotent reschedule would dedup onto that doomed row and
-	* never fire — see {@link chatRecoverySchedulePolicy}).
+	* `scheduled` with `reason:"stable_timeout_retry"`, and issues a separate
+	* delayed attempt. It must not join the currently executing attempt: Tasks
+	* enqueue an unkeyed chained run, while the routed fallback creates a
+	* non-idempotent schedule.
 	*
 	* Returns `true` when a retry was scheduled, `false` when there is no incident
 	* (no id / record gone) or the attempt budget is already spent — in which case
@@ -3133,9 +3432,9 @@ var ChatRecoveryEngine = class {
 	* Bumps the incident's durable `oomAttempts` counter, then:
 	*  - if it is still within `maxOomRetries`, issues a delayed, NON-idempotent
 	*    reschedule of the SAME callback (same machinery as
-	*    {@link rescheduleAfterStableTimeout}: the executing one-shot row is
-	*    deleted only after the callback returns, so an idempotent reschedule
-	*    would dedup onto that doomed row) and returns `"rescheduled"`. The small
+	*    {@link rescheduleAfterStableTimeout}: the executing attempt settles
+	*    only after the callback returns, so an idempotent reschedule would
+	*    dedup onto that doomed attempt) and returns `"rescheduled"`. The small
 	*    delay lets a transient memory spike clear before the re-run;
 	*  - otherwise leaves the incremented count persisted (so a begin-path
 	*    re-evaluation agrees) and returns `"exhausted"` — the caller then
@@ -3192,8 +3491,9 @@ var ChatRecoveryEngine = class {
 	* 6. terminalize via `exhaustChatRecovery` — BEFORE sealing. The terminal
 	*    writes can reject with a platform transient in the deploy/storage window
 	*    a give-up runs in (#1730); letting that throw propagate is deliberate, so
-	*    `Agent._executeScheduleCallback` defers the one-shot row and the WHOLE
-	*    give-up re-runs on a healthy isolate. Sealing first would arm the
+	*    the current recovery attempt (a Task run on a root agent, a one-shot
+	*    schedule row on the routed fallback) defers and the WHOLE give-up
+	*    re-runs on a healthy isolate. Sealing first would arm the
 	*    re-entry guard and turn that re-run into a no-op, dropping the durable
 	*    terminal record. The re-run is idempotent (terminal writes overwrite the
 	*    same key); a second banner is the documented at-least-once edge; and
@@ -3448,6 +3748,80 @@ async function* iterateWithStallWatchdog(source, timeoutMs, onStall) {
 	}
 }
 //#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_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_CLEANUP_DELAY_SECONDS, STREAM_RESUME_NONE_REASONS, StreamAccumulator, StreamProgressCreditThrottle, SubmitConcurrencyController, TIMED_OUT, TextSegmentJoiner, TurnQueue, aiSdkRecoveryCodec, applyAgentToolEvent, applyChunkToParts, applyToolUpdate, awaitWithDeadline, transition as broadcastTransition, buildChatRecoveringFrame, buildInClauseStrings, bumpChatRecoveryProgress, byteLength, chatRecoverySchedulePolicy, classifyAgentToolChildRecovery, cleanupStreamBuffers, clearChatTerminal, clientResolvableToolNames, createAgentToolEventState, createChatFiberSnapshot, createToolsFromClientSchemas, crossMessageToolResultUpdate, drainInteractionApplies, enforceRowSizeLimit, hasIncompleteToolBatch, interceptAgentToolBroadcast, 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, unwrapChatFiberSnapshot, wrapChatFiberSnapshot };
+//#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.
+*
+* Use in assembleContext() before sending to the LLM:
+* ```typescript
+* async assembleContext() {
+*   const history = this.sessions.getHistory(this._sessionId);
+*   const truncated = truncateOlderMessages(history);
+*   return convertToModelMessages(truncated);
+* }
+* ```
+*/
+function truncateOlderMessages(messages, options) {
+	const keepRecent = options?.keepRecent ?? 4;
+	const maxToolOutput = options?.maxToolOutputChars ?? 500;
+	const maxText = options?.maxTextChars ?? 1e4;
+	if (messages.length <= keepRecent) return messages;
+	const cutoff = messages.length - keepRecent;
+	const result = [];
+	for (let i = 0; i < messages.length; i++) {
+		if (i >= cutoff) {
+			result.push(messages[i]);
+			continue;
+		}
+		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) {
+				const output = part.output;
+				if (output !== void 0) {
+					const truncated = truncateToolOutput(output, maxToolOutput);
+					if (truncated.truncated) {
+						changed = true;
+						return {
+							...part,
+							output: truncated.output
+						};
+					}
+				}
+			}
+			if (part.type === "text" && "text" in part) {
+				const text = part.text;
+				if (text.length > maxText) {
+					changed = true;
+					return {
+						...part,
+						text: `${text.slice(0, maxText)}... [truncated ${text.length} chars]`
+					};
+				}
+			}
+			return part;
+		});
+		result.push(changed ? {
+			...msg,
+			parts: truncatedParts
+		} : msg);
+	}
+	return result;
+}
+//#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 };
 
 //# sourceMappingURL=index.js.map