agents 0.13.2 → 0.14.0

package/dist/chat/index.js

@@ -1,5 +1,5 @@
 import { i as isReplayChunk, n as createAgentToolEventState, r as applyChunkToParts, t as applyAgentToolEvent } from "../agent-tools-BAdX1vdI.js";
-import { t as truncateToolOutput } from "../tool-output-truncation-CH-khbZ3.js";
+import { t as truncateToolOutput } from "../tool-output-truncation-BF4AZQlw.js";
 import { jsonSchema, tool } from "ai";
 import { nanoid } from "nanoid";
 //#region src/chat/sanitize.ts
@@ -520,7 +520,8 @@ const CHAT_MESSAGE_TYPES = {
 	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"
+	MESSAGE_UPDATED: "cf_agent_message_updated",
+	CHAT_RECOVERING: "cf_agent_chat_recovering"
 };
 //#endregion
 //#region src/chat/resumable-stream.ts
@@ -969,6 +970,22 @@ var ContinuationState = class {
 		this.activeConnectionId = null;
 	}
 	/**
+	* Mark a connection as no longer available without canceling the
+	* continuation it initiated.
+	*/
+	releaseConnection(connectionId) {
+		this.awaitingConnections.delete(connectionId);
+		if (this.pending?.connectionId === connectionId) this.pending = {
+			...this.pending,
+			connectionId: null
+		};
+		if (this.deferred?.connectionId === connectionId) this.deferred = {
+			...this.deferred,
+			connectionId: null
+		};
+		if (this.activeConnectionId === connectionId) this.activeConnectionId = null;
+	}
+	/**
 	* Send STREAM_RESUME_NONE to all connections waiting for a
 	* continuation stream to start, then clear the map.
 	*/
@@ -1019,7 +1036,7 @@ var ContinuationState = class {
 			prerequisite: d.prerequisite,
 			pastCoalesce: false
 		};
-		this.awaitingConnections.set(d.connectionId, d.connection);
+		if (d.connectionId !== null) this.awaitingConnections.set(d.connectionId, d.connection);
 		return this.pending;
 	}
 };
@@ -1172,6 +1189,60 @@ function toolResultUpdate(toolCallId, output, overrideState, errorText) {
 	};
 }
 /**
+* Build an update descriptor for a terminal tool result that belongs to a
+* tool part in a *different* (earlier) assistant message than the one
+* currently being streamed.
+*
+* This is the "cross-message" case: an approved server tool executes during a
+* continuation stream, but its tool part lives in the assistant message that
+* originally requested it. `StreamAccumulator` surfaces this as a
+* `cross-message-tool-update` action because the accumulator only owns the
+* current turn's new content and cannot mutate a part from a prior message.
+*
+* Compared to {@link toolResultUpdate} this builder is deliberately more
+* defensive, mirroring the equivalent fallback in `@cloudflare/ai-chat`:
+*
+* - It matches the broad set of pre-terminal **and** terminal states, so a
+*   provider that replays the entire prior tool round-trip during a
+*   continuation (notably the OpenAI Responses API — issue #1404) still
+*   resolves to the same part instead of silently missing it.
+* - It is **first-write-wins**: a chunk arriving for a tool that already holds
+*   a terminal result is treated as a replay and the existing output is never
+*   overwritten. In that case `apply` returns the *same part reference*, which
+*   callers use as an idempotent-no-op signal to skip the durable write and a
+*   redundant `MESSAGE_UPDATED` broadcast.
+* - It preserves a streamed `preliminary` flag when one is present, otherwise
+*   marks the result final (`preliminary: false`).
+*/
+function crossMessageToolResultUpdate(toolCallId, updateType, output, errorText, preliminary) {
+	return {
+		toolCallId,
+		matchStates: [
+			"input-streaming",
+			"input-available",
+			"approval-requested",
+			"approval-responded",
+			"output-available",
+			"output-error",
+			"output-denied"
+		],
+		apply: (part) => {
+			if (part.state === "output-available" || part.state === "output-error" || part.state === "output-denied") return part;
+			if (updateType === "output-error") return {
+				...part,
+				state: "output-error",
+				errorText: errorText ?? "Tool execution failed"
+			};
+			return {
+				...part,
+				state: "output-available",
+				output,
+				preliminary: preliminary ?? false
+			};
+		}
+	};
+}
+/**
 * Build an update descriptor for applying a tool approval.
 *
 * Matches parts in `input-available` or `approval-requested` state.
@@ -1311,23 +1382,35 @@ function assistantContentKey(message, sanitize) {
 	return JSON.stringify(sanitized.parts);
 }
 function mergeServerToolOutputs(incoming, serverMessages) {
-	const serverToolOutputs = /* @__PURE__ */ new Map();
+	const serverResolvedParts = /* @__PURE__ */ new Map();
 	for (const msg of serverMessages) {
 		if (msg.role !== "assistant") continue;
-		for (const part of msg.parts) if ("toolCallId" in part && "state" in part && part.state === "output-available" && "output" in part) serverToolOutputs.set(part.toolCallId, part.output);
+		for (const part of msg.parts) {
+			const record = part;
+			if ("toolCallId" in record && "state" in record && (record.state === "output-available" || record.state === "output-error" || record.state === "output-denied")) serverResolvedParts.set(record.toolCallId, record);
+		}
 	}
-	if (serverToolOutputs.size === 0) return incoming;
+	if (serverResolvedParts.size === 0) return incoming;
 	return incoming.map((msg) => {
 		if (msg.role !== "assistant") return msg;
 		let hasChanges = false;
 		const updatedParts = msg.parts.map((part) => {
-			if ("toolCallId" in part && "state" in part && (part.state === "input-available" || part.state === "approval-requested" || part.state === "approval-responded") && serverToolOutputs.has(part.toolCallId)) {
+			const record = part;
+			if ("toolCallId" in record && "state" in record && (record.state === "input-available" || record.state === "approval-requested" || record.state === "approval-responded") && serverResolvedParts.has(record.toolCallId)) {
 				hasChanges = true;
-				return {
+				const server = serverResolvedParts.get(record.toolCallId);
+				const merged = {
 					...part,
-					state: "output-available",
-					output: serverToolOutputs.get(part.toolCallId)
+					state: server.state
 				};
+				if (server.state === "output-available") {
+					if ("output" in server) merged.output = server.output;
+				} else if (server.state === "output-error") {
+					if ("errorText" in server) merged.errorText = server.errorText;
+				} else if (server.state === "output-denied") {
+					if ("approval" in server) merged.approval = server.approval;
+				}
+				return merged;
 			}
 			return part;
 		});
@@ -1378,6 +1461,56 @@ function findMessageByToolCallId(messages, toolCallId) {
 	}
 }
 //#endregion
-export { AbortRegistry, CHAT_MESSAGE_TYPES, ContinuationState, ROW_MAX_BYTES, ResumableStream, StreamAccumulator, SubmitConcurrencyController, TurnQueue, applyAgentToolEvent, applyChunkToParts, applyToolUpdate, assistantContentKey, transition as broadcastTransition, byteLength, createAgentToolEventState, createToolsFromClientSchemas, enforceRowSizeLimit, isReplayChunk, parseProtocolMessage, reconcileMessages, resolveToolMergeId, sanitizeMessage, toolApprovalUpdate, toolResultUpdate };
+//#region src/chat/recovery.ts
+function createChatFiberSnapshot({ kind, requestId, recoveryRootRequestId, continuation, messages, lastBody, lastClientTools }) {
+	const latestMessage = messages.length > 0 ? messages[messages.length - 1] : void 0;
+	let latestUser;
+	for (let index = messages.length - 1; index >= 0; index--) if (messages[index].role === "user") {
+		latestUser = messages[index];
+		break;
+	}
+	return {
+		kind,
+		version: 1,
+		requestId,
+		recoveryRootRequestId,
+		continuation,
+		latestMessageId: latestMessage?.id,
+		latestMessageRole: latestMessage?.role,
+		latestUserMessageId: latestUser?.id,
+		startedAt: Date.now(),
+		lastBody,
+		lastClientTools
+	};
+}
+function wrapChatFiberSnapshot(key, snapshot, user) {
+	return {
+		[key]: snapshot,
+		user
+	};
+}
+function unwrapChatFiberSnapshot(key, value, expectedKind) {
+	if (typeof value !== "object" || value === null || !(key in value)) return {
+		snapshot: null,
+		user: value
+	};
+	const envelope = value;
+	const snapshot = envelope[key];
+	if (typeof snapshot !== "object" || snapshot === null) return {
+		snapshot: null,
+		user: value
+	};
+	const candidate = snapshot;
+	if (candidate.version !== 1 || expectedKind !== void 0 && candidate.kind !== expectedKind || typeof candidate.requestId !== "string" || typeof candidate.continuation !== "boolean") return {
+		snapshot: null,
+		user: value
+	};
+	return {
+		snapshot,
+		user: envelope.user ?? null
+	};
+}
+//#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, parseProtocolMessage, reconcileMessages, resolveToolMergeId, sanitizeMessage, toolApprovalUpdate, toolResultUpdate, unwrapChatFiberSnapshot, wrapChatFiberSnapshot };
 
 //# sourceMappingURL=index.js.map