agents 0.8.7 → 0.10.0

package/dist/chat/index.js

@@ -0,0 +1,1285 @@
+import { nanoid } from "nanoid";
+import { jsonSchema, tool } from "ai";
+//#region src/chat/message-builder.ts
+/**
+* Applies a stream chunk to a mutable parts array, building up the message
+* incrementally. Returns true if the chunk was handled, false if it was
+* an unrecognized type (caller may handle it with additional logic).
+*
+* Handles all common chunk types that both server and client need:
+* - text-start / text-delta / text-end
+* - reasoning-start / reasoning-delta / reasoning-end
+* - file
+* - source-url / source-document
+* - tool-input-start / tool-input-delta / tool-input-available / tool-input-error
+* - tool-output-available / tool-output-error
+* - step-start (aliased from start-step)
+* - data-* (developer-defined typed JSON blobs)
+*
+* @param parts - The mutable parts array to update
+* @param chunk - The parsed stream chunk data
+* @returns true if handled, false if the chunk type is not recognized
+*/
+function applyChunkToParts(parts, chunk) {
+	switch (chunk.type) {
+		case "text-start":
+			parts.push({
+				type: "text",
+				text: "",
+				state: "streaming"
+			});
+			return true;
+		case "text-delta": {
+			const lastTextPart = findLastPartByType(parts, "text");
+			if (lastTextPart && lastTextPart.type === "text") lastTextPart.text += chunk.delta ?? "";
+			else parts.push({
+				type: "text",
+				text: chunk.delta ?? "",
+				state: "streaming"
+			});
+			return true;
+		}
+		case "text-end": {
+			const lastTextPart = findLastPartByType(parts, "text");
+			if (lastTextPart && "state" in lastTextPart) lastTextPart.state = "done";
+			return true;
+		}
+		case "reasoning-start":
+			parts.push({
+				type: "reasoning",
+				text: "",
+				state: "streaming"
+			});
+			return true;
+		case "reasoning-delta": {
+			const lastReasoningPart = findLastPartByType(parts, "reasoning");
+			if (lastReasoningPart && lastReasoningPart.type === "reasoning") lastReasoningPart.text += chunk.delta ?? "";
+			else parts.push({
+				type: "reasoning",
+				text: chunk.delta ?? "",
+				state: "streaming"
+			});
+			return true;
+		}
+		case "reasoning-end": {
+			const lastReasoningPart = findLastPartByType(parts, "reasoning");
+			if (lastReasoningPart && "state" in lastReasoningPart) lastReasoningPart.state = "done";
+			return true;
+		}
+		case "file":
+			parts.push({
+				type: "file",
+				mediaType: chunk.mediaType,
+				url: chunk.url
+			});
+			return true;
+		case "source-url":
+			parts.push({
+				type: "source-url",
+				sourceId: chunk.sourceId,
+				url: chunk.url,
+				title: chunk.title,
+				providerMetadata: chunk.providerMetadata
+			});
+			return true;
+		case "source-document":
+			parts.push({
+				type: "source-document",
+				sourceId: chunk.sourceId,
+				mediaType: chunk.mediaType,
+				title: chunk.title,
+				filename: chunk.filename,
+				providerMetadata: chunk.providerMetadata
+			});
+			return true;
+		case "tool-input-start":
+			parts.push({
+				type: `tool-${chunk.toolName}`,
+				toolCallId: chunk.toolCallId,
+				toolName: chunk.toolName,
+				state: "input-streaming",
+				input: void 0,
+				...chunk.providerExecuted != null ? { providerExecuted: chunk.providerExecuted } : {},
+				...chunk.providerMetadata != null ? { callProviderMetadata: chunk.providerMetadata } : {},
+				...chunk.title != null ? { title: chunk.title } : {}
+			});
+			return true;
+		case "tool-input-delta": {
+			const toolPart = findToolPartByCallId(parts, chunk.toolCallId);
+			if (toolPart) toolPart.input = chunk.input;
+			return true;
+		}
+		case "tool-input-available": {
+			const existing = findToolPartByCallId(parts, chunk.toolCallId);
+			if (existing) {
+				const p = existing;
+				p.state = "input-available";
+				p.input = chunk.input;
+				if (chunk.providerExecuted != null) p.providerExecuted = chunk.providerExecuted;
+				if (chunk.providerMetadata != null) p.callProviderMetadata = chunk.providerMetadata;
+				if (chunk.title != null) p.title = chunk.title;
+			} else parts.push({
+				type: `tool-${chunk.toolName}`,
+				toolCallId: chunk.toolCallId,
+				toolName: chunk.toolName,
+				state: "input-available",
+				input: chunk.input,
+				...chunk.providerExecuted != null ? { providerExecuted: chunk.providerExecuted } : {},
+				...chunk.providerMetadata != null ? { callProviderMetadata: chunk.providerMetadata } : {},
+				...chunk.title != null ? { title: chunk.title } : {}
+			});
+			return true;
+		}
+		case "tool-input-error": {
+			const existing = findToolPartByCallId(parts, chunk.toolCallId);
+			if (existing) {
+				const p = existing;
+				p.state = "output-error";
+				p.errorText = chunk.errorText;
+				p.input = chunk.input;
+				if (chunk.providerExecuted != null) p.providerExecuted = chunk.providerExecuted;
+				if (chunk.providerMetadata != null) p.callProviderMetadata = chunk.providerMetadata;
+			} else parts.push({
+				type: `tool-${chunk.toolName}`,
+				toolCallId: chunk.toolCallId,
+				toolName: chunk.toolName,
+				state: "output-error",
+				input: chunk.input,
+				errorText: chunk.errorText,
+				...chunk.providerExecuted != null ? { providerExecuted: chunk.providerExecuted } : {},
+				...chunk.providerMetadata != null ? { callProviderMetadata: chunk.providerMetadata } : {}
+			});
+			return true;
+		}
+		case "tool-approval-request": {
+			const toolPart = findToolPartByCallId(parts, chunk.toolCallId);
+			if (toolPart) {
+				const p = toolPart;
+				p.state = "approval-requested";
+				p.approval = { id: chunk.approvalId };
+			}
+			return true;
+		}
+		case "tool-output-denied": {
+			const toolPart = findToolPartByCallId(parts, chunk.toolCallId);
+			if (toolPart) {
+				const p = toolPart;
+				p.state = "output-denied";
+			}
+			return true;
+		}
+		case "tool-output-available": {
+			const toolPart = findToolPartByCallId(parts, chunk.toolCallId);
+			if (toolPart) {
+				const p = toolPart;
+				p.state = "output-available";
+				p.output = chunk.output;
+				if (chunk.preliminary !== void 0) p.preliminary = chunk.preliminary;
+			}
+			return true;
+		}
+		case "tool-output-error": {
+			const toolPart = findToolPartByCallId(parts, chunk.toolCallId);
+			if (toolPart) {
+				const p = toolPart;
+				p.state = "output-error";
+				p.errorText = chunk.errorText;
+			}
+			return true;
+		}
+		case "step-start":
+		case "start-step":
+			parts.push({ type: "step-start" });
+			return true;
+		default:
+			if (chunk.type.startsWith("data-")) {
+				if (chunk.transient) return true;
+				if (chunk.id != null) {
+					const existing = findDataPartByTypeAndId(parts, chunk.type, chunk.id);
+					if (existing) {
+						existing.data = chunk.data;
+						return true;
+					}
+				}
+				parts.push({
+					type: chunk.type,
+					...chunk.id != null && { id: chunk.id },
+					data: chunk.data
+				});
+				return true;
+			}
+			return false;
+	}
+}
+/**
+* Finds the last part in the array matching the given type.
+* Searches from the end for efficiency (the part we want is usually recent).
+*/
+function findLastPartByType(parts, type) {
+	for (let i = parts.length - 1; i >= 0; i--) if (parts[i].type === type) return parts[i];
+}
+/**
+* Finds a tool part by its toolCallId.
+* Searches from the end since the tool part is usually recent.
+*/
+function findToolPartByCallId(parts, toolCallId) {
+	if (!toolCallId) return void 0;
+	for (let i = parts.length - 1; i >= 0; i--) {
+		const p = parts[i];
+		if ("toolCallId" in p && p.toolCallId === toolCallId) return p;
+	}
+}
+/**
+* Finds a data part by its type and id for reconciliation.
+* Data parts use type+id as a composite key so when the same combination
+* is seen again, the existing part's data is updated in-place.
+*/
+function findDataPartByTypeAndId(parts, type, id) {
+	for (let i = parts.length - 1; i >= 0; i--) {
+		const p = parts[i];
+		if (p.type === type && "id" in p && p.id === id) return p;
+	}
+}
+//#endregion
+//#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;
+	});
+	return {
+		...message,
+		parts: sanitizedParts
+	};
+}
+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
+	};
+	else if (Object.keys(restMetadata).length > 0) newMetadata = restMetadata;
+	const { [metadataKey]: _oldMeta, ...restPart } = part;
+	if (newMetadata) return {
+		...restPart,
+		[metadataKey]: newMetadata
+	};
+	return restPart;
+}
+/**
+* Enforce SQLite row size limits by compacting tool outputs and text parts
+* when a serialized message exceeds the safety threshold (1.8MB).
+*
+* Compaction strategy:
+* 1. Compact tool outputs over 1KB (replace with summary)
+* 2. If still too big, truncate text parts from oldest to newest
+*/
+function enforceRowSizeLimit(message) {
+	let json = JSON.stringify(message);
+	let size = byteLength(json);
+	if (size <= 18e5) return message;
+	if (message.role !== "assistant") return truncateTextParts(message);
+	const compactedParts = message.parts.map((part) => {
+		if ("output" in part && "toolCallId" in part && "state" in part && part.state === "output-available") {
+			const outputJson = JSON.stringify(part.output);
+			if (outputJson.length > 1e3) return {
+				...part,
+				output: `This tool output was too large to persist in storage (${outputJson.length} bytes). If the user asks about this data, suggest re-running the tool. Preview: ${outputJson.slice(0, 500)}...`
+			};
+		}
+		return part;
+	});
+	let result = {
+		...message,
+		parts: compactedParts
+	};
+	json = JSON.stringify(result);
+	size = byteLength(json);
+	if (size <= 18e5) return result;
+	return truncateTextParts(result);
+}
+function truncateTextParts(message) {
+	const parts = [...message.parts];
+	for (let i = 0; i < parts.length; i++) {
+		const part = parts[i];
+		if (part.type === "text" && "text" in part) {
+			const text = part.text;
+			if (text.length > 1e3) {
+				parts[i] = {
+					...part,
+					text: `[Text truncated for storage (${text.length} chars). First 500 chars: ${text.slice(0, 500)}...]`
+				};
+				const candidate = {
+					...message,
+					parts
+				};
+				if (byteLength(JSON.stringify(candidate)) <= 18e5) break;
+			}
+		}
+	}
+	return {
+		...message,
+		parts
+	};
+}
+//#endregion
+//#region src/chat/stream-accumulator.ts
+function asMetadata(value) {
+	if (value != null && typeof value === "object" && !Array.isArray(value)) return value;
+}
+var StreamAccumulator = class {
+	constructor(options) {
+		this.messageId = options.messageId;
+		this._isContinuation = options.continuation ?? false;
+		this.parts = options.existingParts ? [...options.existingParts] : [];
+		this.metadata = options.existingMetadata ? { ...options.existingMetadata } : void 0;
+	}
+	applyChunk(chunk) {
+		const handled = applyChunkToParts(this.parts, chunk);
+		if (chunk.type === "tool-approval-request" && chunk.toolCallId) return {
+			handled,
+			action: {
+				type: "tool-approval-request",
+				toolCallId: chunk.toolCallId
+			}
+		};
+		if ((chunk.type === "tool-output-available" || chunk.type === "tool-output-error") && chunk.toolCallId) {
+			if (!this.parts.some((p) => "toolCallId" in p && p.toolCallId === chunk.toolCallId)) return {
+				handled,
+				action: {
+					type: "cross-message-tool-update",
+					updateType: chunk.type === "tool-output-available" ? "output-available" : "output-error",
+					toolCallId: chunk.toolCallId,
+					output: chunk.output,
+					errorText: chunk.errorText,
+					preliminary: chunk.preliminary
+				}
+			};
+		}
+		if (!handled) switch (chunk.type) {
+			case "start": {
+				if (chunk.messageId != null && !this._isContinuation) this.messageId = chunk.messageId;
+				const startMeta = asMetadata(chunk.messageMetadata);
+				if (startMeta) this.metadata = this.metadata ? {
+					...this.metadata,
+					...startMeta
+				} : { ...startMeta };
+				return {
+					handled: true,
+					action: {
+						type: "start",
+						messageId: chunk.messageId,
+						metadata: startMeta
+					}
+				};
+			}
+			case "finish": {
+				const finishMeta = asMetadata(chunk.messageMetadata);
+				if (finishMeta) this.metadata = this.metadata ? {
+					...this.metadata,
+					...finishMeta
+				} : { ...finishMeta };
+				return {
+					handled: true,
+					action: {
+						type: "finish",
+						finishReason: "finishReason" in chunk ? chunk.finishReason : void 0,
+						metadata: finishMeta
+					}
+				};
+			}
+			case "message-metadata": {
+				const msgMeta = asMetadata(chunk.messageMetadata);
+				if (msgMeta) this.metadata = this.metadata ? {
+					...this.metadata,
+					...msgMeta
+				} : { ...msgMeta };
+				return {
+					handled: true,
+					action: {
+						type: "message-metadata",
+						metadata: msgMeta ?? {}
+					}
+				};
+			}
+			case "finish-step": return { handled: true };
+			case "error": return {
+				handled: true,
+				action: {
+					type: "error",
+					error: chunk.errorText ?? JSON.stringify(chunk)
+				}
+			};
+		}
+		return { handled };
+	}
+	/** Snapshot the current state as a UIMessage. */
+	toMessage() {
+		return {
+			id: this.messageId,
+			role: "assistant",
+			parts: [...this.parts],
+			...this.metadata != null && { metadata: this.metadata }
+		};
+	}
+	/**
+	* Merge this accumulator's message into an existing message array.
+	* Handles continuation (walk backward for last assistant), replacement
+	* (update existing by messageId), or append (new message).
+	*/
+	mergeInto(messages) {
+		let existingIdx = messages.findIndex((m) => m.id === this.messageId);
+		if (existingIdx < 0 && this._isContinuation) {
+			for (let i = messages.length - 1; i >= 0; i--) if (messages[i].role === "assistant") {
+				existingIdx = i;
+				break;
+			}
+		}
+		const partialMessage = {
+			id: existingIdx >= 0 ? messages[existingIdx].id : this.messageId,
+			role: "assistant",
+			parts: [...this.parts],
+			...this.metadata != null && { metadata: this.metadata }
+		};
+		if (existingIdx >= 0) {
+			const updated = [...messages];
+			updated[existingIdx] = partialMessage;
+			return updated;
+		}
+		return [...messages, partialMessage];
+	}
+};
+//#endregion
+//#region src/chat/turn-queue.ts
+var TurnQueue = class {
+	constructor() {
+		this._queue = Promise.resolve();
+		this._generation = 0;
+		this._activeRequestId = null;
+		this._countsByGeneration = /* @__PURE__ */ new Map();
+	}
+	get generation() {
+		return this._generation;
+	}
+	get activeRequestId() {
+		return this._activeRequestId;
+	}
+	get isActive() {
+		return this._activeRequestId !== null;
+	}
+	async enqueue(requestId, fn, options) {
+		const previousTurn = this._queue;
+		let releaseTurn;
+		const capturedGeneration = options?.generation ?? this._generation;
+		this._countsByGeneration.set(capturedGeneration, (this._countsByGeneration.get(capturedGeneration) ?? 0) + 1);
+		this._queue = new Promise((resolve) => {
+			releaseTurn = resolve;
+		});
+		await previousTurn;
+		if (this._generation !== capturedGeneration) {
+			this._decrementCount(capturedGeneration);
+			releaseTurn();
+			return { status: "stale" };
+		}
+		this._activeRequestId = requestId;
+		try {
+			return {
+				status: "completed",
+				value: await fn()
+			};
+		} finally {
+			this._activeRequestId = null;
+			this._decrementCount(capturedGeneration);
+			releaseTurn();
+		}
+	}
+	/**
+	* Advance the generation counter. All turns enqueued under older
+	* generations will be skipped when they reach the front of the queue.
+	*/
+	reset() {
+		this._generation++;
+	}
+	/**
+	* Wait until the queue is fully drained (no pending or active turns).
+	*/
+	async waitForIdle() {
+		let queue;
+		do {
+			queue = this._queue;
+			await queue;
+		} while (this._queue !== queue);
+	}
+	/**
+	* Number of active + queued turns for a given generation.
+	* Defaults to the current generation.
+	*/
+	queuedCount(generation) {
+		return this._countsByGeneration.get(generation ?? this._generation) ?? 0;
+	}
+	_decrementCount(generation) {
+		const count = (this._countsByGeneration.get(generation) ?? 1) - 1;
+		if (count <= 0) this._countsByGeneration.delete(generation);
+		else this._countsByGeneration.set(generation, count);
+	}
+};
+//#endregion
+//#region src/chat/broadcast-state.ts
+function transition(state, event) {
+	switch (event.type) {
+		case "clear": return {
+			state: { status: "idle" },
+			isStreaming: false
+		};
+		case "resume-fallback": {
+			const accumulator = new StreamAccumulator({ messageId: event.messageId });
+			return {
+				state: {
+					status: "observing",
+					streamId: event.streamId,
+					accumulator
+				},
+				isStreaming: true
+			};
+		}
+		case "response": {
+			let accumulator;
+			if (state.status === "idle" || state.streamId !== event.streamId) {
+				let messageId = event.messageId;
+				let existingParts;
+				let existingMetadata;
+				if (event.continuation && event.currentMessages) {
+					for (let i = event.currentMessages.length - 1; i >= 0; i--) if (event.currentMessages[i].role === "assistant") {
+						messageId = event.currentMessages[i].id;
+						existingParts = [...event.currentMessages[i].parts];
+						if (event.currentMessages[i].metadata != null) existingMetadata = { ...event.currentMessages[i].metadata };
+						break;
+					}
+				}
+				accumulator = new StreamAccumulator({
+					messageId,
+					continuation: event.continuation,
+					existingParts,
+					existingMetadata
+				});
+			} else accumulator = state.accumulator;
+			if (event.chunkData) accumulator.applyChunk(event.chunkData);
+			let messagesUpdate;
+			if (event.done) {
+				messagesUpdate = (prev) => accumulator.mergeInto(prev);
+				return {
+					state: { status: "idle" },
+					messagesUpdate,
+					isStreaming: false
+				};
+			}
+			if (event.chunkData && !event.replay) messagesUpdate = (prev) => accumulator.mergeInto(prev);
+			else if (event.replayComplete) messagesUpdate = (prev) => accumulator.mergeInto(prev);
+			return {
+				state: {
+					status: "observing",
+					streamId: event.streamId,
+					accumulator
+				},
+				messagesUpdate,
+				isStreaming: true
+			};
+		}
+	}
+}
+//#endregion
+//#region src/chat/protocol.ts
+/**
+* Wire protocol message type constants for the cf_agent_chat_* protocol.
+*
+* These are the string values used on the wire between agent servers and
+* clients. Both @cloudflare/ai-chat (via its MessageType enum) and
+* @cloudflare/think use these values.
+*/
+const CHAT_MESSAGE_TYPES = {
+	CHAT_MESSAGES: "cf_agent_chat_messages",
+	USE_CHAT_REQUEST: "cf_agent_use_chat_request",
+	USE_CHAT_RESPONSE: "cf_agent_use_chat_response",
+	CHAT_CLEAR: "cf_agent_chat_clear",
+	CHAT_REQUEST_CANCEL: "cf_agent_chat_request_cancel",
+	STREAM_RESUMING: "cf_agent_stream_resuming",
+	STREAM_RESUME_ACK: "cf_agent_stream_resume_ack",
+	STREAM_RESUME_REQUEST: "cf_agent_stream_resume_request",
+	STREAM_RESUME_NONE: "cf_agent_stream_resume_none",
+	TOOL_RESULT: "cf_agent_tool_result",
+	TOOL_APPROVAL: "cf_agent_tool_approval",
+	MESSAGE_UPDATED: "cf_agent_message_updated"
+};
+//#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.
+*
+* Handles:
+* - Chunk buffering (batched writes to SQLite for performance)
+* - Stream lifecycle (start, complete, error)
+* - Chunk replay for reconnecting clients
+* - Stale stream cleanup
+* - Active stream restoration after agent restart
+*/
+/** Number of chunks to buffer before flushing to SQLite */
+const CHUNK_BUFFER_SIZE = 10;
+/** Maximum buffer size to prevent memory issues on rapid reconnections */
+const CHUNK_BUFFER_MAX_SIZE = 100;
+/** 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();
+var ResumableStream = class ResumableStream {
+	constructor(sql) {
+		this.sql = sql;
+		this._activeStreamId = null;
+		this._activeRequestId = null;
+		this._streamChunkIndex = 0;
+		this._isLive = false;
+		this._chunkBuffer = [];
+		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
+    )`;
+		this.sql`create index if not exists idx_stream_chunks_stream_id 
+      on cf_ai_chat_stream_chunks(stream_id, chunk_index)`;
+		this.restore();
+	}
+	get activeStreamId() {
+		return this._activeStreamId;
+	}
+	get activeRequestId() {
+		return this._activeRequestId;
+	}
+	hasActiveStream() {
+		return this._activeStreamId !== null;
+	}
+	/**
+	* Whether the active stream has a live LLM reader (started in this
+	* instance) vs being restored from SQLite after hibernation (orphaned).
+	*/
+	get isLive() {
+		return this._isLive;
+	}
+	/**
+	* Start tracking a new stream for resumable streaming.
+	* Creates metadata entry in SQLite and sets up tracking state.
+	* @param requestId - The unique ID of the chat request
+	* @returns The generated stream ID
+	*/
+	start(requestId) {
+		this.flushBuffer();
+		const streamId = nanoid();
+		this._activeStreamId = streamId;
+		this._activeRequestId = requestId;
+		this._streamChunkIndex = 0;
+		this._isLive = true;
+		this.sql`
+      insert into cf_ai_chat_stream_metadata (id, request_id, status, created_at)
+      values (${streamId}, ${requestId}, 'streaming', ${Date.now()})
+    `;
+		return streamId;
+	}
+	/**
+	* Mark a stream as completed and flush any pending chunks.
+	* @param streamId - The stream to mark as completed
+	*/
+	complete(streamId) {
+		this.flushBuffer();
+		this.sql`
+      update cf_ai_chat_stream_metadata 
+      set status = 'completed', completed_at = ${Date.now()} 
+      where id = ${streamId}
+    `;
+		this._activeStreamId = null;
+		this._activeRequestId = null;
+		this._streamChunkIndex = 0;
+		this._isLive = false;
+		this._maybeCleanupOldStreams();
+	}
+	/**
+	* Mark a stream as errored and clean up state.
+	* @param streamId - The stream to mark as errored
+	*/
+	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._streamChunkIndex = 0;
+		this._isLive = false;
+	}
+	/**
+	* Buffer a stream chunk for batch write to SQLite.
+	* 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.
+	* @param streamId - The stream this chunk belongs to
+	* @param body - The serialized chunk body
+	*/
+	storeChunk(streamId, body) {
+		const bodyBytes = textEncoder.encode(body).byteLength;
+		if (bodyBytes > ResumableStream.CHUNK_MAX_BYTES) {
+			console.warn(`[ResumableStream] Skipping oversized chunk (${bodyBytes} bytes) to prevent SQLite row limit crash. Live clients still receive it.`);
+			return;
+		}
+		if (this._chunkBuffer.length >= CHUNK_BUFFER_MAX_SIZE) this.flushBuffer();
+		this._chunkBuffer.push({
+			id: nanoid(),
+			streamId,
+			body,
+			index: this._streamChunkIndex
+		});
+		this._streamChunkIndex++;
+		if (this._chunkBuffer.length >= CHUNK_BUFFER_SIZE) this.flushBuffer();
+	}
+	/**
+	* Flush buffered chunks to SQLite in a single batch.
+	* Uses a lock to prevent concurrent flush operations.
+	*/
+	flushBuffer() {
+		if (this._isFlushingChunks || this._chunkBuffer.length === 0) return;
+		this._isFlushingChunks = true;
+		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})
+        `;
+		} finally {
+			this._isFlushingChunks = false;
+		}
+	}
+	/**
+	* Send stored stream chunks to a connection for replay.
+	* Chunks are marked with replay: true so the client can batch-apply them.
+	*
+	* Three outcomes:
+	* - **Live stream**: sends chunks + `replayComplete` — client flushes and
+	*   continues receiving live chunks from the LLM reader.
+	* - **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`.
+	*
+	* @param connection - The WebSocket connection
+	* @param requestId - The original request ID
+	* @returns The stream ID if the stream was orphaned and finalized, null otherwise.
+	*          When non-null the caller should reconstruct the message from chunks.
+	*/
+	replayChunks(connection, requestId) {
+		const streamId = this._activeStreamId;
+		if (!streamId) return null;
+		this.flushBuffer();
+		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 || []) connection.send(JSON.stringify({
+			body: chunk.body,
+			done: false,
+			id: requestId,
+			type: CHAT_MESSAGE_TYPES.USE_CHAT_RESPONSE,
+			replay: true
+		}));
+		if (this._activeStreamId !== streamId) {
+			connection.send(JSON.stringify({
+				body: "",
+				done: true,
+				id: requestId,
+				type: CHAT_MESSAGE_TYPES.USE_CHAT_RESPONSE,
+				replay: true
+			}));
+			return null;
+		}
+		if (!this._isLive) {
+			connection.send(JSON.stringify({
+				body: "",
+				done: true,
+				id: requestId,
+				type: CHAT_MESSAGE_TYPES.USE_CHAT_RESPONSE,
+				replay: true
+			}));
+			this.complete(streamId);
+			return streamId;
+		}
+		connection.send(JSON.stringify({
+			body: "",
+			done: false,
+			id: requestId,
+			type: CHAT_MESSAGE_TYPES.USE_CHAT_RESPONSE,
+			replay: true,
+			replayComplete: true
+		}));
+		return null;
+	}
+	/**
+	* Restore active stream state if the agent was restarted during streaming.
+	* All streams are restored regardless of age — stale cleanup happens
+	* 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;
+			const lastChunk = this.sql`
+        select max(chunk_index) as max_index 
+        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;
+		}
+	}
+	/**
+	* Clear all stream data (called on chat history clear).
+	*/
+	clearAll() {
+		this._chunkBuffer = [];
+		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;
+	}
+	/**
+	* Drop all stream tables (called on destroy).
+	*/
+	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;
+	}
+	_maybeCleanupOldStreams() {
+		const now = Date.now();
+		if (now - this._lastCleanupTime < CLEANUP_INTERVAL_MS) return;
+		this._lastCleanupTime = now;
+		const cutoff = now - CLEANUP_AGE_THRESHOLD_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 < ${cutoff}
+      )
+    `;
+		this.sql`
+      delete from cf_ai_chat_stream_metadata 
+      where status in ('completed', 'error') and completed_at < ${cutoff}
+    `;
+		this.sql`
+      delete from cf_ai_chat_stream_chunks
+      where stream_id in (
+        select id from cf_ai_chat_stream_metadata
+        where status = 'streaming' and created_at < ${cutoff}
+      )
+    `;
+		this.sql`
+      delete from cf_ai_chat_stream_metadata
+      where status = 'streaming' and created_at < ${cutoff}
+    `;
+	}
+	/** @internal For testing only */
+	getStreamChunks(streamId) {
+		return this.sql`
+        select body, chunk_index from cf_ai_chat_stream_chunks 
+        where stream_id = ${streamId} 
+        order by chunk_index asc
+      ` || [];
+	}
+	/** @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;
+	}
+	/** @internal For testing only */
+	getAllStreamMetadata() {
+		return this.sql`select id, status, request_id, created_at from cf_ai_chat_stream_metadata` || [];
+	}
+	/** @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})
+    `;
+	}
+};
+ResumableStream.CHUNK_MAX_BYTES = 18e5;
+//#endregion
+//#region src/chat/client-tools.ts
+/**
+* Converts client tool schemas to AI SDK tool format.
+*
+* These tools have no `execute` function — when the AI model calls them,
+* the tool call is sent back to the client for execution.
+*
+* @param clientTools - Array of tool schemas from the client
+* @returns Record of AI SDK tools that can be spread into your tools object
+*/
+function createToolsFromClientSchemas(clientTools) {
+	if (!clientTools || clientTools.length === 0) return {};
+	const seenNames = /* @__PURE__ */ new Set();
+	for (const t of clientTools) {
+		if (seenNames.has(t.name)) console.warn(`[createToolsFromClientSchemas] Duplicate tool name "${t.name}" found. Later definitions will override earlier ones.`);
+		seenNames.add(t.name);
+	}
+	return Object.fromEntries(clientTools.map((t) => [t.name, tool({
+		description: t.description ?? "",
+		inputSchema: jsonSchema(t.parameters ?? { type: "object" })
+	})]));
+}
+//#endregion
+//#region src/chat/continuation-state.ts
+/**
+* ContinuationState — shared state container for auto-continuation lifecycle.
+*
+* Tracks pending, deferred, and active continuation state for the
+* tool-result → auto-continue flow. Both AIChatAgent and Think use this
+* to manage which connection/tools/body a continuation turn should use
+* and to coordinate with clients requesting stream resume.
+*
+* The scheduling algorithm (prerequisite chaining, debounce, TurnQueue
+* enrollment) stays in the host — this class only manages the data.
+*/
+const MSG_STREAM_RESUME_NONE = CHAT_MESSAGE_TYPES.STREAM_RESUME_NONE;
+var ContinuationState = class {
+	constructor() {
+		this.pending = null;
+		this.deferred = null;
+		this.activeRequestId = null;
+		this.activeConnectionId = null;
+		this.awaitingConnections = /* @__PURE__ */ new Map();
+	}
+	/** Clear pending state and awaiting connections (without sending RESUME_NONE). */
+	clearPending() {
+		this.pending = null;
+		this.awaitingConnections.clear();
+	}
+	clearDeferred() {
+		this.deferred = null;
+	}
+	clearAll() {
+		this.clearPending();
+		this.clearDeferred();
+		this.activeRequestId = null;
+		this.activeConnectionId = null;
+	}
+	/**
+	* Send STREAM_RESUME_NONE to all connections waiting for a
+	* continuation stream to start, then clear the map.
+	*/
+	sendResumeNone() {
+		const msg = JSON.stringify({ type: MSG_STREAM_RESUME_NONE });
+		for (const connection of this.awaitingConnections.values()) connection.send(msg);
+		this.awaitingConnections.clear();
+	}
+	/**
+	* Flush awaiting connections by notifying each one via the provided
+	* callback (typically sends STREAM_RESUMING), then clear.
+	*/
+	flushAwaitingConnections(notify) {
+		for (const connection of this.awaitingConnections.values()) notify(connection);
+		this.awaitingConnections.clear();
+	}
+	/**
+	* Transition pending → active. Called when the continuation stream
+	* actually starts. Moves request/connection IDs to active slots,
+	* clears pending fields.
+	*/
+	activatePending() {
+		if (!this.pending) return;
+		this.activeRequestId = this.pending.requestId;
+		this.activeConnectionId = this.pending.connectionId;
+		this.pending = null;
+	}
+	/**
+	* Transition deferred → pending. Called when a continuation turn
+	* completes and there's a deferred follow-up waiting.
+	*
+	* Returns the new pending state (so the host can enqueue the turn),
+	* or null if there was nothing deferred.
+	*/
+	activateDeferred(generateRequestId) {
+		if (this.pending || !this.deferred) return null;
+		const d = this.deferred;
+		this.deferred = null;
+		this.activeRequestId = null;
+		this.activeConnectionId = null;
+		this.pending = {
+			connection: d.connection,
+			connectionId: d.connectionId,
+			requestId: generateRequestId(),
+			clientTools: d.clientTools,
+			body: d.body,
+			errorPrefix: d.errorPrefix,
+			prerequisite: d.prerequisite,
+			pastCoalesce: false
+		};
+		this.awaitingConnections.set(d.connectionId, d.connection);
+		return this.pending;
+	}
+};
+//#endregion
+//#region src/chat/abort-registry.ts
+/**
+* AbortRegistry — manages per-request AbortControllers.
+*
+* Shared between AIChatAgent and Think for chat turn cancellation.
+* Each request gets its own AbortController keyed by request ID.
+* Controllers are created lazily on first signal access.
+*/
+var AbortRegistry = class {
+	constructor() {
+		this.controllers = /* @__PURE__ */ new Map();
+	}
+	/**
+	* Get or create an AbortController for the given ID and return its signal.
+	* Creates the controller lazily on first access.
+	*/
+	getSignal(id) {
+		if (typeof id !== "string") return;
+		if (!this.controllers.has(id)) this.controllers.set(id, new AbortController());
+		return this.controllers.get(id).signal;
+	}
+	/**
+	* Get the signal for an existing controller without creating one.
+	* Returns undefined if no controller exists for this ID.
+	*/
+	getExistingSignal(id) {
+		return this.controllers.get(id)?.signal;
+	}
+	/** Cancel a specific request by aborting its controller. */
+	cancel(id) {
+		this.controllers.get(id)?.abort();
+	}
+	/** Remove a controller after the request completes. */
+	remove(id) {
+		this.controllers.delete(id);
+	}
+	/** Abort all pending requests and clear the registry. */
+	destroyAll() {
+		for (const controller of this.controllers.values()) controller.abort();
+		this.controllers.clear();
+	}
+	/** Check if a controller exists for the given ID. */
+	has(id) {
+		return this.controllers.has(id);
+	}
+	/** Number of tracked controllers. */
+	get size() {
+		return this.controllers.size;
+	}
+};
+//#endregion
+//#region src/chat/tool-state.ts
+/**
+* Apply a tool part update to a parts array.
+* Finds the first part matching `update.toolCallId` in one of `update.matchStates`,
+* applies the update immutably, and returns the new parts array with the index.
+*
+* Returns `null` if no matching part was found.
+*/
+function applyToolUpdate(parts, update) {
+	for (let i = 0; i < parts.length; i++) {
+		const part = parts[i];
+		if ("toolCallId" in part && part.toolCallId === update.toolCallId && "state" in part && update.matchStates.includes(part.state)) {
+			const updatedParts = [...parts];
+			updatedParts[i] = update.apply(part);
+			return {
+				parts: updatedParts,
+				index: i
+			};
+		}
+	}
+	return null;
+}
+/**
+* Build an update descriptor for applying a tool result.
+*
+* Matches parts in `input-available`, `approval-requested`, or `approval-responded` state.
+* Sets state to `output-available` (with output) or `output-error` (with errorText).
+*/
+function toolResultUpdate(toolCallId, output, overrideState, errorText) {
+	return {
+		toolCallId,
+		matchStates: [
+			"input-available",
+			"approval-requested",
+			"approval-responded"
+		],
+		apply: (part) => ({
+			...part,
+			...overrideState === "output-error" ? {
+				state: "output-error",
+				errorText: errorText ?? "Tool execution denied by user"
+			} : {
+				state: "output-available",
+				output,
+				preliminary: false
+			}
+		})
+	};
+}
+/**
+* Build an update descriptor for applying a tool approval.
+*
+* Matches parts in `input-available` or `approval-requested` state.
+* Sets state to `approval-responded` (if approved) or `output-denied` (if denied).
+*/
+function toolApprovalUpdate(toolCallId, approved) {
+	return {
+		toolCallId,
+		matchStates: ["input-available", "approval-requested"],
+		apply: (part) => ({
+			...part,
+			state: approved ? "approval-responded" : "output-denied",
+			approval: {
+				...part.approval,
+				approved
+			}
+		})
+	};
+}
+//#endregion
+//#region src/chat/parse-protocol.ts
+/**
+* Protocol Message Parser — typed parsing of cf_agent_chat_* WebSocket messages.
+*
+* Parses raw WebSocket messages into a discriminated union of protocol events.
+* Both AIChatAgent and Think can use this instead of manual JSON.parse + type checking.
+*/
+/**
+* Parse a raw WebSocket message string into a typed protocol event.
+*
+* Returns `null` if the message is not valid JSON or not a recognized
+* protocol message type. Callers should fall through to the user's
+* `onMessage` handler when `null` is returned.
+*
+* @example
+* ```typescript
+* const event = parseProtocolMessage(rawMessage);
+* if (!event) return userOnMessage(connection, rawMessage);
+*
+* switch (event.type) {
+*   case "chat-request": { ... }
+*   case "clear": { ... }
+*   case "tool-result": { ... }
+* }
+* ```
+*/
+function parseProtocolMessage(raw) {
+	let data;
+	try {
+		data = JSON.parse(raw);
+	} catch {
+		return null;
+	}
+	const wireType = data.type;
+	if (!wireType) return null;
+	switch (wireType) {
+		case CHAT_MESSAGE_TYPES.USE_CHAT_REQUEST: return {
+			type: "chat-request",
+			id: data.id,
+			init: data.init ?? {}
+		};
+		case CHAT_MESSAGE_TYPES.CHAT_CLEAR: return { type: "clear" };
+		case CHAT_MESSAGE_TYPES.CHAT_REQUEST_CANCEL: return {
+			type: "cancel",
+			id: data.id
+		};
+		case CHAT_MESSAGE_TYPES.TOOL_RESULT: return {
+			type: "tool-result",
+			toolCallId: data.toolCallId,
+			toolName: data.toolName ?? "",
+			output: data.output,
+			state: data.state,
+			errorText: data.errorText,
+			autoContinue: data.autoContinue,
+			clientTools: data.clientTools
+		};
+		case CHAT_MESSAGE_TYPES.TOOL_APPROVAL: return {
+			type: "tool-approval",
+			toolCallId: data.toolCallId,
+			approved: data.approved,
+			autoContinue: data.autoContinue
+		};
+		case CHAT_MESSAGE_TYPES.STREAM_RESUME_REQUEST: return { type: "stream-resume-request" };
+		case CHAT_MESSAGE_TYPES.STREAM_RESUME_ACK: return {
+			type: "stream-resume-ack",
+			id: data.id
+		};
+		case CHAT_MESSAGE_TYPES.CHAT_MESSAGES: return {
+			type: "messages",
+			messages: data.messages ?? []
+		};
+		default: return null;
+	}
+}
+//#endregion
+export { AbortRegistry, CHAT_MESSAGE_TYPES, ContinuationState, ROW_MAX_BYTES, ResumableStream, StreamAccumulator, TurnQueue, applyChunkToParts, applyToolUpdate, transition as broadcastTransition, byteLength, createToolsFromClientSchemas, enforceRowSizeLimit, parseProtocolMessage, sanitizeMessage, toolApprovalUpdate, toolResultUpdate };
+
+//# sourceMappingURL=index.js.map