agents/dist/broadcast-state-CEyI4uAK.js

A home for your AI agents

import { r as StreamAccumulator } from "./protocol-eXeJxhgu.js";
//#region src/chat/broadcast-state.ts
function textOf(parts) {
	let text = "";
	for (const part of parts) if (part.type === "text") text += part.text;
	return text;
}
/**
* Whether `messages` already holds a copy of the observed message whose text
* the accumulator does not extend. A healthy live accumulator is always the
* stored copy plus more; one that diverges holds interleaved or duplicated
* chunks (#2166), so the stored copy must win or the corruption never heals.
*/
function observedDivergesFrom(accumulator, messages) {
	const existing = messages.find((m) => m.id === accumulator.messageId);
	if (!existing) return false;
	return !textOf(accumulator.parts).startsWith(textOf(existing.parts));
}
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;
			const isReplayedStart = event.replay === true && event.chunkData?.type === "start";
			if (state.status === "idle" || state.streamId !== event.streamId || isReplayedStart) accumulator = new StreamAccumulator({
				messageId: event.messageId,
				continuation: event.continuation
			});
			else accumulator = state.accumulator;
			if (event.chunkData) accumulator.applyChunk(event.chunkData);
			let messagesUpdate;
			const mergeUnlessDiverged = (prev) => observedDivergesFrom(accumulator, prev) ? prev : accumulator.mergeInto(prev);
			if (event.done) return {
				state: { status: "idle" },
				messagesUpdate: mergeUnlessDiverged,
				isStreaming: false
			};
			if (event.chunkData && !event.replay) messagesUpdate = mergeUnlessDiverged;
			else if (event.replayComplete) messagesUpdate = (prev) => accumulator.mergeInto(prev);
			return {
				state: {
					status: "observing",
					streamId: event.streamId,
					accumulator
				},
				messagesUpdate,
				isStreaming: true
			};
		}
	}
}
//#endregion
export { transition as n, observedDivergesFrom as t };

//# sourceMappingURL=broadcast-state-CEyI4uAK.js.map