eve 0.44.0 → 0.44.2

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # eve
 
+## 0.44.2
+
+### Patch Changes
+
+- e79dd2f: Generated Web Chat apps now include their new-session and resumable-session routes. Abandoned browser session streams also release their local workflow listeners instead of accumulating them across navigation.
+
+## 0.44.1
+
+### Patch Changes
+
+- 7c99773: Linq setup now recognizes Vercel CLI versions that lack required trigger options and offers to upgrade the CLI from the `/add` flow instead of reporting a generic connector failure.
+- 02403b9: Dynamic tool callbacks are now identified by tool name and phase instead of byte offsets in the authored source. Editing an agent file no longer risks a parked approval replaying the wrong tool: after a redeploy or crash, parked calls run the latest deployed callback code under the same name, and a tool that no longer exists fails closed with an explicit error. Session-scoped resolvers may run once more on resume to rebind callbacks, so keep them idempotent.
+- 84ddb09: Apply release-age policies during project and extension setup instead of bypassing them. New standalone pnpm projects use strict enforcement, while projects inside an existing workspace retain that workspace's policy.
+- 85b2dc8: Redact model, tool, approval, and delivery content from hosted instrumentation for private and unknown channel audiences. Content-denied Workflow runs now carry a metadata marker and omit their content-derived title so dashboards can exclude them without reading the event stream. Local `eve dev` tracing continues to retain content for unknown TUI and HTTP sessions.
+- a4fd288: Add declarative `resume: true` and imperative `resume()` support for replaying durable frontend sessions and following in-flight turns. Generated Web Chat apps now keep session IDs in `/s/{sessionId}` URLs, restore conversations on reload, and provide a sessionless `/s` route for starting a new chat.
+- 923921c: Give models runtime-authored task state after background work starts so initiating turns acknowledge launch, partial task wakes stay silent, and settled cohorts produce one combined report.
+- 673def2: Allow `useEveAgent` message sends with `turnPolicy: "steer"` while a turn is active, keeping the local projection attached to the durable replacement stream. Generated web chats now keep the composer enabled during responses and steer by default when a follow-up is submitted. Cancelled turns preserve their accepted user input in durable history, so replacement turns retain the interrupted request as context.
+
 ## 0.44.0
 
 ### Minor Changes

package/dist/src/chunks/{use-eve-agent-C0SG1Ttk.js → use-eve-agent-BsLJiIbc.js}

@@ -527,14 +527,14 @@ function isStreamDisconnectError(error) {
 	const errorCode = "code" in error && typeof error.code === "string" ? error.code : void 0;
 	return error.name === "AbortError" || error.message === "terminated" || errorCode === "UND_ERR_SOCKET" || error instanceof TypeError && /^(?:failed to fetch|fetch failed)$/i.test(error.message) || /abort|cancel|disconnect|premature close|socket|terminated/i.test(error.message);
 }
-async function* readNdjsonStream(body) {
+async function* readNdjsonStream(body, options) {
 	const reader = body.getReader();
 	const decoder = new TextDecoder();
 	let buffer = "";
 	let reachedEof = false;
 	try {
 		while (true) {
-			const result = await reader.read();
+			const result = await readWithIdleTimeout(reader, options?.idleTimeoutMs);
 			if (result.done) {
 				reachedEof = true;
 				buffer += decoder.decode();
@@ -556,6 +556,17 @@ async function* readNdjsonStream(body) {
 		reader.releaseLock();
 	}
 }
+async function readWithIdleTimeout(reader, idleTimeoutMs) {
+	if (idleTimeoutMs === void 0) return await reader.read();
+	let timeout;
+	try {
+		return await Promise.race([reader.read(), new Promise((_resolve, reject) => {
+			timeout = setTimeout(() => reject(new DOMException("Session stream was idle.", "AbortError")), idleTimeoutMs);
+		})]);
+	} finally {
+		if (timeout !== void 0) clearTimeout(timeout);
+	}
+}
 
 //#endregion
 //#region src/client/url.ts
@@ -600,6 +611,7 @@ function formatSearch(searchParams) {
 
 //#endregion
 //#region src/client/open-stream.ts
+const DEFAULT_STREAM_READ_IDLE_TIMEOUT_MS = 15e3;
 const DEFAULT_STREAM_RECONNECT_POLICY = {
 	retryableErrorStatuses: /* @__PURE__ */ new Set([
 		404,
@@ -672,17 +684,17 @@ async function* followStreamIterable(input) {
 		if (input.follow === false && tailIndex === void 0) {
 			tailIndex = connection.tailIndex;
 			if (tailIndex === void 0) {
-				await connection.body.cancel().catch(() => {});
+				connection.close();
 				throw new Error(`stream({ follow: false }) requires the server to report the ${EVE_STREAM_TAIL_INDEX_HEADER} header. The agent may be running an older eve version.`);
 			}
 		}
 		if (tailIndex !== void 0 && startIndex > tailIndex) {
-			await connection.body.cancel().catch(() => {});
+			connection.close();
 			return;
 		}
 		let deliveredEvent = false;
 		try {
-			for await (const event of readNdjsonStream(connection.body)) {
+			for await (const event of readNdjsonStream(connection.body, { idleTimeoutMs: input.streamReadIdleTimeoutMs ?? DEFAULT_STREAM_READ_IDLE_TIMEOUT_MS })) {
 				startIndex += 1;
 				deliveredEvent = true;
 				reconnectDelayMs = idleRetryPolicy.baseDelayMs;
@@ -692,6 +704,8 @@ async function* followStreamIterable(input) {
 			}
 		} catch (error) {
 			if (!isStreamDisconnectError(error)) throw error;
+		} finally {
+			connection.close();
 		}
 		if (input.signal?.aborted || input.startIndex < 0 || idleRetryPolicy.maxAttempts === 0) return;
 		if (input.keepAlive !== true && !deliveredEvent && !initialConnection && (idleReconnects += 1) >= idleRetryPolicy.maxAttempts) return;
@@ -714,13 +728,15 @@ async function openStreamBody(input) {
 	for (let attempt = 0; attempt < openRetryPolicy.maxAttempts; attempt += 1) {
 		const url = createClientUrl(input.host, createEveSessionStreamRoutePath(input.sessionId), Object.keys(searchParams).length > 0 ? searchParams : void 0);
 		const headers = await input.resolveHeaders();
+		const connectionController = new AbortController();
+		const signal = input.signal ? AbortSignal.any([input.signal, connectionController.signal]) : connectionController.signal;
 		let response;
 		try {
 			response = await fetch(url, {
 				cache: "no-store",
 				headers,
 				redirect: input.redirect,
-				signal: input.signal ?? null
+				signal
 			});
 		} catch (error) {
 			if (input.signal?.aborted || !isStreamDisconnectError(error) || attempt === openRetryPolicy.maxAttempts - 1) throw error;
@@ -732,6 +748,7 @@ async function openStreamBody(input) {
 			if (!response.body) throw new ClientError(response.status, "Response body is null.", response.headers);
 			return {
 				body: response.body,
+				close: () => connectionController.abort(),
 				tailIndex: parseTailIndexHeader(response.headers)
 			};
 		}
@@ -1317,6 +1334,51 @@ function createEventDeduper() {
 	};
 }
 
+//#endregion
+//#region src/client/eve-agent-store-helpers.ts
+function isSettledSessionTail(events) {
+	const tail = events.at(-1);
+	return tail !== void 0 && isCurrentTurnBoundaryEvent(tail) && (tail.type !== "session.waiting" || collectPendingAuthorizations(events).size === 0);
+}
+function collectPendingAuthorizations(events) {
+	const pending = /* @__PURE__ */ new Set();
+	for (const event of events) updatePendingAuthorizations(pending, event);
+	return pending;
+}
+function updatePendingAuthorizations(pending, event) {
+	if (event.type === "authorization.required" && event.data.webhookUrl !== void 0) pending.add(event.data.name);
+	else if (event.type === "authorization.completed") pending.delete(event.data.name);
+}
+function assertExclusiveTurnInput(input) {
+	if (input.message !== void 0 === (input.inputResponses !== void 0)) throw new Error("A turn requires exactly one of message or inputResponses.");
+}
+let submissionSequence = 0;
+function createSubmissionId() {
+	const randomUUID = globalThis.crypto?.randomUUID;
+	if (randomUUID !== void 0) return randomUUID.call(globalThis.crypto);
+	submissionSequence += 1;
+	return `submission_${submissionSequence.toString()}`;
+}
+function createAbortSignal(first, second) {
+	return first ? AbortSignal.any([first, second]) : second;
+}
+function summarizeUserContent(message) {
+	if (typeof message === "string") return message;
+	const parts = [];
+	for (const part of message) if (part.type === "text") parts.push(part.text);
+	else if (part.type === "file") parts.push(part.filename ? `[file: ${part.filename}]` : "[file]");
+	return parts.join("\n");
+}
+function isAbortError(error) {
+	return error instanceof Error && error.name === "AbortError";
+}
+function toTerminalStreamFailureError(event) {
+	if (event.type !== "session.failed") return void 0;
+	const error = new Error(event.data.message);
+	error.name = event.data.code;
+	return error;
+}
+
 //#endregion
 //#region src/client/eve-agent-store.ts
 const detachStore = Symbol("detachEveAgentStore");
@@ -1332,8 +1394,9 @@ var EveAgentStore = class {
 	#data;
 	#error;
 	#events;
-	#pendingMessageSubmission;
+	#pendingMessageSubmissions = [];
 	#projectionEvents;
+	#resumePromise;
 	#session;
 	#snapshot;
 	#status = "ready";
@@ -1367,10 +1430,17 @@ var EveAgentStore = class {
 		};
 	}
 	async send(input) {
-		if (this.#status === "streaming" || this.#status === "submitted") throw new Error("eve session is already processing a turn.");
+		if (this.#activeTurn !== void 0) return await this.#sendFollowUp(this.#activeTurn, input);
 		const response = Promise.withResolvers();
+		const completion = Promise.withResolvers();
 		const turn = {
 			abortController: new AbortController(),
+			acceptedFollowUps: 0,
+			cancel: () => turn.acceptedFollowUps > 0 && this.#session !== void 0 ? this.#session.cancel() : response.promise.then((messageResponse) => messageResponse === void 0 ? { status: "no_active_turn" } : messageResponse.cancel()),
+			completion: completion.promise,
+			followUpDispatches: /* @__PURE__ */ new Set(),
+			receivedFollowUps: 0,
+			resolveCompletion: completion.resolve,
 			response: response.promise,
 			resolveResponse: response.resolve
 		};
@@ -1392,21 +1462,13 @@ var EveAgentStore = class {
 			const response = await this.#dispatchTurn(turnInput);
 			if (!this.#isActiveTurn(turn)) return;
 			turn.resolveResponse(response);
-			let sawEvent = false;
 			for await (const event of response) {
 				if (!this.#isActiveTurn(turn)) return;
-				if (!sawEvent) {
-					sawEvent = true;
-					this.#status = "streaming";
-				}
-				if (!this.#seenEvents.admit(event)) continue;
-				this.#events = [...this.#events, event];
-				this.#applyServerEvent(event);
-				this.#callbacks.onEvent?.(event);
-				this.#applyTerminalStreamFailure(event);
-				this.#publish();
+				this.#acceptServerEvent(event);
 			}
 			if (!this.#isActiveTurn(turn)) return;
+			await this.#followSteeredTurns(turn);
+			if (!this.#isActiveTurn(turn)) return;
 			this.#status = this.#error === void 0 ? "ready" : "error";
 		} catch (error) {
 			if (!this.#isActiveTurn(turn)) return;
@@ -1426,13 +1488,89 @@ var EveAgentStore = class {
 				this.#callbacks.onSessionChange?.(this.#session?.state);
 				this.#publish();
 				this.#callbacks.onFinish?.(this.#snapshot);
+				turn.resolveCompletion();
+			}
+		}
+	}
+	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 === "streaming" || this.#status === "submitted") throw new Error("eve session is already processing a turn.");
+		if (this.#session === void 0) throw new Error("An eve session is required before resuming.");
+		const response = Promise.withResolvers();
+		const completion = Promise.withResolvers();
+		const session = this.#session;
+		const turn = {
+			abortController: new AbortController(),
+			acceptedFollowUps: 0,
+			cancel: () => session.cancel(),
+			completion: completion.promise,
+			followUpDispatches: /* @__PURE__ */ new Set(),
+			receivedFollowUps: 0,
+			resolveCompletion: completion.resolve,
+			response: response.promise,
+			resolveResponse: response.resolve
+		};
+		this.#activeTurn = turn;
+		turn.resolveResponse(void 0);
+		this.#error = void 0;
+		this.#status = "submitted";
+		this.#publish();
+		try {
+			const replayed = [];
+			for await (const event of session.stream({
+				follow: false,
+				signal: turn.abortController.signal,
+				startIndex: 0
+			})) {
+				if (!this.#isActiveTurn(turn)) return;
+				replayed.push(event);
+				this.#acceptServerEvent(event, false);
+			}
+			if (!this.#isActiveTurn(turn)) return;
+			this.#publish();
+			if (!isSettledSessionTail(replayed)) {
+				const pendingAuthorizations = collectPendingAuthorizations(replayed);
+				for await (const event of session.stream({ signal: turn.abortController.signal })) {
+					if (!this.#isActiveTurn(turn)) return;
+					this.#acceptServerEvent(event);
+					updatePendingAuthorizations(pendingAuthorizations, event);
+					if (isCurrentTurnBoundaryEvent(event) && (event.type !== "session.waiting" || pendingAuthorizations.size === 0)) break;
+				}
+			}
+			await this.#followSteeredTurns(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 {
+			if (this.#isActiveTurn(turn)) {
+				turn.resolveResponse(void 0);
+				this.#activeTurn = void 0;
+				this.#callbacks.onSessionChange?.(session.state);
+				this.#publish();
+				this.#callbacks.onFinish?.(this.#snapshot);
+				turn.resolveCompletion();
 			}
 		}
 	}
 	cancel() {
 		const turn = this.#activeTurn;
 		if (turn === void 0) return Promise.resolve({ status: "no_active_turn" });
-		return turn.response.then((response) => response === void 0 ? { status: "no_active_turn" } : response.cancel());
+		return turn.cancel();
 	}
 	[detachStore]() {
 		this.#activeTurn?.abortController.abort();
@@ -1441,11 +1579,12 @@ var EveAgentStore = class {
 		const turn = this.#activeTurn;
 		this.#activeTurn = void 0;
 		turn?.resolveResponse(void 0);
+		turn?.resolveCompletion();
 		turn?.abortController.abort();
 		if (!this.#externalSession) this.#session = void 0;
 		this.#events = [];
 		this.#seenEvents = createEventDeduper();
-		this.#pendingMessageSubmission = void 0;
+		this.#pendingMessageSubmissions = [];
 		this.#projectionEvents = [];
 		this.#data = this.#reducer.initial();
 		this.#error = void 0;
@@ -1453,6 +1592,47 @@ var EveAgentStore = class {
 		this.#callbacks.onSessionChange?.(this.#session?.state);
 		this.#publish();
 	}
+	async #sendFollowUp(turn, input) {
+		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 replace it.");
+		const preparedInput = await this.#callbacks.prepareSend?.(input) ?? input;
+		assertExclusiveTurnInput(preparedInput);
+		if (preparedInput.message === void 0 || preparedInput.turnPolicy !== "steer") throw new Error("An in-flight follow-up requires a message with turnPolicy: \"steer\".");
+		if (!this.#isActiveTurn(turn)) return await this.send(preparedInput);
+		const submissionId = this.#projectOptimisticMessage(preparedInput);
+		this.#publish();
+		let dispatch;
+		dispatch = (async () => {
+			try {
+				await turn.response;
+				if (!this.#isActiveTurn(turn) || this.#session === void 0) throw new Error("The active eve turn ended before the follow-up could be sent.");
+				const { message, ...options } = preparedInput;
+				await this.#session.send(message, options);
+				turn.acceptedFollowUps += 1;
+			} catch (error) {
+				this.#failPendingMessageSubmission(toError(error), submissionId);
+				this.#publish();
+				throw error;
+			} finally {
+				turn.followUpDispatches.delete(dispatch);
+			}
+		})();
+		turn.followUpDispatches.add(dispatch);
+		await dispatch;
+		await turn.completion;
+	}
+	async #followSteeredTurns(turn) {
+		while (turn.followUpDispatches.size > 0) await Promise.allSettled(turn.followUpDispatches);
+		if (turn.receivedFollowUps >= turn.acceptedFollowUps || this.#session === void 0) return;
+		for await (const event of this.#session.stream({ signal: turn.abortController.signal })) {
+			if (!this.#isActiveTurn(turn)) return;
+			if (event.type === "message.received") turn.receivedFollowUps += 1;
+			this.#acceptServerEvent(event);
+			if (isCurrentTurnBoundaryEvent(event)) {
+				while (turn.followUpDispatches.size > 0) await Promise.allSettled(turn.followUpDispatches);
+				if (turn.receivedFollowUps >= turn.acceptedFollowUps) return;
+			}
+		}
+	}
 	async #createFirstTurn(input) {
 		if (this.#client === void 0) throw new Error("An external eve session is required before sending.");
 		if (input.message === void 0) throw new Error("Cannot answer an input request before the session starts.");
@@ -1485,7 +1665,7 @@ var EveAgentStore = class {
 			id,
 			message: summarizeUserContent(input.message)
 		};
-		this.#pendingMessageSubmission = pending;
+		this.#pendingMessageSubmissions = [...this.#pendingMessageSubmissions, pending];
 		this.#appendProjectionEvent({
 			data: {
 				createdAt: pending.createdAt,
@@ -1494,6 +1674,7 @@ var EveAgentStore = class {
 			},
 			type: "client.message.submitted"
 		});
+		return id;
 	}
 	#projectInputResponses(input) {
 		if (input.inputResponses === void 0 || input.inputResponses.length === 0) return;
@@ -1505,10 +1686,20 @@ var EveAgentStore = class {
 			type: "client.input.responded"
 		});
 	}
+	#acceptServerEvent(event, publish = true) {
+		if (!this.#seenEvents.admit(event)) return;
+		this.#events = [...this.#events, event];
+		this.#applyServerEvent(event);
+		this.#callbacks.onEvent?.(event);
+		this.#status = "streaming";
+		this.#applyTerminalStreamFailure(event);
+		if (publish) this.#publish();
+	}
 	#applyServerEvent(event) {
-		if (event.type === "message.received" && this.#pendingMessageSubmission !== void 0) {
-			const submissionId = this.#pendingMessageSubmission.id;
-			this.#pendingMessageSubmission = void 0;
+		const pendingSubmission = this.#pendingMessageSubmissions[0];
+		if (event.type === "message.received" && pendingSubmission !== void 0) {
+			const submissionId = pendingSubmission.id;
+			this.#pendingMessageSubmissions = this.#pendingMessageSubmissions.slice(1);
 			this.#replaceProjectionEvent((candidate) => candidate.type === "client.message.submitted" && candidate.data.submissionId === submissionId, event);
 			return;
 		}
@@ -1524,10 +1715,10 @@ var EveAgentStore = class {
 			this.#callbacks.onError?.(error);
 		}
 	}
-	#failPendingMessageSubmission(error) {
-		const pending = this.#pendingMessageSubmission;
+	#failPendingMessageSubmission(error, submissionId) {
+		const pending = submissionId === void 0 ? this.#pendingMessageSubmissions[0] : this.#pendingMessageSubmissions.find((candidate) => candidate.id === submissionId);
 		if (pending === void 0) return;
-		this.#pendingMessageSubmission = void 0;
+		this.#pendingMessageSubmissions = this.#pendingMessageSubmissions.filter((candidate) => candidate.id !== pending.id);
 		this.#replaceProjectionEvent((event) => event.type === "client.message.submitted" && event.data.submissionId === pending.id, {
 			data: {
 				createdAt: pending.createdAt,
@@ -1576,40 +1767,6 @@ var EveAgentStore = class {
 function detachEveAgentStore(store) {
 	store[detachStore]();
 }
-function assertExclusiveTurnInput(input) {
-	if (input.message !== void 0 === (input.inputResponses !== void 0)) throw new Error("A turn requires exactly one of message or inputResponses.");
-}
-let submissionSequence = 0;
-function createSubmissionId() {
-	const randomUUID = globalThis.crypto?.randomUUID;
-	if (randomUUID !== void 0) return randomUUID.call(globalThis.crypto);
-	submissionSequence += 1;
-	return `submission_${submissionSequence.toString()}`;
-}
-function createAbortSignal(first, second) {
-	return first ? AbortSignal.any([first, second]) : second;
-}
-function summarizeUserContent(message) {
-	if (typeof message === "string") return message;
-	const parts = [];
-	for (const part of message) {
-		if (part.type === "text") {
-			parts.push(part.text);
-			continue;
-		}
-		if (part.type === "file") parts.push(part.filename ? `[file: ${part.filename}]` : "[file]");
-	}
-	return parts.join("\n");
-}
-function isAbortError(error) {
-	return error instanceof Error && error.name === "AbortError";
-}
-function toTerminalStreamFailureError(event) {
-	if (event.type !== "session.failed") return;
-	const error = new Error(event.data.message);
-	error.name = event.data.code;
-	return error;
-}
 
 //#endregion
 //#region src/client/agent-host.ts
@@ -2233,6 +2390,9 @@ var SvelteEveAgent = class {
 	reset = () => {
 		this.#store.reset();
 	};
+	resume = () => {
+		return this.#store.resume();
+	};
 	respond = (inputResponses, options) => {
 		return this.#store.send({
 			...options,
@@ -2247,6 +2407,7 @@ var SvelteEveAgent = class {
 	};
 };
 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 store = new EveAgentStore({
 		auth: options.auth,
@@ -2268,6 +2429,7 @@ function useEveAgent(options = {}) {
 		onSessionChange: options.onSessionChange,
 		prepareSend: options.prepareSend
 	});
+	if ("window" in globalThis && options.resume) store.resume();
 	return new SvelteEveAgent(store);
 }