agents 0.14.5 → 0.16.0

package/dist/chat/index.js

@@ -456,7 +456,8 @@ function transition(state, event) {
 		}
 		case "response": {
 			let accumulator;
-			if (state.status === "idle" || state.streamId !== event.streamId) {
+			const isReplayedStart = event.replay === true && event.chunkData?.type === "start";
+			if (state.status === "idle" || state.streamId !== event.streamId || isReplayedStart) {
 				let messageId = event.messageId;
 				let existingParts;
 				let existingMetadata;
@@ -550,8 +551,28 @@ const CHUNK_BUFFER_MAX_SIZE = 100;
 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;
+/**
+* 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).
+*/
+const COMPLETED_RETENTION_MS = 600 * 1e3;
+/**
+* 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.
+*/
+const ABANDONED_STREAM_RETENTION_MS = 3600 * 1e3;
 /** Shared encoder for UTF-8 byte length measurement */
 const textEncoder = new TextEncoder();
 /**
@@ -588,6 +609,7 @@ var ResumableStream = class ResumableStream {
 		this._activeRequestId = null;
 		this._segmentIndex = 0;
 		this._isLive = false;
+		this._activeIsContinuation = false;
 		this._chunkBuffer = [];
 		this._chunkBufferBytes = 0;
 		this._isFlushingChunks = false;
@@ -618,9 +640,11 @@ var ResumableStream = class ResumableStream {
 	* error-driven control flow.
 	*/
 	_migrateMetadataColumns() {
-		if (!(this.sql`
+		const columns = this.sql`
         select name from pragma_table_info('cf_ai_chat_stream_metadata')
-      ` ?? []).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 === "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`;
 	}
 	get activeStreamId() {
 		return this._activeStreamId;
@@ -651,10 +675,11 @@ var ResumableStream = class ResumableStream {
 		this._activeRequestId = requestId;
 		this._segmentIndex = 0;
 		this._isLive = true;
+		this._activeIsContinuation = options.continuation ?? false;
 		const messageId = options.messageId ?? null;
 		this.sql`
-      insert into cf_ai_chat_stream_metadata (id, request_id, status, created_at, message_id)
-      values (${streamId}, ${requestId}, 'streaming', ${Date.now()}, ${messageId})
+      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})
     `;
 		return streamId;
 	}
@@ -687,6 +712,7 @@ var ResumableStream = class ResumableStream {
 		this._activeRequestId = null;
 		this._segmentIndex = 0;
 		this._isLive = false;
+		this._activeIsContinuation = false;
 		this._maybeCleanupOldStreams();
 	}
 	/**
@@ -704,6 +730,7 @@ var ResumableStream = class ResumableStream {
 		this._activeRequestId = null;
 		this._segmentIndex = 0;
 		this._isLive = false;
+		this._activeIsContinuation = false;
 	}
 	/**
 	* Buffer a stream chunk for batch write to SQLite.
@@ -780,6 +807,7 @@ var ResumableStream = class ResumableStream {
 		const streamId = this._activeStreamId;
 		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} 
@@ -790,7 +818,8 @@ var ResumableStream = class ResumableStream {
 			done: false,
 			id: requestId,
 			type: CHAT_MESSAGE_TYPES.USE_CHAT_RESPONSE,
-			replay: true
+			replay: true,
+			...continuation && { continuation: true }
 		}))) return null;
 		if (this._activeStreamId !== streamId) {
 			sendIfOpen$1(connection, JSON.stringify({
@@ -798,7 +827,8 @@ var ResumableStream = class ResumableStream {
 				done: true,
 				id: requestId,
 				type: CHAT_MESSAGE_TYPES.USE_CHAT_RESPONSE,
-				replay: true
+				replay: true,
+				...continuation && { continuation: true }
 			}));
 			return null;
 		}
@@ -808,7 +838,8 @@ var ResumableStream = class ResumableStream {
 				done: true,
 				id: requestId,
 				type: CHAT_MESSAGE_TYPES.USE_CHAT_RESPONSE,
-				replay: true
+				replay: true,
+				...continuation && { continuation: true }
 			}));
 			this.complete(streamId);
 			return streamId;
@@ -819,23 +850,65 @@ var ResumableStream = class ResumableStream {
 			id: requestId,
 			type: CHAT_MESSAGE_TYPES.USE_CHAT_RESPONSE,
 			replay: true,
-			replayComplete: true
+			replayComplete: true,
+			...continuation && { continuation: true }
 		}));
 		return 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$1(connection, JSON.stringify({
+			body: "",
+			done: true,
+			id: requestId,
+			type: CHAT_MESSAGE_TYPES.USE_CHAT_RESPONSE,
+			replay: true,
+			...continuation && { continuation: true }
+		}));
+	}
+	/**
+	* Replay the stored chunks of an errored stream for a request, WITHOUT a
+	* terminal frame — the caller follows up with the `done: true, error: true`
+	* 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).
+	*
+	* Returns true when the caller should proceed to send its terminal frame:
+	* either no errored stream existed (nothing to replay) or its chunks were
+	* replayed successfully. Returns false only when a send failed mid-replay,
+	* signalling the caller to skip the terminal frame — the connection is gone
+	* 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();
-		const stream = this.sql`
+		return this.sql`
       select * from cf_ai_chat_stream_metadata
       where request_id = ${requestId}
-      and status = 'completed'
+      and status = ${status}
       order by created_at desc
       limit 1
     `[0];
-		if (!stream) return false;
+	}
+	/**
+	* Send a finished stream's stored chunks to a connection as replay frames.
+	* Returns false if the connection closed mid-replay.
+	*/
+	_replayStoredChunks(connection, streamId, requestId, continuation = false) {
 		const chunks = this.sql`
       select * from cf_ai_chat_stream_chunks
-      where stream_id = ${stream.id}
+      where stream_id = ${streamId}
       order by chunk_index asc
     `;
 		for (const chunk of chunks || []) for (const body of unpackSegmentBody(chunk.body)) if (!sendIfOpen$1(connection, JSON.stringify({
@@ -843,15 +916,10 @@ var ResumableStream = class ResumableStream {
 			done: false,
 			id: requestId,
 			type: CHAT_MESSAGE_TYPES.USE_CHAT_RESPONSE,
-			replay: true
+			replay: true,
+			...continuation && { continuation: true }
 		}))) return false;
-		return sendIfOpen$1(connection, JSON.stringify({
-			body: "",
-			done: true,
-			id: requestId,
-			type: CHAT_MESSAGE_TYPES.USE_CHAT_RESPONSE,
-			replay: true
-		}));
+		return true;
 	}
 	/**
 	* Restore active stream state if the agent was restarted during streaming.
@@ -869,6 +937,7 @@ var ResumableStream = class ResumableStream {
 			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 
@@ -888,6 +957,7 @@ var ResumableStream = class ResumableStream {
 		this._activeStreamId = null;
 		this._activeRequestId = null;
 		this._segmentIndex = 0;
+		this._activeIsContinuation = false;
 	}
 	/**
 	* Drop all stream tables (called on destroy).
@@ -898,33 +968,76 @@ var ResumableStream = class ResumableStream {
 		this.sql`drop table if exists cf_ai_chat_stream_metadata`;
 		this._activeStreamId = null;
 		this._activeRequestId = null;
+		this._activeIsContinuation = false;
+	}
+	/**
+	* 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;
-		const cutoff = now - CLEANUP_AGE_THRESHOLD_MS;
+		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 < ${cutoff}
+        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 < ${cutoff}
+      where status in ('completed', 'error') and completed_at < ${completedCutoff}
     `;
+		const abandonedCutoff = now - ABANDONED_STREAM_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 = 'streaming' and created_at < ${cutoff}
+        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 status = 'streaming' and created_at < ${cutoff}
+      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}
+      )
     `;
 	}
 	/**
@@ -970,6 +1083,19 @@ var ResumableStream = class ResumableStream {
       values (${streamId}, ${requestId}, 'streaming', ${createdAt})
     `;
 	}
+	/**
+	* 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.
+	* @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})
+    `;
+	}
 };
 ResumableStream.CHUNK_MAX_BYTES = 18e5;
 //#endregion
@@ -1015,22 +1141,35 @@ function buildInClauseStrings(prefix, count) {
 /**
 * 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.
+* By default these tools have no `execute` function — when the AI model calls
+* them, the tool call is sent back to the client for execution.
+*
+* When `options.execute` is provided, each tool is built WITH an `execute` that
+* delegates to it. This is used by the RPC path (e.g. a parent agent driving a
+* Think sub-agent) so the model's client-tool call is resolved inline within
+* the same turn.
 *
 * @param clientTools - Array of tool schemas from the client
+* @param options - Optional `execute` delegate to run the tools inline
 * @returns Record of AI SDK tools that can be spread into your tools object
 */
-function createToolsFromClientSchemas(clientTools) {
+function createToolsFromClientSchemas(clientTools, options) {
 	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({
+	const execute = options?.execute;
+	const createTool = tool;
+	return Object.fromEntries(clientTools.map((t) => [t.name, createTool({
 		description: t.description ?? "",
-		inputSchema: jsonSchema(t.parameters ?? { type: "object" })
+		inputSchema: jsonSchema(t.parameters ?? { type: "object" }),
+		...execute ? { execute: (input, executeOptions) => execute({
+			toolName: t.name,
+			input,
+			toolCallId: executeOptions?.toolCallId ?? ""
+		}) } : {}
 	})]));
 }
 //#endregion
@@ -1359,6 +1498,39 @@ function crossMessageToolResultUpdate(toolCallId, updateType, output, errorText,
 	};
 }
 /**
+* Build an update descriptor that replaces the output of a *paused durable
+* execution* tool part (e.g. a codemode runtime tool that paused for
+* approval).
+*
+* A paused execution completes its tool call normally — the part is already
+* `output-available` with an output of `{ status: "paused", executionId }`.
+* When the host later approves/rejects the execution, the new outcome
+* (completed / rejected / paused-again) must replace that output in place.
+*
+* Matching is deliberately narrow and idempotent:
+*
+* - only `output-available` parts are considered;
+* - the existing output must be a paused-execution object carrying the same
+*   `executionId` — anything else (already replaced, different execution)
+*   returns the *same part reference*, which callers treat as a no-op signal
+*   (skip persist + broadcast), mirroring {@link crossMessageToolResultUpdate}.
+*/
+function pausedExecutionUpdate(toolCallId, executionId, output) {
+	return {
+		toolCallId,
+		matchStates: ["output-available"],
+		apply: (part) => {
+			const current = part.output;
+			if (current == null || typeof current !== "object" || current.status !== "paused" || current.executionId !== executionId) return part;
+			return {
+				...part,
+				output,
+				preliminary: false
+			};
+		}
+	};
+}
+/**
 * Build an update descriptor for applying a tool approval.
 *
 * Matches parts in `input-available` or `approval-requested` state.
@@ -1627,6 +1799,6 @@ function unwrapChatFiberSnapshot(key, value, expectedKind) {
 	};
 }
 //#endregion
-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 };
+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, pausedExecutionUpdate, reconcileMessages, resolveToolMergeId, sanitizeMessage, toolApprovalUpdate, toolResultUpdate, unwrapChatFiberSnapshot, wrapChatFiberSnapshot };
 
 //# sourceMappingURL=index.js.map