eve 0.71.2 → 0.72.0

package/dist/src/chunks/{use-eve-agent-CFCaYnrI.js → use-eve-agent-C1GYGCtb.js}

@@ -681,6 +681,464 @@ function isTurnFailureEvent(event) {
 	return event.type === "session.failed" || event.type === "step.failed" || event.type === "turn.failed";
 }
 
+//#endregion
+//#region src/protocol/session-projection.ts
+function initialSessionProjection() {
+	return {
+		authorizations: {},
+		calls: {},
+		candidates: {},
+		inputs: {},
+		nextSequence: 0,
+		tasks: {},
+		turns: {}
+	};
+}
+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 putTask(state, task) {
+	return state.tasks[task.taskId] === task ? state : {
+		...state,
+		tasks: {
+			...state.tasks,
+			[task.taskId]: task
+		}
+	};
+}
+function putTaskCall(task, call) {
+	return task.calls[call.callId] === call ? task : {
+		...task,
+		calls: {
+			...task.calls,
+			[call.callId]: call
+		}
+	};
+}
+function putCall(state, call) {
+	return state.calls[call.callId] === call ? state : {
+		...state,
+		calls: {
+			...state.calls,
+			[call.callId]: call
+		}
+	};
+}
+function updateTask(state, taskId, update) {
+	const task = state.tasks[taskId];
+	if (task === void 0) return state;
+	return putTask(state, update(task));
+}
+function updateCall(state, callId, update) {
+	const call = state.calls[callId];
+	if (call === void 0) return state;
+	return putCall(state, update(call));
+}
+const SETTLED_CALL_STATUSES = /* @__PURE__ */ new Set([
+	"completed",
+	"failed",
+	"rejected",
+	"cancelled"
+]);
+function isSettledCallStatus(status) {
+	return SETTLED_CALL_STATUSES.has(status);
+}
+function settleCall(call, status, error) {
+	if (call.taskId !== void 0 || isSettledCallStatus(call.status)) return call;
+	const { requestId: _requestId, error: _error, ...rest } = call;
+	const settled = {
+		...rest,
+		status
+	};
+	if (call.requestId !== void 0) settled.requestId = call.requestId;
+	if (error !== void 0) settled.error = error;
+	return settled;
+}
+function actionName(action) {
+	switch (action.kind) {
+		case "load-skill": return "load_skill";
+		case "subagent-call":
+		case "remote-agent-call": return action.name;
+		case "tool-call":
+		case "workflow-tool-call": return action.toolName;
+	}
+}
+function resultName(result) {
+	switch (result.kind) {
+		case "load-skill-result": return "load_skill";
+		case "subagent-result": return result.subagentName;
+		default: return result.toolName;
+	}
+}
+function callStatusAfterApproval(outcome) {
+	switch (outcome) {
+		case "approved": return "running";
+		case "denied": return "rejected";
+		case "cancelled": return "cancelled";
+		default: return;
+	}
+}
+const TOOL_EXECUTION_DENIED = "TOOL_EXECUTION_DENIED";
+function foldSession(state, event) {
+	const typed = event;
+	switch (typed.type) {
+		case "session.started": return state.started ? state : {
+			...state,
+			started: true
+		};
+		case "turn.started": {
+			const { sequence, turnId } = typed.data;
+			const turn = {
+				turnId,
+				sequence,
+				status: "active"
+			};
+			return {
+				...state,
+				activeTurnId: turnId,
+				nextSequence: Math.max(state.nextSequence, sequence + 1),
+				turns: {
+					...state.turns,
+					[turnId]: turn
+				}
+			};
+		}
+		case "step.started": return updateTurn(state, typed.data.turnId, (turn) => {
+			if (!turn.waiting && turn.stepIndex === typed.data.stepIndex) return turn;
+			const { waiting: _waiting, ...rest } = turn;
+			return {
+				...rest,
+				stepIndex: typed.data.stepIndex
+			};
+		});
+		case "turn.waiting": return updateTurn(state, typed.data.turnId, (turn) => turn.status === "active" && !turn.waiting ? {
+			...turn,
+			waiting: true
+		} : turn);
+		case "message.appended":
+		case "message.completed":
+		case "result.completed":
+			if (!(typed.type === "message.appended" ? typed.data.messageDelta.length > 0 : typed.type === "message.completed" ? (typed.data.message?.length ?? 0) > 0 : true)) return state;
+			return updateTurn(state, typed.data.turnId, (turn) => turn.outputStarted ? turn : {
+				...turn,
+				outputStarted: true
+			});
+		case "turn.completed":
+		case "turn.cancelled":
+		case "turn.failed": {
+			const { turnId } = typed.data;
+			const status = typed.type === "turn.completed" ? "completed" : typed.type === "turn.failed" ? "failed" : "cancelled";
+			const { waiting: _waiting, ...rest } = state.turns[turnId] ?? {
+				turnId,
+				sequence: typed.data.sequence
+			};
+			return {
+				...state,
+				activeTurnId: state.activeTurnId === turnId ? void 0 : state.activeTurnId,
+				turns: {
+					...state.turns,
+					[turnId]: {
+						...rest,
+						status
+					}
+				}
+			};
+		}
+		case "context.cleared": return {
+			...state,
+			calls: Object.fromEntries(Object.entries(state.calls).filter(([, call]) => call.taskId !== void 0))
+		};
+		case "session.waiting": return state.activeTurnId === void 0 ? state : {
+			...state,
+			activeTurnId: void 0
+		};
+		case "session.completed":
+		case "session.failed": {
+			const { activeTurnId: _activeTurnId, ...rest } = state;
+			return {
+				...rest,
+				ended: true
+			};
+		}
+		case "actions.requested": {
+			let calls;
+			for (const action of typed.data.actions) {
+				if (state.calls[action.callId] !== void 0) continue;
+				calls ??= { ...state.calls };
+				calls[action.callId] = {
+					callId: action.callId,
+					name: actionName(action),
+					turnId: typed.data.turnId,
+					stepIndex: typed.data.stepIndex,
+					status: "running"
+				};
+			}
+			return calls === void 0 ? state : {
+				...state,
+				calls
+			};
+		}
+		case "action.result": {
+			const { result, status, error } = typed.data;
+			const call = state.calls[result.callId];
+			if (call?.taskId !== void 0) return state;
+			const settled = status === "rejected" || error?.code === TOOL_EXECUTION_DENIED ? "rejected" : status === "failed" || result.isError === true ? "failed" : "completed";
+			if (call === void 0) {
+				const unannounced = {
+					callId: result.callId,
+					name: resultName(result),
+					turnId: typed.data.turnId,
+					stepIndex: typed.data.stepIndex,
+					status: settled
+				};
+				if (error !== void 0) unannounced.error = error;
+				return putCall(state, unannounced);
+			}
+			return updateCall(state, result.callId, (current) => settleCall(current, settled, error));
+		}
+		case "task.started": {
+			const { callId, kind, name, taskId, turnId } = typed.data;
+			const task = state.tasks[taskId] ?? {
+				taskId,
+				name,
+				kind,
+				calls: {}
+			};
+			let next = state;
+			if (task.calls[callId] === void 0) next = putTask(next, putTaskCall(task, {
+				callId,
+				turnId,
+				status: "working"
+			}));
+			const call = next.calls[callId];
+			if (call?.taskId === taskId) return next;
+			const linked = {
+				callId,
+				name: call?.name ?? name,
+				stepIndex: call?.stepIndex ?? 0,
+				taskId,
+				turnId: call?.turnId ?? turnId
+			};
+			if (call?.requestId !== void 0) linked.requestId = call.requestId;
+			return putCall(next, linked);
+		}
+		case "task.settled": {
+			const { callId, error, output, status, taskId } = typed.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 putTaskCall(task, status === "completed" && output !== void 0 ? {
+					...settled,
+					output
+				} : status === "failed" && error !== void 0 ? {
+					...settled,
+					error
+				} : settled);
+			});
+		}
+		case "input.requested": {
+			const inputs = { ...state.inputs };
+			let calls;
+			for (const request of typed.data.requests) {
+				if (inputs[request.requestId] !== void 0) continue;
+				const input = {
+					request,
+					sequence: typed.data.sequence,
+					turnId: typed.data.turnId,
+					stepIndex: typed.data.stepIndex,
+					status: "open"
+				};
+				if (typed.data.taskId !== void 0) input.taskId = typed.data.taskId;
+				if (typed.data.callId !== void 0) input.callId = typed.data.callId;
+				inputs[request.requestId] = input;
+				if (request.kind !== "tool-approval" || isRelayed(typed.data)) continue;
+				const { callId, toolName } = request.action;
+				calls ??= { ...state.calls };
+				const call = calls[callId];
+				if (call?.taskId !== void 0) continue;
+				if (call !== void 0 && isSettledCallStatus(call.status)) continue;
+				calls[callId] = {
+					...call ?? {
+						callId,
+						name: toolName,
+						turnId: typed.data.turnId,
+						stepIndex: typed.data.stepIndex
+					},
+					requestId: request.requestId,
+					status: "awaiting-input"
+				};
+			}
+			return calls === void 0 ? {
+				...state,
+				inputs
+			} : {
+				...state,
+				calls,
+				inputs
+			};
+		}
+		case "approval.candidate": {
+			const { candidateId, outcome, requestId } = typed.data;
+			state = {
+				...state,
+				candidates: {
+					...state.candidates,
+					[candidateId]: {
+						candidateId,
+						outcome,
+						requestId
+					}
+				}
+			};
+			const current = state.inputs[typed.data.requestId];
+			if (current === void 0 || current.status === "settled") return state;
+			if (typed.data.outcome === "pending" || current.status === "open") return state;
+			const { response: _response, ...rest } = current;
+			return {
+				...state,
+				inputs: {
+					...state.inputs,
+					[typed.data.requestId]: {
+						...rest,
+						status: "open"
+					}
+				}
+			};
+		}
+		case "approval.settled": {
+			const current = state.inputs[typed.data.requestId];
+			if (current === void 0 || current.status === "settled") return state;
+			const outcome = typed.data.outcome === "approved" ? "approved" : "denied";
+			return settleApprovalCall({
+				...state,
+				inputs: {
+					...state.inputs,
+					[typed.data.requestId]: {
+						...current,
+						status: "settled",
+						outcome
+					}
+				}
+			}, current, outcome);
+		}
+		case "input.resolved": {
+			let next = state;
+			for (const resolution of typed.data.resolutions) {
+				const current = next.inputs[resolution.requestId];
+				if (current === void 0 || current.status === "settled") continue;
+				const response = resolution.response ?? current.response;
+				const settled = {
+					...current,
+					status: "settled",
+					outcome: resolution.outcome
+				};
+				if (response !== void 0) settled.response = response;
+				next = {
+					...next,
+					inputs: {
+						...next.inputs,
+						[resolution.requestId]: settled
+					}
+				};
+				next = settleApprovalCall(next, current, resolution.outcome);
+			}
+			return next;
+		}
+		case "authorization.required": {
+			const attemptId = typed.data.attemptId ?? typed.data.name;
+			const authorization = {
+				attemptId,
+				name: typed.data.name,
+				sequence: typed.data.sequence,
+				turnId: typed.data.turnId,
+				stepIndex: typed.data.stepIndex,
+				status: "required"
+			};
+			if (typed.data.taskId !== void 0) authorization.taskId = typed.data.taskId;
+			if (typed.data.principalId !== void 0) authorization.principalId = typed.data.principalId;
+			if (typed.data.candidateId !== void 0) authorization.candidateId = typed.data.candidateId;
+			if (typed.data.webhookUrl !== void 0) authorization.awaitsCallback = true;
+			return {
+				...state,
+				authorizations: {
+					...state.authorizations,
+					[attemptId]: authorization
+				}
+			};
+		}
+		case "authorization.completed": {
+			const attemptId = typed.data.attemptId ?? typed.data.name;
+			const completed = {
+				...state.authorizations[attemptId] ?? {
+					attemptId,
+					name: typed.data.name,
+					sequence: typed.data.sequence,
+					turnId: typed.data.turnId,
+					stepIndex: typed.data.stepIndex
+				},
+				status: typed.data.outcome
+			};
+			return {
+				...state,
+				authorizations: {
+					...state.authorizations,
+					[attemptId]: completed
+				}
+			};
+		}
+		default: return state;
+	}
+}
+function isRelayed(request) {
+	return request.callId !== void 0 || request.taskId !== void 0;
+}
+function settleApprovalCall(state, input, outcome) {
+	if (input.request.kind !== "tool-approval" || isRelayed(input)) return state;
+	const status = callStatusAfterApproval(outcome);
+	if (status === void 0) return state;
+	return updateCall(state, input.request.action.callId, (call) => {
+		if (call.status !== "awaiting-input" || call.requestId !== input.request.requestId) return call;
+		return status === "running" ? {
+			...call,
+			status
+		} : settleCall(call, status);
+	});
+}
+function openInputs(state) {
+	return Object.values(state.inputs).filter((input) => input.status !== "settled");
+}
+function openSignIns(state) {
+	return Object.values(state.authorizations).filter((attempt) => attempt.status === "required");
+}
+function callStatus(state, callId, options = {}) {
+	const call = state.calls[callId];
+	if (call === void 0) return void 0;
+	const status = reportedCallStatus(state, call);
+	if (status !== "running" || call.taskId !== void 0) return status;
+	const turn = state.turns[call.turnId];
+	if (options.streaming === false || turn !== void 0 && turn.status !== "active") return "interrupted";
+	return status;
+}
+function reportedCallStatus(state, call) {
+	if (call.taskId === void 0) return call.status;
+	const status = state.tasks[call.taskId]?.calls[call.callId]?.status;
+	return status === void 0 || status === "working" ? "running" : status;
+}
+
 //#endregion
 //#region src/client/session-utils.ts
 function summarizeTurnEvents(events) {
@@ -713,46 +1171,30 @@ function endsTurnSegment(event, open) {
 	return isCurrentTurnBoundaryEvent(event) && (event.type !== "session.waiting" || !open.callbacks);
 }
 var TurnSegment = class {
+	#projection = initialSessionProjection();
 	#authorizations = /* @__PURE__ */ new Map();
 	#followCallbacks;
-	#requests = /* @__PURE__ */ new Map();
 	constructor(options = {}) {
 		this.#followCallbacks = options.followCallbacks === true;
 	}
 	get inputRequests() {
-		return [...this.#requests.values()];
+		return openInputs(this.#projection).map((input) => input.request);
 	}
 	get pendingAuthorizations() {
-		return [...this.#authorizations.values()];
+		return openSignIns(this.#projection).flatMap((attempt) => this.#authorizations.get(attempt.attemptId) ?? []);
 	}
 	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));
-		}
+		this.#projection = foldSession(this.#projection, event);
+		if (event.type === "authorization.required") this.#authorizations.set(event.data.attemptId ?? event.data.name, event.data);
 		return endsTurnSegment(event, {
-			callbacks: this.#followCallbacks && [...this.#authorizations.values()].some((authorization) => authorization.webhookUrl !== void 0),
-			requests: this.#requests.size > 0
+			callbacks: this.#followCallbacks && openSignIns(this.#projection).some((attempt) => attempt.awaitsCallback === true),
+			requests: openInputs(this.#projection).length > 0
 		});
 	}
 };
 function isFinalMessageCompleted(event) {
 	return event.type === "message.completed" && event.data.finishReason !== "tool-calls";
 }
-function authorizationKey(data) {
-	return data.attemptId === void 0 ? `name:${data.name}` : `attempt:${data.attemptId}`;
-}
 
 //#endregion
 //#region src/protocol/message-version.ts
@@ -1929,7 +2371,8 @@ var ClientSession = class ClientSession {
 					const terminal = event.type === "session.failed" || event.type === "session.completed";
 					if (!matches && terminal && (!started || event.type === "session.completed")) throw new Error("The session ended before the accepted message reached its turn boundary.");
 					if (!started && !matches) continue;
-					if (!terminal && event.meta?.deliveryIds !== void 0 && !matches) continue;
+					const attributed = event.meta?.deliveryIds !== void 0;
+					if (!terminal && attributed && !matches) continue;
 					started = true;
 				}
 				reachedBoundary = segment.observe(event);
@@ -2239,16 +2682,24 @@ var EveAgentProjection = class {
 	}
 };
 
+//#endregion
+//#region src/client/conversation-projection.ts
+const projectionKey = Symbol("eve.conversationProjection");
+function conversationProjection(state) {
+	return state[projectionKey] ?? initialSessionProjection();
+}
+function withConversationProjection(state, projection) {
+	if (state[projectionKey] === projection) return state;
+	return Object.defineProperty({ ...state }, projectionKey, { value: projection });
+}
+
 //#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);
+	return openSignIns(conversationProjection(state)).some((attempt) => attempt.awaitsCallback === true);
 }
 function agentToolTask(state, agent) {
 	const task = agent.taskId === void 0 ? void 0 : state.tasks[agent.taskId];
@@ -2655,15 +3106,6 @@ function mergeToolMetadata(current, next) {
 		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) {
@@ -2802,33 +3244,104 @@ function transition(message, input) {
 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,
+//#region src/client/tool-part-state.ts
+function toolPartState(data, part) {
+	const content = part;
+	const projection = conversationProjection(data);
+	const call = projection.calls[part.toolCallId];
+	const requestId = content.approval?.id;
+	const input = requestId === void 0 ? void 0 : projection.inputs[requestId];
+	const base = {
+		input: part.input,
+		stepIndex: part.stepIndex,
+		toolCallId: part.toolCallId,
+		toolMetadata: part.toolMetadata,
+		toolName: part.toolName,
 		type: "dynamic-tool"
 	};
-	switch (event.data.status) {
+	const requested = requestId === void 0 ? void 0 : {
+		id: requestId,
+		...content.approval?.isAutomatic !== void 0 && { isAutomatic: content.approval.isAutomatic }
+	};
+	const responded = (approved, reason) => ({
+		...base,
+		approval: {
+			...requested,
+			...approved && { approved: true },
+			...reason !== void 0 && { reason }
+		},
+		state: "approval-responded"
+	});
+	const approvedTrue = requested === void 0 ? void 0 : {
+		...requested,
+		approved: true
+	};
+	if (requested !== void 0 && input !== void 0 && input.status !== "settled" && (call === void 0 || !isSettledCallStatus(reportedCallStatus(projection, call)))) return {
+		...base,
+		approval: requested,
+		state: "approval-requested"
+	};
+	const task = call?.taskId === void 0 ? void 0 : projection.tasks[call.taskId]?.calls[part.toolCallId];
+	if (call === void 0) {
+		if (input === void 0) return part;
+		return input.response === void 0 ? {
+			...base,
+			output: { status: input.outcome },
+			state: "output-available"
+		} : responded(input.outcome === "approved", input.response.text);
+	}
+	switch (reportedCallStatus(projection, call)) {
+		case "running":
+		case "awaiting-input":
+			if (content.partial === true) return {
+				...base,
+				approval: approvedTrue,
+				output: content.output,
+				partial: true,
+				state: "output-available"
+			};
+			if (input !== void 0 && (input.outcome === "approved" || input.response !== void 0)) return responded(input.outcome === "approved", input.response?.text);
+			return {
+				...base,
+				state: "input-available"
+			};
 		case "completed": return {
-			...settledPartBase,
-			output: event.data.output,
+			...base,
+			approval: approvedTrue,
+			output: task?.output ?? content.output,
 			state: "output-available"
 		};
 		case "failed": return {
-			...settledPartBase,
-			errorText: event.data.error?.message ?? "Task failed.",
+			...base,
+			approval: approvedTrue,
+			errorText: task?.error?.message ?? content.errorText ?? call.error?.message ?? (call.taskId === void 0 ? "Action failed." : "Task failed."),
 			state: "output-error"
 		};
-		case "cancelled": return {
-			...settledPartBase,
-			errorText: "Task was cancelled.",
-			state: "output-error"
+		case "rejected": return {
+			...base,
+			approval: {
+				id: requestId ?? part.toolCallId,
+				approved: false,
+				reason: call.error?.message ?? content.errorText
+			},
+			state: "output-denied"
 		};
+		case "cancelled":
+			if (requestId !== void 0 && input?.outcome === "cancelled") return {
+				...base,
+				approval: {
+					id: requestId,
+					approved: false,
+					reason: "Tool execution was cancelled."
+				},
+				state: "output-denied"
+			};
+			return {
+				...base,
+				approval: approvedTrue,
+				errorText: call.taskId === void 0 ? content.errorText ?? call.error?.message ?? "Action was cancelled." : "Task was cancelled.",
+				state: "output-error"
+			};
 	}
 }
 
@@ -2840,7 +3353,7 @@ function receivedMessageEventId(event) {
 function defaultMessageReducer() {
 	return {
 		initial() {
-			return { messages: [] };
+			return withConversationProjection({ messages: [] }, initialSessionProjection());
 		},
 		reduce(data, event) {
 			return reduceMessageData(data, event);
@@ -2848,6 +3361,12 @@ function defaultMessageReducer() {
 	};
 }
 function reduceMessageData(data, event) {
+	const projection = foldSession(conversationProjection(data), event);
+	const content = withConversationProjection(reduceContent(data, event), projection);
+	const callIds = toolCallIds(content, event);
+	return withConversationProjection(callIds.length === 0 ? content : withToolPartStates(content, callIds), projection);
+}
+function reduceContent(data, event) {
 	switch (event.type) {
 		case "client.message.submitted":
 		case "client.message.failed": return upsertMessage(data, {
@@ -2862,11 +3381,6 @@ function reduceMessageData(data, event) {
 			}],
 			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: {
@@ -2900,9 +3414,10 @@ function reduceMessageData(data, event) {
 		case "action.input.appended": {
 			const existing = findToolPart(data, event.data.callId);
 			if (existing !== void 0 && existing.state !== "input-streaming") return data;
-			const nextPart = {
+			const inputText = (existing?.state === "input-streaming" ? existing.inputText : "") + event.data.inputTextDelta;
+			return upsertToolPart(data, event.data.turnId, event.data.stepIndex, {
 				input: void 0,
-				inputText: (existing?.state === "input-streaming" ? existing.inputText : "") + event.data.inputTextDelta,
+				inputText,
 				state: "input-streaming",
 				stepIndex: event.data.stepIndex,
 				toolCallId: event.data.callId,
@@ -2912,8 +3427,7 @@ function reduceMessageData(data, event) {
 				} },
 				toolName: event.data.toolName,
 				type: "dynamic-tool"
-			};
-			return upsertToolPart(data, event.data.turnId, event.data.stepIndex, nextPart);
+			});
 		}
 		case "actions.requested": {
 			let next = data;
@@ -2940,10 +3454,11 @@ function reduceMessageData(data, event) {
 				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), {
+					...existing,
 					approval: { id: request.requestId },
 					input: request.action.input,
 					state: "approval-requested",
-					stepIndex: event.data.stepIndex,
+					stepIndex: existing?.stepIndex ?? event.data.stepIndex,
 					toolCallId: request.action.callId,
 					toolMetadata: createToolMetadata(descriptor, { inputRequest: toMessageInputRequest(request) }),
 					toolName: descriptor.toolName,
@@ -2952,97 +3467,75 @@ function reduceMessageData(data, event) {
 			}
 			return next;
 		}
-		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"
-				});
-			}
-			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"
-			});
-		}
 		case "action.result": {
-			const descriptor = normalizeActionResult(event.data.result);
+			if (conversationProjection(data).calls[event.data.result.callId]?.taskId !== void 0) return data;
 			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 = {
+			const descriptor = normalizeActionResult(event.data.result);
+			const succeeded = event.data.status === void 0 || event.data.status === "completed" ? event.data.result.isError !== true && event.data.error === void 0 : false;
+			const part = {
+				...existing,
 				input: existing?.input,
-				stepIndex: event.data.stepIndex,
+				stepIndex: existing?.stepIndex ?? event.data.stepIndex,
 				toolCallId: event.data.result.callId,
-				toolMetadata,
+				toolMetadata: mergeToolMetadata(existing?.toolMetadata, createToolMetadata(descriptor)),
 				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),
+			const outcome = succeeded ? {
+				errorText: void 0,
+				output: event.data.result.output
+			} : {
 				errorText: event.data.error?.message ?? stringifyUnknown(event.data.result.output),
-				state: "output-error"
+				output: void 0
 			};
-			else nextPart = {
-				...resultPartBase,
-				approval: approvedApproval(existing),
-				output: event.data.result.output,
-				state: "output-available"
-			};
-			return upsertToolPart(data, event.data.turnId, event.data.stepIndex, nextPart);
+			return upsertToolPart(data, event.data.turnId, event.data.stepIndex, {
+				...part,
+				...outcome,
+				partial: void 0
+			});
 		}
 		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),
+			return upsertToolPart(data, event.data.turnId, event.data.stepIndex, {
+				...existing,
 				input: existing?.input,
 				output: event.data.result.output,
 				partial: true,
 				state: "output-available",
-				stepIndex: event.data.stepIndex,
+				stepIndex: existing?.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);
+			});
+		}
+		case "input.resolved": {
+			let next = data;
+			for (const { requestId, response } of event.data.resolutions) {
+				const existing = response === void 0 ? void 0 : findToolPartByApprovalId(next, requestId);
+				if (existing === void 0) continue;
+				next = replaceToolPart(next, {
+					...existing,
+					toolMetadata: mergeToolMetadata(existing.toolMetadata, { eve: {
+						inputResponse: response,
+						kind: existing.toolMetadata?.eve?.kind ?? "unknown",
+						name: existing.toolMetadata?.eve?.name ?? existing.toolName
+					} })
+				});
+			}
+			return next;
 		}
 		case "task.settled": {
 			const existing = findToolPart(data, event.data.callId);
 			if (existing === void 0) return data;
-			return replaceToolPart(data, createSettledTaskPart(existing, event));
+			const { error, output, status } = event.data;
+			const outcome = status === "completed" ? { output } : { errorText: error?.message };
+			return replaceToolPart(data, {
+				...existing,
+				...outcome
+			});
 		}
 		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);
@@ -3067,24 +3560,10 @@ function reduceMessageData(data, event) {
 				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.completed":
+		case "turn.cancelled":
 		case "turn.failed":
-			if (data.messages.find((message) => message.role === "assistant" && message.metadata?.turnId === event.data.turnId) === void 0) return data;
+			if (event.type === "turn.failed" && !data.messages.some((message) => message.role === "assistant" && message.metadata?.turnId === event.data.turnId)) return data;
 			return updateAssistantMessage(data, event.data.turnId, (message) => ({
 				...message,
 				metadata: {
@@ -3093,10 +3572,33 @@ function reduceMessageData(data, event) {
 				},
 				parts: removeStreamingToolParts(closeStreamingRuns(message.parts))
 			}));
-		case "session.failed": return data;
 		default: return data;
 	}
 }
+function toolCallIds(data, event) {
+	const byRequest = (requestId) => findToolPartByApprovalId(data, requestId)?.toolCallId ?? [];
+	switch (event.type) {
+		case "actions.requested": return event.data.actions.map((action) => action.callId);
+		case "input.requested": return event.data.requests.map((request) => request.action.callId);
+		case "action.result":
+		case "action.partial": return [event.data.result.callId];
+		case "task.started":
+		case "task.settled": return [event.data.callId];
+		case "input.resolved": return event.data.resolutions.flatMap((resolution) => byRequest(resolution.requestId));
+		case "approval.settled": return [byRequest(event.data.requestId)].flat();
+		default: return [];
+	}
+}
+function withToolPartStates(data, callIds) {
+	let next = data;
+	for (const callId of new Set(callIds)) {
+		const part = findToolPart(next, callId);
+		if (part === void 0) continue;
+		const derived = toolPartState(next, part);
+		if (derived !== part) next = withConversationProjection(replaceToolPart(next, derived), conversationProjection(data));
+	}
+	return next;
+}
 function closeStreamingRuns(parts, stepIndex) {
 	return parts.map((part) => (part.type === "text" || part.type === "reasoning") && part.state === "streaming" && (stepIndex === void 0 || part.stepIndex === stepIndex) ? {
 		...part,
@@ -3106,50 +3608,6 @@ function closeStreamingRuns(parts, stepIndex) {
 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;
-	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
-	});
-}
-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 {
-		input: part.input,
-		stepIndex: part.stepIndex,
-		toolCallId: part.toolCallId,
-		toolMetadata: part.toolMetadata,
-		toolName: part.toolName,
-		type: part.type
-	};
-}
 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));
@@ -3235,37 +3693,13 @@ function findToolPartByApprovalId(data, approvalId) {
 //#endregion
 //#region src/client/conversation-reducer.ts
 function initialConversationState() {
-	return {
-		messages: [],
+	return withConversationProjection({
 		turns: {},
 		inputs: {},
 		tasks: {},
+		messages: [],
 		agents: {}
-	};
-}
-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 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
-		}
-	};
+	}, initialSessionProjection());
 }
 function updateObservation(state, sessionId, update) {
 	const agent = state.agents[sessionId];
@@ -3288,99 +3722,6 @@ function observedConversation(observation) {
 }
 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 "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;
@@ -3392,31 +3733,13 @@ function reduceConversationLifecycle(state, event) {
 				observation: { status: "not-followed" }
 			};
 			if (taskId !== void 0) agent.taskId = taskId;
-			return {
+			return withConversationProjection({
 				...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
-			};
+			}, conversationProjection(state));
 		}
 		case "client.input.responded": {
 			const inputs = { ...state.inputs };
@@ -3429,64 +3752,33 @@ function reduceConversationLifecycle(state, event) {
 					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] = {
+			const projection = conversationProjection(state);
+			const projectedInputs = { ...projection.inputs };
+			for (const response of event.data.responses) {
+				const current = projectedInputs[response.requestId];
+				if (current?.status === "open") projectedInputs[response.requestId] = {
 					...current,
-					status: "settled",
-					outcome: resolution.outcome,
-					response: resolution.response ?? current.response
+					response,
+					status: "responded"
 				};
 			}
-			return {
+			return withConversationProjection({
 				...state,
 				inputs
-			};
+			}, {
+				...projection,
+				inputs: projectedInputs
+			});
 		}
 		default: return state;
 	}
 }
 const messageReducer = defaultMessageReducer();
 function reduceConversation(state, event) {
+	const next = reduceConversationEvent(state, event);
+	return event.type.startsWith("client.agent.") ? withConversationProjection(next, conversationProjection(state)) : next;
+}
+function reduceConversationEvent(state, event) {
 	switch (event.type) {
 		case "client.agent.following": return updateObservation(state, event.data.sessionId, (observation) => observation.status === "following" ? observation : {
 			status: "following",
@@ -3507,13 +3799,31 @@ function reduceConversation(state, event) {
 				conversation
 			};
 		});
-		default: {
-			const projected = messageReducer.reduce(state, event);
-			return reduceConversationLifecycle({
-				...state,
-				...projected
-			}, event);
-		}
+		default:
+			const messages = messageReducer.reduce(state, event);
+			const projection = conversationProjection(messages);
+			const { activeTurnId: _activeTurnId, ...rest } = state;
+			const { activeTurnId: _messageTurnId, ...messageData } = messages;
+			const conversation = {
+				...rest,
+				...messageData,
+				turns: Object.fromEntries(Object.entries(projection.turns).map(([id, turn]) => {
+					const { turnId, status, waiting } = turn;
+					const publicTurn = {
+						turnId,
+						status
+					};
+					if (waiting !== void 0) publicTurn.waiting = waiting;
+					return [id, publicTurn];
+				})),
+				inputs: Object.fromEntries(Object.entries(projection.inputs).map(([id, input]) => {
+					const { sequence: _sequence, callId: _callId, ...publicInput } = input;
+					return [id, publicInput];
+				})),
+				tasks: projection.tasks
+			};
+			if (projection.activeTurnId !== void 0) conversation.activeTurnId = projection.activeTurnId;
+			return reduceConversationLifecycle(withConversationProjection(conversation, projection), event);
 	}
 }
 const canonicalConversationReducer = {
@@ -4369,4 +4679,4 @@ function useEveAgent(options = {}) {
 }
 
 //#endregion
-export { openConversationInputs as i, conversationReducer as n, defaultMessageReducer as r, useEveAgent as t };
+export { conversationProjection as a, openConversationInputs as i, conversationReducer as n, callStatus as o, defaultMessageReducer as r, useEveAgent as t };