agents 0.14.1 → 0.14.3

package/dist/chat/index.js

@@ -1,4 +1,4 @@
-import { a as normalizeToolInput, i as isReplayChunk, n as createAgentToolEventState, r as applyChunkToParts, t as applyAgentToolEvent } from "../agent-tools-DYrkT-Kx.js";
+import { a as normalizeToolInput, i as isReplayChunk, n as createAgentToolEventState, r as applyChunkToParts, t as applyAgentToolEvent } from "../agent-tools-3zLG7MgA.js";
 import { t as truncateToolOutput } from "../tool-output-truncation-CNnnGZQ3.js";
 import { jsonSchema, tool } from "ai";
 import { nanoid } from "nanoid";
@@ -536,16 +536,39 @@ const CHAT_MESSAGE_TYPES = {
 * - Stale stream cleanup
 * - Active stream restoration after agent restart
 */
-/** Number of chunks to buffer before flushing to SQLite */
+/** Number of chunks to pack into a single SQLite row 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.
+*/
+const SEGMENT_MAX_BYTES = 512e3;
 /** Default cleanup interval for old streams (ms) - every 10 minutes */
 const CLEANUP_INTERVAL_MS = 600 * 1e3;
 /** Default age threshold for cleaning up completed streams (ms) - 24 hours */
 const CLEANUP_AGE_THRESHOLD_MS = 1440 * 60 * 1e3;
 /** Shared encoder for UTF-8 byte length measurement */
 const textEncoder = new TextEncoder();
+/**
+* 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.
+*/
+function unpackSegmentBody(rowBody) {
+	try {
+		const parsed = JSON.parse(rowBody);
+		if (Array.isArray(parsed)) return parsed;
+	} catch {}
+	return [rowBody];
+}
 function sendIfOpen$1(connection, message) {
 	try {
 		connection.send(message);
@@ -563,9 +586,10 @@ var ResumableStream = class ResumableStream {
 		this.sql = sql;
 		this._activeStreamId = null;
 		this._activeRequestId = null;
-		this._streamChunkIndex = 0;
+		this._segmentIndex = 0;
 		this._isLive = false;
 		this._chunkBuffer = [];
+		this._chunkBufferBytes = 0;
 		this._isFlushingChunks = false;
 		this._lastCleanupTime = 0;
 		this.sql`create table if not exists cf_ai_chat_stream_chunks (
@@ -613,7 +637,7 @@ var ResumableStream = class ResumableStream {
 		const streamId = nanoid();
 		this._activeStreamId = streamId;
 		this._activeRequestId = requestId;
-		this._streamChunkIndex = 0;
+		this._segmentIndex = 0;
 		this._isLive = true;
 		this.sql`
       insert into cf_ai_chat_stream_metadata (id, request_id, status, created_at)
@@ -634,7 +658,7 @@ var ResumableStream = class ResumableStream {
     `;
 		this._activeStreamId = null;
 		this._activeRequestId = null;
-		this._streamChunkIndex = 0;
+		this._segmentIndex = 0;
 		this._isLive = false;
 		this._maybeCleanupOldStreams();
 	}
@@ -651,7 +675,7 @@ var ResumableStream = class ResumableStream {
     `;
 		this._activeStreamId = null;
 		this._activeRequestId = null;
-		this._streamChunkIndex = 0;
+		this._segmentIndex = 0;
 		this._isLive = false;
 	}
 	/**
@@ -669,18 +693,22 @@ var ResumableStream = class ResumableStream {
 			return;
 		}
 		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({
-			id: nanoid(),
 			streamId,
-			body,
-			index: this._streamChunkIndex
+			body
 		});
-		this._streamChunkIndex++;
+		this._chunkBufferBytes += bodyBytes;
 		if (this._chunkBuffer.length >= CHUNK_BUFFER_SIZE) this.flushBuffer();
 	}
 	/**
-	* Flush buffered chunks to SQLite in a single batch.
+	* Flush the buffered chunks to SQLite as a single packed row.
 	* 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.
 	*/
 	flushBuffer() {
 		if (this._isFlushingChunks || this._chunkBuffer.length === 0) return;
@@ -688,11 +716,14 @@ var ResumableStream = class ResumableStream {
 		try {
 			const chunks = this._chunkBuffer;
 			this._chunkBuffer = [];
-			const now = Date.now();
-			for (const chunk of chunks) this.sql`
-          insert into cf_ai_chat_stream_chunks (id, stream_id, body, chunk_index, created_at)
-          values (${chunk.id}, ${chunk.streamId}, ${chunk.body}, ${chunk.index}, ${now})
-        `;
+			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++;
 		} finally {
 			this._isFlushingChunks = false;
 		}
@@ -727,8 +758,8 @@ var ResumableStream = class ResumableStream {
       where stream_id = ${streamId} 
       order by chunk_index asc
     `;
-		for (const chunk of chunks || []) if (!sendIfOpen$1(connection, JSON.stringify({
-			body: chunk.body,
+		for (const chunk of chunks || []) for (const body of unpackSegmentBody(chunk.body)) if (!sendIfOpen$1(connection, JSON.stringify({
+			body,
 			done: false,
 			id: requestId,
 			type: CHAT_MESSAGE_TYPES.USE_CHAT_RESPONSE,
@@ -780,8 +811,8 @@ var ResumableStream = class ResumableStream {
       where stream_id = ${stream.id}
       order by chunk_index asc
     `;
-		for (const chunk of chunks || []) if (!sendIfOpen$1(connection, JSON.stringify({
-			body: chunk.body,
+		for (const chunk of chunks || []) for (const body of unpackSegmentBody(chunk.body)) if (!sendIfOpen$1(connection, JSON.stringify({
+			body,
 			done: false,
 			id: requestId,
 			type: CHAT_MESSAGE_TYPES.USE_CHAT_RESPONSE,
@@ -816,7 +847,7 @@ var ResumableStream = class ResumableStream {
         from cf_ai_chat_stream_chunks 
         where stream_id = ${this._activeStreamId}
       `;
-			this._streamChunkIndex = lastChunk && lastChunk[0]?.max_index != null ? lastChunk[0].max_index + 1 : 0;
+			this._segmentIndex = lastChunk && lastChunk[0]?.max_index != null ? lastChunk[0].max_index + 1 : 0;
 		}
 	}
 	/**
@@ -824,11 +855,12 @@ var ResumableStream = class ResumableStream {
 	*/
 	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._activeStreamId = null;
 		this._activeRequestId = null;
-		this._streamChunkIndex = 0;
+		this._segmentIndex = 0;
 	}
 	/**
 	* Drop all stream tables (called on destroy).
@@ -868,13 +900,28 @@ var ResumableStream = class ResumableStream {
       where status = 'streaming' and created_at < ${cutoff}
     `;
 	}
-	/** @internal For testing only */
+	/**
+	* 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.
+	*/
 	getStreamChunks(streamId) {
-		return this.sql`
-        select body, chunk_index from cf_ai_chat_stream_chunks 
+		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;
 	}
 	/** @internal For testing only */
 	getStreamMetadata(streamId) {
@@ -899,6 +946,44 @@ var ResumableStream = class ResumableStream {
 };
 ResumableStream.CHUNK_MAX_BYTES = 18e5;
 //#endregion
+//#region src/chat/sql-batch.ts
+/**
+* Helpers for building batched SQLite statements that run through the Agent's
+* `sql` tagged template (which interleaves a `?` placeholder between every
+* string fragment). Used to collapse per-row INSERT/DELETE loops into a small
+* number of multi-row statements.
+*
+* SQLite (Durable Object / D1) caps bound parameters at 100 per query, so
+* callers must chunk their inputs to stay within {@link MAX_BOUND_PARAMS}.
+* See https://developers.cloudflare.com/d1/platform/limits/
+*/
+/** Maximum bound parameters allowed in a single SQLite (DO / D1) query. */
+const MAX_BOUND_PARAMS = 100;
+/**
+* Attach a self-referential `raw` property so a plain string[] satisfies the
+* TemplateStringsArray shape. `sql` only reads indexed string fragments, so
+* `raw` is never consumed — this just keeps the type system happy.
+*/
+function asTemplateStringsArray(parts) {
+	parts.raw = parts;
+	return parts;
+}
+/**
+* Build a TemplateStringsArray for a single-column `IN (...)` clause. Produces
+* fragments for:
+*   `${prefix}(?, ?, ...)`
+*
+* @throws if `count` is less than 1.
+*/
+function buildInClauseStrings(prefix, count) {
+	if (count < 1) throw new Error(`buildInClauseStrings requires count >= 1 (got ${count})`);
+	const parts = new Array(count + 1);
+	parts[0] = `${prefix}(`;
+	for (let i = 1; i < count; i++) parts[i] = ", ";
+	parts[count] = ")";
+	return asTemplateStringsArray(parts);
+}
+//#endregion
 //#region src/chat/client-tools.ts
 /**
 * Converts client tool schemas to AI SDK tool format.
@@ -1082,9 +1167,13 @@ var AbortRegistry = class {
 	remove(id) {
 		this.controllers.delete(id);
 	}
-	/** Abort all pending requests and clear the registry. */
-	destroyAll() {
-		for (const controller of this.controllers.values()) controller.abort();
+	/**
+	* Abort all pending requests and clear the registry. Optionally propagate a
+	* reason — surfaces as `signal.reason` on each controller and through any
+	* `AbortError` it produces downstream, exactly like {@link cancel}.
+	*/
+	destroyAll(reason) {
+		for (const controller of this.controllers.values()) controller.abort(reason);
 		this.controllers.clear();
 	}
 	/** Check if a controller exists for the given ID. */
@@ -1511,6 +1600,6 @@ function unwrapChatFiberSnapshot(key, value, expectedKind) {
 	};
 }
 //#endregion
-export { AbortRegistry, CHAT_MESSAGE_TYPES, ContinuationState, ROW_MAX_BYTES, ResumableStream, StreamAccumulator, SubmitConcurrencyController, TurnQueue, applyAgentToolEvent, applyChunkToParts, applyToolUpdate, assistantContentKey, transition as broadcastTransition, byteLength, createAgentToolEventState, createChatFiberSnapshot, createToolsFromClientSchemas, crossMessageToolResultUpdate, enforceRowSizeLimit, isReplayChunk, normalizeToolInput, parseProtocolMessage, reconcileMessages, resolveToolMergeId, sanitizeMessage, toolApprovalUpdate, toolResultUpdate, unwrapChatFiberSnapshot, wrapChatFiberSnapshot };
+export { AbortRegistry, CHAT_MESSAGE_TYPES, ContinuationState, MAX_BOUND_PARAMS, ROW_MAX_BYTES, ResumableStream, StreamAccumulator, SubmitConcurrencyController, TurnQueue, applyAgentToolEvent, applyChunkToParts, applyToolUpdate, assistantContentKey, transition as broadcastTransition, buildInClauseStrings, byteLength, createAgentToolEventState, createChatFiberSnapshot, createToolsFromClientSchemas, crossMessageToolResultUpdate, enforceRowSizeLimit, isReplayChunk, normalizeToolInput, parseProtocolMessage, reconcileMessages, resolveToolMergeId, sanitizeMessage, toolApprovalUpdate, toolResultUpdate, unwrapChatFiberSnapshot, wrapChatFiberSnapshot };
 
 //# sourceMappingURL=index.js.map