eve 0.69.0 → 0.70.1

package/dist/src/chunks/{use-eve-agent-Dab2MnT2.js → use-eve-agent-CJQeE7-t.js}

@@ -684,28 +684,22 @@ function isTurnFailureEvent(event) {
 //#endregion
 //#region src/client/session-utils.ts
 function summarizeTurnEvents(events) {
+	const segment = new TurnSegment();
 	let boundary;
 	let failure;
 	let message;
-	const inputRequests = [];
-	const pendingInputRequests = /* @__PURE__ */ new Set();
-	const pendingAuthorizations = /* @__PURE__ */ new Map();
 	for (const event of events) {
-		updatePendingInputRequests(pendingInputRequests, event);
-		if (isTurnSegmentBoundary(event, pendingInputRequests)) boundary = event;
+		if (segment.observe(event)) boundary = event;
 		if (isTurnFailureEvent(event)) failure = event;
 		if (isFinalMessageCompleted(event)) message = event.data.message ?? void 0;
 		if (event.type === "turn.waiting") message = void 0;
-		if (event.type === "input.requested") inputRequests.push(...event.data.requests);
-		if (event.type === "authorization.required") pendingAuthorizations.set(event.data.name, event.data);
-		if (event.type === "authorization.completed") pendingAuthorizations.delete(event.data.name);
 	}
 	return {
 		boundary,
 		failure,
-		inputRequests,
+		inputRequests: segment.inputRequests,
 		message,
-		pendingAuthorizations: [...pendingAuthorizations.values()],
+		pendingAuthorizations: segment.pendingAuthorizations,
 		status: summarizeBoundaryStatus(boundary)
 	};
 }
@@ -714,20 +708,50 @@ function summarizeBoundaryStatus(boundary) {
 	if (boundary?.type === "session.failed") return "failed";
 	return "completed";
 }
-function isTurnSegmentBoundary(event, pendingInputRequests) {
-	if (event.type === "turn.waiting") return pendingInputRequests.size > 0;
-	return isCurrentTurnBoundaryEvent(event);
-}
-function updatePendingInputRequests(pending, event) {
-	if (event.type === "input.requested") for (const request of event.data.requests) pending.add(request.requestId);
-	else if (event.type === "input.resolved") for (const resolution of event.data.resolutions) pending.delete(resolution.requestId);
+function endsTurnSegment(event, open) {
+	if (event.type === "turn.waiting") return open.requests || event.data.on === "input" && !open.callbacks;
+	return isCurrentTurnBoundaryEvent(event) && (event.type !== "session.waiting" || !open.callbacks);
 }
+var TurnSegment = class {
+	#authorizations = /* @__PURE__ */ new Map();
+	#followCallbacks;
+	#requests = /* @__PURE__ */ new Map();
+	constructor(options = {}) {
+		this.#followCallbacks = options.followCallbacks === true;
+	}
+	get inputRequests() {
+		return [...this.#requests.values()];
+	}
+	get pendingAuthorizations() {
+		return [...this.#authorizations.values()];
+	}
+	observe(event) {
+		switch (event.type) {
+			case "input.requested":
+				for (const request of event.data.requests) this.#requests.set(request.requestId, request);
+				break;
+			case "approval.settled":
+				this.#requests.delete(event.data.requestId);
+				break;
+			case "input.resolved":
+				for (const resolution of event.data.resolutions) this.#requests.delete(resolution.requestId);
+				break;
+			case "authorization.required":
+				this.#authorizations.set(authorizationKey(event.data), event.data);
+				break;
+			case "authorization.completed": this.#authorizations.delete(authorizationKey(event.data));
+		}
+		return endsTurnSegment(event, {
+			callbacks: this.#followCallbacks && [...this.#authorizations.values()].some((authorization) => authorization.webhookUrl !== void 0),
+			requests: this.#requests.size > 0
+		});
+	}
+};
 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);
+function authorizationKey(data) {
+	return data.attemptId === void 0 ? `name:${data.name}` : `attempt:${data.attemptId}`;
 }
 
 //#endregion
@@ -1890,8 +1914,7 @@ var ClientSession = class ClientSession {
 		let eventCount = 0;
 		let started = deliveryId === void 0;
 		let reachedBoundary = false;
-		const pendingAuthorizations = /* @__PURE__ */ new Set();
-		const pendingInputRequests = /* @__PURE__ */ new Set();
+		const segment = new TurnSegment({ followCallbacks: true });
 		try {
 			for await (const event of source ?? this.#readStream({
 				headers: input.headers,
@@ -1909,9 +1932,7 @@ var ClientSession = class ClientSession {
 					if (!terminal && event.meta?.deliveryIds !== void 0 && !matches) continue;
 					started = true;
 				}
-				updatePendingAuthorizations(pendingAuthorizations, event);
-				updatePendingInputRequests(pendingInputRequests, event);
-				reachedBoundary = isTurnSegmentBoundary(event, pendingInputRequests) && (event.type !== "session.waiting" || pendingAuthorizations.size === 0);
+				reachedBoundary = segment.observe(event);
 				yield event;
 				if (reachedBoundary) break;
 			}
@@ -2176,117 +2197,6 @@ 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 {
@@ -2295,18 +2205,21 @@ var EveAgentProjection = class {
 	#data;
 	constructor(reducer, events) {
 		this.#reducer = reducer;
-		this.#events = events;
+		this.#events = [...events];
 		this.#data = this.#reduce();
 	}
 	get data() {
 		return this.#data;
 	}
+	get reducer() {
+		return this.#reducer;
+	}
 	reset() {
 		this.#events = [];
 		this.#data = this.#reducer.initial();
 	}
 	append(event) {
-		this.#events = [...this.#events, event];
+		this.#events.push(event);
 		this.#data = this.#reducer.reduce(this.#data, event);
 	}
 	remove(predicate) {
@@ -2315,7 +2228,8 @@ var EveAgentProjection = class {
 	}
 	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);
+		if (index === -1) this.#events.push(replacement);
+		else this.#events[index] = replacement;
 		this.#data = this.#reduce();
 	}
 	#reduce() {
@@ -2325,18 +2239,68 @@ var EveAgentProjection = class {
 	}
 };
 
+//#endregion
+//#region src/client/conversation-state.ts
+function openConversationInputs(state) {
+	return Object.values(state.inputs).filter((input) => input.status === "open");
+}
+function conversationAuthorizations(state) {
+	return state.messages.flatMap((message) => message.role === "assistant" ? message.parts.filter((part) => part.type === "authorization") : []);
+}
+function hasPendingAuthorizations(state) {
+	return conversationAuthorizations(state).some((part) => part.state === "required" && part.awaitsCallback === true);
+}
+function agentToolTask(state, agent) {
+	const task = agent.taskId === void 0 ? void 0 : state.tasks[agent.taskId];
+	return task?.kind === "agent" ? task : void 0;
+}
+function isAgentSessionCaughtUp(state, agent) {
+	if (agent.observation.status !== "following" && agent.observation.status !== "idle") return false;
+	const task = agentToolTask(state, agent);
+	if (task === void 0) return false;
+	const calls = Object.values(task.calls);
+	if (calls.some((call) => call.status === "working")) return false;
+	const child = agent.observation.conversation;
+	if (child.activeTurnId !== void 0) return false;
+	if (Object.values(child.inputs).some((input) => input.status !== "settled")) return false;
+	if (hasPendingAuthorizations(child)) return false;
+	return child.messages.filter((message) => message.role === "user").length >= calls.filter((call) => call.status === "completed").length;
+}
+
 //#endregion
 //#region src/client/eve-agent-store-helpers.ts
-function isSettledSessionTail(events) {
+function activeTurnForOptimisticFollowUp(events) {
+	const lastTurn = events.findLast((event) => event.type === "turn.started" || event.type === "turn.completed" || event.type === "turn.failed" || event.type === "turn.cancelled" || isCurrentTurnBoundaryEvent(event));
+	return lastTurn?.type === "turn.started" ? lastTurn.data.turnId : void 0;
+}
+function isResponseBoundary(event, conversation) {
+	return endsTurnSegment(event, {
+		callbacks: hasPendingAuthorizations(conversation),
+		requests: Object.values(conversation.inputs).some((input) => input.status !== "settled")
+	});
+}
+function settledStatus(error, conversation) {
+	if (error !== void 0) return "error";
+	return conversation.activeTurnId === void 0 ? "ready" : "streaming";
+}
+function isSettledSessionTail(events, conversation) {
 	const tail = events.at(-1);
-	if (tail === void 0) return false;
-	const pendingAuthorizations = /* @__PURE__ */ new Set();
-	const pendingInputRequests = /* @__PURE__ */ new Set();
-	for (const event of events) {
-		updatePendingAuthorizations(pendingAuthorizations, event);
-		updatePendingInputRequests(pendingInputRequests, event);
+	return tail !== void 0 && isResponseBoundary(tail, conversation);
+}
+function assertAnswerable(input, conversation) {
+	for (const { requestId } of input.inputResponses ?? []) {
+		const status = conversation.inputs[requestId]?.status;
+		if (status !== void 0 && status !== "open") throw new Error(`Input request ${requestId} was already answered.`);
 	}
-	return isTurnSegmentBoundary(tail, pendingInputRequests) && (tail.type !== "session.waiting" || pendingAuthorizations.size === 0);
+}
+function assertInFlightFollowUp(input) {
+	if (input.inputResponses !== void 0) return;
+	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, or answer an open input request.");
+}
+function validateFollowUp(input) {
+	assertExclusiveTurnInput(input);
+	assertInFlightFollowUp(input);
+	return input;
 }
 function assertExclusiveTurnInput(input) {
 	if (input.message !== void 0 === (input.inputResponses !== void 0)) throw new Error("A turn requires exactly one of message or inputResponses.");
@@ -2385,16 +2349,25 @@ function createActiveTurn(cancel) {
 	};
 	return turn;
 }
+function countFollowUpDeliveries(turn, reconciliation) {
+	let followed = 0;
+	for (const id of reconciliation.ids) if (turn.followUpSubmissionIds.delete(id)) followed += 1;
+	if (followed === 0) return;
+	if (reconciliation.alreadyProjected) turn.receivedFollowUps += followed;
+	else {
+		const previous = turn.receivedFollowUpEvents.get(reconciliation.event) ?? 0;
+		turn.receivedFollowUpEvents.set(reconciliation.event, previous + followed);
+	}
+}
 async function followSteeredTurns(turn, events, isActive) {
 	while (turn.followUpDispatches.size > 0) await Promise.allSettled(turn.followUpDispatches);
 	if (turn.receivedFollowUps >= turn.acceptedFollowUps) return;
-	const pendingInputRequests = /* @__PURE__ */ new Set();
+	const segment = new TurnSegment({ followCallbacks: true });
 	for await (const event of events) {
 		if (!isActive()) return;
 		turn.receivedFollowUps += turn.receivedFollowUpEvents.get(event) ?? 0;
 		turn.receivedFollowUpEvents.delete(event);
-		updatePendingInputRequests(pendingInputRequests, event);
-		if (isTurnSegmentBoundary(event, pendingInputRequests)) {
+		if (segment.observe(event)) {
 			while (turn.followUpDispatches.size > 0) await Promise.allSettled(turn.followUpDispatches);
 			if (turn.receivedFollowUps >= turn.acceptedFollowUps) return;
 		}
@@ -2417,43 +2390,52 @@ async function waitWithSignal(promise, signal) {
 //#region src/client/optimistic-message-submissions.ts
 var OptimisticMessageSubmissions = class {
 	#optimistic;
-	#projection;
+	#projections;
 	#pending = [];
-	constructor(projection, optimistic) {
-		this.#projection = projection;
+	constructor(projections, optimistic) {
+		this.#projections = projections;
 		this.#optimistic = optimistic;
 	}
 	reset() {
 		this.#pending = [];
 	}
-	submit(input, eventStartIndex) {
+	submit(input, eventStartIndex, turnId) {
 		if (input.message === void 0) return void 0;
 		const pending = {
 			createdAt: Date.now(),
 			eventStartIndex,
 			id: createSubmissionId(),
 			message: summarizeUserContent(input.message),
+			turnId,
 			requiresDeliveryId: true
 		};
 		this.#pending = [...this.#pending, pending];
-		if (this.#optimistic) this.#projection.append({
+		if (this.#optimistic) for (const projection of this.#projections) projection.append({
 			data: {
 				createdAt: pending.createdAt,
 				message: pending.message,
-				submissionId: pending.id
+				submissionId: pending.id,
+				turnId
 			},
 			type: "client.message.submitted"
 		});
 		return pending.id;
 	}
+	resubmit(submissionId, input) {
+		const pending = this.#pending.find((candidate) => candidate.id === submissionId);
+		const message = input.message === void 0 ? void 0 : summarizeUserContent(input.message);
+		if (pending?.message === message) return submissionId;
+		if (pending !== void 0) this.#withdraw([pending.id]);
+		return this.submit(input, pending?.eventStartIndex ?? 0, pending?.turnId);
+	}
 	apply(event) {
 		if (event.type !== "message.received") {
-			this.#projection.append(event);
+			for (const projection of this.#projections) projection.append(event);
 			return;
 		}
 		const matching = this.#matching(event);
 		if (matching.length === 0) {
-			this.#projection.append(event);
+			for (const projection of this.#projections) projection.append(event);
 			return;
 		}
 		return this.#reconcile(matching, event, false);
@@ -2477,12 +2459,13 @@ var OptimisticMessageSubmissions = class {
 		const pending = submissionId === void 0 ? this.#pending[0] : this.#pending.find((candidate) => candidate.id === submissionId);
 		if (pending === void 0) return;
 		this.#pending = this.#pending.filter((candidate) => candidate.id !== pending.id);
-		this.#projection.replace((event) => event.type === "client.message.submitted" && event.data.submissionId === pending.id, {
+		for (const projection of this.#projections) projection.replace((event) => event.type === "client.message.submitted" && event.data.submissionId === pending.id, {
 			data: {
 				createdAt: pending.createdAt,
 				error: { message: error.message },
 				message: pending.message,
-				submissionId: pending.id
+				submissionId: pending.id,
+				turnId: pending.turnId
 			},
 			type: "client.message.failed"
 		});
@@ -2495,1188 +2478,1840 @@ var OptimisticMessageSubmissions = class {
 	}
 	#reconcile(submissions, event, alreadyProjected) {
 		const ids = submissions.map((pending) => pending.id);
-		const idSet = new Set(ids);
-		this.#pending = this.#pending.filter((pending) => !idSet.has(pending.id));
-		if (alreadyProjected) this.#projection.remove((candidate) => candidate.type === "client.message.submitted" && idSet.has(candidate.data.submissionId));
-		else {
-			this.#projection.replace((candidate) => candidate.type === "client.message.submitted" && candidate.data.submissionId === ids[0], event);
-			this.#projection.remove((candidate) => candidate.type === "client.message.submitted" && idSet.has(candidate.data.submissionId));
-		}
+		this.#withdraw(ids);
+		if (!alreadyProjected) for (const projection of this.#projections) projection.append(event);
 		return {
 			alreadyProjected,
 			event,
 			ids
 		};
 	}
+	#withdraw(ids) {
+		const idSet = new Set(ids);
+		this.#pending = this.#pending.filter((pending) => !idSet.has(pending.id));
+		for (const projection of this.#projections) projection.remove((candidate) => candidate.type === "client.message.submitted" && idSet.has(candidate.data.submissionId));
+	}
 };
 
 //#endregion
-//#region src/protocol/event-dedupe.ts
-function createEventDeduper() {
-	const seen = /* @__PURE__ */ new Set();
-	return {
-		admit(event) {
-			const id = event.meta?.id;
-			if (id === void 0) return true;
-			if (seen.has(id)) return false;
-			seen.add(id);
-			return true;
-		},
-		get size() {
-			return seen.size;
+//#region src/client/agent-stream-follower.ts
+const agentStreamReconnectPolicy = {
+	streamIdleReconnectPolicy: { maxAttempts: Infinity },
+	streamOpenReconnectPolicy: { maxAttempts: Infinity }
+};
+var AgentStreamFollower = class {
+	#options;
+	#started = /* @__PURE__ */ new Map();
+	#controllers = /* @__PURE__ */ new Map();
+	#failed = /* @__PURE__ */ new Set();
+	#disposed = false;
+	constructor(options) {
+		this.#options = options;
+	}
+	acceptParentEvent(event) {
+		if (event.type === "agent.started") this.#started.set(event.data.sessionId, event);
+	}
+	reconcile() {
+		if (this.#disposed) return;
+		const state = this.#options.getState();
+		for (const agent of Object.values(state.agents)) {
+			if (agentToolTask(state, agent) === void 0) continue;
+			const controller = this.#controllers.get(agent.sessionId);
+			const caughtUp = isAgentSessionCaughtUp(state, agent);
+			if (controller !== void 0 && caughtUp) {
+				this.#controllers.delete(agent.sessionId);
+				controller.abort();
+				this.#options.onIdle(agent.sessionId);
+			} else if (controller === void 0 && !caughtUp && !this.#failed.has(agent.sessionId)) this.#follow(agent.sessionId);
 		}
-	};
-}
-
-//#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();
-	#pendingInputRequests = /* @__PURE__ */ new Set();
-	#externalSession;
-	#optimistic;
-	#projection;
-	#subscribers = /* @__PURE__ */ new Set();
-	#seenEvents = createEventDeduper();
-	#activeTurn;
-	#callbacks = {};
-	#error;
-	#events;
-	#messageSubmissions;
-	#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,
-			headers: init.headers,
-			host: init.host ?? ""
-		});
-		const initialEvents = [];
-		for (const event of init.initialEvents ?? []) {
-			if (this.#seenEvents.admit(event)) initialEvents.push(event);
-			this.#trackPendingRequests(event);
-		}
-		this.#events = initialEvents;
-		this.#projection = new EveAgentProjection(init.reducer, this.#events);
-		this.#optimistic = init.optimistic ?? true;
-		this.#messageSubmissions = new OptimisticMessageSubmissions(this.#projection, this.#optimistic);
-		this.#session = init.session ?? (init.initialSession === void 0 ? void 0 : this.#client?.sessions.attach(init.initialSession.sessionId, { streamIndex: init.initialSession.streamIndex }));
-		this.#snapshot = this.#createSnapshot();
-	}
-	get snapshot() {
-		return this.#snapshot;
 	}
-	setCallbacks(callbacks) {
-		this.#callbacks = callbacks;
-	}
-	subscribe(callback) {
-		this.#subscribers.add(callback);
-		return () => {
-			this.#subscribers.delete(callback);
-		};
+	abortAll() {
+		this.#disposed = true;
+		for (const controller of this.#controllers.values()) controller.abort();
+		this.#controllers.clear();
 	}
-	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;
+	#follow(sessionId) {
+		const started = this.#started.get(sessionId);
+		if (started === void 0) return;
 		const controller = new AbortController();
-		this.#prewarmController = controller;
-		const promise = (async () => {
+		this.#controllers.set(sessionId, controller);
+		this.#options.onFollowing(sessionId);
+		const { cursors } = this.#options;
+		(async () => {
+			let cursor = cursors.get(sessionId) ?? 0;
 			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();
+				for await (const event of this.#options.session.agent(started).stream({
+					signal: controller.signal,
+					startIndex: cursor,
+					streamReconnectPolicy: agentStreamReconnectPolicy
+				})) {
+					if (controller.signal.aborted) return;
+					cursors.set(sessionId, ++cursor);
+					this.#options.onEvent(sessionId, event);
+					this.reconcile();
 				}
-				throw error;
-			}
+			} catch {}
+			if (controller.signal.aborted || this.#controllers.get(sessionId) !== controller) return;
+			this.#controllers.delete(sessionId);
+			this.#failed.add(sessionId);
+			this.#options.onUnavailable(sessionId);
 		})();
-		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, prepareSend);
-		}
-		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 (prepareSend === void 0 ? input : waitWithSignal(Promise.resolve(prepareSend(input)), createAbortSignal(input.signal, turn.abortController.signal)));
-			assertExclusiveTurnInput(preparedInput);
-			if (!this.#isActiveTurn(turn)) return;
-			const submissionId = this.#messageSubmissions.submit(preparedInput, this.#events.length);
-			this.#projectInputResponses(preparedInput);
-			this.#publish();
-			const turnInput = {
-				...preparedInput,
-				signal: createAbortSignal(preparedInput.signal, turn.abortController.signal)
-			};
-			const dispatched = await this.#dispatchTurn(turnInput);
-			const response = dispatched.response;
-			reader = dispatched.reader;
-			if (!this.#isActiveTurn(turn)) return;
-			turn.resolveResponse(response);
-			if (this.#handleReconciliation(this.#messageSubmissions.correlate(submissionId, getMessageResponseDeliveryId(response), this.#events))) this.#publish();
-			for await (const event of consumeMessageResponse(response, reader)) {
-				if (!this.#isActiveTurn(turn)) return;
-				turn.receivedFollowUps += turn.receivedFollowUpEvents.get(event) ?? 0;
-				turn.receivedFollowUpEvents.delete(event);
-			}
-			if (!this.#isActiveTurn(turn)) return;
-			await followSteeredTurns(turn, reader, () => this.#isActiveTurn(turn));
-			if (!this.#isActiveTurn(turn)) return;
-			this.#status = this.#error === void 0 ? "ready" : "error";
-		} catch (error) {
-			if (!this.#isActiveTurn(turn)) return;
-			if (isAbortError(error)) {
-				this.#status = "ready";
-				this.#messageSubmissions.fail(toError(error));
-			} else {
-				const reported = this.#error !== void 0;
-				this.#error ??= toError(error);
-				this.#status = "error";
-				this.#messageSubmissions.fail(this.#error);
-				if (!reported) this.#callbacks.onError?.(this.#error);
-			}
-		} finally {
-			reader?.[Symbol.dispose]();
-			this.#finishTurn(turn);
-		}
+};
+
+//#endregion
+//#region src/client/authorization-message-parts.ts
+function createAuthorizationRequiredPart(event) {
+	const displayName = event.data.authorization?.displayName ?? formatAuthorizationDisplayName(event.data.name);
+	const part = {
+		authorization: event.data.authorization,
+		description: normalizeAuthorizationDescription(event.data.description, event.data.name, displayName),
+		displayName,
+		name: event.data.name,
+		state: "required",
+		stepIndex: event.data.stepIndex,
+		turnId: event.data.turnId,
+		type: "authorization"
+	};
+	if (event.data.attemptId !== void 0) part.attemptId = event.data.attemptId;
+	if (event.data.webhookUrl !== void 0) part.awaitsCallback = true;
+	return part;
+}
+function createAuthorizationCompletedPart(event, existing) {
+	const displayName = event.data.authorization?.displayName ?? existing?.displayName ?? formatAuthorizationDisplayName(event.data.name);
+	const part = {
+		authorization: existing?.authorization || event.data.authorization ? {
+			...existing?.authorization,
+			...event.data.authorization
+		} : void 0,
+		description: existing?.description ?? buildCompletedAuthorizationDescription(displayName, event.data.outcome, event.data.reason),
+		displayName,
+		name: event.data.name,
+		outcome: event.data.outcome,
+		state: "completed",
+		stepIndex: existing?.stepIndex ?? event.data.stepIndex,
+		turnId: existing?.turnId ?? event.data.turnId,
+		type: "authorization"
+	};
+	const attemptId = event.data.attemptId ?? existing?.attemptId;
+	if (attemptId !== void 0) part.attemptId = attemptId;
+	if (existing?.awaitsCallback) part.awaitsCallback = true;
+	if (event.data.reason !== void 0) part.reason = event.data.reason;
+	return part;
+}
+function buildCompletedAuthorizationDescription(displayName, outcome, reason) {
+	if (outcome === "authorized") return `${displayName} connected.`;
+	return `${displayName} authorization ${outcome}${reason !== void 0 ? ` (${reason})` : ""}.`;
+}
+function normalizeAuthorizationDescription(description, name, displayName) {
+	if (description === `Authorization required for ${name}`) return `Authorization required for ${displayName}`;
+	return description;
+}
+function formatAuthorizationDisplayName(name) {
+	if (name.length === 0) return name;
+	return `${name.charAt(0).toUpperCase()}${name.slice(1)}`;
+}
+
+//#endregion
+//#region src/shared/action-request-name.ts
+function actionRequestName(action) {
+	switch (action.kind) {
+		case "load-skill": return "load_skill";
+		case "subagent-call": return action.subagentName;
+		case "remote-agent-call": return action.remoteAgentName;
+		case "tool-call":
+		case "workflow-tool-call": return action.toolName;
 	}
-	resume() {
-		if (this.#resumePromise !== void 0) return this.#resumePromise;
-		const promise = this.#resume();
-		this.#resumePromise = promise;
-		const clear = () => {
-			if (this.#resumePromise === promise) this.#resumePromise = void 0;
+}
+
+//#endregion
+//#region src/client/message-action-parts.ts
+function toMessageInputRequest(request) {
+	return {
+		allowFreeform: request.allowFreeform,
+		display: request.display,
+		kind: request.kind,
+		options: request.options,
+		prompt: request.prompt,
+		requestId: request.requestId
+	};
+}
+function createToolMetadata(descriptor, extra) {
+	return { eve: {
+		inputRequest: extra?.inputRequest,
+		kind: descriptor.kind,
+		name: descriptor.name
+	} };
+}
+function mergeToolMetadata(current, next) {
+	const kind = next.eve?.kind ?? current?.eve?.kind ?? "unknown";
+	const name = next.eve?.name ?? current?.eve?.name ?? "unknown";
+	return { eve: {
+		...current?.eve,
+		...next.eve,
+		inputRequest: next.eve?.inputRequest ?? current?.eve?.inputRequest,
+		inputResponse: next.eve?.inputResponse ?? current?.eve?.inputResponse,
+		kind,
+		name
+	} };
+}
+function approvedApproval(part) {
+	if (!part?.approval?.id) return;
+	return {
+		approved: true,
+		id: part.approval.id,
+		isAutomatic: part.approval.isAutomatic,
+		reason: part.approval.reason
+	};
+}
+function normalizeActionRequest(action) {
+	const name = actionRequestName(action);
+	switch (action.kind) {
+		case "load-skill": return {
+			kind: "load-skill",
+			name,
+			toolName: "eve:load-skill"
+		};
+		case "tool-call":
+		case "workflow-tool-call": return {
+			kind: "tool-call",
+			name,
+			toolName: name
+		};
+		case "subagent-call":
+		case "remote-agent-call": return {
+			kind: "subagent-call",
+			name,
+			toolName: `eve:subagent:${name}`
 		};
-		promise.then(clear, clear);
-		return promise;
-	}
-	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 session = this.#session;
-		const turn = createActiveTurn(() => session.cancel());
-		this.#activeTurn = turn;
-		turn.resolveResponse(void 0);
-		this.#error = void 0;
-		this.#status = "resuming";
-		this.#publish();
-		let reader;
-		try {
-			const stream = this.#ensureStream({
-				catchUp: true,
-				startIndex: this.#events.length === session.state.streamIndex ? session.state.streamIndex : 0
-			});
-			reader = stream.subscribe(turn.abortController.signal);
-			await stream.caughtUp;
-			if (!this.#isActiveTurn(turn)) return;
-			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();
-				for await (const event of reader) {
-					if (!this.#isActiveTurn(turn)) return;
-					turn.receivedFollowUps += turn.receivedFollowUpEvents.get(event) ?? 0;
-					turn.receivedFollowUpEvents.delete(event);
-					if (this.#isSettledAt(event)) break;
-				}
-			}
-			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;
-			if (isAbortError(error)) this.#status = "ready";
-			else {
-				this.#error = toError(error);
-				this.#status = "error";
-				this.#callbacks.onError?.(this.#error);
-			}
-		} finally {
-			reader?.[Symbol.dispose]();
-			this.#finishTurn(turn);
-		}
-	}
-	cancel() {
-		const turn = this.#activeTurn;
-		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;
+}
+function normalizeActionResult(result) {
+	switch (result.kind) {
+		case "load-skill-result": return {
+			kind: "load-skill",
+			name: result.name ?? "load_skill",
+			toolName: "eve:load-skill"
+		};
+		case "tool-result": return {
+			kind: "tool-call",
+			name: result.toolName,
+			toolName: result.toolName
+		};
+		case "subagent-result": return {
+			kind: "subagent-call",
+			name: result.subagentName,
+			toolName: `eve:subagent:${result.subagentName}`
+		};
 	}
-	reset() {
-		this.#stream?.close();
-		this.#stream = void 0;
-		this.#pendingAuthorizations.clear();
-		this.#pendingInputRequests.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.#messageSubmissions.reset();
-		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(() => {});
+}
+function stringifyUnknown(value) {
+	if (typeof value === "string") return value;
+	try {
+		return JSON.stringify(value);
+	} catch {
+		return "Action failed.";
 	}
-	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 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.#submit(preparedInput);
-		const submissionId = this.#messageSubmissions.submit(preparedInput, this.#events.length);
-		if (submissionId !== void 0) turn.followUpSubmissionIds.add(submissionId);
-		this.#publish();
-		this.#ensureStream({
-			headers: preparedInput.headers,
-			streamReconnectPolicy: preparedInput.streamReconnectPolicy
-		});
-		let dispatch;
-		dispatch = (async () => {
-			try {
-				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;
-				const response = await this.#session.send(message, {
-					...options,
-					signal
-				});
-				turn.acceptedFollowUps += 1;
-				if (this.#handleReconciliation(this.#messageSubmissions.correlate(submissionId, getMessageResponseDeliveryId(response), this.#events))) this.#publish();
-			} catch (error) {
-				if (this.#isActiveTurn(turn)) {
-					this.#messageSubmissions.fail(toError(error), submissionId);
-					this.#publish();
-				}
-				throw error;
-			} finally {
-				turn.followUpDispatches.delete(dispatch);
-			}
-		})();
-		turn.followUpDispatches.add(dispatch);
-		await dispatch;
-		await turn.completion;
+}
+
+//#endregion
+//#region src/client/message-reducer-primitives.ts
+function projectReceivedParts(parts, message) {
+	return parts?.map((part) => part.type === "text" ? {
+		state: "done",
+		text: part.text,
+		type: "text"
+	} : {
+		filename: part.filename,
+		mediaType: part.mediaType,
+		size: part.size,
+		type: "file",
+		url: part.url
+	}) ?? [{
+		state: "done",
+		text: message,
+		type: "text"
+	}];
+}
+function partKey(part) {
+	switch (part.type) {
+		case "text": return `text:${part.stepIndex ?? 0}`;
+		case "reasoning": return `reasoning:${part.stepIndex ?? 0}`;
+		case "file": return `file:${part.stepIndex ?? 0}:${part.filename ?? part.url ?? part.mediaType}`;
+		case "step-start": return "step-start";
+		case "authorization": return part.attemptId === void 0 ? `authorization:${part.turnId}:${part.stepIndex}:${part.name}` : `authorization:${part.attemptId}`;
+		case "dynamic-tool": return `dynamic-tool:${part.toolCallId}`;
 	}
-	async #dispatchTurn(input) {
-		const streamOptions = {
-			headers: input.headers,
-			streamReconnectPolicy: input.streamReconnectPolicy
+}
+function upsertMessage(data, next, beforeAssistantTurnId) {
+	const index = data.messages.findIndex((message) => message.id === next.id);
+	if (index !== -1) return {
+		...data,
+		messages: [
+			...data.messages.slice(0, index),
+			next,
+			...data.messages.slice(index + 1)
+		]
+	};
+	const before = beforeAssistantTurnId === void 0 ? -1 : data.messages.findIndex((message) => message.role === "assistant" && message.metadata?.turnId === beforeAssistantTurnId);
+	if (before === -1) return {
+		...data,
+		messages: [...data.messages, next]
+	};
+	return {
+		...data,
+		messages: [
+			...data.messages.slice(0, before),
+			next,
+			...data.messages.slice(before)
+		]
+	};
+}
+function optimisticUserMessageId(submissionId) {
+	return `optimistic:${submissionId}:user`;
+}
+
+//#endregion
+//#region src/client/message-run-parts.ts
+function transition(message, input) {
+	const index = message.parts.findLastIndex((part) => part.type === input.type && part.stepIndex === input.stepIndex);
+	const previous = index === -1 ? void 0 : message.parts[index];
+	if (input.kind === "append" && !input.delta) return message;
+	const current = previous?.state === "streaming" ? previous : void 0;
+	const part = {
+		id: current?.id ?? input.id ?? `${message.id}:${input.type}:${message.parts.length}`,
+		state: input.kind === "append" ? "streaming" : "done",
+		stepIndex: input.stepIndex,
+		text: input.kind === "append" ? (current?.text ?? "") + input.delta : input.text,
+		type: input.type
+	};
+	const parts = current ? [
+		...message.parts.slice(0, index),
+		part,
+		...message.parts.slice(index + 1)
+	] : [...message.parts, part];
+	return {
+		...message,
+		metadata: {
+			...message.metadata,
+			status: input.type === "text" && part.state === "done" ? "complete" : "streaming"
+		},
+		parts
+	};
+}
+const messageRun = { transition };
+
+//#endregion
+//#region src/client/message-task-parts.ts
+function createSettledTaskPart(existing, event) {
+	const settledPartBase = {
+		approval: approvedApproval(existing),
+		input: existing.input,
+		stepIndex: existing.stepIndex,
+		toolCallId: existing.toolCallId,
+		toolMetadata: existing.toolMetadata,
+		toolName: existing.toolName,
+		type: "dynamic-tool"
+	};
+	switch (event.data.status) {
+		case "completed": return {
+			...settledPartBase,
+			output: event.data.output,
+			state: "output-available"
 		};
-		if (this.#prewarmPromise !== void 0) {
-			await waitWithSignal(this.#prewarmPromise.catch((error) => {
-				if (this.#session !== void 0) throw error;
-			}), input.signal);
-			input.signal?.throwIfAborted();
+		case "failed": return {
+			...settledPartBase,
+			errorText: event.data.error?.message ?? "Task failed.",
+			state: "output-error"
+		};
+		case "cancelled": return {
+			...settledPartBase,
+			errorText: "Task was cancelled.",
+			state: "output-error"
+		};
+	}
+}
+
+//#endregion
+//#region src/client/message-reducer.ts
+function receivedMessageEventId(event) {
+	return event.meta.id ?? `${event.data.turnId}:${event.data.sequence}`;
+}
+function defaultMessageReducer() {
+	return {
+		initial() {
+			return { messages: [] };
+		},
+		reduce(data, event) {
+			return reduceMessageData(data, event);
 		}
-		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)
+	};
+}
+function reduceMessageData(data, event) {
+	switch (event.type) {
+		case "client.message.submitted":
+		case "client.message.failed": return upsertMessage(data, {
+			id: optimisticUserMessageId(event.data.submissionId),
+			metadata: {
+				optimistic: true,
+				status: event.type === "client.message.failed" ? "failed" : "submitted"
+			},
+			parts: [{
+				type: "text",
+				text: event.data.message
+			}],
+			role: "user"
+		}, event.data.turnId);
+		case "input.resolved": {
+			let next = data;
+			for (const resolution of event.data.resolutions) next = resolveInputRequest(next, resolution);
+			return next;
+		}
+		case "message.received": return upsertMessage(data, {
+			id: `${receivedMessageEventId(event)}:user`,
+			metadata: {
+				status: "complete",
+				turnId: event.data.turnId
+			},
+			parts: projectReceivedParts(event.data.parts, event.data.message),
+			role: "user"
+		}, event.data.turnId);
+		case "step.started": return updateAssistantMessage(data, event.data.turnId, (message) => ensureStepStartPart(message, event.data.stepIndex));
+		case "step.completed":
+			if (data.messages.find((message) => message.role === "assistant" && message.metadata?.turnId === event.data.turnId) === void 0) return data;
+			return updateAssistantMessage(data, event.data.turnId, (message) => ({
+				...message,
+				parts: closeStreamingRuns(message.parts, event.data.stepIndex)
+			}));
+		case "reasoning.appended": return updateAssistantMessage(data, event.data.turnId, (message) => messageRun.transition(ensureStepStartPart(message, event.data.stepIndex), {
+			kind: "append",
+			delta: event.data.reasoningDelta,
+			id: event.meta?.id,
+			stepIndex: event.data.stepIndex,
+			type: "reasoning"
+		}));
+		case "reasoning.completed": return updateAssistantMessage(data, event.data.turnId, (message) => messageRun.transition(ensureStepStartPart(message, event.data.stepIndex), {
+			kind: "complete",
+			stepIndex: event.data.stepIndex,
+			text: event.data.reasoning,
+			id: event.meta?.id,
+			type: "reasoning"
+		}));
+		case "action.input.appended": {
+			const existing = findToolPart(data, event.data.callId);
+			if (existing !== void 0 && existing.state !== "input-streaming") return data;
+			const nextPart = {
+				input: void 0,
+				inputText: (existing?.state === "input-streaming" ? existing.inputText : "") + event.data.inputTextDelta,
+				state: "input-streaming",
+				stepIndex: event.data.stepIndex,
+				toolCallId: event.data.callId,
+				toolMetadata: existing?.toolMetadata ?? { eve: {
+					kind: "unknown",
+					name: event.data.toolName
+				} },
+				toolName: event.data.toolName,
+				type: "dynamic-tool"
 			};
+			return upsertToolPart(data, event.data.turnId, event.data.stepIndex, nextPart);
 		}
-		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
-				};
+		case "actions.requested": {
+			let next = data;
+			for (const action of event.data.actions) {
+				const existing = findToolPart(next, action.callId);
+				if (existing !== void 0 && existing.state !== "input-streaming") continue;
+				const descriptor = normalizeActionRequest(action);
+				next = updateAssistantMessage(next, event.data.turnId, (message) => upsertPart(ensureStepStartPart(message, event.data.stepIndex), {
+					input: "input" in action ? action.input : void 0,
+					state: "input-available",
+					stepIndex: event.data.stepIndex,
+					toolCallId: action.callId,
+					toolMetadata: createToolMetadata(descriptor),
+					toolName: descriptor.toolName,
+					type: "dynamic-tool"
+				}));
 			}
-			const { inputResponses, ...options } = input;
-			return {
-				response: await this.#session.respond(inputResponses, options),
-				reader
-			};
-		} catch (error) {
-			reader[Symbol.dispose]();
-			throw error;
+			return next;
 		}
-	}
-	#ensureStream(options = {}) {
-		if (this.#stream !== void 0 && !this.#stream.ended) {
-			this.#stream.setOptions(options);
-			return this.#stream;
+		case "input.requested": {
+			let next = data;
+			for (const request of event.data.requests) {
+				const existing = findToolPart(next, request.action.callId);
+				if (existing?.approval?.id === request.requestId || existing !== void 0 && isSettledToolPart(existing)) continue;
+				const descriptor = normalizeActionRequest(request.action);
+				next = updateAssistantMessage(next, event.data.turnId, (message) => upsertPart(ensureStepStartPart(message, event.data.stepIndex), {
+					approval: { id: request.requestId },
+					input: request.action.input,
+					state: "approval-requested",
+					stepIndex: event.data.stepIndex,
+					toolCallId: request.action.callId,
+					toolMetadata: createToolMetadata(descriptor, { inputRequest: toMessageInputRequest(request) }),
+					toolName: descriptor.toolName,
+					type: "dynamic-tool"
+				}));
+			}
+			return next;
 		}
-		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();
+		case "approval.candidate": return data;
+		case "approval.settled": {
+			const existing = findToolPartByApprovalId(data, event.data.requestId);
+			if (existing === void 0) return data;
+			if (event.data.outcome === "approved") {
+				const approval = {
+					approved: true,
+					id: event.data.requestId,
+					reason: void 0
+				};
+				return updateToolPart(data, existing.toolCallId, existing.state === "output-available" ? {
+					...existing,
+					approval
+				} : {
+					...toolPartIdentity(existing),
+					approval,
+					state: "approval-responded"
+				});
 			}
-		});
-		return this.#stream;
-	}
-	#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();
+			if (existing.state === "output-available") return data;
+			return updateToolPart(data, existing.toolCallId, {
+				...toolPartIdentity(existing),
+				approval: {
+					approved: false,
+					id: event.data.requestId,
+					reason: "Tool execution was cancelled."
+				},
+				state: "output-denied"
+			});
 		}
-	}
-	#isActiveTurn(turn) {
-		return this.#activeTurn === turn;
-	}
-	#projectInputResponses(input) {
-		if (input.inputResponses === void 0 || input.inputResponses.length === 0) return;
-		this.#projection.append({
-			data: {
-				createdAt: Date.now(),
-				responses: input.inputResponses
-			},
-			type: "client.input.responded"
-		});
-	}
-	#acceptServerEvent(event) {
-		if (!this.#seenEvents.admit(event)) return;
-		const wasStreaming = this.#status === "streaming";
-		this.#trackPendingRequests(event);
-		this.#events = [...this.#events, event];
-		this.#handleReconciliation(this.#messageSubmissions.apply(event));
-		this.#callbacks.onEvent?.(event);
-		this.#applyTerminalStreamFailure(event);
-		const settled = this.#isSettledAt(event);
-		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";
+		case "action.result": {
+			const descriptor = normalizeActionResult(event.data.result);
+			const existing = findToolPart(data, event.data.result.callId);
+			const denied = event.data.status === "rejected" || event.data.error?.code === "TOOL_EXECUTION_DENIED";
+			const failed = event.data.status === "failed" && !denied;
+			const approvalId = existing?.approval?.id ?? event.data.result.callId;
+			const toolMetadata = mergeToolMetadata(existing?.toolMetadata, createToolMetadata(descriptor));
+			const resultPartBase = {
+				input: existing?.input,
+				stepIndex: event.data.stepIndex,
+				toolCallId: event.data.result.callId,
+				toolMetadata,
+				toolName: existing?.toolName ?? descriptor.toolName,
+				type: "dynamic-tool"
+			};
+			let nextPart;
+			if (denied) nextPart = {
+				...resultPartBase,
+				approval: {
+					approved: false,
+					id: approvalId,
+					reason: event.data.error?.message
+				},
+				state: "output-denied"
+			};
+			else if (failed) nextPart = {
+				...resultPartBase,
+				approval: approvedApproval(existing),
+				errorText: event.data.error?.message ?? stringifyUnknown(event.data.result.output),
+				state: "output-error"
+			};
+			else nextPart = {
+				...resultPartBase,
+				approval: approvedApproval(existing),
+				output: event.data.result.output,
+				state: "output-available"
+			};
+			return upsertToolPart(data, event.data.turnId, event.data.stepIndex, nextPart);
 		}
-		this.#callbacks.onSessionChange?.(this.#session?.state);
-		if (this.#status !== "resuming") this.#publish();
-		if (this.#activeTurn === void 0 && wasStreaming && settled) this.#callbacks.onFinish?.(this.#snapshot);
-	}
-	#trackPendingRequests(event) {
-		updatePendingAuthorizations(this.#pendingAuthorizations, event);
-		updatePendingInputRequests(this.#pendingInputRequests, event);
-	}
-	#isSettledAt(event) {
-		return isTurnSegmentBoundary(event, this.#pendingInputRequests) && this.#pendingAuthorizations.size === 0;
-	}
-	#handleReconciliation(reconciliation) {
-		if (reconciliation === void 0) return false;
-		let followed = 0;
-		for (const id of reconciliation.ids) if (this.#activeTurn?.followUpSubmissionIds.delete(id)) followed += 1;
-		if (followed > 0 && this.#activeTurn !== void 0) {
-			if (reconciliation.alreadyProjected) this.#activeTurn.receivedFollowUps += followed;
-			else {
-				const previous = this.#activeTurn.receivedFollowUpEvents.get(reconciliation.event) ?? 0;
-				this.#activeTurn.receivedFollowUpEvents.set(reconciliation.event, previous + followed);
-			}
+		case "action.partial": {
+			const existing = findToolPart(data, event.data.result.callId);
+			if (existing !== void 0 && isSettledToolPart(existing)) return data;
+			const descriptor = normalizeActionResult(event.data.result);
+			const nextPart = {
+				approval: approvedApproval(existing),
+				input: existing?.input,
+				output: event.data.result.output,
+				partial: true,
+				state: "output-available",
+				stepIndex: event.data.stepIndex,
+				toolCallId: event.data.result.callId,
+				toolMetadata: mergeToolMetadata(existing?.toolMetadata, createToolMetadata(descriptor)),
+				toolName: existing?.toolName ?? descriptor.toolName,
+				type: "dynamic-tool"
+			};
+			return upsertToolPart(data, event.data.turnId, event.data.stepIndex, nextPart);
 		}
-		return true;
-	}
-	#applyTerminalStreamFailure(event) {
-		const error = toTerminalStreamFailureError(event);
-		if (error === void 0) return;
-		this.#status = "error";
-		this.#messageSubmissions.failAll(error);
-		if (this.#error === void 0) {
-			this.#error = error;
-			this.#callbacks.onError?.(error);
+		case "task.settled": {
+			const existing = findToolPart(data, event.data.callId);
+			if (existing === void 0) return data;
+			return replaceToolPart(data, createSettledTaskPart(existing, event));
 		}
+		case "authorization.required": return updateAssistantMessage(data, event.data.turnId, (message) => upsertPart(ensureStepStartPart(message, event.data.stepIndex), createAuthorizationRequiredPart(event)));
+		case "authorization.completed": return completeAuthorization(data, event);
+		case "message.appended": return updateAssistantMessage(data, event.data.turnId, (message) => messageRun.transition(ensureStepStartPart(message, event.data.stepIndex), {
+			kind: "append",
+			delta: event.data.messageDelta,
+			id: event.meta?.id,
+			stepIndex: event.data.stepIndex,
+			type: "text"
+		}));
+		case "message.completed": return updateAssistantMessage(data, event.data.turnId, (message) => messageRun.transition(ensureStepStartPart(message, event.data.stepIndex), {
+			kind: "complete",
+			stepIndex: event.data.stepIndex,
+			text: event.data.message,
+			id: event.meta?.id,
+			type: "text"
+		}));
+		case "result.completed": return updateAssistantMessage(data, event.data.turnId, (message) => ({
+			...message,
+			metadata: {
+				...message.metadata,
+				result: event.data.result
+			}
+		}));
+		case "turn.completed": return updateAssistantMessage(data, event.data.turnId, (message) => ({
+			...message,
+			metadata: {
+				...message.metadata,
+				status: "complete"
+			},
+			parts: removeStreamingToolParts(closeStreamingRuns(message.parts))
+		}));
+		case "turn.cancelled": return updateAssistantMessage(data, event.data.turnId, (message) => ({
+			...message,
+			metadata: {
+				...message.metadata,
+				status: "complete"
+			},
+			parts: removeStreamingToolParts(closeStreamingRuns(message.parts))
+		}));
+		case "turn.failed":
+			if (data.messages.find((message) => message.role === "assistant" && message.metadata?.turnId === event.data.turnId) === void 0) return data;
+			return updateAssistantMessage(data, event.data.turnId, (message) => ({
+				...message,
+				metadata: {
+					...message.metadata,
+					status: "complete"
+				},
+				parts: removeStreamingToolParts(closeStreamingRuns(message.parts))
+			}));
+		case "session.failed": return data;
+		default: return data;
 	}
-	#createSnapshot() {
-		return {
-			data: this.#projection.data,
-			error: this.#error,
-			events: this.#events,
-			session: this.#session?.state,
-			status: this.#status
-		};
-	}
-	#publish() {
-		this.#snapshot = this.#createSnapshot();
-		for (const subscriber of this.#subscribers) subscriber();
-	}
-};
-function detachEveAgentStore(store) {
-	store[detachStore]();
 }
-function attachEveAgentStore(store) {
-	store[attachStore]();
+function closeStreamingRuns(parts, stepIndex) {
+	return parts.map((part) => (part.type === "text" || part.type === "reasoning") && part.state === "streaming" && (stepIndex === void 0 || part.stepIndex === stepIndex) ? {
+		...part,
+		state: "done"
+	} : part);
 }
-
-//#endregion
-//#region src/client/agent-host.ts
-const AGENT_NAME_PATTERN = /^[a-z0-9][a-z0-9_-]*$/;
-const EVE_NAMED_AGENT_ROUTE_PREFIX = "/eve";
-function resolveEveAgentHost(input) {
-	if (input.agent === void 0) return input.host ?? "";
-	if (input.host !== void 0) throw new Error("useEveAgent cannot combine agent and host. Use one target option.");
-	assertValidAgentName(input.agent);
-	return `${EVE_NAMED_AGENT_ROUTE_PREFIX}/${input.agent}`;
+function removeStreamingToolParts(parts) {
+	return parts.filter((part) => part.type !== "dynamic-tool" || part.state !== "input-streaming");
 }
-function assertValidAgentName(name) {
-	if (!AGENT_NAME_PATTERN.test(name)) throw new Error(`eve agent name ${JSON.stringify(name)} is invalid. Use lowercase letters, numbers, underscores, or hyphens, starting with a letter or number.`);
+function respondToInputRequest(data, response) {
+	const existing = findToolPartByApprovalId(data, response.requestId);
+	if (!existing) return data;
+	const approval = { id: response.requestId };
+	if (response.text !== void 0) approval.reason = response.text;
+	const toolMetadata = mergeToolMetadata(existing.toolMetadata, { eve: {
+		inputResponse: response,
+		kind: existing.toolMetadata?.eve?.kind ?? "unknown",
+		name: existing.toolMetadata?.eve?.name ?? existing.toolName
+	} });
+	return updateToolPart(data, existing.toolCallId, existing.state === "output-available" ? {
+		...existing,
+		approval: {
+			...approval,
+			approved: true
+		},
+		toolMetadata
+	} : {
+		...toolPartIdentity(existing),
+		approval,
+		state: "approval-responded",
+		toolMetadata
+	});
 }
-
-//#endregion
-//#region src/client/authorization-message-parts.ts
-function createAuthorizationRequiredPart(event) {
-	const displayName = event.data.authorization?.displayName ?? formatAuthorizationDisplayName(event.data.name);
+function resolveInputRequest(data, resolution) {
+	if (resolution.response !== void 0) return findToolPartByApprovalId(data, resolution.requestId)?.approval?.approved === void 0 ? respondToInputRequest(data, resolution.response) : data;
+	const existing = findToolPartByApprovalId(data, resolution.requestId);
+	if (!existing) return data;
+	return updateToolPart(data, existing.toolCallId, {
+		...toolPartIdentity(existing),
+		output: { status: resolution.outcome },
+		state: "output-available"
+	});
+}
+function toolPartIdentity(part) {
 	return {
-		authorization: event.data.authorization,
-		description: normalizeAuthorizationDescription(event.data.description, event.data.name, displayName),
-		displayName,
-		name: event.data.name,
-		state: "required",
-		stepIndex: event.data.stepIndex,
-		turnId: event.data.turnId,
-		type: "authorization"
+		input: part.input,
+		stepIndex: part.stepIndex,
+		toolCallId: part.toolCallId,
+		toolMetadata: part.toolMetadata,
+		toolName: part.toolName,
+		type: part.type
 	};
 }
-function createAuthorizationCompletedPart(event, existing) {
-	const displayName = event.data.authorization?.displayName ?? existing?.displayName ?? formatAuthorizationDisplayName(event.data.name);
+function updateAssistantMessage(data, turnId, update) {
+	const message = data.messages.find((message) => message.role === "assistant" && message.metadata?.turnId === turnId) ?? createAssistantMessage(turnId);
+	return upsertMessage(data, update(message));
+}
+function createAssistantMessage(turnId) {
 	return {
-		authorization: existing?.authorization || event.data.authorization ? {
-			...existing?.authorization,
-			...event.data.authorization
-		} : void 0,
-		description: existing?.description ?? buildCompletedAuthorizationDescription(displayName, event.data.outcome, event.data.reason),
-		displayName,
-		name: event.data.name,
-		outcome: event.data.outcome,
-		reason: event.data.reason,
-		state: "completed",
-		stepIndex: existing?.stepIndex ?? event.data.stepIndex,
-		turnId: existing?.turnId ?? event.data.turnId,
-		type: "authorization"
+		id: `${turnId}:assistant`,
+		metadata: {
+			status: "streaming",
+			turnId
+		},
+		parts: [],
+		role: "assistant"
 	};
 }
-function buildCompletedAuthorizationDescription(displayName, outcome, reason) {
-	if (outcome === "authorized") return `${displayName} connected.`;
-	return `${displayName} authorization ${outcome}${reason !== void 0 ? ` (${reason})` : ""}.`;
+function ensureStepStartPart(message, stepIndex) {
+	const stepStartCount = message.parts.filter((part) => part.type === "step-start").length;
+	if (stepStartCount > stepIndex) return message;
+	const missingCount = stepIndex - stepStartCount + 1;
+	return {
+		...message,
+		parts: [...message.parts, ...Array.from({ length: missingCount }, () => ({ type: "step-start" }))]
+	};
 }
-function normalizeAuthorizationDescription(description, name, displayName) {
-	if (description === `Authorization required for ${name}`) return `Authorization required for ${displayName}`;
-	return description;
+function upsertPart(message, next) {
+	const index = message.parts.findIndex((part) => partKey(part) === partKey(next));
+	const parts = index === -1 ? [...message.parts, next] : [
+		...message.parts.slice(0, index),
+		next,
+		...message.parts.slice(index + 1)
+	];
+	return {
+		...message,
+		metadata: {
+			...message.metadata,
+			status: next.type === "text" && next.state === "done" ? "complete" : "streaming"
+		},
+		parts
+	};
 }
-function formatAuthorizationDisplayName(name) {
-	if (name.length === 0) return name;
-	return `${name.charAt(0).toUpperCase()}${name.slice(1)}`;
+function upsertToolPart(data, turnId, stepIndex, part) {
+	const updated = updateToolPart(data, part.toolCallId, part);
+	return updated !== data ? updated : updateAssistantMessage(data, turnId, (message) => upsertPart(ensureStepStartPart(message, stepIndex), part));
 }
-
-//#endregion
-//#region src/shared/action-request-name.ts
-function actionRequestName(action) {
-	switch (action.kind) {
-		case "load-skill": return "load_skill";
-		case "subagent-call": return action.subagentName;
-		case "remote-agent-call": return action.remoteAgentName;
-		case "tool-call":
-		case "workflow-tool-call": return action.toolName;
+function updateToolPart(data, toolCallId, next) {
+	const message = data.messages.find((candidate) => candidate.role === "assistant" && candidate.parts.some((part) => part.type === "dynamic-tool" && part.toolCallId === toolCallId));
+	if (!message) return data;
+	return upsertMessage(data, upsertPart(message, next));
+}
+function replaceToolPart(data, next) {
+	const message = data.messages.find((candidate) => candidate.parts.some((part) => part.type === "dynamic-tool" && part.toolCallId === next.toolCallId));
+	if (message === void 0) return data;
+	return upsertMessage(data, {
+		...message,
+		parts: message.parts.map((part) => partKey(part) === partKey(next) ? next : part)
+	});
+}
+function completeAuthorization(data, event) {
+	const existing = findPendingAuthorizationPart(data, event.data.name, event.data.attemptId);
+	const next = createAuthorizationCompletedPart(event, existing);
+	return updateAssistantMessage(data, existing?.turnId ?? event.data.turnId, (message) => upsertPart(ensureStepStartPart(message, next.stepIndex), next));
+}
+function findToolPart(data, toolCallId) {
+	for (const message of data.messages) for (const part of message.parts) if (part.type === "dynamic-tool" && part.toolCallId === toolCallId) return part;
+}
+function isSettledToolPart(part) {
+	return part.state === "output-denied" || part.state === "output-error" || part.state === "output-available" && part.partial !== true;
+}
+function findPendingAuthorizationPart(data, name, attemptId) {
+	for (let messageIndex = data.messages.length - 1; messageIndex >= 0; messageIndex -= 1) {
+		const message = data.messages[messageIndex];
+		if (message?.role !== "assistant") continue;
+		for (let partIndex = message.parts.length - 1; partIndex >= 0; partIndex -= 1) {
+			const part = message.parts[partIndex];
+			if (part?.type === "authorization" && part.state === "required" && (attemptId === void 0 ? part.attemptId === void 0 && part.name === name : part.attemptId === attemptId)) return part;
+		}
 	}
 }
-
-//#endregion
-//#region src/client/message-action-parts.ts
-function toMessageInputRequest(request) {
-	return {
-		allowFreeform: request.allowFreeform,
-		display: request.display,
-		kind: request.kind,
-		options: request.options,
-		prompt: request.prompt,
-		requestId: request.requestId
-	};
+function findToolPartByApprovalId(data, approvalId) {
+	for (const message of data.messages) for (const part of message.parts) if (part.type === "dynamic-tool" && part.approval?.id === approvalId) return part;
 }
-function createToolMetadata(descriptor, extra) {
-	return { eve: {
-		inputRequest: extra?.inputRequest,
-		kind: descriptor.kind,
-		name: descriptor.name
-	} };
+
+//#endregion
+//#region src/client/conversation-reducer.ts
+function initialConversationState() {
+	return {
+		messages: [],
+		turns: {},
+		inputs: {},
+		tasks: {},
+		agents: {}
+	};
 }
-function mergeToolMetadata(current, next) {
-	const kind = next.eve?.kind ?? current?.eve?.kind ?? "unknown";
-	const name = next.eve?.name ?? current?.eve?.name ?? "unknown";
-	return { eve: {
-		...current?.eve,
-		...next.eve,
-		inputRequest: next.eve?.inputRequest ?? current?.eve?.inputRequest,
-		inputResponse: next.eve?.inputResponse ?? current?.eve?.inputResponse,
-		kind,
-		name
-	} };
+function updateTurn(state, turnId, update) {
+	const turn = state.turns[turnId];
+	if (turn === void 0) return state;
+	const next = update(turn);
+	return next === turn ? state : {
+		...state,
+		turns: {
+			...state.turns,
+			[turnId]: next
+		}
+	};
 }
-function approvedApproval(part) {
-	if (!part?.approval?.id) return;
+function updateTask(state, taskId, update) {
+	const task = state.tasks[taskId];
+	if (task === void 0) return state;
+	const next = update(task);
+	return next === task ? state : {
+		...state,
+		tasks: {
+			...state.tasks,
+			[taskId]: next
+		}
+	};
+}
+function updateObservation(state, sessionId, update) {
+	const agent = state.agents[sessionId];
+	if (agent === void 0) return state;
+	const observation = update(agent.observation);
+	if (observation === agent.observation) return state;
 	return {
-		approved: true,
-		id: part.approval.id,
-		isAutomatic: part.approval.isAutomatic,
-		reason: part.approval.reason
+		...state,
+		agents: {
+			...state.agents,
+			[sessionId]: {
+				...agent,
+				observation
+			}
+		}
 	};
 }
-function normalizeActionRequest(action) {
-	const name = actionRequestName(action);
-	switch (action.kind) {
-		case "load-skill": return {
-			kind: "load-skill",
-			name,
-			toolName: "eve:load-skill"
-		};
-		case "tool-call":
-		case "workflow-tool-call": return {
-			kind: "tool-call",
-			name,
-			toolName: name
-		};
-		case "subagent-call":
-		case "remote-agent-call": return {
-			kind: "subagent-call",
-			name,
-			toolName: `eve:subagent:${name}`
-		};
-	}
+function observedConversation(observation) {
+	return observation.status === "not-followed" ? void 0 : observation.conversation;
 }
-function normalizeActionResult(result) {
-	switch (result.kind) {
-		case "load-skill-result": return {
-			kind: "load-skill",
-			name: result.name ?? "load_skill",
-			toolName: "eve:load-skill"
-		};
-		case "tool-result": return {
-			kind: "tool-call",
-			name: result.toolName,
-			toolName: result.toolName
+function reduceConversationLifecycle(state, event) {
+	switch (event.type) {
+		case "turn.started": return {
+			...state,
+			activeTurnId: event.data.turnId,
+			turns: {
+				...state.turns,
+				[event.data.turnId]: {
+					turnId: event.data.turnId,
+					status: "active"
+				}
+			}
 		};
-		case "subagent-result": return {
-			kind: "subagent-call",
-			name: result.subagentName,
-			toolName: `eve:subagent:${result.subagentName}`
+		case "turn.waiting": return updateTurn(state, event.data.turnId, (turn) => turn.status === "active" && !turn.waiting ? {
+			...turn,
+			waiting: true
+		} : turn);
+		case "step.started": return updateTurn(state, event.data.turnId, (turn) => turn.waiting ? {
+			turnId: turn.turnId,
+			status: turn.status
+		} : turn);
+		case "turn.completed":
+		case "turn.cancelled":
+		case "turn.failed": {
+			const { turnId } = event.data;
+			return {
+				...state,
+				activeTurnId: state.activeTurnId === turnId ? void 0 : state.activeTurnId,
+				turns: {
+					...state.turns,
+					[turnId]: {
+						turnId,
+						status: event.type === "turn.completed" ? "completed" : event.type === "turn.failed" ? "failed" : "cancelled"
+					}
+				}
+			};
+		}
+		case "session.waiting":
+		case "session.completed":
+		case "session.failed": return state.activeTurnId === void 0 ? state : {
+			...state,
+			activeTurnId: void 0
 		};
+		case "task.started": {
+			const { callId, kind, name, taskId, turnId } = event.data;
+			const task = state.tasks[taskId] ?? {
+				taskId,
+				name,
+				kind,
+				calls: {}
+			};
+			if (task.calls[callId] !== void 0) return state;
+			return {
+				...state,
+				tasks: {
+					...state.tasks,
+					[taskId]: {
+						...task,
+						calls: {
+							...task.calls,
+							[callId]: {
+								callId,
+								turnId,
+								status: "working"
+							}
+						}
+					}
+				}
+			};
+		}
+		case "task.settled": {
+			const { callId, error, output, status, taskId } = event.data;
+			return updateTask(state, taskId, (task) => {
+				const call = task.calls[callId];
+				if (call === void 0 || call.status !== "working") return task;
+				const settled = {
+					callId,
+					turnId: call.turnId,
+					status
+				};
+				return {
+					...task,
+					calls: {
+						...task.calls,
+						[callId]: status === "completed" && output !== void 0 ? {
+							...settled,
+							output
+						} : status === "failed" && error !== void 0 ? {
+							...settled,
+							error
+						} : settled
+					}
+				};
+			});
+		}
+		case "agent.started": {
+			const { callId, name, sessionId, taskId, turnId } = event.data;
+			if (state.agents[sessionId] !== void 0) return state;
+			const agent = {
+				sessionId,
+				name,
+				callId,
+				turnId,
+				observation: { status: "not-followed" }
+			};
+			if (taskId !== void 0) agent.taskId = taskId;
+			return {
+				...state,
+				agents: {
+					...state.agents,
+					[sessionId]: agent
+				}
+			};
+		}
+		case "input.requested": {
+			const inputs = { ...state.inputs };
+			for (const request of event.data.requests) {
+				if (inputs[request.requestId] !== void 0) continue;
+				const input = {
+					request,
+					turnId: event.data.turnId,
+					stepIndex: event.data.stepIndex,
+					status: "open"
+				};
+				if (event.data.taskId !== void 0) input.taskId = event.data.taskId;
+				inputs[request.requestId] = input;
+			}
+			return {
+				...state,
+				inputs
+			};
+		}
+		case "client.input.responded": {
+			const inputs = { ...state.inputs };
+			for (const response of event.data.responses) {
+				const current = inputs[response.requestId];
+				if (current?.status !== "open") continue;
+				inputs[response.requestId] = {
+					...current,
+					response,
+					status: "responded"
+				};
+			}
+			return {
+				...state,
+				inputs
+			};
+		}
+		case "approval.candidate": {
+			const current = state.inputs[event.data.requestId];
+			if (current === void 0 || current.status === "settled") return state;
+			if (event.data.outcome === "pending") return state;
+			return {
+				...state,
+				inputs: {
+					...state.inputs,
+					[event.data.requestId]: {
+						...current,
+						status: "open",
+						response: void 0
+					}
+				}
+			};
+		}
+		case "approval.settled": {
+			const current = state.inputs[event.data.requestId];
+			if (current === void 0 || current.status === "settled") return state;
+			return {
+				...state,
+				inputs: {
+					...state.inputs,
+					[event.data.requestId]: {
+						...current,
+						status: "settled",
+						outcome: event.data.outcome
+					}
+				}
+			};
+		}
+		case "input.resolved": {
+			const inputs = { ...state.inputs };
+			for (const resolution of event.data.resolutions) {
+				const current = inputs[resolution.requestId];
+				if (current === void 0 || current.status === "settled") continue;
+				inputs[resolution.requestId] = {
+					...current,
+					status: "settled",
+					outcome: resolution.outcome,
+					response: resolution.response ?? current.response
+				};
+			}
+			return {
+				...state,
+				inputs
+			};
+		}
+		default: return state;
 	}
 }
-function stringifyUnknown(value) {
-	if (typeof value === "string") return value;
-	try {
-		return JSON.stringify(value);
-	} catch {
-		return "Action failed.";
+const messageReducer = defaultMessageReducer();
+function reduceConversation(state, event) {
+	switch (event.type) {
+		case "client.agent.following": return updateObservation(state, event.data.sessionId, (observation) => observation.status === "following" ? observation : {
+			status: "following",
+			conversation: observedConversation(observation) ?? initialConversationState()
+		});
+		case "client.agent.observed": return updateObservation(state, event.data.sessionId, (observation) => observation.status === "following" ? {
+			status: "following",
+			conversation: reduceConversation(observation.conversation, event.data.event)
+		} : observation);
+		case "client.agent.idle": return updateObservation(state, event.data.sessionId, (observation) => observation.status === "following" ? {
+			status: "idle",
+			conversation: observation.conversation
+		} : observation);
+		case "client.agent.unavailable": return updateObservation(state, event.data.sessionId, (observation) => {
+			const conversation = observedConversation(observation);
+			return conversation === void 0 ? { status: "unavailable" } : {
+				status: "unavailable",
+				conversation
+			};
+		});
+		default: {
+			const projected = messageReducer.reduce(state, event);
+			return reduceConversationLifecycle({
+				...state,
+				...projected
+			}, event);
+		}
 	}
 }
+const canonicalConversationReducer = {
+	initial: initialConversationState,
+	reduce: reduceConversation
+};
+const conversationReducer = canonicalConversationReducer;
 
 //#endregion
-//#region src/client/message-reducer-primitives.ts
-function projectReceivedParts(parts, message) {
-	return parts?.map((part) => part.type === "text" ? {
-		state: "done",
-		text: part.text,
-		type: "text"
-	} : {
-		filename: part.filename,
-		mediaType: part.mediaType,
-		size: part.size,
-		type: "file",
-		url: part.url
-	}) ?? [{
-		state: "done",
-		text: message,
-		type: "text"
-	}];
+//#region src/protocol/event-dedupe.ts
+function createEventDeduper() {
+	const seen = /* @__PURE__ */ new Set();
+	return {
+		admit(event) {
+			const id = event.meta?.id;
+			if (id === void 0) return true;
+			if (seen.has(id)) return false;
+			seen.add(id);
+			return true;
+		},
+		get size() {
+			return seen.size;
+		}
+	};
 }
-function partKey(part) {
-	switch (part.type) {
-		case "text": return `text:${part.stepIndex ?? 0}`;
-		case "reasoning": return `reasoning:${part.stepIndex ?? 0}`;
-		case "file": return `file:${part.stepIndex ?? 0}:${part.filename ?? part.url ?? part.mediaType}`;
-		case "step-start": return "step-start";
-		case "authorization": return `authorization:${part.turnId}:${part.stepIndex}:${part.name}`;
-		case "dynamic-tool": return `dynamic-tool:${part.toolCallId}`;
+
+//#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();
 	}
-}
-function upsertMessage(data, next) {
-	const index = data.messages.findIndex((message) => message.id === next.id);
-	if (index === -1) return { messages: [...data.messages, next] };
-	return { messages: [
-		...data.messages.slice(0, index),
-		next,
-		...data.messages.slice(index + 1)
-	] };
-}
-function removeStreamingToolPartsForTurn(data, turnId) {
-	const index = data.messages.findIndex((message) => message.role === "assistant" && message.metadata?.turnId === turnId);
-	const message = data.messages[index];
-	if (message === void 0) return data;
-	return upsertMessage(data, {
-		...message,
-		parts: message.parts.filter((part) => part.type !== "dynamic-tool" || part.state !== "input-streaming")
-	});
-}
-function optimisticUserMessageId(submissionId) {
-	return `optimistic:${submissionId}:user`;
-}
+	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/message-run-parts.ts
-function append(message, append) {
-	const current = latestStreamingRun(message, append.type, append.stepIndex);
-	return upsert(message, {
-		state: "streaming",
-		stepIndex: append.stepIndex,
-		text: (current?.text ?? "") + append.delta,
-		type: append.type
-	});
-}
-function latestStreamingRun(message, type, stepIndex) {
-	for (let index = message.parts.length - 1; index >= 0; index -= 1) {
-		const part = message.parts[index];
-		if (part?.type === type && part.stepIndex === stepIndex) return part.state === "streaming" ? part : void 0;
+//#region src/client/conversation-client.ts
+var ConversationClient = class {
+	projection;
+	#conversation;
+	#cursors = /* @__PURE__ */ new Map();
+	#seenEvents = createEventDeduper();
+	#follower;
+	#stream;
+	#onChange;
+	#onConversationChange;
+	constructor(projection, onChange, onConversationChange) {
+		this.projection = projection;
+		this.#conversation = projection.reducer === conversationReducer ? projection : new EveAgentProjection(canonicalConversationReducer, []);
+		this.#onChange = onChange;
+		this.#onConversationChange = onConversationChange;
 	}
-}
-function upsert(message, next) {
-	let lastIndex = -1;
-	for (let index = message.parts.length - 1; index >= 0; index -= 1) {
-		const part = message.parts[index];
-		if (part?.type === next.type && part.stepIndex === next.stepIndex) {
-			lastIndex = index;
-			break;
+	get data() {
+		return this.projection.data;
+	}
+	get conversation() {
+		return this.#conversation.data;
+	}
+	get projections() {
+		return this.#conversation === this.projection ? [this.projection] : [this.#conversation, this.projection];
+	}
+	get following() {
+		return this.#follower !== void 0;
+	}
+	append(event) {
+		const previous = this.data;
+		const previousConversation = this.conversation;
+		this.#appendRoot(event);
+		if (previous !== this.data) this.#onChange(this.data, previous);
+		else if (previousConversation !== this.conversation) this.#onConversationChange?.(this.conversation, previousConversation);
+	}
+	projectResponses(responses) {
+		if (!responses?.length) return void 0;
+		const event = {
+			data: {
+				createdAt: Date.now(),
+				responses
+			},
+			type: "client.input.responded"
+		};
+		this.append(event);
+		return () => this.#retract(event);
+	}
+	replaceResponses(retract, input) {
+		retract?.();
+		assertAnswerable(input, this.conversation);
+		return this.projectResponses(input.inputResponses);
+	}
+	#retract(event) {
+		const previous = this.data;
+		const previousConversation = this.conversation;
+		for (const projection of this.projections) projection.remove((entry) => entry === event);
+		if (previous !== this.data) this.#onChange(this.data, previous);
+		else if (previousConversation !== this.conversation) this.#onConversationChange?.(this.conversation, previousConversation);
+	}
+	observe(event, options = {}) {
+		if (!this.#seenEvents.admit(event)) return false;
+		options.onAccepted?.(event);
+		const previous = this.data;
+		const previousConversation = this.conversation;
+		if (options.project) options.project(event);
+		else this.#appendRoot(event);
+		if (options.notify !== false) {
+			if (previous !== this.data) this.#onChange(this.data, previous);
+			else if (previousConversation !== this.conversation) this.#onConversationChange?.(this.conversation, previousConversation);
 		}
+		this.#follower?.acceptParentEvent(event);
+		this.#follower?.reconcile();
+		return true;
+	}
+	hydrate(event) {
+		if (!this.#seenEvents.admit(event)) return false;
+		this.#appendRoot(event);
+		return true;
+	}
+	follow(session, events = []) {
+		this.#follower?.abortAll();
+		const follower = new AgentStreamFollower({
+			session,
+			cursors: this.#cursors,
+			getState: () => this.conversation,
+			onFollowing: (sessionId) => this.#appendChild({
+				type: "client.agent.following",
+				data: { sessionId }
+			}),
+			onEvent: (sessionId, event) => this.#appendChild({
+				type: "client.agent.observed",
+				data: {
+					sessionId,
+					event
+				}
+			}),
+			onIdle: (sessionId) => this.#appendChild({
+				type: "client.agent.idle",
+				data: { sessionId }
+			}),
+			onUnavailable: (sessionId) => this.#appendChild({
+				type: "client.agent.unavailable",
+				data: { sessionId }
+			})
+		});
+		this.#follower = follower;
+		for (const event of events) follower.acceptParentEvent(event);
+		follower.reconcile();
+	}
+	#appendRoot(event) {
+		for (const projection of this.projections) projection.append(event);
+	}
+	#appendChild(event) {
+		const previous = this.data;
+		const previousConversation = this.conversation;
+		this.#conversation.append(event);
+		if (previous !== this.data) this.#onChange(this.data, previous);
+		else if (previousConversation !== this.conversation) this.#onConversationChange?.(this.conversation, previousConversation);
+	}
+	stream(session, options) {
+		if (this.#stream !== void 0 && !this.#stream.ended) {
+			this.#stream.setOptions(options);
+			return this.#stream;
+		}
+		this.#stream = new SessionEventStream(session, options);
+		return this.#stream;
+	}
+	stop() {
+		this.#follower?.abortAll();
+		this.#follower = void 0;
+		this.#stream?.close();
+		this.#stream = void 0;
+	}
+	reset() {
+		this.stop();
+		this.#cursors.clear();
+		this.#seenEvents = createEventDeduper();
+		for (const projection of this.projections) projection.reset();
 	}
-	const parts = lastIndex !== -1 && message.parts[lastIndex].state === "streaming" ? [
-		...message.parts.slice(0, lastIndex),
-		next,
-		...message.parts.slice(lastIndex + 1)
-	] : [...message.parts, next];
-	return {
-		...message,
-		metadata: {
-			...message.metadata,
-			status: next.type === "text" && next.state === "done" ? "complete" : "streaming"
-		},
-		parts
-	};
-}
-const messageRun = {
-	append,
-	upsert
 };
 
 //#endregion
-//#region src/client/message-task-parts.ts
-function createSettledTaskPart(existing, event) {
-	const settledPartBase = {
-		approval: approvedApproval(existing),
-		input: existing.input,
-		stepIndex: existing.stepIndex,
-		toolCallId: existing.toolCallId,
-		toolMetadata: existing.toolMetadata,
-		toolName: existing.toolName,
-		type: "dynamic-tool"
-	};
-	switch (event.data.status) {
-		case "completed": return {
-			...settledPartBase,
-			output: event.data.output,
-			state: "output-available"
-		};
-		case "failed": return {
-			...settledPartBase,
-			errorText: event.data.error?.message ?? "Task failed.",
-			state: "output-error"
+//#region src/client/session-turn-dispatch.ts
+async function dispatchSessionTurn(input) {
+	const { client, session, turn, beforeSend } = input;
+	if (session === void 0) {
+		if (client === void 0) throw new Error("An external eve session is required before sending.");
+		if (turn.message === void 0) throw new Error("Cannot answer an input request before the session starts.");
+		const created = await client.sessions.create({
+			...turn,
+			message: turn.message
+		});
+		turn.signal?.throwIfAborted();
+		return {
+			...created,
+			created: true
 		};
-		case "cancelled": return {
-			...settledPartBase,
-			errorText: "Task was cancelled.",
-			state: "output-error"
+	}
+	beforeSend?.();
+	if (turn.inputResponses === void 0) {
+		const { message, ...options } = turn;
+		return {
+			session,
+			response: await session.send(message, options),
+			created: false
 		};
 	}
-}
-
-//#endregion
-//#region src/client/message-reducer.ts
-function receivedMessageEventId(event) {
-	return event.meta.id ?? `${event.data.turnId}:${event.data.sequence}`;
-}
-function defaultMessageReducer() {
+	const { inputResponses, ...options } = turn;
 	return {
-		initial() {
-			return { messages: [] };
-		},
-		reduce(data, event) {
-			return reduceMessageData(data, event);
-		}
+		session,
+		response: await session.respond(inputResponses, options),
+		created: false
 	};
 }
-function reduceMessageData(data, event) {
-	switch (event.type) {
-		case "client.message.submitted": return upsertMessage(data, {
-			id: optimisticUserMessageId(event.data.submissionId),
-			metadata: {
-				optimistic: true,
-				status: "submitted"
-			},
-			parts: [{
-				type: "text",
-				text: event.data.message
-			}],
-			role: "user"
-		});
-		case "client.message.failed": return upsertMessage(data, {
-			id: optimisticUserMessageId(event.data.submissionId),
-			metadata: {
-				optimistic: true,
-				status: "failed"
-			},
-			parts: [{
-				type: "text",
-				text: event.data.message
-			}],
-			role: "user"
+
+//#endregion
+//#region src/client/eve-agent-store.ts
+const detachStore = Symbol("detachEveAgentStore");
+const attachStore = Symbol("attachEveAgentStore");
+var EveAgentStore = class {
+	#client;
+	#autoPrewarm;
+	#attached = false;
+	#conversationClient;
+	#followChildStreams;
+	#externalSession;
+	#subscribers = /* @__PURE__ */ new Set();
+	#activeTurn;
+	#callbacks = {};
+	#error;
+	#events;
+	#messageSubmissions;
+	#prewarmGeneration = 0;
+	#prewarmPromise;
+	#prewarmController;
+	#resumePromise;
+	#session;
+	#snapshot;
+	#status = "ready";
+	constructor(init) {
+		this.#autoPrewarm = init.prewarm ?? false;
+		this.#followChildStreams = init.followSubagents ?? false;
+		this.#externalSession = init.session !== void 0;
+		this.#client = this.#externalSession ? void 0 : init.client ?? new Client({
+			auth: init.auth,
+			headers: init.headers,
+			host: init.host ?? ""
 		});
-		case "input.resolved": {
-			let next = data;
-			for (const resolution of event.data.resolutions) next = resolveInputRequest(next, resolution);
-			return next;
-		}
-		case "message.received": return upsertMessage(data, {
-			id: `${receivedMessageEventId(event)}:user`,
-			metadata: {
-				status: "complete",
-				turnId: event.data.turnId
-			},
-			parts: projectReceivedParts(event.data.parts, event.data.message),
-			role: "user"
+		this.#conversationClient = new ConversationClient(new EveAgentProjection(init.reducer, []), () => this.#publish(), () => this.#publish());
+		this.#events = (init.initialEvents ?? []).filter((event) => this.#conversationClient.hydrate(event));
+		this.#messageSubmissions = new OptimisticMessageSubmissions(this.#conversationClient.projections, init.optimistic ?? true);
+		this.#session = init.session ?? (init.initialSession === void 0 ? void 0 : this.#client?.sessions.attach(init.initialSession.sessionId, { streamIndex: init.initialSession.streamIndex }));
+		this.#snapshot = this.#createSnapshot();
+	}
+	get snapshot() {
+		return this.#snapshot;
+	}
+	setCallbacks(callbacks) {
+		this.#callbacks = callbacks;
+	}
+	subscribe(callback) {
+		this.#subscribers.add(callback);
+		return () => void 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");
 		});
-		case "step.started": return updateAssistantMessage(data, event.data.turnId, (message) => ensureStepStartPart(message, event.data.stepIndex));
-		case "reasoning.appended": return updateAssistantMessage(data, event.data.turnId, (message) => messageRun.append(ensureStepStartPart(message, event.data.stepIndex), {
-			delta: event.data.reasoningDelta,
-			stepIndex: event.data.stepIndex,
-			type: "reasoning"
-		}));
-		case "reasoning.completed": return updateAssistantMessage(data, event.data.turnId, (message) => messageRun.upsert(ensureStepStartPart(message, event.data.stepIndex), {
-			state: "done",
-			stepIndex: event.data.stepIndex,
-			text: event.data.reasoning,
-			type: "reasoning"
-		}));
-		case "action.input.appended": {
-			const existing = findToolPart(data, event.data.callId);
-			if (existing !== void 0 && existing.state !== "input-streaming") return data;
-			const nextPart = {
-				input: void 0,
-				inputText: (existing?.state === "input-streaming" ? existing.inputText : "") + event.data.inputTextDelta,
-				state: "input-streaming",
-				stepIndex: event.data.stepIndex,
-				toolCallId: event.data.callId,
-				toolMetadata: existing?.toolMetadata ?? { eve: {
-					kind: "unknown",
-					name: event.data.toolName
-				} },
-				toolName: event.data.toolName,
-				type: "dynamic-tool"
-			};
-			if (existing !== void 0) return updateToolPart(data, event.data.callId, nextPart);
-			return updateAssistantMessage(data, event.data.turnId, (message) => upsertPart(ensureStepStartPart(message, event.data.stepIndex), nextPart));
-		}
-		case "actions.requested": {
-			let next = data;
-			for (const action of event.data.actions) {
-				const descriptor = normalizeActionRequest(action);
-				next = updateAssistantMessage(next, event.data.turnId, (message) => upsertPart(ensureStepStartPart(message, event.data.stepIndex), {
-					input: "input" in action ? action.input : void 0,
-					state: "input-available",
-					stepIndex: event.data.stepIndex,
-					toolCallId: action.callId,
-					toolMetadata: createToolMetadata(descriptor),
-					toolName: descriptor.toolName,
-					type: "dynamic-tool"
-				}));
+		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.#error = void 0;
+				if (this.#status === "error") this.#status = "ready";
+				this.#adoptSession(created.session);
+				this.#ensureStream();
+			} catch (error) {
+				if (generation === this.#prewarmGeneration && this.#activeTurn === void 0 && this.#error === void 0) this.#fail(error);
+				throw error;
+			}
+		})();
+		this.#prewarmPromise = promise;
+		const clear = () => {
+			if (this.#prewarmPromise === promise) {
+				this.#prewarmPromise = void 0;
+				this.#prewarmController = void 0;
 			}
-			return next;
+		};
+		promise.then(clear, clear);
+		return promise;
+	}
+	async send(input) {
+		return await this.#submit(input, this.#callbacks.prepareSend);
+	}
+	async #submit(input, prepareSend) {
+		assertAnswerable(input, this.#conversationClient.conversation);
+		if (this.#activeTurn !== void 0) {
+			if (this.#status === "resuming") throw new Error("eve session is resuming.");
+			return await this.#sendFollowUp(this.#activeTurn, input, prepareSend);
 		}
-		case "input.requested": {
-			let next = data;
-			for (const request of event.data.requests) {
-				const descriptor = normalizeActionRequest(request.action);
-				next = updateAssistantMessage(next, event.data.turnId, (message) => upsertPart(ensureStepStartPart(message, event.data.stepIndex), {
-					approval: { id: request.requestId },
-					input: request.action.input,
-					state: "approval-requested",
-					stepIndex: event.data.stepIndex,
-					toolCallId: request.action.callId,
-					toolMetadata: createToolMetadata(descriptor, { inputRequest: toMessageInputRequest(request) }),
-					toolName: descriptor.toolName,
-					type: "dynamic-tool"
-				}));
+		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";
+		let reader;
+		let submissionId;
+		let retractResponses;
+		try {
+			assertExclusiveTurnInput(input);
+			submissionId = this.#messageSubmissions.submit(input, this.#events.length);
+			retractResponses = this.#conversationClient.projectResponses(input.inputResponses);
+			this.#publish();
+			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;
+			if (preparedInput !== input) {
+				submissionId = this.#messageSubmissions.resubmit(submissionId, preparedInput);
+				retractResponses = this.#conversationClient.replaceResponses(retractResponses, preparedInput);
+				this.#publish();
 			}
-			return next;
+			const turnInput = {
+				...preparedInput,
+				signal: createAbortSignal(preparedInput.signal, turn.abortController.signal)
+			};
+			const dispatched = await this.#dispatchTurn(turnInput);
+			retractResponses = void 0;
+			const response = dispatched.response;
+			reader = dispatched.reader;
+			if (!this.#isActiveTurn(turn)) return;
+			turn.resolveResponse(response);
+			this.#correlate(submissionId, response);
+			for await (const event of consumeMessageResponse(response, reader)) {
+				if (!this.#isActiveTurn(turn)) return;
+				turn.receivedFollowUps += turn.receivedFollowUpEvents.get(event) ?? 0;
+				turn.receivedFollowUpEvents.delete(event);
+			}
+			if (!this.#isActiveTurn(turn)) return;
+			await followSteeredTurns(turn, reader, () => this.#isActiveTurn(turn));
+			if (!this.#isActiveTurn(turn)) return;
+			this.#status = settledStatus(this.#error, this.#conversationClient.conversation);
+		} catch (error) {
+			if (!this.#isActiveTurn(turn)) return;
+			retractResponses?.();
+			if (isAbortError(error)) {
+				this.#status = "ready";
+				this.#messageSubmissions.fail(toError(error), submissionId);
+			} else {
+				const reported = this.#error !== void 0;
+				this.#error ??= toError(error);
+				this.#status = "error";
+				this.#messageSubmissions.fail(this.#error, submissionId);
+				if (!reported) this.#callbacks.onError?.(this.#error);
+			}
+		} finally {
+			reader?.[Symbol.dispose]();
+			this.#finishTurn(turn);
 		}
-		case "approval.candidate": return data;
-		case "approval.settled": {
-			const existing = findToolPartByApprovalId(data, event.data.requestId);
-			if (existing === void 0) return data;
-			if (event.data.outcome === "approved") return updateToolPart(data, existing.toolCallId, {
-				approval: {
-					approved: true,
-					id: event.data.requestId,
-					reason: void 0
-				},
-				input: existing.input,
-				state: "approval-responded",
-				stepIndex: existing.stepIndex,
-				toolCallId: existing.toolCallId,
-				toolMetadata: existing.toolMetadata,
-				toolName: existing.toolName,
-				type: "dynamic-tool"
-			});
-			return updateToolPart(data, existing.toolCallId, {
-				approval: {
-					approved: false,
-					id: event.data.requestId,
-					reason: "Tool execution was cancelled."
-				},
-				input: existing.input,
-				state: "output-denied",
-				stepIndex: existing.stepIndex,
-				toolCallId: existing.toolCallId,
-				toolMetadata: existing.toolMetadata,
-				toolName: existing.toolName,
-				type: "dynamic-tool"
+	}
+	resume() {
+		if (this.#resumePromise !== void 0) return this.#resumePromise;
+		const promise = this.#resume();
+		this.#resumePromise = promise;
+		const clear = () => {
+			if (this.#resumePromise === promise) this.#resumePromise = void 0;
+		};
+		promise.then(clear, clear);
+		return promise;
+	}
+	async #resume() {
+		if (this.#status !== "ready" && this.#status !== "error") 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 session = this.#session;
+		const turn = createActiveTurn(() => session.cancel());
+		this.#activeTurn = turn;
+		turn.resolveResponse(void 0);
+		this.#error = void 0;
+		this.#status = "resuming";
+		this.#publish();
+		let reader;
+		try {
+			const stream = this.#ensureStream({
+				catchUp: true,
+				startIndex: this.#events.length === session.state.streamIndex ? session.state.streamIndex : 0
 			});
+			reader = stream.subscribe(turn.abortController.signal);
+			await stream.caughtUp;
+			if (!this.#isActiveTurn(turn)) return;
+			reader.discard();
+			const tail = this.#events.at(-1);
+			if (tail !== void 0) this.#applyTerminalStreamFailure(tail);
+			if (tail && !this.#error && !isSettledSessionTail(this.#events, this.#conversationClient.conversation)) {
+				this.#status = "streaming";
+				this.#publish();
+				for await (const event of reader) {
+					if (!this.#isActiveTurn(turn)) return;
+					turn.receivedFollowUps += turn.receivedFollowUpEvents.get(event) ?? 0;
+					turn.receivedFollowUpEvents.delete(event);
+					if (isResponseBoundary(event, this.#conversationClient.conversation)) break;
+				}
+			}
+			await followSteeredTurns(turn, reader, () => this.#isActiveTurn(turn));
+			if (this.#isActiveTurn(turn)) this.#status = settledStatus(this.#error, this.#conversationClient.conversation);
+		} catch (error) {
+			if (!this.#isActiveTurn(turn)) return;
+			if (isAbortError(error)) this.#status = "ready";
+			else {
+				this.#error = toError(error);
+				this.#status = "error";
+				this.#callbacks.onError?.(this.#error);
+			}
+		} finally {
+			reader?.[Symbol.dispose]();
+			this.#finishTurn(turn);
 		}
-		case "action.result": {
-			const descriptor = normalizeActionResult(event.data.result);
-			const existing = findToolPart(data, event.data.result.callId);
-			const denied = event.data.error?.code === "TOOL_EXECUTION_DENIED";
-			const failed = event.data.status === "failed" && !denied;
-			const approvalId = existing?.approval?.id ?? event.data.result.callId;
-			const toolMetadata = mergeToolMetadata(existing?.toolMetadata, createToolMetadata(descriptor));
-			const resultPartBase = {
-				input: existing?.input,
-				stepIndex: event.data.stepIndex,
-				toolCallId: event.data.result.callId,
-				toolMetadata,
-				toolName: existing?.toolName ?? descriptor.toolName,
-				type: "dynamic-tool"
-			};
-			let nextPart;
-			if (denied) nextPart = {
-				...resultPartBase,
-				approval: {
-					approved: false,
-					id: approvalId,
-					reason: event.data.error?.message
-				},
-				state: "output-denied"
-			};
-			else if (failed) nextPart = {
-				...resultPartBase,
-				approval: approvedApproval(existing),
-				errorText: event.data.error?.message ?? stringifyUnknown(event.data.result.output),
-				state: "output-error"
-			};
-			else nextPart = {
-				...resultPartBase,
-				approval: approvedApproval(existing),
-				output: event.data.result.output,
-				state: "output-available"
-			};
-			if (existing !== void 0) return updateToolPart(data, event.data.result.callId, nextPart);
-			return updateAssistantMessage(data, event.data.turnId, (message) => upsertPart(ensureStepStartPart(message, event.data.stepIndex), nextPart));
+	}
+	cancel() {
+		const turn = this.#activeTurn;
+		if (turn === void 0) return this.#status === "streaming" && this.#session !== void 0 ? this.#session.cancel() : Promise.resolve({ status: "no_active_turn" });
+		return turn.cancel();
+	}
+	async compact() {
+		return await this.#session?.compact() ?? { status: "no_active_session" };
+	}
+	async clear() {
+		return await this.#session?.clear() ?? { status: "no_active_session" };
+	}
+	async retire() {
+		if (this.#externalSession) throw new Error("retire() needs a store-owned session. Call reset() on the session you supplied, then create a new store for the next session.");
+		const result = await this.#session?.reset() ?? { status: "no_active_session" };
+		this.reset();
+		return result;
+	}
+	[attachStore]() {
+		this.#attached = true;
+		if (this.#followChildStreams && !this.#conversationClient.following) this.#followSubagents();
+		if (this.#autoPrewarm && this.#session === void 0) this.prewarm().catch(() => {});
+	}
+	[detachStore]() {
+		this.#attached = false;
+		this.#conversationClient.stop();
+		this.#activeTurn?.abortController.abort();
+		this.#resetPrewarm();
+		this.#resumePromise = void 0;
+	}
+	reset() {
+		this.#conversationClient.stop();
+		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.#conversationClient.reset();
+		this.#messageSubmissions.reset();
+		if (this.#followChildStreams && this.#attached) this.#followSubagents();
+		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, prepareSend) {
+		assertInFlightFollowUp(input);
+		const generation = this.#prewarmGeneration;
+		const signal = createAbortSignal(input.signal, turn.abortController.signal);
+		let retractResponses = this.#conversationClient.projectResponses(input.inputResponses);
+		const preparedInput = await waitWithSignal(Promise.resolve(prepareSend?.(input)), signal).then((prepared) => {
+			const next = validateFollowUp(prepared ?? input);
+			if (next === input) return next;
+			retractResponses = this.#conversationClient.replaceResponses(retractResponses, next);
+			return next;
+		}).catch((error) => {
+			retractResponses?.();
+			throw error;
+		});
+		if (generation !== this.#prewarmGeneration) return;
+		if (!this.#isActiveTurn(turn)) {
+			retractResponses?.();
+			return await this.#submit(preparedInput);
+		}
+		const submissionId = this.#messageSubmissions.submit(preparedInput, this.#events.length, activeTurnForOptimisticFollowUp(this.#events));
+		if (submissionId !== void 0) turn.followUpSubmissionIds.add(submissionId);
+		this.#publish();
+		let dispatch;
+		dispatch = (async () => {
+			try {
+				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.");
+				this.#ensureStream({
+					headers: preparedInput.headers,
+					streamReconnectPolicy: preparedInput.streamReconnectPolicy
+				});
+				const response = (await dispatchSessionTurn({
+					session: this.#session,
+					turn: {
+						...preparedInput,
+						signal
+					}
+				})).response;
+				retractResponses = void 0;
+				if (preparedInput.message === void 0) return;
+				turn.acceptedFollowUps += 1;
+				this.#correlate(submissionId, response);
+			} catch (error) {
+				if (this.#isActiveTurn(turn)) {
+					this.#messageSubmissions.fail(toError(error), submissionId);
+					retractResponses?.();
+					this.#publish();
+				}
+				throw error;
+			} finally {
+				turn.followUpDispatches.delete(dispatch);
+			}
+		})();
+		turn.followUpDispatches.add(dispatch);
+		await dispatch;
+		await turn.completion;
+	}
+	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();
 		}
-		case "action.partial": {
-			const existing = findToolPart(data, event.data.result.callId);
-			if (existing !== void 0 && isSettledToolPart(existing)) return data;
-			const descriptor = normalizeActionResult(event.data.result);
-			const nextPart = {
-				approval: approvedApproval(existing),
-				input: existing?.input,
-				output: event.data.result.output,
-				partial: true,
-				state: "output-available",
-				stepIndex: event.data.stepIndex,
-				toolCallId: event.data.result.callId,
-				toolMetadata: mergeToolMetadata(existing?.toolMetadata, createToolMetadata(descriptor)),
-				toolName: existing?.toolName ?? descriptor.toolName,
-				type: "dynamic-tool"
+		const session = this.#session;
+		let reader;
+		try {
+			const dispatched = await dispatchSessionTurn({
+				client: this.#client,
+				session,
+				turn: input,
+				beforeSend: () => {
+					reader = this.#ensureStream(streamOptions).subscribe(input.signal);
+				}
+			});
+			if (dispatched.created) {
+				this.#adoptSession(dispatched.session);
+				reader = this.#ensureStream(streamOptions).subscribe(input.signal);
+			}
+			return {
+				response: dispatched.response,
+				reader
 			};
-			if (existing !== void 0) return updateToolPart(data, event.data.result.callId, nextPart);
-			return updateAssistantMessage(data, event.data.turnId, (message) => upsertPart(ensureStepStartPart(message, event.data.stepIndex), nextPart));
-		}
-		case "task.settled": {
-			const existing = findToolPart(data, event.data.callId);
-			if (existing === void 0) return data;
-			return replaceToolPart(data, createSettledTaskPart(existing, event));
+		} catch (error) {
+			reader?.[Symbol.dispose]();
+			throw error;
 		}
-		case "authorization.required": return updateAssistantMessage(data, event.data.turnId, (message) => upsertPart(ensureStepStartPart(message, event.data.stepIndex), createAuthorizationRequiredPart(event)));
-		case "authorization.completed": return completeAuthorization(data, event);
-		case "message.appended": return updateAssistantMessage(data, event.data.turnId, (message) => messageRun.append(ensureStepStartPart(message, event.data.stepIndex), {
-			delta: event.data.messageDelta,
-			stepIndex: event.data.stepIndex,
-			type: "text"
-		}));
-		case "message.completed": return updateAssistantMessage(data, event.data.turnId, (message) => {
-			return messageRun.upsert(ensureStepStartPart(message, event.data.stepIndex), {
-				state: "done",
-				stepIndex: event.data.stepIndex,
-				text: event.data.message,
-				type: "text"
-			});
+	}
+	#ensureStream(options = {}) {
+		if (this.#session === void 0) throw new Error("A session is required before opening its stream.");
+		const generation = this.#prewarmGeneration;
+		if (this.#followChildStreams && !this.#conversationClient.following) this.#followSubagents();
+		return this.#conversationClient.stream(this.#session, {
+			...options,
+			onEvent: (event) => {
+				if (generation === this.#prewarmGeneration) this.#acceptServerEvent(event);
+			},
+			onError: (error) => {
+				if (generation !== this.#prewarmGeneration || this.#activeTurn !== void 0) return;
+				this.#fail(error);
+			}
 		});
-		case "result.completed": return updateAssistantMetadata(data, event.data.turnId, { result: event.data.result });
-		case "turn.completed": return updateAssistantMessage(data, event.data.turnId, (message) => ({
-			...message,
-			metadata: {
-				...message.metadata,
-				status: "complete"
+	}
+	#adoptSession(session) {
+		this.#session = session;
+		if (this.#followChildStreams && this.#attached) this.#followSubagents();
+		this.#callbacks.onSessionChange?.(session.state);
+		this.#publish();
+	}
+	#fail(error) {
+		this.#error = toError(error);
+		this.#status = "error";
+		this.#callbacks.onError?.(this.#error);
+		this.#publish();
+	}
+	#followSubagents() {
+		if (this.#session) this.#conversationClient.follow(this.#session, this.#events);
+	}
+	#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();
+		}
+	}
+	#isActiveTurn(turn) {
+		return this.#activeTurn === turn;
+	}
+	#acceptServerEvent(event) {
+		const wasStreaming = this.#status === "streaming";
+		if (!this.#conversationClient.observe(event, {
+			onAccepted: () => {
+				this.#events = [...this.#events, event];
 			},
-			parts: removeStreamingToolParts(message.parts)
-		}));
-		case "turn.cancelled": return updateAssistantMessage(data, event.data.turnId, (message) => ({
-			...message,
-			metadata: {
-				...message.metadata,
-				status: "complete"
+			project: (accepted) => {
+				this.#handleReconciliation(this.#messageSubmissions.apply(accepted));
 			},
-			parts: removeStreamingToolParts(message.parts.map((part) => (part.type === "text" || part.type === "reasoning") && part.state === "streaming" ? {
-				...part,
-				state: "done"
-			} : part))
-		}));
-		case "turn.failed": return removeStreamingToolPartsForTurn(data, event.data.turnId);
-		case "session.failed": return data;
-		default: return data;
+			notify: false
+		})) return false;
+		this.#callbacks.onEvent?.(event);
+		this.#applyTerminalStreamFailure(event);
+		const { conversation } = this.#conversationClient;
+		const settled = isSettledSessionTail(this.#events, conversation) && conversation.activeTurnId === void 0;
+		if (this.#status !== "resuming" && this.#error === void 0) {
+			if ("data" in event && event.data !== void 0 && "turnId" in event.data) this.#status = "streaming";
+			if (this.#activeTurn === void 0 && settled) this.#status = "ready";
+		}
+		this.#callbacks.onSessionChange?.(this.#session?.state);
+		if (this.#status !== "resuming") this.#publish();
+		if (this.#activeTurn === void 0 && wasStreaming && settled) this.#callbacks.onFinish?.(this.#snapshot);
+		return true;
 	}
-}
-function removeStreamingToolParts(parts) {
-	return parts.filter((part) => part.type !== "dynamic-tool" || part.state !== "input-streaming");
-}
-function respondToInputRequest(data, response) {
-	const existing = findToolPartByApprovalId(data, response.requestId);
-	if (!existing) return data;
-	const approval = { id: response.requestId };
-	if (response.text !== void 0) approval.reason = response.text;
-	return updateToolPart(data, existing.toolCallId, {
-		approval,
-		input: existing.input,
-		state: "approval-responded",
-		stepIndex: existing.stepIndex,
-		toolCallId: existing.toolCallId,
-		toolMetadata: mergeToolMetadata(existing.toolMetadata, { eve: {
-			inputResponse: response,
-			kind: existing.toolMetadata?.eve?.kind ?? "unknown",
-			name: existing.toolMetadata?.eve?.name ?? existing.toolName
-		} }),
-		toolName: existing.toolName,
-		type: "dynamic-tool"
-	});
-}
-function resolveInputRequest(data, resolution) {
-	if (resolution.response !== void 0) return respondToInputRequest(data, resolution.response);
-	const existing = findToolPartByApprovalId(data, resolution.requestId);
-	if (!existing) return data;
-	return updateToolPart(data, existing.toolCallId, {
-		input: existing.input,
-		output: { status: resolution.outcome },
-		state: "output-available",
-		stepIndex: existing.stepIndex,
-		toolCallId: existing.toolCallId,
-		toolMetadata: existing.toolMetadata,
-		toolName: existing.toolName,
-		type: "dynamic-tool"
-	});
-}
-function updateAssistantMessage(data, turnId, update) {
-	const message = data.messages.find((message) => message.role === "assistant" && message.metadata?.turnId === turnId) ?? createAssistantMessage(turnId);
-	return upsertMessage(data, update(message));
-}
-function updateAssistantMetadata(data, turnId, metadata) {
-	return updateAssistantMessage(data, turnId, (message) => ({
-		...message,
-		metadata: {
-			...message.metadata,
-			...metadata
+	#correlate(submissionId, response) {
+		const deliveryId = getMessageResponseDeliveryId(response);
+		const reconciled = this.#messageSubmissions.correlate(submissionId, deliveryId, this.#events);
+		if (this.#handleReconciliation(reconciled)) this.#publish();
+	}
+	#handleReconciliation(reconciliation) {
+		if (reconciliation === void 0) return false;
+		if (this.#activeTurn !== void 0) countFollowUpDeliveries(this.#activeTurn, reconciliation);
+		return true;
+	}
+	#applyTerminalStreamFailure(event) {
+		const error = toTerminalStreamFailureError(event);
+		if (error === void 0) return;
+		this.#status = "error";
+		this.#messageSubmissions.failAll(error);
+		if (this.#error === void 0) {
+			this.#error = error;
+			this.#callbacks.onError?.(error);
 		}
-	}));
-}
-function createAssistantMessage(turnId) {
-	return {
-		id: `${turnId}:assistant`,
-		metadata: {
-			status: "streaming",
-			turnId
-		},
-		parts: [],
-		role: "assistant"
-	};
-}
-function ensureStepStartPart(message, stepIndex) {
-	const stepStartCount = message.parts.filter((part) => part.type === "step-start").length;
-	if (stepStartCount > stepIndex) return message;
-	const missingCount = stepIndex - stepStartCount + 1;
-	return {
-		...message,
-		parts: [...message.parts, ...Array.from({ length: missingCount }, () => ({ type: "step-start" }))]
-	};
-}
-function upsertPart(message, next) {
-	const index = message.parts.findIndex((part) => partKey(part) === partKey(next));
-	const parts = index === -1 ? [...message.parts, next] : [
-		...message.parts.slice(0, index),
-		next,
-		...message.parts.slice(index + 1)
-	];
-	return {
-		...message,
-		metadata: {
-			...message.metadata,
-			status: next.type === "text" && next.state === "done" ? "complete" : "streaming"
-		},
-		parts
-	};
-}
-function updateToolPart(data, toolCallId, next) {
-	const message = data.messages.find((candidate) => candidate.role === "assistant" && candidate.parts.some((part) => part.type === "dynamic-tool" && part.toolCallId === toolCallId));
-	if (!message) return data;
-	return upsertMessage(data, upsertPart(message, next));
-}
-function replaceToolPart(data, next) {
-	const message = data.messages.find((candidate) => candidate.parts.some((part) => part.type === "dynamic-tool" && part.toolCallId === next.toolCallId));
-	if (message === void 0) return data;
-	return upsertMessage(data, {
-		...message,
-		parts: message.parts.map((part) => partKey(part) === partKey(next) ? next : part)
-	});
-}
-function completeAuthorization(data, event) {
-	const existing = findLatestPendingAuthorizationPart(data, event.data.name);
-	const next = createAuthorizationCompletedPart(event, existing);
-	if (existing !== void 0) return updateAuthorizationPart(data, existing, next);
-	return updateAssistantMessage(data, event.data.turnId, (message) => upsertPart(ensureStepStartPart(message, event.data.stepIndex), next));
-}
-function updateAuthorizationPart(data, existing, next) {
-	const message = data.messages.find((candidate) => candidate.role === "assistant" && candidate.parts.some((part) => part === existing));
-	if (!message) return data;
-	return upsertMessage(data, upsertPart(message, next));
-}
-function findToolPart(data, toolCallId) {
-	for (const message of data.messages) for (const part of message.parts) if (part.type === "dynamic-tool" && part.toolCallId === toolCallId) return part;
+	}
+	#createSnapshot() {
+		return {
+			data: this.#conversationClient.data,
+			conversation: this.#conversationClient.conversation,
+			error: this.#error,
+			events: this.#events,
+			session: this.#session?.state,
+			status: this.#status
+		};
+	}
+	#publish() {
+		this.#snapshot = this.#createSnapshot();
+		for (const subscriber of this.#subscribers) subscriber();
+	}
+};
+function detachEveAgentStore(store) {
+	store[detachStore]();
 }
-function isSettledToolPart(part) {
-	return part.state === "output-denied" || part.state === "output-error" || part.state === "output-available" && part.partial !== true;
+function attachEveAgentStore(store) {
+	store[attachStore]();
 }
-function findLatestPendingAuthorizationPart(data, name) {
-	for (let messageIndex = data.messages.length - 1; messageIndex >= 0; messageIndex -= 1) {
-		const message = data.messages[messageIndex];
-		if (message?.role !== "assistant") continue;
-		for (let partIndex = message.parts.length - 1; partIndex >= 0; partIndex -= 1) {
-			const part = message.parts[partIndex];
-			if (part?.type === "authorization" && part.state === "required" && part.name === name) return part;
-		}
-	}
+
+//#endregion
+//#region src/client/agent-host.ts
+const AGENT_NAME_PATTERN = /^[a-z0-9][a-z0-9_-]*$/;
+const EVE_NAMED_AGENT_ROUTE_PREFIX = "/eve";
+function resolveEveAgentHost(input) {
+	if (input.agent === void 0) return input.host ?? "";
+	if (input.host !== void 0) throw new Error("useEveAgent cannot combine agent and host. Use one target option.");
+	assertValidAgentName(input.agent);
+	return `${EVE_NAMED_AGENT_ROUTE_PREFIX}/${input.agent}`;
 }
-function findToolPartByApprovalId(data, approvalId) {
-	for (const message of data.messages) for (const part of message.parts) if (part.type === "dynamic-tool" && part.approval?.id === approvalId) return part;
+function assertValidAgentName(name) {
+	if (!AGENT_NAME_PATTERN.test(name)) throw new Error(`eve agent name ${JSON.stringify(name)} is invalid. Use lowercase letters, numbers, underscores, or hyphens, starting with a letter or number.`);
 }
 
 //#endregion
 //#region src/vue/use-eve-agent.ts
 function useEveAgent(options = {}) {
 	if (options.resume && options.initialSession === void 0 && options.session === void 0) throw new Error("useEveAgent({ resume: true }) requires initialSession or session.");
-	const reducer = options.reducer ?? defaultMessageReducer();
+	const reducer = options.reducer ?? conversationReducer;
 	const store = new EveAgentStore({
 		auth: options.auth,
 		headers: options.headers,
@@ -3687,6 +4322,7 @@ function useEveAgent(options = {}) {
 		initialEvents: options.initialEvents,
 		initialSession: options.initialSession,
 		optimistic: options.optimistic,
+		followSubagents: options.followSubagents,
 		prewarm: options.prewarm,
 		reducer,
 		session: options.session
@@ -3713,6 +4349,7 @@ function useEveAgent(options = {}) {
 	return {
 		cancel: () => store.cancel(),
 		data: computed(() => snapshot.value.data),
+		conversation: computed(() => snapshot.value.conversation),
 		error: computed(() => snapshot.value.error),
 		events: computed(() => snapshot.value.events),
 		prewarm: () => store.prewarm(),
@@ -3732,4 +4369,4 @@ function useEveAgent(options = {}) {
 }
 
 //#endregion
-export { defaultMessageReducer as n, useEveAgent as t };
+export { openConversationInputs as i, conversationReducer as n, defaultMessageReducer as r, useEveAgent as t };