eve 0.30.8 → 0.31.1

package/dist/src/chunks/{use-eve-agent-DDoDDmJ2.js → use-eve-agent-CF5D6jSV.js}

@@ -5,13 +5,13 @@ import { z } from "#compiled/zod/index.js";
 const EVE_ROUTE_PREFIX = "/eve/v1";
 const EVE_HEALTH_ROUTE_PATH = `${EVE_ROUTE_PREFIX}/health`;
 const EVE_INFO_ROUTE_PATH = `${EVE_ROUTE_PREFIX}/info`;
-const EVE_CREATE_SESSION_ROUTE_PATH = `${EVE_ROUTE_PREFIX}/session`;
-const EVE_RESET_SESSION_ROUTE_PATH = `${EVE_ROUTE_PREFIX}/session/reset`;
-const EVE_COMPACT_SESSION_ROUTE_PATH = `${EVE_ROUTE_PREFIX}/session/compact`;
-const EVE_CLEAR_SESSION_ROUTE_PATH = `${EVE_ROUTE_PREFIX}/session/clear`;
-const EVE_CONTINUE_SESSION_ROUTE_PATTERN = `${EVE_ROUTE_PREFIX}/session/:sessionId`;
-const EVE_MESSAGE_STREAM_ROUTE_PATTERN = `${EVE_ROUTE_PREFIX}/session/:sessionId/stream`;
-const EVE_CANCEL_TURN_ROUTE_PATTERN = `${EVE_ROUTE_PREFIX}/session/:sessionId/cancel`;
+const EVE_SESSION_ROUTE_PATH = `${EVE_ROUTE_PREFIX}/session`;
+const EVE_SESSION_ROUTE_PATTERN = `${EVE_SESSION_ROUTE_PATH}/:sessionId`;
+const EVE_SESSION_CANCEL_ROUTE_PATTERN = `${EVE_SESSION_ROUTE_PATH}/:sessionId/cancel`;
+const EVE_SESSION_COMPACT_ROUTE_PATTERN = `${EVE_SESSION_ROUTE_PATH}/:sessionId/compact`;
+const EVE_SESSION_CLEAR_ROUTE_PATTERN = `${EVE_SESSION_ROUTE_PATH}/:sessionId/clear`;
+const EVE_SESSION_RESET_ROUTE_PATTERN = `${EVE_SESSION_ROUTE_PATH}/:sessionId/reset`;
+const EVE_SESSION_STREAM_ROUTE_PATTERN = `${EVE_SESSION_ROUTE_PATH}/:sessionId/stream`;
 const EVE_DEV_DISPATCH_SCHEDULE_ROUTE_PATTERN = `${EVE_ROUTE_PREFIX}/dev/schedules/:scheduleId`;
 const EVE_DEV_RUNTIME_ARTIFACTS_ROUTE_PATH = `${EVE_ROUTE_PREFIX}/dev/runtime-artifacts`;
 const EVE_DEV_RUNTIME_ARTIFACTS_REBUILD_ROUTE_PATH = `${EVE_DEV_RUNTIME_ARTIFACTS_ROUTE_PATH}/rebuild`;
@@ -19,14 +19,23 @@ const EVE_DEV_RUNTIME_ARTIFACTS_SUSPEND_ROUTE_PATH = `${EVE_DEV_RUNTIME_ARTIFACT
 const EVE_DEV_RUNTIME_ARTIFACTS_RESUME_ROUTE_PATH = `${EVE_DEV_RUNTIME_ARTIFACTS_ROUTE_PATH}/resume`;
 const EVE_CONNECTION_CALLBACK_ROUTE_PATTERN = `${EVE_ROUTE_PREFIX}/connections/:name/callback/:token`;
 const EVE_CALLBACK_ROUTE_PATTERN = `${EVE_ROUTE_PREFIX}/callback/:token`;
-function createEveMessageStreamRoutePath(sessionId) {
-	return `${EVE_ROUTE_PREFIX}/session/${encodeURIComponent(sessionId)}/stream`;
+function createEveSessionRoutePath(sessionId) {
+	return `${EVE_SESSION_ROUTE_PATH}/${encodeURIComponent(sessionId)}`;
 }
-function createEveContinueSessionRoutePath(sessionId) {
-	return `${EVE_ROUTE_PREFIX}/session/${encodeURIComponent(sessionId)}`;
+function createEveSessionCancelRoutePath(sessionId) {
+	return `${EVE_SESSION_ROUTE_PATH}/${encodeURIComponent(sessionId)}/cancel`;
 }
-function createEveCancelTurnRoutePath(sessionId) {
-	return `${EVE_ROUTE_PREFIX}/session/${encodeURIComponent(sessionId)}/cancel`;
+function createEveSessionCompactRoutePath(sessionId) {
+	return `${EVE_SESSION_ROUTE_PATH}/${encodeURIComponent(sessionId)}/compact`;
+}
+function createEveSessionClearRoutePath(sessionId) {
+	return `${EVE_SESSION_ROUTE_PATH}/${encodeURIComponent(sessionId)}/clear`;
+}
+function createEveSessionResetRoutePath(sessionId) {
+	return `${EVE_SESSION_ROUTE_PATH}/${encodeURIComponent(sessionId)}/reset`;
+}
+function createEveSessionStreamRoutePath(sessionId) {
+	return `${EVE_SESSION_ROUTE_PATH}/${encodeURIComponent(sessionId)}/stream`;
 }
 
 //#endregion
@@ -254,17 +263,23 @@ function isObject(value) {
 //#endregion
 //#region src/client/client-error.ts
 var ClientError = class extends Error {
+	code;
 	status;
 	body;
 	headers;
 	constructor(status, body, headers) {
 		let message = body || `Server returned ${status}.`;
+		let code;
 		try {
 			const parsed = JSON.parse(body);
-			if (isObject(parsed) && typeof parsed.error === "string") message = parsed.error;
+			if (isObject(parsed)) {
+				if (typeof parsed.error === "string") message = parsed.error;
+				if (typeof parsed.code === "string") code = parsed.code;
+			}
 		} catch {}
 		super(message);
 		this.name = "ClientError";
+		this.code = code;
 		this.status = status;
 		this.body = body;
 		this.headers = Object.freeze(Object.fromEntries(new Headers(headers).entries()));
@@ -377,47 +392,6 @@ function isTurnFailureEvent(event) {
 	return event.type === "session.failed" || event.type === "step.failed" || event.type === "turn.failed";
 }
 
-//#endregion
-//#region src/protocol/cancel-turn.ts
-const CancelTurnResponseSchema = z.object({
-	ok: z.literal(true),
-	sessionId: z.string().min(1),
-	status: z.enum(["accepted", "no_active_turn"])
-});
-
-//#endregion
-//#region src/protocol/clear-session.ts
-const ClearResponseSchema = z.discriminatedUnion("status", [z.object({
-	ok: z.literal(true),
-	sessionId: z.string().min(1),
-	status: z.literal("accepted")
-}), z.object({
-	ok: z.literal(true),
-	status: z.literal("no_active_session")
-})]);
-
-//#endregion
-//#region src/protocol/compact-session.ts
-const CompactResponseSchema = z.discriminatedUnion("status", [z.object({
-	ok: z.literal(true),
-	sessionId: z.string().min(1),
-	status: z.literal("accepted")
-}), z.object({
-	ok: z.literal(true),
-	status: z.literal("no_active_session")
-})]);
-
-//#endregion
-//#region src/protocol/reset-session.ts
-const ResetResponseSchema = z.discriminatedUnion("status", [z.object({
-	ok: z.literal(true),
-	previousSessionId: z.string().min(1),
-	status: z.literal("reset")
-}), z.object({
-	ok: z.literal(true),
-	status: z.literal("no_active_session")
-})]);
-
 //#endregion
 //#region src/client/output-schema.ts
 function extractCompletedResult(events) {
@@ -431,24 +405,6 @@ function isResultCompletedEvent(event) {
 
 //#endregion
 //#region src/client/session-utils.ts
-function createInitialSessionState() {
-	return { streamIndex: 0 };
-}
-function advanceSession(input) {
-	const boundaryEvent = findBoundaryEvent(input.events);
-	const streamIndex = input.session.streamIndex + input.events.length;
-	if (boundaryEvent?.type === "session.waiting" || input.preserveCompletedSessions === true && boundaryEvent?.type === "session.completed") return {
-		continuationToken: boundaryEvent?.type === "session.waiting" ? boundaryEvent.data.continuationToken : input.continuationToken ?? input.session.continuationToken,
-		sessionId: input.sessionId,
-		streamIndex
-	};
-	if (boundaryEvent === void 0) return {
-		continuationToken: input.continuationToken ?? input.session.continuationToken,
-		sessionId: input.sessionId,
-		streamIndex
-	};
-	return createInitialSessionState();
-}
 function summarizeTurnEvents(events) {
 	let boundary;
 	let failure;
@@ -472,12 +428,6 @@ function summarizeTurnEvents(events) {
 		status: boundary?.type === "session.waiting" ? "waiting" : boundary?.type === "session.failed" ? "failed" : "completed"
 	};
 }
-function findBoundaryEvent(events) {
-	for (let i = events.length - 1; i >= 0; i--) {
-		const event = events[i];
-		if (event !== void 0 && isCurrentTurnBoundaryEvent(event)) return event;
-	}
-}
 function isFinalMessageCompleted(event) {
 	return event.type === "message.completed" && event.data.finishReason !== "tool-calls";
 }
@@ -485,12 +435,10 @@ function isFinalMessageCompleted(event) {
 //#endregion
 //#region src/client/message-response.ts
 var MessageResponse = class {
-	continuationToken;
 	sessionId;
 	#consumed = false;
 	#createStream;
 	constructor(input) {
-		this.continuationToken = input.continuationToken;
 		this.sessionId = input.sessionId;
 		this.#createStream = input.createStream;
 	}
@@ -682,7 +630,7 @@ async function* followStreamIterable(input) {
 		if (input.signal?.aborted || input.startIndex < 0 || idleRetryPolicy.maxAttempts === 0) return;
 		if (!deliveredEvent && !initialConnection && (idleReconnects += 1) >= idleRetryPolicy.maxAttempts) return;
 		initialConnection = false;
-		await sleep$1(reconnectDelayMs, input.signal);
+		await sleep(reconnectDelayMs, input.signal);
 		if (input.signal?.aborted) return;
 		reconnectDelayMs = Math.min(reconnectDelayMs * 2, idleRetryPolicy.maxDelayMs);
 	}
@@ -698,7 +646,7 @@ async function openStreamBody(input) {
 	if (input.startIndex !== 0) searchParams.startIndex = String(input.startIndex);
 	if (input.requestTailIndex === true) searchParams.includeTailIndex = "1";
 	for (let attempt = 0; attempt < openRetryPolicy.maxAttempts; attempt += 1) {
-		const url = createClientUrl(input.host, createEveMessageStreamRoutePath(input.sessionId), Object.keys(searchParams).length > 0 ? searchParams : void 0);
+		const url = createClientUrl(input.host, createEveSessionStreamRoutePath(input.sessionId), Object.keys(searchParams).length > 0 ? searchParams : void 0);
 		const headers = await input.resolveHeaders();
 		let response;
 		try {
@@ -710,7 +658,7 @@ async function openStreamBody(input) {
 			});
 		} catch (error) {
 			if (input.signal?.aborted || !isStreamDisconnectError(error) || attempt === openRetryPolicy.maxAttempts - 1) throw error;
-			await sleep$1(retryDelayMs, input.signal);
+			await sleep(retryDelayMs, input.signal);
 			retryDelayMs = Math.min(retryDelayMs * 2, openRetryPolicy.maxDelayMs);
 			continue;
 		}
@@ -726,7 +674,7 @@ async function openStreamBody(input) {
 		lastHeaders = response.headers;
 		if (!retryPolicy.retryableErrorStatuses.has(response.status)) throw new ClientError(response.status, lastBody, response.headers);
 		if (attempt < openRetryPolicy.maxAttempts - 1) {
-			await sleep$1(retryDelayMs, input.signal);
+			await sleep(retryDelayMs, input.signal);
 			retryDelayMs = Math.min(retryDelayMs * 2, openRetryPolicy.maxDelayMs);
 		}
 	}
@@ -738,7 +686,7 @@ function parseTailIndexHeader(headers) {
 	const parsed = Number(raw);
 	return Number.isSafeInteger(parsed) ? parsed : void 0;
 }
-async function sleep$1(ms, signal) {
+async function sleep(ms, signal) {
 	if (signal?.aborted) return;
 	await new Promise((resolve) => {
 		const onAbort = () => {
@@ -753,6 +701,132 @@ async function sleep$1(ms, signal) {
 	});
 }
 
+//#endregion
+//#region src/protocol/cancel-turn.ts
+const CancelTurnResponseSchema = z.discriminatedUnion("status", [z.strictObject({
+	ok: z.literal(true),
+	sessionId: z.string().min(1),
+	status: z.literal("accepted")
+}), z.strictObject({
+	ok: z.literal(true),
+	status: z.literal("no_active_turn")
+})]);
+
+//#endregion
+//#region src/protocol/clear-session.ts
+const ClearResponseSchema = z.discriminatedUnion("status", [z.object({
+	ok: z.literal(true),
+	sessionId: z.string().min(1),
+	status: z.literal("accepted")
+}), z.object({
+	ok: z.literal(true),
+	status: z.literal("no_active_session")
+})]);
+
+//#endregion
+//#region src/protocol/compact-session.ts
+const CompactResponseSchema = z.discriminatedUnion("status", [z.object({
+	ok: z.literal(true),
+	sessionId: z.string().min(1),
+	status: z.literal("accepted")
+}), z.object({
+	ok: z.literal(true),
+	status: z.literal("no_active_session")
+})]);
+
+//#endregion
+//#region src/protocol/reset-session.ts
+const ResetResponseSchema = z.discriminatedUnion("status", [z.object({
+	ok: z.literal(true),
+	previousSessionId: z.string().min(1),
+	status: z.literal("reset")
+}), z.object({
+	ok: z.literal(true),
+	status: z.literal("no_active_session")
+})]);
+
+//#endregion
+//#region src/client/session-controls.ts
+async function cancelClientSession(input) {
+	const { payload, response } = await postJson({
+		body: input.options,
+		context: input.context,
+		operation: "Cancel",
+		path: createEveSessionCancelRoutePath(input.sessionId)
+	});
+	const result = CancelTurnResponseSchema.safeParse(payload);
+	if (!result.success || result.data.status === "accepted" && result.data.sessionId !== input.sessionId) throw new Error(`Cancel route returned an invalid response (${response.status}).`);
+	return result.data.status === "accepted" ? {
+		sessionId: result.data.sessionId,
+		status: "accepted"
+	} : { status: "no_active_turn" };
+}
+async function clearClientSession(input) {
+	const { payload } = await postJson({
+		context: input.context,
+		operation: "Clear",
+		path: createEveSessionClearRoutePath(input.sessionId)
+	});
+	const result = ClearResponseSchema.safeParse(payload);
+	if (!result.success || result.data.status === "accepted" && result.data.sessionId !== input.sessionId) throw new Error("Clear route returned an invalid response.");
+	return result.data.status === "accepted" ? {
+		sessionId: result.data.sessionId,
+		status: "accepted"
+	} : { status: "no_active_session" };
+}
+async function compactClientSession(input) {
+	const { payload } = await postJson({
+		context: input.context,
+		operation: "Compact",
+		path: createEveSessionCompactRoutePath(input.sessionId)
+	});
+	const result = CompactResponseSchema.safeParse(payload);
+	if (!result.success || result.data.status === "accepted" && result.data.sessionId !== input.sessionId) throw new Error("Compact route returned an invalid response.");
+	return result.data.status === "accepted" ? {
+		sessionId: result.data.sessionId,
+		status: "accepted"
+	} : { status: "no_active_session" };
+}
+async function resetClientSession(input) {
+	const { payload } = await postJson({
+		body: input.options,
+		context: input.context,
+		operation: "Reset",
+		path: createEveSessionResetRoutePath(input.sessionId)
+	});
+	const result = ResetResponseSchema.safeParse(payload);
+	if (!result.success || result.data.status === "reset" && result.data.previousSessionId !== input.sessionId) throw new Error("Reset route returned an invalid response.");
+	return result.data.status === "reset" ? {
+		previousSessionId: result.data.previousSessionId,
+		status: "reset"
+	} : { status: "no_active_session" };
+}
+async function postJson(input) {
+	const headers = await input.context.resolveHeaders();
+	headers.set("content-type", "application/json");
+	const response = await fetch(createClientUrl(input.context.host, input.path), withRedirectPolicy$1({
+		body: input.body === void 0 ? void 0 : JSON.stringify(input.body),
+		headers,
+		method: "POST"
+	}, input.context.redirect));
+	const text = await response.text();
+	if (!response.ok) throw new ClientError(response.status, text, response.headers);
+	try {
+		return {
+			payload: JSON.parse(text),
+			response
+		};
+	} catch {
+		throw new Error(`${input.operation} route returned invalid JSON (${response.status}).`);
+	}
+}
+function withRedirectPolicy$1(init, redirect) {
+	return redirect === void 0 ? init : {
+		...init,
+		redirect
+	};
+}
+
 //#endregion
 //#region src/shared/json.ts
 const INVALID_JSON_VALUE_CANDIDATE = Symbol("invalid-json-value-candidate");
@@ -823,266 +897,139 @@ function isStandardJsonSchema(value) {
 
 //#endregion
 //#region src/client/session.ts
-const DELIVER_RETRY_ATTEMPTS = 10;
-const DELIVER_RETRY_DELAY_MS = 200;
-var ClientSession = class {
+var ClientSession = class ClientSession {
 	#context;
 	#state;
 	constructor(context, state) {
 		this.#context = context;
 		this.#state = state;
 	}
+	static async create(context, input) {
+		const response = await postTurn(context, EVE_SESSION_ROUTE_PATH, input, true);
+		const sessionId = await readSessionId(response);
+		const session = new ClientSession(context, {
+			sessionId,
+			streamIndex: 0
+		});
+		return {
+			response: session.#messageResponse(response, input, 0),
+			session
+		};
+	}
 	get state() {
 		return this.#state;
 	}
 	async snapshot(options) {
 		options?.signal?.throwIfAborted();
-		const initialState = this.#state;
-		const sessionId = initialState.sessionId;
-		if (!sessionId) throw new Error("Session has no session ID. Send a message first.");
 		const events = [];
 		for await (const event of this.#readStream({
 			follow: false,
-			sessionId,
 			signal: options?.signal,
 			startIndex: 0
 		})) events.push(event);
 		options?.signal?.throwIfAborted();
-		const lastEvent = events.at(-1);
-		const continuationToken = lastEvent?.type === "session.waiting" ? lastEvent.data.continuationToken : lastEvent?.type === "session.completed" && this.#context.preserveCompletedSessions ? initialState.continuationToken : void 0;
 		return {
 			events,
-			session: continuationToken === void 0 ? {
-				sessionId,
-				streamIndex: events.length
-			} : {
-				continuationToken,
-				sessionId,
+			session: {
+				sessionId: this.#state.sessionId,
 				streamIndex: events.length
 			}
 		};
 	}
-	async send(input) {
-		const payload = normalizeSendTurnInput(input);
-		const state = this.#state;
-		const { continuationToken, sessionId } = await this.#postTurn(payload, state);
-		if (this.#state === state) {
-			const nextState = {
-				...state,
-				sessionId
-			};
-			if (continuationToken !== void 0) nextState.continuationToken = continuationToken;
-			this.#state = nextState;
-		}
-		return new MessageResponse({
-			continuationToken,
-			createStream: () => this.#createEventStream(sessionId, continuationToken, state, payload),
-			sessionId
+	async send(message, options = {}) {
+		return await this.#send({
+			...options,
+			message
 		});
 	}
+	async respond(inputResponses, options = {}) {
+		if (inputResponses.length === 0) throw new Error("ClientSession.respond() requires at least one input response.");
+		return await this.#send({
+			...options,
+			inputResponses
+		});
+	}
+	async #send(input) {
+		const initialStreamIndex = this.#state.streamIndex;
+		const response = await postTurn(this.#context, createEveSessionRoutePath(this.#state.sessionId), input, false);
+		if (await readSessionId(response, this.#state.sessionId) !== this.#state.sessionId) throw new Error("Message route returned a different session id.");
+		return this.#messageResponse(response, input, initialStreamIndex);
+	}
 	async cancel(options) {
-		const sessionId = this.#state.sessionId;
-		if (!sessionId) throw new Error("Session has no session ID. Send a message first.");
-		const url = createClientUrl(this.#context.host, createEveCancelTurnRoutePath(sessionId));
-		const headers = await this.#context.resolveHeaders();
-		headers.set("content-type", "application/json");
-		const response = await fetch(url, withRedirectPolicy$1({
-			headers,
-			method: "POST",
-			body: options ? JSON.stringify(options) : void 0
-		}, this.#context.redirect));
-		const body = await response.text();
-		if (!response.ok) throw new ClientError(response.status, body, response.headers);
-		let payload;
-		try {
-			payload = JSON.parse(body);
-		} catch {
-			throw new Error(`Cancel route returned invalid JSON (${response.status}).`);
-		}
-		const result = CancelTurnResponseSchema.safeParse(payload);
-		if (!result.success || result.data.sessionId !== sessionId) throw new Error(`Cancel route returned an invalid response (${response.status}).`);
-		return {
-			sessionId: result.data.sessionId,
-			status: result.data.status
-		};
+		return await cancelClientSession({
+			context: this.#context,
+			options,
+			sessionId: this.#state.sessionId
+		});
 	}
 	async clear() {
-		const state = this.#state;
-		const continuationToken = state.continuationToken;
-		if (continuationToken === void 0) {
-			if (state.sessionId !== void 0) throw new Error("Session has no continuation token. Consume its event stream before clearing.");
-			return { status: "no_active_session" };
-		}
-		const url = createClientUrl(this.#context.host, EVE_CLEAR_SESSION_ROUTE_PATH);
-		const headers = await this.#context.resolveHeaders();
-		headers.set("content-type", "application/json");
-		const response = await fetch(url, withRedirectPolicy$1({
-			body: JSON.stringify({ continuationToken }),
-			headers,
-			method: "POST"
-		}, this.#context.redirect));
-		const body = await response.text();
-		if (!response.ok) throw new ClientError(response.status, body, response.headers);
-		let payload;
-		try {
-			payload = JSON.parse(body);
-		} catch {
-			throw new Error(`Clear route returned invalid JSON (${response.status}).`);
-		}
-		const result = ClearResponseSchema.safeParse(payload);
-		if (!result.success || result.data.status === "accepted" && state.sessionId !== void 0 && result.data.sessionId !== state.sessionId) throw new Error(`Clear route returned an invalid response (${response.status}).`);
-		return result.data.status === "accepted" ? {
-			sessionId: result.data.sessionId,
-			status: "accepted"
-		} : { status: "no_active_session" };
+		return await clearClientSession({
+			context: this.#context,
+			sessionId: this.#state.sessionId
+		});
 	}
 	async compact() {
-		const state = this.#state;
-		const continuationToken = state.continuationToken;
-		if (continuationToken === void 0) {
-			if (state.sessionId !== void 0) throw new Error("Session has no continuation token. Consume its event stream before compacting.");
-			return { status: "no_active_session" };
-		}
-		const url = createClientUrl(this.#context.host, EVE_COMPACT_SESSION_ROUTE_PATH);
-		const headers = await this.#context.resolveHeaders();
-		headers.set("content-type", "application/json");
-		const response = await fetch(url, withRedirectPolicy$1({
-			body: JSON.stringify({ continuationToken }),
-			headers,
-			method: "POST"
-		}, this.#context.redirect));
-		const body = await response.text();
-		if (!response.ok) throw new ClientError(response.status, body, response.headers);
-		let payload;
-		try {
-			payload = JSON.parse(body);
-		} catch {
-			throw new Error(`Compact route returned invalid JSON (${response.status}).`);
-		}
-		const result = CompactResponseSchema.safeParse(payload);
-		if (!result.success || result.data.status === "accepted" && state.sessionId !== void 0 && result.data.sessionId !== state.sessionId) throw new Error(`Compact route returned an invalid response (${response.status}).`);
-		return result.data.status === "accepted" ? {
-			sessionId: result.data.sessionId,
-			status: "accepted"
-		} : { status: "no_active_session" };
-	}
-	async reset() {
-		const state = this.#state;
-		const continuationToken = state.continuationToken;
-		if (continuationToken === void 0) {
-			if (state.sessionId !== void 0) throw new Error("Session has no continuation token. Consume its event stream before resetting.");
-			this.#state = createInitialSessionState();
-			return { status: "no_active_session" };
-		}
-		const url = createClientUrl(this.#context.host, EVE_RESET_SESSION_ROUTE_PATH);
-		const headers = await this.#context.resolveHeaders();
-		headers.set("content-type", "application/json");
-		const response = await fetch(url, withRedirectPolicy$1({
-			body: JSON.stringify({ continuationToken }),
-			headers,
-			method: "POST"
-		}, this.#context.redirect));
-		const body = await response.text();
-		if (!response.ok) throw new ClientError(response.status, body, response.headers);
-		let payload;
-		try {
-			payload = JSON.parse(body);
-		} catch {
-			throw new Error(`Reset route returned invalid JSON (${response.status}).`);
-		}
-		const result = ResetResponseSchema.safeParse(payload);
-		if (!result.success) throw new Error(`Reset route returned an invalid response (${response.status}).`);
-		if (result.data.status === "reset" && state.sessionId !== void 0 && result.data.previousSessionId !== state.sessionId) throw new Error(`Reset route returned an invalid response (${response.status}).`);
-		if (this.#state === state) this.#state = createInitialSessionState();
-		return result.data.status === "reset" ? {
-			previousSessionId: result.data.previousSessionId,
-			status: "reset"
-		} : { status: "no_active_session" };
+		return await compactClientSession({
+			context: this.#context,
+			sessionId: this.#state.sessionId
+		});
+	}
+	async reset(options) {
+		return await resetClientSession({
+			context: this.#context,
+			options,
+			sessionId: this.#state.sessionId
+		});
 	}
 	stream(options) {
-		const sessionId = this.#state.sessionId;
-		if (!sessionId) throw new Error("Session has no session ID. Send a message first.");
 		if (options?.follow === false && (options.startIndex ?? this.#state.streamIndex) < 0) throw new Error("stream({ follow: false }) requires a nonnegative startIndex; a tail-relative cursor cannot be bounded.");
-		return this.#streamAndAdvance(sessionId, options);
-	}
-	async #postTurn(input, session) {
-		const routePath = session.sessionId ? createEveContinueSessionRoutePath(session.sessionId) : EVE_CREATE_SESSION_ROUTE_PATH;
-		const url = createClientUrl(this.#context.host, routePath);
-		const headers = await this.#context.resolveHeaders(input.headers);
-		headers.set("content-type", "application/json");
-		const body = createHandleMessageBody({
-			input,
-			outputSchema: serializeOutputSchema(input.outputSchema),
-			session
-		});
-		if (body === null) throw new Error("Session.send requires a non-empty message, inputResponses, or both.");
-		const response = await postTurnWithRetry({
-			body: JSON.stringify(body),
-			headers,
-			mustDeliver: (input.inputResponses?.length ?? 0) > 0,
-			redirect: this.#context.redirect,
-			signal: input.signal,
-			url
+		return this.#streamAndAdvance(options);
+	}
+	#messageResponse(response, input, initialStreamIndex) {
+		response.body?.cancel().catch(() => {});
+		return new MessageResponse({
+			createStream: () => this.#createEventStream(initialStreamIndex, input),
+			sessionId: this.#state.sessionId
 		});
-		const payload = await response.json();
-		const sessionId = (typeof payload.sessionId === "string" ? payload.sessionId : void 0) ?? response.headers.get("x-eve-session-id")?.trim() ?? session.sessionId;
-		if (!sessionId) throw new Error("Message route did not return a session id.");
-		return {
-			continuationToken: typeof payload.continuationToken === "string" ? payload.continuationToken : void 0,
-			sessionId
-		};
 	}
-	async *#createEventStream(sessionId, continuationToken, initialState, input) {
-		const events = [];
+	async *#createEventStream(initialStreamIndex, input) {
+		let eventCount = 0;
 		try {
 			for await (const event of this.#readStream({
 				headers: input.headers,
-				streamReconnectPolicy: input.streamReconnectPolicy,
-				sessionId,
 				signal: input.signal,
-				startIndex: initialState.sessionId === sessionId ? initialState.streamIndex : 0
+				startIndex: initialStreamIndex,
+				streamReconnectPolicy: input.streamReconnectPolicy
 			})) {
-				events.push(event);
+				eventCount += 1;
 				yield event;
 				if (isCurrentTurnBoundaryEvent(event)) break;
 			}
 		} finally {
-			this.#state = advanceSession({
-				continuationToken,
-				events,
-				preserveCompletedSessions: this.#context.preserveCompletedSessions,
-				sessionId,
-				session: initialState
-			});
+			this.#state = {
+				sessionId: this.#state.sessionId,
+				streamIndex: initialStreamIndex + eventCount
+			};
 		}
 	}
-	async *#streamAndAdvance(sessionId, options) {
-		const initialState = this.#state;
-		const streamIndex = options?.startIndex ?? initialState.streamIndex;
-		const events = [];
+	async *#streamAndAdvance(options) {
+		const startIndex = options?.startIndex ?? this.#state.streamIndex;
+		let eventCount = 0;
 		try {
 			for await (const event of this.#readStream({
 				follow: options?.follow,
-				sessionId,
 				signal: options?.signal,
-				startIndex: streamIndex,
+				startIndex,
 				streamReconnectPolicy: options?.streamReconnectPolicy
 			})) {
-				events.push(event);
+				eventCount += 1;
 				yield event;
 			}
 		} finally {
-			if (streamIndex >= 0) this.#state = advanceSession({
-				continuationToken: initialState.continuationToken,
-				events,
-				preserveCompletedSessions: this.#context.preserveCompletedSessions,
-				session: {
-					...initialState,
-					sessionId,
-					streamIndex
-				},
-				sessionId
-			});
+			if (startIndex >= 0) this.#state = {
+				sessionId: this.#state.sessionId,
+				streamIndex: startIndex + eventCount
+			};
 		}
 	}
 	#readStream(input) {
@@ -1091,62 +1038,67 @@ var ClientSession = class {
 			host: this.#context.host,
 			resolveHeaders: () => this.#context.resolveHeaders(input.headers),
 			redirect: this.#context.redirect,
-			streamReconnectPolicy: input.streamReconnectPolicy,
-			sessionId: input.sessionId,
+			sessionId: this.#state.sessionId,
 			signal: input.signal,
-			startIndex: input.startIndex
+			startIndex: input.startIndex,
+			streamReconnectPolicy: input.streamReconnectPolicy
 		});
 	}
 };
-async function postTurnWithRetry(input) {
-	const attempts = input.mustDeliver ? DELIVER_RETRY_ATTEMPTS : 1;
-	let lastStatus;
-	let lastBody;
-	let lastHeaders;
-	for (let attempt = 0; attempt < attempts; attempt += 1) {
-		const response = await fetch(input.url, {
-			body: input.body,
-			headers: input.headers,
-			method: "POST",
-			redirect: input.redirect,
-			signal: input.signal ?? null
-		});
-		if (response.ok) return response;
-		lastStatus = response.status;
-		lastBody = await response.text();
-		lastHeaders = response.headers;
-		if (!isRetryableDeliveryFailure(response.status, lastBody)) throw new ClientError(response.status, lastBody, response.headers);
-		if (attempt < attempts - 1) await sleep(DELIVER_RETRY_DELAY_MS);
+async function postTurn(context, path, input, requireMessage) {
+	const body = createMessageBody(input, requireMessage);
+	if (body === null) throw new Error(requireMessage ? "Creating a session requires a non-empty message." : "A session turn requires a non-empty message or inputResponses.");
+	const headers = await context.resolveHeaders(input.headers);
+	headers.set("content-type", "application/json");
+	const response = await fetch(createClientUrl(context.host, path), {
+		body: JSON.stringify(body),
+		headers,
+		method: "POST",
+		redirect: context.redirect,
+		signal: input.signal ?? null
+	});
+	if (!response.ok) {
+		const responseBody = await response.text();
+		throw new ClientError(response.status, responseBody, response.headers);
 	}
-	throw new ClientError(lastStatus ?? 0, lastBody ?? "Failed to deliver session turn.", lastHeaders);
-}
-function isRetryableDeliveryFailure(status, body) {
-	return status === 500 && /target session was not found/i.test(body);
+	return response;
 }
-async function sleep(ms) {
-	await new Promise((resolve) => setTimeout(resolve, ms));
+async function readSessionId(response, expected) {
+	const payload = await response.json();
+	const sessionId = (typeof payload.sessionId === "string" ? payload.sessionId : void 0) ?? response.headers.get("x-eve-session-id")?.trim() ?? expected;
+	if (!sessionId) throw new Error("Message route did not return a session id.");
+	return sessionId;
 }
-function normalizeSendTurnInput(input) {
-	return typeof input === "string" ? { message: input } : input;
-}
-function createHandleMessageBody(input) {
+function createMessageBody(input, requireMessage) {
 	const body = {};
-	if (input.input.message !== void 0) body.message = input.input.message;
-	if (input.input.inputResponses !== void 0 && input.input.inputResponses.length > 0) body.inputResponses = input.input.inputResponses;
-	if (input.input.clientContext !== void 0) body.clientContext = input.input.clientContext;
-	if (input.outputSchema !== void 0) body.outputSchema = input.outputSchema;
-	if (input.session.continuationToken !== void 0) body.continuationToken = input.session.continuationToken;
-	if (Object.keys(body).length === 0) return null;
-	if (input.session.continuationToken === void 0 && body.message === void 0) return null;
-	if (input.session.continuationToken !== void 0 && body.message === void 0 && body.inputResponses === void 0) return null;
+	if (input.message !== void 0) body.message = input.message;
+	if (input.inputResponses !== void 0 && input.inputResponses.length > 0) body.inputResponses = input.inputResponses;
+	if (input.clientContext !== void 0) body.clientContext = input.clientContext;
+	const outputSchema = serializeOutputSchema(input.outputSchema);
+	if (outputSchema !== void 0) body.outputSchema = outputSchema;
+	if (requireMessage && body.message === void 0) return null;
+	if (body.message === void 0 && body.inputResponses === void 0) return null;
 	return body;
 }
-function withRedirectPolicy$1(init, redirect) {
-	return redirect === void 0 ? init : {
-		...init,
-		redirect
-	};
-}
+
+//#endregion
+//#region src/client/sessions.ts
+var ClientSessions = class {
+	#context;
+	constructor(context) {
+		this.#context = context;
+	}
+	async create(input) {
+		return await ClientSession.create(this.#context, input);
+	}
+	attach(sessionId, options) {
+		if (sessionId.length === 0) throw new Error("sessionId must be a non-empty string.");
+		return new ClientSession(this.#context, {
+			sessionId,
+			streamIndex: options?.streamIndex ?? 0
+		});
+	}
+};
 
 //#endregion
 //#region src/client/types.ts
@@ -1158,14 +1110,18 @@ var Client = class {
 	#auth;
 	#headers;
 	#host;
-	#preserveCompletedSessions;
 	#redirect;
+	sessions;
 	constructor(options) {
 		this.#host = options.host;
 		this.#auth = options.auth;
 		this.#headers = options.headers;
-		this.#preserveCompletedSessions = options.preserveCompletedSessions ?? false;
 		this.#redirect = options.redirect;
+		this.sessions = new ClientSessions({
+			host: this.#host,
+			redirect: this.#redirect,
+			resolveHeaders: (perRequest) => this.#resolveHeaders(perRequest)
+		});
 	}
 	async health() {
 		const url = createClientUrl(this.#host, EVE_HEALTH_ROUTE_PATH);
@@ -1204,21 +1160,6 @@ var Client = class {
 			headers
 		}, this.#redirect));
 	}
-	session(state) {
-		let resolved;
-		if (typeof state === "string") resolved = {
-			continuationToken: state,
-			streamIndex: 0
-		};
-		else if (state) resolved = state;
-		else resolved = createInitialSessionState();
-		return new ClientSession({
-			host: this.#host,
-			preserveCompletedSessions: this.#preserveCompletedSessions,
-			redirect: this.#redirect,
-			resolveHeaders: (perRequest) => this.#resolveHeaders(perRequest)
-		}, resolved);
-	}
 	async #resolveHeaders(perRequest) {
 		const headers = new Headers();
 		const [baseHeaders, authHeaders] = await Promise.all([resolveHeadersValue(this.#headers), this.#resolveAuthHeaders()]);
@@ -1288,7 +1229,8 @@ function createEventDeduper() {
 //#endregion
 //#region src/client/eve-agent-store.ts
 var EveAgentStore = class {
-	#createSession;
+	#client;
+	#externalSession;
 	#optimistic;
 	#reducer;
 	#subscribers = /* @__PURE__ */ new Set();
@@ -1305,18 +1247,19 @@ var EveAgentStore = class {
 	#snapshot;
 	#status = "ready";
 	constructor(init) {
-		this.#createSession = init.session ? void 0 : () => new Client({
+		this.#externalSession = init.session !== void 0;
+		this.#client = this.#externalSession ? void 0 : new Client({
 			auth: init.auth,
 			headers: init.headers,
 			host: init.host ?? ""
-		}).session(init.initialSession);
+		});
 		const initialEvents = [];
 		for (const event of init.initialEvents ?? []) if (this.#seenEvents.admit(event)) initialEvents.push(event);
 		this.#events = initialEvents;
 		this.#projectionEvents = [...this.#events];
 		this.#optimistic = init.optimistic ?? true;
 		this.#reducer = init.reducer;
-		this.#session = init.session ?? this.#createOwnedSession();
+		this.#session = init.session ?? (init.initialSession === void 0 ? void 0 : this.#client?.sessions.attach(init.initialSession.sessionId, { streamIndex: init.initialSession.streamIndex }));
 		this.#data = this.#reduceProjectionEvents(this.#projectionEvents);
 		this.#snapshot = this.#createSnapshot();
 	}
@@ -1342,14 +1285,16 @@ var EveAgentStore = class {
 		this.#publish();
 		try {
 			const preparedInput = await this.#callbacks.prepareSend?.(input) ?? input;
+			assertExclusiveTurnInput(preparedInput);
 			if (!this.#isCurrentOperation(operationId)) return;
 			this.#projectOptimisticMessage(preparedInput);
 			this.#projectInputResponses(preparedInput);
 			this.#publish();
-			const response = await this.#session.send({
+			const turnInput = {
 				...preparedInput,
 				signal: createAbortSignal(preparedInput.signal, abortController.signal)
-			});
+			};
+			const response = await this.#dispatchTurn(turnInput);
 			let sawEvent = false;
 			for await (const event of response) {
 				if (!this.#isCurrentOperation(operationId)) return;
@@ -1380,7 +1325,7 @@ var EveAgentStore = class {
 		} finally {
 			if (this.#isCurrentOperation(operationId)) {
 				this.#abortController = void 0;
-				this.#callbacks.onSessionChange?.(this.#session.state);
+				this.#callbacks.onSessionChange?.(this.#session?.state);
 				this.#publish();
 				this.#callbacks.onFinish?.(this.#snapshot);
 			}
@@ -1393,7 +1338,7 @@ var EveAgentStore = class {
 		this.#invalidateOperation();
 		this.stop();
 		this.#abortController = void 0;
-		this.#session = this.#createSession?.() ?? this.#session;
+		if (!this.#externalSession) this.#session = void 0;
 		this.#events = [];
 		this.#seenEvents = createEventDeduper();
 		this.#pendingMessageSubmission = void 0;
@@ -1401,12 +1346,29 @@ var EveAgentStore = class {
 		this.#data = this.#reducer.initial();
 		this.#error = void 0;
 		this.#status = "ready";
-		this.#callbacks.onSessionChange?.(this.#session.state);
+		this.#callbacks.onSessionChange?.(this.#session?.state);
 		this.#publish();
 	}
-	#createOwnedSession() {
-		if (!this.#createSession) throw new Error("Cannot create an owned eve session from an external session.");
-		return this.#createSession();
+	async #createFirstTurn(input) {
+		if (this.#client === void 0) throw new Error("An external eve session is required before sending.");
+		if (input.message === void 0) throw new Error("Cannot answer an input request before the session starts.");
+		const created = await this.#client.sessions.create({
+			...input,
+			message: input.message
+		});
+		this.#session = created.session;
+		this.#callbacks.onSessionChange?.(created.session.state);
+		this.#publish();
+		return created.response;
+	}
+	async #dispatchTurn(input) {
+		if (this.#session === void 0) return await this.#createFirstTurn(input);
+		if (input.inputResponses === void 0) {
+			const { message, ...options } = input;
+			return await this.#session.send(message, options);
+		}
+		const { inputResponses, ...options } = input;
+		return await this.#session.respond(inputResponses, options);
 	}
 	#startOperation() {
 		this.#operationId += 1;
@@ -1505,7 +1467,7 @@ var EveAgentStore = class {
 			data: this.#data,
 			error: this.#error,
 			events: this.#events,
-			session: this.#session.state,
+			session: this.#session?.state,
 			status: this.#status
 		};
 	}
@@ -1514,6 +1476,9 @@ var EveAgentStore = class {
 		for (const subscriber of this.#subscribers) subscriber();
 	}
 };
+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;
@@ -2107,7 +2072,14 @@ function useEveAgent(options = {}) {
 		error: computed(() => snapshot.value.error),
 		events: computed(() => snapshot.value.events),
 		reset: () => store.reset(),
-		send: (input) => store.send(input),
+		respond: (inputResponses, options) => store.send({
+			...options,
+			inputResponses
+		}),
+		send: (message, options) => store.send({
+			...options,
+			message
+		}),
 		session: computed(() => snapshot.value.session),
 		status: computed(() => snapshot.value.status),
 		stop: () => store.stop()