eve 0.58.0 → 0.59.0

package/dist/src/chunks/{use-eve-agent-X0asmJg-.js → use-eve-agent-Dmc6sX4d.js}

@@ -686,17 +686,6 @@ function isTurnFailureEvent(event) {
 	return event.type === "session.failed" || event.type === "step.failed" || event.type === "turn.failed";
 }
 
-//#endregion
-//#region src/client/output-schema.ts
-function extractCompletedResult(events) {
-	let result;
-	for (const event of events) if (isResultCompletedEvent(event)) result = event.data.result;
-	return result;
-}
-function isResultCompletedEvent(event) {
-	return event.type === "result.completed";
-}
-
 //#endregion
 //#region src/client/session-utils.ts
 function summarizeTurnEvents(events) {
@@ -725,9 +714,25 @@ function summarizeTurnEvents(events) {
 function isFinalMessageCompleted(event) {
 	return event.type === "message.completed" && event.data.finishReason !== "tool-calls";
 }
+function updatePendingAuthorizations(pending, event) {
+	if (event.type === "authorization.required" && event.data.webhookUrl !== void 0) pending.add(event.data.name);
+	else if (event.type === "authorization.completed") pending.delete(event.data.name);
+}
+
+//#endregion
+//#region src/client/output-schema.ts
+function extractCompletedResult(events) {
+	let result;
+	for (const event of events) if (isResultCompletedEvent(event)) result = event.data.result;
+	return result;
+}
+function isResultCompletedEvent(event) {
+	return event.type === "result.completed";
+}
 
 //#endregion
 //#region src/client/message-response.ts
+const consumeResponse = Symbol("consumeMessageResponse");
 var MessageResponse = class {
 	sessionId;
 	#cancelTurn;
@@ -765,13 +770,16 @@ var MessageResponse = class {
 		};
 	}
 	[Symbol.asyncIterator]() {
+		return this[consumeResponse]();
+	}
+	[consumeResponse](source) {
 		if (this.#consumed) throw new Error("MessageResponse has already been consumed.");
 		this.#consumed = true;
-		return this.#observeStream();
+		return this.#observeStream(source);
 	}
-	async *#observeStream() {
+	async *#observeStream(source) {
 		try {
-			for await (const event of this.#createStream()) {
+			for await (const event of this.#createStream(source)) {
 				if (event.type === "turn.started") this.#turnId.resolve(event.data.turnId);
 				else if (isCurrentTurnBoundaryEvent(event)) {
 					this.#settled = true;
@@ -784,6 +792,9 @@ var MessageResponse = class {
 		}
 	}
 };
+function consumeMessageResponse(response, source) {
+	return response[consumeResponse](source);
+}
 
 //#endregion
 //#region src/protocol/message-version.ts
@@ -893,9 +904,15 @@ async function* readNdjsonStream(body, options) {
 	const decoder = new TextDecoder();
 	let buffer = "";
 	let reachedEof = false;
+	const abort = () => {
+		reader.cancel().catch(() => {});
+	};
+	options.signal?.addEventListener("abort", abort, { once: true });
 	try {
 		while (true) {
+			options.signal?.throwIfAborted();
 			const result = await readWithIdleTimeout(reader, options?.idleTimeoutMs);
+			options.signal?.throwIfAborted();
 			if (result.done) {
 				reachedEof = true;
 				buffer += decoder.decode();
@@ -921,6 +938,7 @@ async function* readNdjsonStream(body, options) {
 			else yield parseMessageStreamEvent(value, options.streamVersion);
 		}
 	} finally {
+		options.signal?.removeEventListener("abort", abort);
 		if (!reachedEof) reader.cancel().catch(() => {});
 		reader.releaseLock();
 	}
@@ -1065,45 +1083,56 @@ function resolveRetryPolicy(policy, defaults) {
 		...policy
 	};
 }
-function resolveStreamReconnectPolicy(policy) {
+function resolveStreamReconnectPolicy(policy, keepAlive = false) {
 	if (policy && "reconnect" in policy && policy.reconnect === false) return NO_STREAM_RECONNECT_POLICY;
 	const configured = policy;
 	return {
 		retryableErrorStatuses: configured?.retryableErrorStatuses ? new Set(configured.retryableErrorStatuses) : DEFAULT_STREAM_RECONNECT_POLICY.retryableErrorStatuses,
-		streamIdleReconnectPolicy: resolveRetryPolicy(configured?.streamIdleReconnectPolicy, DEFAULT_STREAM_RECONNECT_POLICY.streamIdleReconnectPolicy),
+		streamIdleReconnectPolicy: resolveRetryPolicy(configured?.streamIdleReconnectPolicy, {
+			...DEFAULT_STREAM_RECONNECT_POLICY.streamIdleReconnectPolicy,
+			maxAttempts: keepAlive ? Infinity : DEFAULT_STREAM_RECONNECT_POLICY.streamIdleReconnectPolicy.maxAttempts
+		}),
 		streamOpenReconnectPolicy: resolveRetryPolicy(configured?.streamOpenReconnectPolicy, DEFAULT_STREAM_RECONNECT_POLICY.streamOpenReconnectPolicy)
 	};
 }
 async function* followStreamIterable(input) {
 	if (input.follow === false && input.startIndex < 0) throw new Error("stream({ follow: false }) requires a nonnegative startIndex; a tail-relative cursor cannot be bounded.");
-	const retryPolicy = resolveStreamReconnectPolicy(input.streamReconnectPolicy);
-	const idleRetryPolicy = retryPolicy.streamIdleReconnectPolicy;
+	const resolvePolicy = () => resolveStreamReconnectPolicy(input.resolveReconnectPolicy === void 0 ? input.streamReconnectPolicy : input.resolveReconnectPolicy(), input.keepAlive);
+	let retryPolicy = resolvePolicy();
+	let idleRetryPolicy = retryPolicy.streamIdleReconnectPolicy;
 	let startIndex = input.startIndex;
 	let reconnectDelayMs = idleRetryPolicy.baseDelayMs;
 	let idleReconnects = 0;
 	let initialConnection = true;
 	let tailIndex;
+	let caughtUp = false;
 	while (true) {
+		retryPolicy = resolvePolicy();
+		idleRetryPolicy = retryPolicy.streamIdleReconnectPolicy;
 		let connection;
 		try {
 			connection = await openStreamBody({
 				...input,
 				retryPolicy,
 				startIndex,
-				requestTailIndex: input.follow === false && tailIndex === void 0
+				requestTailIndex: (input.follow === false || input.onCaughtUp !== void 0) && tailIndex === void 0
 			});
 		} catch (error) {
 			if (input.signal?.aborted) return;
 			throw error;
 		}
-		if (input.follow === false && tailIndex === void 0) {
+		if ((input.follow === false || input.onCaughtUp !== void 0) && tailIndex === void 0) {
 			tailIndex = connection.tailIndex;
 			if (tailIndex === void 0) {
 				connection.close();
 				throw new Error(`stream({ follow: false }) requires the server to report the ${EVE_STREAM_TAIL_INDEX_HEADER} header. The agent may be running an older eve version.`);
 			}
 		}
-		if (tailIndex !== void 0 && startIndex > tailIndex) {
+		if (!caughtUp && tailIndex !== void 0 && startIndex > tailIndex) {
+			caughtUp = true;
+			input.onCaughtUp?.();
+		}
+		if (input.follow === false && tailIndex !== void 0 && startIndex > tailIndex) {
 			connection.close();
 			return;
 		}
@@ -1111,6 +1140,7 @@ async function* followStreamIterable(input) {
 		let leaseEnded = false;
 		try {
 			for await (const event of readNdjsonStream(connection.body, {
+				signal: input.signal,
 				controlVersion: connection.controlVersion,
 				idleTimeoutMs: input.streamReadIdleTimeoutMs ?? DEFAULT_STREAM_READ_IDLE_TIMEOUT_MS,
 				onLeaseEnded: () => {
@@ -1123,16 +1153,21 @@ async function* followStreamIterable(input) {
 				reconnectDelayMs = idleRetryPolicy.baseDelayMs;
 				idleReconnects = 0;
 				yield event;
-				if (tailIndex !== void 0 && startIndex > tailIndex) return;
+				if (!caughtUp && tailIndex !== void 0 && startIndex > tailIndex) {
+					caughtUp = true;
+					input.onCaughtUp?.();
+				}
+				if (input.follow === false && tailIndex !== void 0 && startIndex > tailIndex) return;
 			}
 		} catch (error) {
 			if (!isStreamDisconnectError(error)) throw error;
 		} finally {
 			connection.close();
 		}
+		idleRetryPolicy = resolvePolicy().streamIdleReconnectPolicy;
 		if (input.signal?.aborted || input.startIndex < 0 || idleRetryPolicy.maxAttempts === 0) return;
 		if (leaseEnded) continue;
-		if (input.keepAlive !== true && !deliveredEvent && !initialConnection && (idleReconnects += 1) >= idleRetryPolicy.maxAttempts) return;
+		if (!deliveredEvent && !initialConnection && (idleReconnects += 1) >= idleRetryPolicy.maxAttempts) return;
 		initialConnection = false;
 		await sleep(reconnectDelayMs, input.signal);
 		if (input.signal?.aborted) return;
@@ -1140,7 +1175,7 @@ async function* followStreamIterable(input) {
 	}
 }
 async function openStreamBody(input) {
-	const retryPolicy = input.retryPolicy ?? resolveStreamReconnectPolicy(input.streamReconnectPolicy);
+	const retryPolicy = input.retryPolicy ?? resolveStreamReconnectPolicy(input.streamReconnectPolicy, input.keepAlive);
 	const openRetryPolicy = retryPolicy.streamOpenReconnectPolicy;
 	let lastStatus;
 	let lastBody;
@@ -1152,8 +1187,10 @@ async function openStreamBody(input) {
 	if (input.startIndex !== 0) searchParams.startIndex = String(input.startIndex);
 	if (input.requestTailIndex === true) searchParams.includeTailIndex = "1";
 	for (let attempt = 0; attempt < openRetryPolicy.maxAttempts; attempt += 1) {
+		input.signal?.throwIfAborted();
 		const url = createClientUrl(input.host, createEveSessionStreamRoutePath(input.sessionId), Object.keys(searchParams).length > 0 ? searchParams : void 0);
 		const headers = await input.resolveHeaders();
+		input.signal?.throwIfAborted();
 		const connectionController = new AbortController();
 		const signal = input.signal ? AbortSignal.any([input.signal, connectionController.signal]) : connectionController.signal;
 		let response;
@@ -1434,8 +1471,10 @@ function getStandardSchemaProperties(value) {
 
 //#endregion
 //#region src/client/session.ts
-const SESSION_SEND_RETRY_COUNT = 3;
 const SESSION_SEND_RETRY_BASE_DELAY_MS = 250;
+const SESSION_SEND_RETRY_MAX_DELAY_MS = 2e3;
+const SESSION_SEND_READY_TIMEOUT_MS = 2e4;
+const followSession = Symbol("followClientSession");
 var ClientSession = class ClientSession {
 	#context;
 	#state;
@@ -1455,6 +1494,13 @@ var ClientSession = class ClientSession {
 			session
 		};
 	}
+	static async prewarm(context, options = {}) {
+		const { sessionId } = await readAcceptedMessage(await postCreateSession(context, options));
+		return new ClientSession(context, {
+			sessionId,
+			streamIndex: 0
+		});
+	}
 	get state() {
 		return this.#state;
 	}
@@ -1488,10 +1534,10 @@ var ClientSession = class ClientSession {
 			inputResponses
 		}, false);
 	}
-	async #send(input, retrySessionNotActive) {
+	async #send(input, retrySessionNotReady) {
 		const initialStreamIndex = this.#state.streamIndex;
 		const path = createEveSessionRoutePath(this.#state.sessionId);
-		const response = retrySessionNotActive ? await postSessionSend(this.#context, path, input) : await postTurn(this.#context, path, input, false);
+		const response = retrySessionNotReady ? await postSessionSend(this.#context, path, input) : await postTurn(this.#context, path, input, false);
 		const { sessionId: responseSessionId, deliveryId } = await readAcceptedMessage(response, this.#state.sessionId);
 		if (responseSessionId !== this.#state.sessionId) throw new Error("Message route returned a different session id.");
 		if (input.message !== void 0 && deliveryId === void 0) throw new Error("Message route did not return a delivery id. Update the server before sending with this client.");
@@ -1527,23 +1573,29 @@ var ClientSession = class ClientSession {
 		if (options?.follow === false && (options.startIndex ?? this.#state.streamIndex) < 0) throw new Error("stream({ follow: false }) requires a nonnegative startIndex; a tail-relative cursor cannot be bounded.");
 		return this.#streamAndAdvance(options);
 	}
+	[followSession](options) {
+		return this.#streamAndAdvance({
+			...options,
+			keepAlive: true
+		});
+	}
 	#messageResponse(response, input, initialStreamIndex, deliveryId) {
 		response.body?.cancel().catch(() => {});
 		return new MessageResponse({
 			cancelTurn: async (turnId) => await this.cancel({ turnId }),
-			createStream: () => this.#createEventStream(initialStreamIndex, input, deliveryId),
+			createStream: (source) => this.#createEventStream(initialStreamIndex, input, deliveryId, source),
 			sessionId: this.#state.sessionId
 		});
 	}
-	async *#createEventStream(initialStreamIndex, input, deliveryId) {
+	async *#createEventStream(initialStreamIndex, input, deliveryId, source) {
 		let eventCount = 0;
 		let started = deliveryId === void 0;
 		let reachedBoundary = false;
 		const pendingAuthorizations = /* @__PURE__ */ new Set();
 		try {
-			for await (const event of this.#readStream({
+			for await (const event of source ?? this.#readStream({
 				headers: input.headers,
-				keepAlive: shouldKeepActiveTurnAlive(input.streamReconnectPolicy),
+				keepAlive: true,
 				signal: input.signal,
 				startIndex: initialStreamIndex,
 				streamReconnectPolicy: input.streamReconnectPolicy
@@ -1557,73 +1609,92 @@ var ClientSession = class ClientSession {
 					if (!terminal && event.meta?.deliveryIds !== void 0 && !matches) continue;
 					started = true;
 				}
-				if (event.type === "authorization.required" && event.data.webhookUrl !== void 0) pendingAuthorizations.add(event.data.name);
-				else if (event.type === "authorization.completed") pendingAuthorizations.delete(event.data.name);
+				updatePendingAuthorizations(pendingAuthorizations, event);
 				reachedBoundary = isCurrentTurnBoundaryEvent(event) && (event.type !== "session.waiting" || pendingAuthorizations.size === 0);
 				yield event;
 				if (reachedBoundary) break;
 			}
 			if (deliveryId !== void 0 && !reachedBoundary && !input.signal?.aborted) throw new Error("The response stream ended before the accepted message reached its turn boundary.");
 		} finally {
-			this.#state = {
-				sessionId: this.#state.sessionId,
-				streamIndex: Math.max(this.#state.streamIndex, initialStreamIndex + eventCount)
-			};
+			this.#advanceStreamIndex(initialStreamIndex + eventCount);
 		}
 	}
 	async *#streamAndAdvance(options) {
 		const startIndex = options?.startIndex ?? this.#state.streamIndex;
 		let eventCount = 0;
-		try {
-			for await (const event of this.#readStream({
-				follow: options?.follow,
-				signal: options?.signal,
-				startIndex,
-				streamReconnectPolicy: options?.streamReconnectPolicy
-			})) {
-				eventCount += 1;
-				yield event;
-			}
-		} finally {
-			if (startIndex >= 0) this.#state = {
-				sessionId: this.#state.sessionId,
-				streamIndex: startIndex + eventCount
-			};
+		for await (const event of this.#readStream({
+			follow: options?.follow,
+			headers: options?.headers,
+			keepAlive: options?.keepAlive,
+			onCaughtUp: options?.onCaughtUp,
+			resolveHeaders: options?.resolveHeaders,
+			resolveReconnectPolicy: options?.resolveReconnectPolicy,
+			signal: options?.signal,
+			startIndex,
+			streamReconnectPolicy: options?.streamReconnectPolicy
+		})) {
+			eventCount += 1;
+			if (startIndex >= 0) this.#advanceStreamIndex(startIndex + eventCount);
+			yield event;
 		}
 	}
+	#advanceStreamIndex(streamIndex) {
+		this.#state = {
+			sessionId: this.#state.sessionId,
+			streamIndex: Math.max(this.#state.streamIndex, streamIndex)
+		};
+	}
 	#readStream(input) {
 		return followStreamIterable({
+			onCaughtUp: input.onCaughtUp,
 			follow: input.follow,
 			host: this.#context.host,
 			keepAlive: input.keepAlive,
-			resolveHeaders: () => this.#context.resolveHeaders(input.headers),
+			resolveHeaders: () => this.#context.resolveHeaders(input.resolveHeaders?.() ?? input.headers),
 			redirect: this.#context.redirect,
 			sessionId: this.#state.sessionId,
 			signal: input.signal,
 			startIndex: input.startIndex,
-			streamReconnectPolicy: input.streamReconnectPolicy
+			streamReconnectPolicy: input.streamReconnectPolicy,
+			resolveReconnectPolicy: input.resolveReconnectPolicy
 		});
 	}
 };
+function followClientSession(session, options) {
+	return session[followSession](options);
+}
 async function postSessionSend(context, path, input) {
+	const readyDeadline = Date.now() + SESSION_SEND_READY_TIMEOUT_MS;
 	let retryDelayMs = SESSION_SEND_RETRY_BASE_DELAY_MS;
-	for (let retry = 0;; retry += 1) {
+	for (;;) {
 		try {
 			return await postTurn(context, path, input, false);
 		} catch (error) {
-			if (!isSessionNotActive(error) || retry >= SESSION_SEND_RETRY_COUNT) throw error;
+			if (!isSessionNotReady(error)) throw error;
+			const remainingMs = readyDeadline - Date.now();
+			if (remainingMs <= 0) throw error;
+			await sleep(Math.min(retryDelayMs, remainingMs), input.signal);
 		}
-		await sleep(retryDelayMs, input.signal);
 		input.signal?.throwIfAborted();
-		retryDelayMs *= 2;
+		retryDelayMs = Math.min(retryDelayMs * 2, SESSION_SEND_RETRY_MAX_DELAY_MS);
 	}
 }
-function isSessionNotActive(error) {
-	return error instanceof ClientError && error.status === 409 && error.code === "session_not_active";
+async function postCreateSession(context, options) {
+	const headers = await context.resolveHeaders(options.headers);
+	const response = await fetch(createClientUrl(context.host, EVE_SESSION_ROUTE_PATH), {
+		headers,
+		method: "POST",
+		redirect: context.redirect,
+		signal: options.signal ?? null
+	});
+	if (!response.ok) {
+		const responseBody = await response.text();
+		throw new ClientError(response.status, responseBody, response.headers);
+	}
+	return response;
 }
-function shouldKeepActiveTurnAlive(policy) {
-	if (policy && "reconnect" in policy) return false;
-	return policy?.streamIdleReconnectPolicy?.maxAttempts === void 0;
+function isSessionNotReady(error) {
+	return error instanceof ClientError && error.status === 409 && error.code === "session_not_ready";
 }
 async function postTurn(context, path, input, requireMessage) {
 	const body = createMessageBody(input, requireMessage);
@@ -1672,8 +1743,9 @@ var ClientSessions = class {
 	constructor(context) {
 		this.#context = context;
 	}
-	async create(input) {
-		return await ClientSession.create(this.#context, input);
+	async create(input = {}) {
+		if ("message" in input) return await ClientSession.create(this.#context, input);
+		return { session: await ClientSession.prewarm(this.#context, input) };
 	}
 	attach(sessionId, options) {
 		if (sessionId.length === 0) throw new Error("sessionId must be a non-empty string.");
@@ -1803,6 +1875,151 @@ function withRedirectPolicy(init, redirect) {
 	};
 }
 
+//#endregion
+//#region src/client/session-event-stream.ts
+var SessionEventStream = class {
+	#controller = new AbortController();
+	#readers = /* @__PURE__ */ new Set();
+	#caughtUp = Promise.withResolvers();
+	caughtUp = this.#caughtUp.promise;
+	#ended = false;
+	#error;
+	#headers;
+	#reconnectPolicy;
+	constructor(session, options) {
+		this.setOptions(options);
+		this.caughtUp.catch(() => {});
+		if (!options.catchUp) this.#caughtUp.resolve();
+		(async () => {
+			try {
+				for await (const event of followClientSession(session, {
+					signal: this.#controller.signal,
+					resolveHeaders: () => this.#headers,
+					resolveReconnectPolicy: () => this.#reconnectPolicy,
+					startIndex: options.startIndex,
+					onCaughtUp: options.catchUp ? () => this.#caughtUp.resolve() : void 0
+				})) {
+					if (this.#controller.signal.aborted) return;
+					options.onEvent(event);
+					for (const reader of this.#readers) reader.push(event);
+					if (event.type === "session.completed" || event.type === "session.failed") break;
+				}
+				this.#caughtUp.resolve();
+				this.#finish();
+			} catch (error) {
+				this.#caughtUp.reject(error);
+				this.#finish(error);
+				if (!this.#controller.signal.aborted) options.onError(error);
+			}
+		})();
+	}
+	subscribe(signal) {
+		const reader = new SessionEventReader(() => this.#readers.delete(reader), signal);
+		if (this.#ended) reader.end(this.#error);
+		else this.#readers.add(reader);
+		return reader;
+	}
+	get ended() {
+		return this.#ended;
+	}
+	setOptions(options) {
+		if ("headers" in options) this.#headers = options.headers;
+		if ("streamReconnectPolicy" in options) this.#reconnectPolicy = options.streamReconnectPolicy;
+	}
+	close() {
+		const error = new DOMException("Session stream was detached.", "AbortError");
+		this.#controller.abort(error);
+		this.#caughtUp.reject(error);
+		this.#finish(error);
+	}
+	#finish(error) {
+		if (this.#ended) return;
+		this.#ended = true;
+		this.#error = error;
+		for (const reader of this.#readers) reader.end(error);
+	}
+};
+var SessionEventReader = class {
+	#events = [];
+	#wake = Promise.withResolvers();
+	#ended = false;
+	#error;
+	#dispose;
+	constructor(unsubscribe, signal) {
+		const abort = () => this.end(signal?.reason);
+		signal?.addEventListener("abort", abort, { once: true });
+		this.#dispose = () => {
+			signal?.removeEventListener("abort", abort);
+			unsubscribe();
+		};
+		if (signal?.aborted) abort();
+	}
+	push(event) {
+		if (this.#ended) return;
+		this.#events.push(event);
+		this.#wake.resolve();
+	}
+	end(error) {
+		if (this.#ended) return;
+		this.#ended = true;
+		this.#error = error;
+		this.#wake.resolve();
+	}
+	[Symbol.dispose]() {
+		this.end();
+		this.#events = [];
+		this.#dispose();
+	}
+	discard() {
+		this.#events = [];
+	}
+	async *[Symbol.asyncIterator]() {
+		for (;;) {
+			while (this.#events.length > 0) yield this.#events.shift();
+			if (this.#ended) {
+				if (this.#error !== void 0) throw this.#error;
+				return;
+			}
+			this.#wake = Promise.withResolvers();
+			await this.#wake.promise;
+		}
+	}
+};
+
+//#endregion
+//#region src/client/eve-agent-projection.ts
+var EveAgentProjection = class {
+	#reducer;
+	#events;
+	#data;
+	constructor(reducer, events) {
+		this.#reducer = reducer;
+		this.#events = events;
+		this.#data = this.#reduce();
+	}
+	get data() {
+		return this.#data;
+	}
+	reset() {
+		this.#events = [];
+		this.#data = this.#reducer.initial();
+	}
+	append(event) {
+		this.#events = [...this.#events, event];
+		this.#data = this.#reducer.reduce(this.#data, event);
+	}
+	replace(predicate, replacement) {
+		const index = this.#events.findIndex(predicate);
+		this.#events = index === -1 ? [...this.#events, replacement] : this.#events.map((event, i) => i === index ? replacement : event);
+		this.#data = this.#reduce();
+	}
+	#reduce() {
+		let data = this.#reducer.initial();
+		for (const event of this.#events) data = this.#reducer.reduce(data, event);
+		return data;
+	}
+};
+
 //#endregion
 //#region src/protocol/event-dedupe.ts
 function createEventDeduper() {
@@ -1832,10 +2049,6 @@ function collectPendingAuthorizations(events) {
 	for (const event of events) updatePendingAuthorizations(pending, event);
 	return pending;
 }
-function updatePendingAuthorizations(pending, event) {
-	if (event.type === "authorization.required" && event.data.webhookUrl !== void 0) pending.add(event.data.name);
-	else if (event.type === "authorization.completed") pending.delete(event.data.name);
-}
 function assertExclusiveTurnInput(input) {
 	if (input.message !== void 0 === (input.inputResponses !== void 0)) throw new Error("A turn requires exactly one of message or inputResponses.");
 }
@@ -1865,29 +2078,78 @@ function toTerminalStreamFailureError(event) {
 	error.name = event.data.code;
 	return error;
 }
+function createActiveTurn(cancel) {
+	const response = Promise.withResolvers();
+	const completion = Promise.withResolvers();
+	const turn = {
+		abortController: new AbortController(),
+		acceptedFollowUps: 0,
+		cancel: () => cancel(turn),
+		completion: completion.promise,
+		followUpDispatches: /* @__PURE__ */ new Set(),
+		receivedFollowUps: 0,
+		receivedFollowUpEvents: /* @__PURE__ */ new Set(),
+		followUpSubmissionIds: /* @__PURE__ */ new Set(),
+		resolveCompletion: completion.resolve,
+		response: response.promise,
+		resolveResponse: response.resolve
+	};
+	return turn;
+}
+async function followSteeredTurns(turn, events, isActive) {
+	while (turn.followUpDispatches.size > 0) await Promise.allSettled(turn.followUpDispatches);
+	if (turn.receivedFollowUps >= turn.acceptedFollowUps) return;
+	for await (const event of events) {
+		if (!isActive()) return;
+		if (turn.receivedFollowUpEvents.delete(event)) turn.receivedFollowUps += 1;
+		if (isCurrentTurnBoundaryEvent(event)) {
+			while (turn.followUpDispatches.size > 0) await Promise.allSettled(turn.followUpDispatches);
+			if (turn.receivedFollowUps >= turn.acceptedFollowUps) return;
+		}
+	}
+}
+async function waitWithSignal(promise, signal) {
+	if (signal === void 0) return await promise;
+	const aborted = Promise.withResolvers();
+	const onAbort = () => aborted.reject(signal.reason);
+	signal.addEventListener("abort", onAbort, { once: true });
+	if (signal.aborted) onAbort();
+	try {
+		return await Promise.race([aborted.promise, promise]);
+	} finally {
+		signal.removeEventListener("abort", onAbort);
+	}
+}
 
 //#endregion
 //#region src/client/eve-agent-store.ts
 const detachStore = Symbol("detachEveAgentStore");
+const attachStore = Symbol("attachEveAgentStore");
 var EveAgentStore = class {
 	#client;
+	#autoPrewarm;
+	#attached = false;
+	#stream;
+	#pendingAuthorizations = /* @__PURE__ */ new Set();
 	#externalSession;
 	#optimistic;
-	#reducer;
+	#projection;
 	#subscribers = /* @__PURE__ */ new Set();
 	#seenEvents = createEventDeduper();
 	#activeTurn;
 	#callbacks = {};
-	#data;
 	#error;
 	#events;
 	#pendingMessageSubmissions = [];
-	#projectionEvents;
+	#prewarmGeneration = 0;
+	#prewarmPromise;
+	#prewarmController;
 	#resumePromise;
 	#session;
 	#snapshot;
 	#status = "ready";
 	constructor(init) {
+		this.#autoPrewarm = init.prewarm ?? false;
 		this.#externalSession = init.session !== void 0;
 		this.#client = this.#externalSession ? void 0 : new Client({
 			auth: init.auth,
@@ -1895,13 +2157,14 @@ var EveAgentStore = class {
 			host: init.host ?? ""
 		});
 		const initialEvents = [];
-		for (const event of init.initialEvents ?? []) if (this.#seenEvents.admit(event)) initialEvents.push(event);
+		for (const event of init.initialEvents ?? []) {
+			if (this.#seenEvents.admit(event)) initialEvents.push(event);
+			updatePendingAuthorizations(this.#pendingAuthorizations, event);
+		}
 		this.#events = initialEvents;
-		this.#projectionEvents = [...this.#events];
+		this.#projection = new EveAgentProjection(init.reducer, this.#events);
 		this.#optimistic = init.optimistic ?? true;
-		this.#reducer = init.reducer;
 		this.#session = init.session ?? (init.initialSession === void 0 ? void 0 : this.#client?.sessions.attach(init.initialSession.sessionId, { streamIndex: init.initialSession.streamIndex }));
-		this.#data = this.#reduceProjectionEvents(this.#projectionEvents);
 		this.#snapshot = this.#createSnapshot();
 	}
 	get snapshot() {
@@ -1916,31 +2179,63 @@ var EveAgentStore = class {
 			this.#subscribers.delete(callback);
 		};
 	}
+	prewarm() {
+		if (this.#prewarmPromise !== void 0) return this.#prewarmPromise;
+		if (this.#session !== void 0 || this.#externalSession) return Promise.resolve();
+		if (this.#activeTurn !== void 0) return this.#activeTurn.response.then((response) => {
+			if (response === void 0) throw this.#error ?? new DOMException("Session creation was aborted.", "AbortError");
+		});
+		const client = this.#client;
+		if (client === void 0) return Promise.reject(/* @__PURE__ */ new Error("This eve agent store does not own a session client."));
+		const generation = this.#prewarmGeneration;
+		const controller = new AbortController();
+		this.#prewarmController = controller;
+		const promise = (async () => {
+			try {
+				const created = await client.sessions.create({ signal: controller.signal });
+				if (generation !== this.#prewarmGeneration) return;
+				this.#session = created.session;
+				this.#error = void 0;
+				if (this.#status === "error") this.#status = "ready";
+				this.#callbacks.onSessionChange?.(created.session.state);
+				this.#publish();
+				this.#ensureStream();
+			} catch (error) {
+				if (generation === this.#prewarmGeneration && this.#activeTurn === void 0 && this.#error === void 0) {
+					this.#error = toError(error);
+					this.#status = "error";
+					this.#callbacks.onError?.(this.#error);
+					this.#publish();
+				}
+				throw error;
+			}
+		})();
+		this.#prewarmPromise = promise;
+		const clear = () => {
+			if (this.#prewarmPromise === promise) {
+				this.#prewarmPromise = void 0;
+				this.#prewarmController = void 0;
+			}
+		};
+		promise.then(clear, clear);
+		return promise;
+	}
 	async send(input) {
+		return await this.#submit(input, this.#callbacks.prepareSend);
+	}
+	async #submit(input, prepareSend) {
 		if (this.#activeTurn !== void 0) {
 			if (this.#status === "resuming") throw new Error("eve session is resuming.");
-			return await this.#sendFollowUp(this.#activeTurn, input);
+			return await this.#sendFollowUp(this.#activeTurn, input, prepareSend);
 		}
-		const response = Promise.withResolvers();
-		const completion = Promise.withResolvers();
-		const turn = {
-			abortController: new AbortController(),
-			acceptedFollowUps: 0,
-			cancel: () => turn.acceptedFollowUps > 0 && this.#session !== void 0 ? this.#session.cancel() : response.promise.then((messageResponse) => messageResponse === void 0 ? { status: "no_active_turn" } : messageResponse.cancel()),
-			completion: completion.promise,
-			followUpDispatches: /* @__PURE__ */ new Set(),
-			receivedFollowUps: 0,
-			followUpSubmissionIds: /* @__PURE__ */ new Set(),
-			resolveCompletion: completion.resolve,
-			response: response.promise,
-			resolveResponse: response.resolve
-		};
+		const turn = createActiveTurn((turn) => turn.acceptedFollowUps > 0 && this.#session !== void 0 ? this.#session.cancel() : turn.response.then((response) => response === void 0 ? { status: "no_active_turn" } : response.cancel()));
 		this.#activeTurn = turn;
 		this.#error = void 0;
 		this.#status = "submitted";
 		this.#publish();
+		let reader;
 		try {
-			const preparedInput = await this.#callbacks.prepareSend?.(input) ?? input;
+			const preparedInput = await (prepareSend === void 0 ? input : waitWithSignal(Promise.resolve(prepareSend(input)), createAbortSignal(input.signal, turn.abortController.signal)));
 			assertExclusiveTurnInput(preparedInput);
 			if (!this.#isActiveTurn(turn)) return;
 			this.#projectOptimisticMessage(preparedInput);
@@ -1950,15 +2245,17 @@ var EveAgentStore = class {
 				...preparedInput,
 				signal: createAbortSignal(preparedInput.signal, turn.abortController.signal)
 			};
-			const response = await this.#dispatchTurn(turnInput);
+			const dispatched = await this.#dispatchTurn(turnInput);
+			const response = dispatched.response;
+			reader = dispatched.reader;
 			if (!this.#isActiveTurn(turn)) return;
 			turn.resolveResponse(response);
-			for await (const event of response) {
+			for await (const event of consumeMessageResponse(response, reader)) {
 				if (!this.#isActiveTurn(turn)) return;
-				this.#acceptServerEvent(event);
+				if (turn.receivedFollowUpEvents.delete(event)) turn.receivedFollowUps += 1;
 			}
 			if (!this.#isActiveTurn(turn)) return;
-			await this.#followSteeredTurns(turn);
+			await followSteeredTurns(turn, reader, () => this.#isActiveTurn(turn));
 			if (!this.#isActiveTurn(turn)) return;
 			this.#status = this.#error === void 0 ? "ready" : "error";
 		} catch (error) {
@@ -1967,20 +2264,15 @@ var EveAgentStore = class {
 				this.#status = "ready";
 				this.#failPendingMessageSubmission(toError(error));
 			} else {
-				this.#error = toError(error);
+				const reported = this.#error !== void 0;
+				this.#error ??= toError(error);
 				this.#status = "error";
 				this.#failPendingMessageSubmission(this.#error);
-				this.#callbacks.onError?.(this.#error);
+				if (!reported) this.#callbacks.onError?.(this.#error);
 			}
 		} finally {
-			if (this.#isActiveTurn(turn)) {
-				turn.resolveResponse(void 0);
-				this.#activeTurn = void 0;
-				this.#callbacks.onSessionChange?.(this.#session?.state);
-				this.#publish();
-				this.#callbacks.onFinish?.(this.#snapshot);
-				turn.resolveCompletion();
-			}
+			reader?.[Symbol.dispose]();
+			this.#finishTurn(turn);
 		}
 	}
 	resume() {
@@ -1996,70 +2288,34 @@ var EveAgentStore = class {
 	async #resume() {
 		if (this.#status === "resuming" || this.#status === "streaming" || this.#status === "submitted") throw new Error("eve session is already processing a turn.");
 		if (this.#session === void 0) throw new Error("An eve session is required before resuming.");
-		const response = Promise.withResolvers();
-		const completion = Promise.withResolvers();
 		const session = this.#session;
-		const turn = {
-			abortController: new AbortController(),
-			acceptedFollowUps: 0,
-			cancel: () => session.cancel(),
-			completion: completion.promise,
-			followUpDispatches: /* @__PURE__ */ new Set(),
-			receivedFollowUps: 0,
-			followUpSubmissionIds: /* @__PURE__ */ new Set(),
-			resolveCompletion: completion.resolve,
-			response: response.promise,
-			resolveResponse: response.resolve
-		};
+		const turn = createActiveTurn(() => session.cancel());
 		this.#activeTurn = turn;
 		turn.resolveResponse(void 0);
 		this.#error = void 0;
 		this.#status = "resuming";
 		this.#publish();
 		try {
-			const hasCompleteInitialPrefix = this.#events.length === session.state.streamIndex;
-			const replayed = hasCompleteInitialPrefix ? [...this.#events] : [];
-			for await (const event of session.stream({
-				follow: false,
-				signal: turn.abortController.signal,
-				startIndex: hasCompleteInitialPrefix ? session.state.streamIndex : 0
-			})) {
-				if (!this.#isActiveTurn(turn)) return;
-				replayed.push(event);
-				this.#acceptServerEvent(event, {
-					publish: false,
-					transitionToStreaming: false
-				});
-			}
+			const stream = this.#ensureStream({
+				catchUp: true,
+				startIndex: this.#events.length === session.state.streamIndex ? session.state.streamIndex : 0
+			});
+			using reader = stream.subscribe(turn.abortController.signal);
+			await stream.caughtUp;
 			if (!this.#isActiveTurn(turn)) return;
-			const replayTail = replayed.at(-1);
-			if (replayTail !== void 0) this.#applyTerminalStreamFailure(replayTail);
-			const replaySettled = isSettledSessionTail(replayed);
-			if (this.#error === void 0 && (!replaySettled || replayTail?.type === "session.waiting")) {
-				const pendingAuthorizations = collectPendingAuthorizations(replayed);
-				if (!replaySettled) this.#status = "streaming";
+			reader.discard();
+			const tail = this.#events.at(-1);
+			if (tail !== void 0) this.#applyTerminalStreamFailure(tail);
+			if (tail !== void 0 && this.#error === void 0 && !isSettledSessionTail(this.#events)) {
+				this.#status = "streaming";
 				this.#publish();
-				let followLive = !replaySettled;
-				for (;;) {
-					for await (const event of session.stream({
-						follow: followLive ? void 0 : false,
-						signal: turn.abortController.signal
-					})) {
-						if (!this.#isActiveTurn(turn)) return;
-						replayed.push(event);
-						this.#acceptServerEvent(event);
-						updatePendingAuthorizations(pendingAuthorizations, event);
-						if (followLive && isCurrentTurnBoundaryEvent(event) && (event.type !== "session.waiting" || pendingAuthorizations.size === 0)) break;
-					}
+				for await (const event of reader) {
 					if (!this.#isActiveTurn(turn)) return;
-					if (followLive || isSettledSessionTail(replayed)) break;
-					followLive = true;
+					if (turn.receivedFollowUpEvents.delete(event)) turn.receivedFollowUps += 1;
+					if (isCurrentTurnBoundaryEvent(event) && this.#pendingAuthorizations.size === 0) break;
 				}
-			} else {
-				this.#status = this.#error === void 0 ? "ready" : "error";
-				this.#publish();
 			}
-			await this.#followSteeredTurns(turn);
+			await followSteeredTurns(turn, reader, () => this.#isActiveTurn(turn));
 			if (this.#isActiveTurn(turn)) this.#status = this.#error === void 0 ? "ready" : "error";
 		} catch (error) {
 			if (!this.#isActiveTurn(turn)) return;
@@ -2070,61 +2326,81 @@ var EveAgentStore = class {
 				this.#callbacks.onError?.(this.#error);
 			}
 		} finally {
-			if (this.#isActiveTurn(turn)) {
-				turn.resolveResponse(void 0);
-				this.#activeTurn = void 0;
-				this.#callbacks.onSessionChange?.(session.state);
-				this.#publish();
-				this.#callbacks.onFinish?.(this.#snapshot);
-				turn.resolveCompletion();
-			}
+			this.#finishTurn(turn);
 		}
 	}
 	cancel() {
 		const turn = this.#activeTurn;
-		if (turn === void 0) return Promise.resolve({ status: "no_active_turn" });
+		if (turn === void 0) return this.#status === "streaming" && this.#session !== void 0 ? this.#session.cancel() : Promise.resolve({ status: "no_active_turn" });
 		return turn.cancel();
 	}
+	[attachStore]() {
+		this.#attached = true;
+		if (this.#autoPrewarm && this.#session === void 0) this.prewarm().catch(() => {});
+	}
 	[detachStore]() {
+		this.#attached = false;
+		this.#stream?.close();
+		this.#stream = void 0;
 		this.#activeTurn?.abortController.abort();
+		this.#resetPrewarm();
+		this.#resumePromise = void 0;
 	}
 	reset() {
+		this.#stream?.close();
+		this.#stream = void 0;
+		this.#pendingAuthorizations.clear();
 		const turn = this.#activeTurn;
 		this.#activeTurn = void 0;
 		turn?.resolveResponse(void 0);
 		turn?.resolveCompletion();
 		turn?.abortController.abort();
+		this.#resetPrewarm();
+		this.#resumePromise = void 0;
 		if (!this.#externalSession) this.#session = void 0;
 		this.#events = [];
 		this.#seenEvents = createEventDeduper();
 		this.#pendingMessageSubmissions = [];
-		this.#projectionEvents = [];
-		this.#data = this.#reducer.initial();
+		this.#projection.reset();
 		this.#error = void 0;
 		this.#status = "ready";
 		this.#callbacks.onSessionChange?.(this.#session?.state);
 		this.#publish();
+		if (this.#autoPrewarm && this.#attached) this.prewarm().catch(() => {});
 	}
-	async #sendFollowUp(turn, input) {
+	async #sendFollowUp(turn, input, prepareSend) {
 		if (input.message === void 0 || input.turnPolicy !== "steer") throw new Error("eve session is already processing a turn. Send a message with turnPolicy: \"steer\" to guide it at the next boundary.");
-		const preparedInput = await this.#callbacks.prepareSend?.(input) ?? input;
+		const generation = this.#prewarmGeneration;
+		const signal = createAbortSignal(input.signal, turn.abortController.signal);
+		const preparedInput = await waitWithSignal(Promise.resolve(prepareSend?.(input)), signal) ?? input;
+		if (generation !== this.#prewarmGeneration) return;
 		assertExclusiveTurnInput(preparedInput);
 		if (preparedInput.message === void 0 || preparedInput.turnPolicy !== "steer") throw new Error("An in-flight follow-up requires a message with turnPolicy: \"steer\".");
-		if (!this.#isActiveTurn(turn)) return await this.send(preparedInput);
+		if (!this.#isActiveTurn(turn)) return await this.#submit(preparedInput);
 		const submissionId = this.#projectOptimisticMessage(preparedInput);
 		if (submissionId !== void 0) turn.followUpSubmissionIds.add(submissionId);
 		this.#publish();
+		this.#ensureStream({
+			headers: preparedInput.headers,
+			streamReconnectPolicy: preparedInput.streamReconnectPolicy
+		});
 		let dispatch;
 		dispatch = (async () => {
 			try {
-				await turn.response;
+				const signal = createAbortSignal(preparedInput.signal, turn.abortController.signal);
+				await waitWithSignal(turn.response, signal);
 				if (!this.#isActiveTurn(turn) || this.#session === void 0) throw new Error("The active eve turn ended before the follow-up could be sent.");
 				const { message, ...options } = preparedInput;
-				await this.#session.send(message, options);
+				await this.#session.send(message, {
+					...options,
+					signal
+				});
 				turn.acceptedFollowUps += 1;
 			} catch (error) {
-				this.#failPendingMessageSubmission(toError(error), submissionId);
-				this.#publish();
+				if (this.#isActiveTurn(turn)) {
+					this.#failPendingMessageSubmission(toError(error), submissionId);
+					this.#publish();
+				}
 				throw error;
 			} finally {
 				turn.followUpDispatches.delete(dispatch);
@@ -2134,38 +2410,94 @@ var EveAgentStore = class {
 		await dispatch;
 		await turn.completion;
 	}
-	async #followSteeredTurns(turn) {
-		while (turn.followUpDispatches.size > 0) await Promise.allSettled(turn.followUpDispatches);
-		if (turn.receivedFollowUps >= turn.acceptedFollowUps || this.#session === void 0) return;
-		for await (const event of this.#session.stream({ signal: turn.abortController.signal })) {
-			if (!this.#isActiveTurn(turn)) return;
-			this.#acceptServerEvent(event);
-			if (isCurrentTurnBoundaryEvent(event)) {
-				while (turn.followUpDispatches.size > 0) await Promise.allSettled(turn.followUpDispatches);
-				if (turn.receivedFollowUps >= turn.acceptedFollowUps) return;
+	async #dispatchTurn(input) {
+		const streamOptions = {
+			headers: input.headers,
+			streamReconnectPolicy: input.streamReconnectPolicy
+		};
+		if (this.#prewarmPromise !== void 0) {
+			await waitWithSignal(this.#prewarmPromise.catch((error) => {
+				if (this.#session !== void 0) throw error;
+			}), input.signal);
+			input.signal?.throwIfAborted();
+		}
+		if (this.#session === void 0) {
+			if (this.#client === void 0) throw new Error("An external eve session is required before sending.");
+			if (input.message === void 0) throw new Error("Cannot answer an input request before the session starts.");
+			const created = await this.#client.sessions.create({
+				...input,
+				message: input.message
+			});
+			input.signal?.throwIfAborted();
+			this.#session = created.session;
+			this.#callbacks.onSessionChange?.(created.session.state);
+			this.#publish();
+			return {
+				response: created.response,
+				reader: this.#ensureStream(streamOptions).subscribe(input.signal)
+			};
+		}
+		const reader = this.#ensureStream(streamOptions).subscribe(input.signal);
+		try {
+			if (input.inputResponses === void 0) {
+				const { message, ...options } = input;
+				return {
+					response: await this.#session.send(message, options),
+					reader
+				};
 			}
+			const { inputResponses, ...options } = input;
+			return {
+				response: await this.#session.respond(inputResponses, options),
+				reader
+			};
+		} catch (error) {
+			reader[Symbol.dispose]();
+			throw error;
 		}
 	}
-	async #createFirstTurn(input) {
-		if (this.#client === void 0) throw new Error("An external eve session is required before sending.");
-		if (input.message === void 0) throw new Error("Cannot answer an input request before the session starts.");
-		const created = await this.#client.sessions.create({
-			...input,
-			message: input.message
+	#ensureStream(options = {}) {
+		if (this.#stream !== void 0 && !this.#stream.ended) {
+			this.#stream.setOptions(options);
+			return this.#stream;
+		}
+		if (this.#session === void 0) throw new Error("A session is required before opening its stream.");
+		const session = this.#session;
+		const generation = this.#prewarmGeneration;
+		this.#stream = new SessionEventStream(session, {
+			...options,
+			onEvent: (event) => {
+				if (generation === this.#prewarmGeneration) this.#acceptServerEvent(event);
+			},
+			onError: (error) => {
+				if (generation !== this.#prewarmGeneration) return;
+				this.#stream = void 0;
+				if (this.#activeTurn !== void 0) return;
+				this.#error = toError(error);
+				this.#status = "error";
+				this.#callbacks.onError?.(this.#error);
+				this.#publish();
+			}
 		});
-		this.#session = created.session;
-		this.#callbacks.onSessionChange?.(created.session.state);
-		this.#publish();
-		return created.response;
+		return this.#stream;
 	}
-	async #dispatchTurn(input) {
-		if (this.#session === void 0) return await this.#createFirstTurn(input);
-		if (input.inputResponses === void 0) {
-			const { message, ...options } = input;
-			return await this.#session.send(message, options);
+	#resetPrewarm() {
+		this.#prewarmGeneration += 1;
+		this.#prewarmController?.abort();
+		this.#prewarmController = void 0;
+		this.#prewarmPromise = void 0;
+	}
+	#finishTurn(turn) {
+		if (!this.#isActiveTurn(turn)) return;
+		turn.resolveResponse(void 0);
+		this.#activeTurn = void 0;
+		try {
+			this.#callbacks.onSessionChange?.(this.#session?.state);
+			this.#publish();
+			this.#callbacks.onFinish?.(this.#snapshot);
+		} finally {
+			turn.resolveCompletion();
 		}
-		const { inputResponses, ...options } = input;
-		return await this.#session.respond(inputResponses, options);
 	}
 	#isActiveTurn(turn) {
 		return this.#activeTurn === turn;
@@ -2179,7 +2511,7 @@ var EveAgentStore = class {
 			message: summarizeUserContent(input.message)
 		};
 		this.#pendingMessageSubmissions = [...this.#pendingMessageSubmissions, pending];
-		if (this.#optimistic) this.#appendProjectionEvent({
+		if (this.#optimistic) this.#projection.append({
 			data: {
 				createdAt: pending.createdAt,
 				message: pending.message,
@@ -2191,7 +2523,7 @@ var EveAgentStore = class {
 	}
 	#projectInputResponses(input) {
 		if (input.inputResponses === void 0 || input.inputResponses.length === 0) return;
-		this.#appendProjectionEvent({
+		this.#projection.append({
 			data: {
 				createdAt: Date.now(),
 				responses: input.inputResponses
@@ -2199,25 +2531,33 @@ var EveAgentStore = class {
 			type: "client.input.responded"
 		});
 	}
-	#acceptServerEvent(event, options = {}) {
+	#acceptServerEvent(event) {
 		if (!this.#seenEvents.admit(event)) return;
+		const wasStreaming = this.#status === "streaming";
+		updatePendingAuthorizations(this.#pendingAuthorizations, event);
 		this.#events = [...this.#events, event];
 		this.#applyServerEvent(event);
 		this.#callbacks.onEvent?.(event);
-		if (options.transitionToStreaming ?? true) this.#status = "streaming";
 		this.#applyTerminalStreamFailure(event);
-		if (options.publish ?? true) this.#publish();
+		const settled = isCurrentTurnBoundaryEvent(event) && this.#pendingAuthorizations.size === 0;
+		if (this.#status !== "resuming" && this.#error === void 0) {
+			if ("data" in event && "turnId" in event.data) this.#status = "streaming";
+			if (this.#activeTurn === void 0 && settled) this.#status = "ready";
+		}
+		this.#callbacks.onSessionChange?.(this.#session?.state);
+		this.#publish();
+		if (this.#activeTurn === void 0 && wasStreaming && settled) this.#callbacks.onFinish?.(this.#snapshot);
 	}
 	#applyServerEvent(event) {
 		const pendingSubmission = this.#pendingMessageSubmissions[0];
 		if (event.type === "message.received" && pendingSubmission !== void 0) {
 			const submissionId = pendingSubmission.id;
-			if (this.#activeTurn?.followUpSubmissionIds.delete(submissionId)) this.#activeTurn.receivedFollowUps += 1;
+			if (this.#activeTurn?.followUpSubmissionIds.delete(submissionId)) this.#activeTurn.receivedFollowUpEvents.add(event);
 			this.#pendingMessageSubmissions = this.#pendingMessageSubmissions.slice(1);
-			this.#replaceProjectionEvent((candidate) => candidate.type === "client.message.submitted" && candidate.data.submissionId === submissionId, event);
+			this.#projection.replace((candidate) => candidate.type === "client.message.submitted" && candidate.data.submissionId === submissionId, event);
 			return;
 		}
-		this.#appendProjectionEvent(event);
+		this.#projection.append(event);
 	}
 	#applyTerminalStreamFailure(event) {
 		const error = toTerminalStreamFailureError(event);
@@ -2233,7 +2573,7 @@ var EveAgentStore = class {
 		const pending = submissionId === void 0 ? this.#pendingMessageSubmissions[0] : this.#pendingMessageSubmissions.find((candidate) => candidate.id === submissionId);
 		if (pending === void 0) return;
 		this.#pendingMessageSubmissions = this.#pendingMessageSubmissions.filter((candidate) => candidate.id !== pending.id);
-		this.#replaceProjectionEvent((event) => event.type === "client.message.submitted" && event.data.submissionId === pending.id, {
+		this.#projection.replace((event) => event.type === "client.message.submitted" && event.data.submissionId === pending.id, {
 			data: {
 				createdAt: pending.createdAt,
 				error: { message: error.message },
@@ -2243,30 +2583,9 @@ var EveAgentStore = class {
 			type: "client.message.failed"
 		});
 	}
-	#appendProjectionEvent(event) {
-		this.#projectionEvents = [...this.#projectionEvents, event];
-		this.#data = this.#reducer.reduce(this.#data, event);
-	}
-	#replaceProjectionEvent(predicate, replacement) {
-		let replaced = false;
-		this.#projectionEvents = this.#projectionEvents.map((event) => {
-			if (!replaced && predicate(event)) {
-				replaced = true;
-				return replacement;
-			}
-			return event;
-		});
-		if (!replaced) this.#projectionEvents = [...this.#projectionEvents, replacement];
-		this.#data = this.#reduceProjectionEvents(this.#projectionEvents);
-	}
-	#reduceProjectionEvents(events) {
-		let data = this.#reducer.initial();
-		for (const event of events) data = this.#reducer.reduce(data, event);
-		return data;
-	}
 	#createSnapshot() {
 		return {
-			data: this.#data,
+			data: this.#projection.data,
 			error: this.#error,
 			events: this.#events,
 			session: this.#session?.state,
@@ -2281,6 +2600,9 @@ var EveAgentStore = class {
 function detachEveAgentStore(store) {
 	store[detachStore]();
 }
+function attachEveAgentStore(store) {
+	store[attachStore]();
+}
 
 //#endregion
 //#region src/client/agent-host.ts
@@ -2935,6 +3257,7 @@ function useEveAgent(options = {}) {
 		initialEvents: options.initialEvents,
 		initialSession: options.initialSession,
 		optimistic: options.optimistic,
+		prewarm: options.prewarm,
 		reducer,
 		session: options.session
 	});
@@ -2950,6 +3273,7 @@ function useEveAgent(options = {}) {
 		const unsubscribe = store.subscribe(() => {
 			snapshot.value = store.snapshot;
 		});
+		attachEveAgentStore(store);
 		if (options.resume) store.resume();
 		onScopeDispose(() => {
 			unsubscribe();
@@ -2961,6 +3285,7 @@ function useEveAgent(options = {}) {
 		data: computed(() => snapshot.value.data),
 		error: computed(() => snapshot.value.error),
 		events: computed(() => snapshot.value.events),
+		prewarm: () => store.prewarm(),
 		reset: () => store.reset(),
 		respond: (inputResponses, options) => store.send({
 			...options,