eve 0.83.2 → 0.84.0

package/dist/src/chunks/use-eve-agent-DnbG9c7c.js

@@ -1,4921 +0,0 @@
-import { computed, onScopeDispose, shallowRef } from "vue";
-import { z } from "#compiled/zod/index.js";
-import "ai";
-import { Validator } from "#compiled/@cfworker/json-schema/index.js";
-
-//#region src/client/abort-signal.ts
-function throwIfAborted(signal) {
-	if (signal === void 0) return;
-	const nativeThrowIfAborted = signal.throwIfAborted;
-	if (typeof nativeThrowIfAborted === "function") {
-		nativeThrowIfAborted.call(signal);
-		return;
-	}
-	if (!signal.aborted) return;
-	if (signal.reason !== void 0) throw signal.reason;
-	const error = /* @__PURE__ */ new Error("The operation was aborted.");
-	error.name = "AbortError";
-	throw error;
-}
-
-//#endregion
-//#region src/protocol/routes.ts
-const EVE_ROUTE_PREFIX = "/eve/v1";
-const EVE_PRODUCTION_CRON_ROUTE_PATTERN = `${EVE_ROUTE_PREFIX}/cron/:token`;
-const EVE_HEALTH_ROUTE_PATH = `${EVE_ROUTE_PREFIX}/health`;
-const EVE_INFO_ROUTE_PATH = `${EVE_ROUTE_PREFIX}/info`;
-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_STUBS_ROUTE_PATTERN = `${EVE_SESSION_ROUTE_PATH}/:sessionId/stubs`;
-const EVE_SESSION_STREAM_ROUTE_PATTERN = `${EVE_SESSION_ROUTE_PATH}/:sessionId/stream`;
-const EVE_SUBAGENT_STREAM_ROUTE_PATTERN = `${EVE_SESSION_ROUTE_PATH}/:parentSessionId/subagents/:callId/:childSessionId/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`;
-const EVE_DEV_RUNTIME_ARTIFACTS_SUSPEND_ROUTE_PATH = `${EVE_DEV_RUNTIME_ARTIFACTS_ROUTE_PATH}/suspend`;
-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/:attemptId/:token`;
-const EVE_CALLBACK_ROUTE_PATTERN = `${EVE_ROUTE_PREFIX}/callback/:token`;
-function createEveSessionRoutePath(sessionId) {
-	return `${EVE_SESSION_ROUTE_PATH}/${encodeURIComponent(sessionId)}`;
-}
-function createEveSessionCancelRoutePath(sessionId) {
-	return `${EVE_SESSION_ROUTE_PATH}/${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
-//#region src/client/agent-info-error.ts
-var AgentInfoResponseError = class extends Error {
-	issues;
-	constructor(issues = []) {
-		const detail = issues.length === 0 ? "" : ` (${issues.join("; ")})`;
-		super(`The server returned an unrecognized response from the eve agent info route.${detail}`);
-		this.name = "AgentInfoResponseError";
-		this.issues = issues;
-	}
-};
-
-//#endregion
-//#region src/client/health-response-error.ts
-var HealthResponseError = class extends Error {
-	issues;
-	constructor(issues = []) {
-		const detail = issues.length === 0 ? "" : ` (${issues.join("; ")})`;
-		super(`The server returned an unrecognized eve health response.${detail}`);
-		this.name = "HealthResponseError";
-		this.issues = issues;
-	}
-};
-
-//#endregion
-//#region src/client/health-schema.ts
-const HealthResultSchema = z.object({
-	ok: z.literal(true),
-	status: z.literal("ready"),
-	workflowId: z.string().min(1)
-}).strict();
-
-//#endregion
-//#region src/internal/http/basic-auth.ts
-function encodeBasicCredentials(username, password) {
-	const bytes = new TextEncoder().encode(`${username}:${password}`);
-	const binaryString = Array.from(bytes, (byte) => String.fromCodePoint(byte)).join("");
-	return btoa(binaryString);
-}
-
-//#endregion
-//#region src/shared/extension-mount.ts
-const mountIdSchema = z.string().min(1);
-
-//#endregion
-//#region src/client/agent-info-schema.ts
-const owner = z.discriminatedUnion("kind", [
-	z.object({ kind: z.literal("application") }).strict(),
-	z.object({
-		feature: z.string(),
-		kind: z.literal("framework")
-	}).strict(),
-	z.object({
-		kind: z.literal("extension"),
-		mountId: mountIdSchema.optional(),
-		namespace: z.string(),
-		packageName: z.string()
-	}).strict()
-]);
-const moduleBacking = z.discriminatedUnion("kind", [z.object({
-	externalDependencies: z.array(z.string()),
-	extensionScope: z.object({
-		namespace: z.string(),
-		sourceRoot: z.string()
-	}).strict().optional(),
-	kind: z.literal("filesystem"),
-	mountId: z.string().optional(),
-	sourcePath: z.string()
-}).strict(), z.object({
-	dependencies: z.record(z.string(), z.string()).optional(),
-	kind: z.literal("programmatic"),
-	mountId: z.string().optional(),
-	moduleId: z.string(),
-	parameters: z.record(z.string(), z.unknown()).optional(),
-	registryId: z.string(),
-	revision: z.string(),
-	semanticRevision: z.string().optional()
-}).strict()]);
-const binding = z.object({
-	backing: moduleBacking,
-	logicalPath: z.string(),
-	owner
-}).strict();
-const source = z.object({
-	binding: binding.optional(),
-	exportName: z.string().optional(),
-	logicalPath: z.string(),
-	owner,
-	sourceId: z.string(),
-	sourceKind: z.enum([
-		"markdown",
-		"module",
-		"skill-package"
-	])
-}).strict();
-const entry = source.extend({ name: z.string() }).strict();
-const dynamicResolver = source.extend({
-	eventNames: z.array(z.string()),
-	slug: z.string()
-}).strict();
-const modelRouting = z.discriminatedUnion("kind", [z.object({
-	kind: z.literal("gateway"),
-	target: z.string(),
-	byok: z.string().optional()
-}).strict(), z.object({
-	kind: z.literal("external"),
-	provider: z.string()
-}).strict()]);
-const modelEndpoint = z.union([
-	z.object({
-		kind: z.literal("external"),
-		provider: z.string()
-	}).strict(),
-	z.object({
-		kind: z.literal("chatgpt"),
-		state: z.enum([
-			"checking",
-			"ready",
-			"signed-out",
-			"reauth-required",
-			"unavailable"
-		]),
-		accountLabel: z.string().optional()
-	}).strict(),
-	z.object({
-		kind: z.literal("gateway"),
-		connected: z.literal(true),
-		credential: z.enum([
-			"api-key",
-			"oidc",
-			"oauth"
-		]),
-		team: z.optional(z.string())
-	}).strict(),
-	z.object({
-		kind: z.literal("gateway"),
-		connected: z.literal(false)
-	}).strict()
-]);
-const modelBaseFields = {
-	contextWindowTokens: z.number().optional(),
-	providerOptions: z.unknown().optional(),
-	reasoning: z.enum([
-		"provider-default",
-		"none",
-		"minimal",
-		"low",
-		"medium",
-		"high",
-		"xhigh"
-	]).optional().catch(void 0),
-	source: source.optional()
-};
-const agentModel = z.union([z.object({
-	...modelBaseFields,
-	endpoint: modelEndpoint.optional(),
-	id: z.string(),
-	routing: modelRouting
-}).strict(), z.object({
-	...modelBaseFields,
-	endpoint: z.never().optional(),
-	id: z.never().optional(),
-	routing: z.object({
-		kind: z.literal("dynamic"),
-		resolver: dynamicResolver
-	}).strict()
-}).strict()]);
-const tool = entry.extend({
-	description: z.string(),
-	hasAuth: z.boolean(),
-	hasExecute: z.boolean(),
-	hasModelOutputProjection: z.boolean(),
-	hasOutputSchema: z.boolean(),
-	inputSchema: z.unknown(),
-	outputSchema: z.unknown().optional(),
-	requiresApproval: z.boolean()
-}).strict();
-const skill = entry.extend({
-	description: z.string(),
-	license: z.string().optional(),
-	markdown: z.string(),
-	metadata: z.record(z.string(), z.string()).optional()
-}).strict();
-const instructions = entry.extend({
-	content: z.string(),
-	role: z.enum(["system", "user"])
-}).strict();
-const schedule = entry.extend({
-	cron: z.string(),
-	hasRun: z.boolean(),
-	markdown: z.string().optional()
-}).strict();
-const channelMethod = z.enum([
-	"GET",
-	"HEAD",
-	"POST",
-	"PUT",
-	"PATCH",
-	"DELETE",
-	"OPTIONS",
-	"WEBSOCKET"
-]);
-const channelRoute = entry.extend({
-	adapterKind: z.string().optional(),
-	method: channelMethod,
-	urlPath: z.string()
-}).strict();
-const sourceDescriptor = z.object({
-	backing: z.union([moduleBacking, z.object({
-		kind: z.literal("resource"),
-		sourcePath: z.string()
-	}).strict()]),
-	form: z.enum(["derived", "direct"]),
-	layer: z.enum([
-		"framework-default",
-		"extension-package",
-		"extension-override",
-		"application"
-	]),
-	logicalPath: z.string(),
-	owner,
-	sourceId: z.string()
-}).strict();
-const shadowedChannelRoute = z.object({
-	method: channelMethod,
-	source: sourceDescriptor,
-	urlPath: z.string(),
-	winnerSourceId: z.string()
-}).strict();
-const connection = source.extend({
-	connectionName: z.string(),
-	description: z.string(),
-	hasApproval: z.boolean(),
-	hasAuthorization: z.boolean(),
-	hasHeaders: z.boolean(),
-	protocol: z.string(),
-	toolFilter: z.unknown().optional(),
-	url: z.string()
-}).strict();
-const hook = source.extend({
-	eventNames: z.array(z.string()),
-	slug: z.string()
-}).strict();
-const memory = source.extend({
-	description: z.string().optional(),
-	slot: z.string(),
-	visibility: z.enum(["scope", "session"])
-}).strict();
-const sandbox = source.extend({
-	provider: z.string().optional(),
-	environmentExportName: z.string().optional(),
-	revisionHash: z.string()
-}).strict();
-const subagent = entry.extend({
-	configResolver: dynamicResolver.optional(),
-	description: z.string().optional(),
-	entryPath: z.string(),
-	nodeId: z.string(),
-	parentNodeId: z.string(),
-	rootPath: z.string(),
-	summary: z.object({
-		channels: z.number(),
-		connections: z.number(),
-		hooks: z.number(),
-		instructions: z.number(),
-		memories: z.number(),
-		schedules: z.number(),
-		skills: z.number(),
-		tools: z.number()
-	}).strict()
-}).strict();
-const remoteAgent = entry.extend({
-	description: z.string(),
-	nodeId: z.string(),
-	parentNodeId: z.string(),
-	url: z.string().optional()
-}).strict();
-const kernelEffect = z.object({
-	action: z.union([z.enum(["subagent-call", "workflow-tool-call"]), z.literal("unrecognized")]).catch("unrecognized").optional(),
-	audience: z.array(z.union([z.literal("root-session"), z.literal("unrecognized")]).catch("unrecognized")),
-	kind: z.union([z.enum(["dispatch", "provider-tool"]), z.literal("unrecognized")]).catch("unrecognized"),
-	sourceId: z.string()
-}).strict();
-const compositionDiagnostic = z.object({
-	kind: z.enum(["disabled", "shadowed"]),
-	logicalPath: z.string(),
-	owner,
-	sourceId: z.string(),
-	winnerSourceId: z.string().optional()
-}).strict();
-const AgentInfoResultSchema = z.object({
-	agent: z.object({
-		agentRoot: z.string(),
-		appRoot: z.string(),
-		config: source.extend({ binding }).strict(),
-		description: z.string().optional(),
-		model: agentModel,
-		name: z.string(),
-		nodeId: z.string(),
-		outputSchema: z.unknown().optional()
-	}).strict(),
-	capabilities: z.object({ devRoutes: z.boolean() }).strict(),
-	channels: z.object({
-		routes: z.array(channelRoute),
-		shadowed: z.array(shadowedChannelRoute)
-	}).strict(),
-	composition: z.object({
-		disabled: z.array(compositionDiagnostic),
-		shadowed: z.array(compositionDiagnostic)
-	}).strict(),
-	connections: z.array(connection),
-	diagnostics: z.object({
-		discoveryErrors: z.number(),
-		discoveryWarnings: z.number()
-	}).strict(),
-	hooks: z.array(hook),
-	instructions: z.object({
-		dynamic: z.array(dynamicResolver),
-		static: z.array(instructions)
-	}).strict(),
-	instrumentation: source.optional(),
-	kernelEffects: z.array(kernelEffect),
-	kind: z.literal("eve-agent-info"),
-	memories: z.array(memory),
-	mode: z.enum(["development", "production"]),
-	remoteAgents: z.object({
-		entries: z.array(remoteAgent),
-		total: z.number()
-	}).strict(),
-	sandbox,
-	schedules: z.array(schedule),
-	skills: z.object({
-		dynamic: z.array(dynamicResolver),
-		static: z.array(skill)
-	}).strict(),
-	subagents: z.object({
-		local: z.array(subagent),
-		total: z.number()
-	}).strict(),
-	tools: z.object({
-		dynamic: z.array(dynamicResolver),
-		static: z.array(tool)
-	}).strict(),
-	version: z.literal(5),
-	workspace: z.object({
-		resourceRoot: z.unknown(),
-		rootEntries: z.array(z.string())
-	}).strict()
-}).strict().superRefine((value, context) => {
-	const assertUnique = (entries, identity, path) => {
-		const seen = /* @__PURE__ */ new Set();
-		entries.forEach((entry, index) => {
-			const key = identity(entry);
-			if (seen.has(key)) context.addIssue({
-				code: "custom",
-				message: `Duplicate public identity "${key}".`,
-				path: [...path, index]
-			});
-			seen.add(key);
-		});
-	};
-	const assertTotal = (total, entries, path) => {
-		if (!Number.isSafeInteger(total) || total < 0 || total !== entries.length) context.addIssue({
-			code: "custom",
-			message: `Expected total ${entries.length}, received ${total}.`,
-			path: [...path]
-		});
-	};
-	assertUnique(value.tools.static, (entry) => entry.name, ["tools", "static"]);
-	assertUnique(value.tools.dynamic, (entry) => entry.slug, ["tools", "dynamic"]);
-	assertUnique(value.skills.static, (entry) => entry.name, ["skills", "static"]);
-	assertUnique(value.skills.dynamic, (entry) => entry.slug, ["skills", "dynamic"]);
-	assertUnique(value.instructions.static, (entry) => entry.name, ["instructions", "static"]);
-	assertUnique(value.instructions.dynamic, (entry) => entry.slug, ["instructions", "dynamic"]);
-	assertUnique(value.schedules, (entry) => entry.name, ["schedules"]);
-	assertUnique(value.connections, (entry) => entry.connectionName, ["connections"]);
-	assertUnique(value.hooks, (entry) => entry.slug, ["hooks"]);
-	assertUnique(value.memories, (entry) => entry.slot, ["memories"]);
-	assertUnique(value.channels.routes, (entry) => `${entry.method} ${normalizeRoutePattern(entry.urlPath)}`, ["channels", "routes"]);
-	assertUnique(value.subagents.local, (entry) => entry.nodeId, ["subagents", "local"]);
-	assertUnique(value.remoteAgents.entries, (entry) => entry.nodeId, ["remoteAgents", "entries"]);
-	assertTotal(value.subagents.total, value.subagents.local, ["subagents", "total"]);
-	assertTotal(value.remoteAgents.total, value.remoteAgents.entries, ["remoteAgents", "total"]);
-	const boundSources = [
-		[value.agent.config, ["agent", "config"]],
-		...value.agent.model.source === void 0 ? [] : [[value.agent.model.source, [
-			"agent",
-			"model",
-			"source"
-		]]],
-		...value.agent.model.routing.kind === "dynamic" ? [[value.agent.model.routing.resolver, [
-			"agent",
-			"model",
-			"routing",
-			"resolver"
-		]]] : [],
-		...value.channels.routes.map((entry, index) => [entry, [
-			"channels",
-			"routes",
-			index
-		]]),
-		...value.connections.map((entry, index) => [entry, ["connections", index]]),
-		...value.hooks.map((entry, index) => [entry, ["hooks", index]]),
-		...value.instructions.dynamic.map((entry, index) => [entry, [
-			"instructions",
-			"dynamic",
-			index
-		]]),
-		...value.instructions.static.map((entry, index) => [entry, [
-			"instructions",
-			"static",
-			index
-		]]),
-		...value.memories.map((entry, index) => [entry, ["memories", index]]),
-		...value.instrumentation === void 0 ? [] : [[value.instrumentation, ["instrumentation"]]],
-		...value.remoteAgents.entries.map((entry, index) => [entry, [
-			"remoteAgents",
-			"entries",
-			index
-		]]),
-		...value.schedules.map((entry, index) => [entry, ["schedules", index]]),
-		...value.skills.dynamic.map((entry, index) => [entry, [
-			"skills",
-			"dynamic",
-			index
-		]]),
-		...value.skills.static.map((entry, index) => [entry, [
-			"skills",
-			"static",
-			index
-		]]),
-		...value.subagents.local.flatMap((entry, index) => entry.configResolver === void 0 ? [] : [[entry.configResolver, [
-			"subagents",
-			"local",
-			index,
-			"configResolver"
-		]]]),
-		...value.tools.dynamic.map((entry, index) => [entry, [
-			"tools",
-			"dynamic",
-			index
-		]]),
-		...value.tools.static.map((entry, index) => [entry, [
-			"tools",
-			"static",
-			index
-		]]),
-		[value.sandbox, ["sandbox"]]
-	];
-	for (const [entry, path] of boundSources) {
-		if (entry.sourceKind === "module" && entry.binding === void 0) {
-			context.addIssue({
-				code: "custom",
-				message: "Module source is missing its compiled binding.",
-				path: [...path, "binding"]
-			});
-			continue;
-		}
-		if (entry.sourceKind !== "module" && entry.binding !== void 0) {
-			context.addIssue({
-				code: "custom",
-				message: `${entry.sourceKind} source cannot carry a module binding.`,
-				path: [...path, "binding"]
-			});
-			continue;
-		}
-		if (entry.binding === void 0) continue;
-		if (entry.binding.logicalPath !== entry.logicalPath) context.addIssue({
-			code: "custom",
-			message: "Source and binding logical paths do not match.",
-			path: [
-				...path,
-				"binding",
-				"logicalPath"
-			]
-		});
-		if (JSON.stringify(entry.binding.owner) !== JSON.stringify(entry.owner)) context.addIssue({
-			code: "custom",
-			message: "Source and binding owners do not match.",
-			path: [
-				...path,
-				"binding",
-				"owner"
-			]
-		});
-	}
-});
-function normalizeRoutePattern(path) {
-	return path.replace(/^\/+|\/+$/g, "").split("/").map((segment) => segment.startsWith(":") || /^\[[^\]]+\]$/.test(segment) ? ":" : segment).join("/");
-}
-
-//#endregion
-//#region src/shared/guards.ts
-function isObject(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-//#endregion
-//#region src/client/client-error.ts
-var ClientError = class extends Error {
-	code;
-	status;
-	body;
-	headers;
-	constructor(status, body, headers) {
-		const normalizedHeaders = Object.freeze(Object.fromEntries(new Headers(headers).entries()));
-		const contentType = normalizedHeaders["content-type"]?.toLowerCase();
-		const parsed = parseJsonObject$1(body);
-		let message = body || `Server returned ${status}.`;
-		if (typeof parsed?.error === "string") message = parsed.error;
-		else if (parsed === void 0 && contentType?.includes("text/html")) message = `Server returned ${status} with an HTML response. Check the eve route and development server configuration.`;
-		super(message);
-		this.name = "ClientError";
-		this.code = typeof parsed?.code === "string" ? parsed.code : void 0;
-		this.status = status;
-		this.body = body;
-		this.headers = normalizedHeaders;
-	}
-};
-var ClientSessionStrandedError = class extends ClientError {
-	eveVersion;
-	constructor(status, body, headers, details) {
-		super(status, body, headers);
-		this.name = "ClientSessionStrandedError";
-		this.eveVersion = details.eveVersion;
-	}
-};
-function createClientError(status, body, headers) {
-	const parsed = status === 409 ? parseJsonObject$1(body) : void 0;
-	if (parsed?.code !== "session_stranded") return new ClientError(status, body, headers);
-	return new ClientSessionStrandedError(status, body, headers, { eveVersion: typeof parsed.eveVersion === "string" ? parsed.eveVersion : void 0 });
-}
-function parseJsonObject$1(body) {
-	try {
-		const parsed = JSON.parse(body);
-		return isObject(parsed) ? parsed : void 0;
-	} catch {
-		return;
-	}
-}
-
-//#endregion
-//#region src/internal/attachments/media-metadata.ts
-const PDF_MEDIA_TYPE = "application/pdf";
-const INLINE_IMAGE_MEDIA_TYPES = /* @__PURE__ */ new Set([
-	"image/gif",
-	"image/jpeg",
-	"image/png",
-	"image/webp"
-]);
-const VERIFIABLE_MEDIA_TYPES = /* @__PURE__ */ new Set([
-	...INLINE_IMAGE_MEDIA_TYPES,
-	"image/jpg",
-	PDF_MEDIA_TYPE
-]);
-
-//#endregion
-//#region src/shared/ulid.ts
-const ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
-const TIME_CHARS = 10;
-const TIME_MAX = 2 ** 48 - 1;
-const RANDOM_BYTES = 10;
-function createUlidFactory() {
-	let lastTimeMs = -1;
-	const lastRandom = new Uint8Array(RANDOM_BYTES);
-	return function createUlidFromFactory() {
-		const now = Date.now();
-		if (!Number.isInteger(now) || now < 0 || now > TIME_MAX) throw new Error(`Cannot mint a ULID: timestamp must be an integer from 0 to ${TIME_MAX}.`);
-		if (now > lastTimeMs) {
-			lastTimeMs = now;
-			randomFill(lastRandom);
-		} else if (!incrementRandom(lastRandom)) {
-			if (lastTimeMs === TIME_MAX) throw new Error("Cannot mint a ULID: random component overflowed at the maximum timestamp.");
-			lastTimeMs += 1;
-			randomFill(lastRandom);
-		}
-		return `${encodeTime(lastTimeMs)}${encodeRandom(lastRandom)}`;
-	};
-}
-const createUlid = createUlidFactory();
-function randomFill(target) {
-	const webCrypto = globalThis.crypto;
-	if (typeof webCrypto?.getRandomValues !== "function") throw new Error("Cannot mint a ULID: globalThis.crypto.getRandomValues is unavailable.");
-	webCrypto.getRandomValues(target);
-}
-function encodeTime(timeMs) {
-	let remaining = timeMs;
-	let encoded = "";
-	for (let index = 0; index < TIME_CHARS; index += 1) {
-		encoded = ENCODING[remaining % 32] + encoded;
-		remaining = Math.floor(remaining / 32);
-	}
-	return encoded;
-}
-function encodeRandom(bytes) {
-	let buffer = 0;
-	let bufferedBits = 0;
-	let encoded = "";
-	for (const byte of bytes) {
-		buffer = buffer << 8 | byte;
-		bufferedBits += 8;
-		while (bufferedBits >= 5) {
-			bufferedBits -= 5;
-			encoded += ENCODING[buffer >>> bufferedBits & 31];
-		}
-		buffer &= (1 << bufferedBits) - 1;
-	}
-	return encoded;
-}
-function incrementRandom(bytes) {
-	for (let index = bytes.length - 1; index >= 0; index -= 1) {
-		const byte = bytes[index] ?? 0;
-		if (byte < 255) {
-			bytes[index] = byte + 1;
-			bytes.fill(0, index + 1);
-			return true;
-		}
-	}
-	return false;
-}
-
-//#endregion
-//#region src/protocol/message.ts
-const EVE_SESSION_ID_HEADER = "x-eve-session-id";
-const EVE_STREAM_TAIL_INDEX_HEADER = "x-eve-stream-tail-index";
-const EVE_STREAM_VERSION_HEADER = "x-eve-stream-version";
-const EVE_STREAM_CONTROL_VERSION_QUERY = "streamControlVersion";
-const EVE_STREAM_LEASE_ENDED_CONTROL = {
-	$eve: "stream.lease-ended",
-	version: 1
-};
-const textEncoder = new TextEncoder();
-function isCurrentTurnBoundaryEvent(event) {
-	return event.type === "session.completed" || event.type === "session.failed" || event.type === "session.waiting";
-}
-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 action.name;
-		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 result.name;
-		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.grant !== void 0) authorization.grant = typed.data.grant;
-			if (typed.data.principal !== void 0) authorization.principal = typed.data.principal;
-			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
-			};
-			if (typed.data.grant !== void 0) completed.grant = typed.data.grant;
-			if (typed.data.principal !== void 0) completed.principal = typed.data.principal;
-			if (typed.data.retryable !== void 0) completed.retryable = typed.data.retryable;
-			if (typed.data.reason !== void 0) completed.reason = typed.data.reason;
-			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) {
-	const segment = new TurnSegment();
-	let boundary;
-	let failure;
-	let message;
-	for (const event of events) {
-		if (segment.observe(event)) boundary = event;
-		if (isTurnFailureEvent(event)) failure = event;
-		if (isFinalMessageCompleted(event)) message = event.data.message ?? void 0;
-	}
-	return {
-		boundary,
-		failure,
-		inputRequests: segment.inputRequests,
-		message,
-		pendingAuthorizations: segment.pendingAuthorizations,
-		status: summarizeBoundaryStatus(boundary)
-	};
-}
-function summarizeBoundaryStatus(boundary) {
-	if (boundary?.type === "session.waiting" || boundary?.type === "turn.waiting") return "waiting";
-	if (boundary?.type === "session.failed") return "failed";
-	return "completed";
-}
-function endsTurnSegment(event, open) {
-	if (event.type === "turn.waiting") return open.requests || event.data.on === "input" && !open.callbacks;
-	return isCurrentTurnBoundaryEvent(event) && (event.type !== "session.waiting" || !open.callbacks);
-}
-var TurnSegment = class {
-	#projection = initialSessionProjection();
-	#authorizations = /* @__PURE__ */ new Map();
-	#followCallbacks;
-	constructor(options = {}) {
-		this.#followCallbacks = options.followCallbacks === true;
-	}
-	get inputRequests() {
-		return openInputs(this.#projection).map((input) => input.request);
-	}
-	get pendingAuthorizations() {
-		return openSignIns(this.#projection).flatMap((attempt) => this.#authorizations.get(attempt.attemptId) ?? []);
-	}
-	observe(event) {
-		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 && 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";
-}
-
-//#endregion
-//#region src/protocol/message-version.ts
-function normalizeMessageStreamEvent(version, event) {
-	return nameSkillLoads(normalizeAppendEvent(version, event));
-}
-function normalizeAppendEvent(version, event) {
-	switch (version) {
-		case "21":
-		case "22":
-		case "23":
-		case "24": return normalizeLegacyMessageStreamEvent(version, event);
-		case "25":
-		case "26": return validateDeltaMessageStreamEvent(version, event);
-		default: return assertNever(version);
-	}
-}
-function normalizeLegacyMessageStreamEvent(version, event) {
-	if (event.type === "message.appended") {
-		assertLegacyAppendSnapshot(event.data.messageSoFar, event.data.messageDelta, "message", version);
-		return {
-			data: {
-				messageDelta: event.data.messageDelta,
-				sequence: event.data.sequence,
-				stepIndex: event.data.stepIndex,
-				turnId: event.data.turnId
-			},
-			meta: event.meta,
-			type: "message.appended"
-		};
-	}
-	if (event.type === "reasoning.appended") {
-		assertLegacyAppendSnapshot(event.data.reasoningSoFar, event.data.reasoningDelta, "reasoning", version);
-		return {
-			data: {
-				reasoningDelta: event.data.reasoningDelta,
-				sequence: event.data.sequence,
-				stepIndex: event.data.stepIndex,
-				turnId: event.data.turnId
-			},
-			meta: event.meta,
-			type: "reasoning.appended"
-		};
-	}
-	if (event.type === "action.input.appended") {
-		if (version !== void 0 && version !== "24") throw new TypeError(`Invalid action input append for stream version ${version}.`);
-		assertLegacyActionInputOffset(event.data.inputTextOffset, version);
-		return {
-			data: {
-				callId: event.data.callId,
-				inputTextDelta: event.data.inputTextDelta,
-				sequence: event.data.sequence,
-				stepIndex: event.data.stepIndex,
-				toolName: event.data.toolName,
-				turnId: event.data.turnId
-			},
-			meta: event.meta,
-			type: "action.input.appended"
-		};
-	}
-	return event;
-}
-function nameSkillLoads(event) {
-	if (event.type !== "actions.requested" || !event.data.actions.some(isUnnamedSkillLoad)) return event;
-	return {
-		...event,
-		data: {
-			...event.data,
-			actions: event.data.actions.map((action) => isUnnamedSkillLoad(action) ? {
-				...action,
-				name: releasedSkillName(action)
-			} : action)
-		}
-	};
-}
-function isUnnamedSkillLoad(action) {
-	return action.kind === "load-skill" && typeof Reflect.get(action, "name") !== "string";
-}
-function releasedSkillName(action) {
-	const skill = action.input.skill;
-	return typeof skill === "string" ? skill : "load_skill";
-}
-function validateDeltaMessageStreamEvent(version, event) {
-	if (event.type === "message.appended") {
-		assertAppendDelta(event.data.messageDelta, "message", version);
-		assertUnsupportedAppendField(event.data, "messageOffset", "message", version);
-		assertUnsupportedAppendField(event.data, "messageSoFar", "message", version);
-	} else if (event.type === "reasoning.appended") {
-		assertAppendDelta(event.data.reasoningDelta, "reasoning", version);
-		assertUnsupportedAppendField(event.data, "reasoningOffset", "reasoning", version);
-		assertUnsupportedAppendField(event.data, "reasoningSoFar", "reasoning", version);
-	} else if (event.type === "action.input.appended") {
-		assertAppendDelta(event.data.inputTextDelta, "action input", version);
-		assertUnsupportedAppendField(event.data, "inputTextOffset", "action input", version);
-	}
-	return event;
-}
-function assertAppendDelta(delta, stream, version) {
-	if (typeof delta !== "string") throw new TypeError(`Invalid ${stream} append delta for stream version ${version}.`);
-}
-function assertUnsupportedAppendField(data, field, stream, version) {
-	if (field in data) throw new TypeError(`Invalid ${stream} append shape for stream version ${version}.`);
-}
-function assertNever(value) {
-	throw new TypeError(`Unsupported message stream version: ${String(value)}.`);
-}
-function assertLegacyActionInputOffset(offset, version) {
-	if (!Number.isSafeInteger(offset) || offset < 0) {
-		const source = version === void 0 ? "persisted stream" : `stream version ${version}`;
-		throw new TypeError(`Invalid action input append offset for ${source}.`);
-	}
-}
-function assertLegacyAppendSnapshot(snapshot, delta, stream, version) {
-	const offset = snapshot.length - delta.length;
-	if (offset < 0 || snapshot.slice(offset) !== delta) {
-		const source = version === void 0 ? "persisted stream" : `stream version ${version}`;
-		throw new TypeError(`Invalid cumulative ${stream} append for ${source}.`);
-	}
-}
-
-//#endregion
-//#region src/client/ndjson.ts
-function isStreamDisconnectError(error) {
-	if (error instanceof DOMException) return error.name === "AbortError";
-	if (!(error instanceof Error)) return false;
-	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|load failed|networkerror when attempting to fetch resource\.)$/i.test(error.message) || /abort|cancel|disconnect|premature close|socket|terminated/i.test(error.message);
-}
-async function* readNdjsonStream(body, options) {
-	const reader = body.getReader();
-	const decoder = new TextDecoder();
-	let buffer = "";
-	let reachedEof = false;
-	const abort = () => {
-		reader.cancel().catch(() => {});
-	};
-	options.signal?.addEventListener("abort", abort, { once: true });
-	try {
-		while (true) {
-			throwIfAborted(options.signal);
-			const result = await readWithIdleTimeout(reader, options?.idleTimeoutMs);
-			throwIfAborted(options.signal);
-			if (result.done) {
-				reachedEof = true;
-				buffer += decoder.decode();
-				break;
-			}
-			if (result.value) buffer += decoder.decode(result.value, { stream: true });
-			let newlineIndex = buffer.indexOf("\n");
-			while (newlineIndex !== -1) {
-				const line = buffer.slice(0, newlineIndex).trim();
-				buffer = buffer.slice(newlineIndex + 1);
-				if (line.length > 0) {
-					const value = JSON.parse(line);
-					if (options.controlVersion === "1" && isLeaseEndedControl(value)) options.onLeaseEnded?.();
-					else yield parseMessageStreamEvent(value, options.streamVersion);
-				}
-				newlineIndex = buffer.indexOf("\n");
-			}
-		}
-		const trailing = buffer.trim();
-		if (trailing.length > 0) {
-			const value = JSON.parse(trailing);
-			if (options.controlVersion === "1" && isLeaseEndedControl(value)) options.onLeaseEnded?.();
-			else yield parseMessageStreamEvent(value, options.streamVersion);
-		}
-	} finally {
-		options.signal?.removeEventListener("abort", abort);
-		if (!reachedEof) reader.cancel().catch(() => {});
-		reader.releaseLock();
-	}
-}
-function isLeaseEndedControl(value) {
-	if (value === null || typeof value !== "object") return false;
-	const record = value;
-	return record.$eve === EVE_STREAM_LEASE_ENDED_CONTROL.$eve && record.version === EVE_STREAM_LEASE_ENDED_CONTROL.version;
-}
-function parseMessageStreamEvent(value, version) {
-	return normalizeMessageStreamEvent(version, value);
-}
-async function readWithIdleTimeout(reader, idleTimeoutMs) {
-	let timeout;
-	try {
-		if (idleTimeoutMs === void 0) return await reader.read();
-		return await Promise.race([reader.read(), new Promise((_resolve, reject) => {
-			timeout = setTimeout(() => reject(new DOMException("Session stream was idle.", "AbortError")), idleTimeoutMs);
-		})]);
-	} catch (error) {
-		if (error instanceof TypeError) throw new Error("Session stream disconnected.", { cause: error });
-		throw error;
-	} finally {
-		if (timeout !== void 0) clearTimeout(timeout);
-	}
-}
-
-//#endregion
-//#region src/client/stream-version.ts
-const supportedMessageStreamVersions = {
-	"21": true,
-	"22": true,
-	"23": true,
-	"24": true,
-	"25": true,
-	"26": true
-};
-function readMessageStreamVersion(headers) {
-	const version = headers.get(EVE_STREAM_VERSION_HEADER);
-	if (version !== null && Object.hasOwn(supportedMessageStreamVersions, version)) return version;
-	if (version === null) throw new TypeError(`Missing ${EVE_STREAM_VERSION_HEADER} response header.`);
-	throw new TypeError(`Unsupported message stream version: ${version}.`);
-}
-
-//#endregion
-//#region src/shared/eve-route-path.ts
-const EVE_NAMED_AGENT_MOUNT_PATTERN = /^\/eve\/[a-z0-9][a-z0-9_-]*$/;
-const EVE_NAMED_AGENT_PROTOCOL_PATTERN = /^\/eve\/[a-z0-9][a-z0-9_-]*\/v1$/;
-function joinEveRoutePath(basePath, routePath) {
-	const base = trimTrailingSlash$1(basePath);
-	const route = routePath.startsWith("/") ? routePath : `/${routePath}`;
-	if (route === "/eve/v1" || route.startsWith(`${"/eve/v1"}/`)) {
-		if (EVE_NAMED_AGENT_MOUNT_PATTERN.test(base)) return `${base}${route.slice(4)}`;
-		if (EVE_NAMED_AGENT_PROTOCOL_PATTERN.test(base)) return `${base}${route.slice(EVE_ROUTE_PREFIX.length)}`;
-	}
-	return `${base}${route}`;
-}
-function trimTrailingSlash$1(value) {
-	if (value === "/") return "";
-	return value.endsWith("/") ? value.slice(0, -1) : value;
-}
-
-//#endregion
-//#region src/client/url.ts
-function createClientUrl(host, routePath, searchParams) {
-	const queryIndex = routePath.indexOf("?");
-	const pathOnly = queryIndex === -1 ? routePath : routePath.slice(0, queryIndex);
-	const embeddedQuery = queryIndex === -1 ? "" : routePath.slice(queryIndex + 1);
-	const normalizedRoute = pathOnly.startsWith("/") ? pathOnly : `/${pathOnly}`;
-	if (isAbsoluteUrl(host)) {
-		const url = new URL(host);
-		const basePath = trimTrailingSlash(url.pathname);
-		url.pathname = joinEveRoutePath(basePath, normalizedRoute);
-		mergeEmbeddedQuery(url.searchParams, embeddedQuery);
-		mergeSearchParams(url.searchParams, searchParams);
-		url.hash = "";
-		return url.toString();
-	}
-	const url = new URL(host, "http://eve.local");
-	const basePath = trimTrailingSlash(url.pathname);
-	mergeEmbeddedQuery(url.searchParams, embeddedQuery);
-	mergeSearchParams(url.searchParams, searchParams);
-	return `${joinEveRoutePath(basePath, normalizedRoute)}${formatSearch(url.searchParams)}`;
-}
-function mergeEmbeddedQuery(target, embeddedQuery) {
-	if (embeddedQuery.length === 0) return;
-	for (const [name, value] of new URLSearchParams(embeddedQuery)) target.append(name, value);
-}
-function isAbsoluteUrl(value) {
-	return /^[a-z][a-z\d+\-.]*:/i.test(value);
-}
-function trimTrailingSlash(value) {
-	if (value === "/") return "";
-	return value.endsWith("/") ? value.slice(0, -1) : value;
-}
-function mergeSearchParams(target, searchParams) {
-	if (searchParams === void 0) return;
-	for (const [name, value] of Object.entries(searchParams)) target.set(name, value);
-}
-function formatSearch(searchParams) {
-	const value = searchParams.toString();
-	return value.length === 0 ? "" : `?${value}`;
-}
-
-//#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,
-		409,
-		425,
-		500,
-		502,
-		503,
-		504
-	]),
-	streamIdleReconnectPolicy: {
-		baseDelayMs: 250,
-		maxAttempts: 5,
-		maxDelayMs: 4e3
-	},
-	streamOpenReconnectPolicy: {
-		baseDelayMs: 250,
-		maxAttempts: 12,
-		maxDelayMs: 5e3
-	}
-};
-const NO_STREAM_RECONNECT_POLICY = {
-	...DEFAULT_STREAM_RECONNECT_POLICY,
-	streamIdleReconnectPolicy: {
-		...DEFAULT_STREAM_RECONNECT_POLICY.streamIdleReconnectPolicy,
-		maxAttempts: 0
-	},
-	streamOpenReconnectPolicy: {
-		...DEFAULT_STREAM_RECONNECT_POLICY.streamOpenReconnectPolicy,
-		maxAttempts: 1
-	}
-};
-function resolveRetryPolicy(policy, defaults) {
-	return {
-		...defaults,
-		...policy
-	};
-}
-function resolveStreamReconnectPolicy(policy, keepAlive = false) {
-	if (policy && "reconnect" in policy && policy.reconnect === false) return NO_STREAM_RECONNECT_POLICY;
-	const configured = policy;
-	return {
-		retryableErrorStatuses: configured?.retryableErrorStatuses ? new Set(configured.retryableErrorStatuses) : DEFAULT_STREAM_RECONNECT_POLICY.retryableErrorStatuses,
-		streamIdleReconnectPolicy: resolveRetryPolicy(configured?.streamIdleReconnectPolicy, {
-			...DEFAULT_STREAM_RECONNECT_POLICY.streamIdleReconnectPolicy,
-			maxAttempts: keepAlive ? Infinity : DEFAULT_STREAM_RECONNECT_POLICY.streamIdleReconnectPolicy.maxAttempts
-		}),
-		streamOpenReconnectPolicy: resolveRetryPolicy(configured?.streamOpenReconnectPolicy, DEFAULT_STREAM_RECONNECT_POLICY.streamOpenReconnectPolicy)
-	};
-}
-async function* followStreamIterable(input) {
-	if (input.follow === false && input.startIndex < 0) throw new Error("stream({ follow: false }) requires a nonnegative startIndex; a tail-relative cursor cannot be bounded.");
-	const resolvePolicy = () => resolveStreamReconnectPolicy(input.resolveReconnectPolicy === void 0 ? input.streamReconnectPolicy : input.resolveReconnectPolicy(), input.keepAlive);
-	let retryPolicy = resolvePolicy();
-	let idleRetryPolicy = retryPolicy.streamIdleReconnectPolicy;
-	let startIndex = input.startIndex;
-	let reconnectDelayMs = idleRetryPolicy.baseDelayMs;
-	let idleReconnects = 0;
-	let initialConnection = true;
-	let tailIndex;
-	let caughtUp = false;
-	while (true) {
-		retryPolicy = resolvePolicy();
-		idleRetryPolicy = retryPolicy.streamIdleReconnectPolicy;
-		let connection;
-		try {
-			connection = await openStreamBody({
-				...input,
-				retryPolicy,
-				startIndex,
-				requestTailIndex: (input.follow === false || input.onCaughtUp !== void 0) && tailIndex === void 0
-			});
-		} catch (error) {
-			if (input.signal?.aborted) return;
-			throw error;
-		}
-		if ((input.follow === false || input.onCaughtUp !== void 0) && tailIndex === void 0) {
-			tailIndex = connection.tailIndex;
-			if (tailIndex === void 0) {
-				connection.close();
-				throw new Error(`stream({ follow: false }) requires the server to report the ${EVE_STREAM_TAIL_INDEX_HEADER} header. The agent may be running an older eve version.`);
-			}
-		}
-		if (!caughtUp && tailIndex !== void 0 && startIndex > tailIndex) {
-			caughtUp = true;
-			input.onCaughtUp?.();
-		}
-		if (input.follow === false && tailIndex !== void 0 && startIndex > tailIndex) {
-			connection.close();
-			return;
-		}
-		let deliveredEvent = false;
-		let leaseEnded = false;
-		try {
-			for await (const event of readNdjsonStream(connection.body, {
-				signal: input.signal,
-				controlVersion: connection.controlVersion,
-				idleTimeoutMs: input.streamReadIdleTimeoutMs ?? DEFAULT_STREAM_READ_IDLE_TIMEOUT_MS,
-				onLeaseEnded: () => {
-					leaseEnded = true;
-				},
-				streamVersion: connection.streamVersion
-			})) {
-				startIndex += 1;
-				deliveredEvent = true;
-				reconnectDelayMs = idleRetryPolicy.baseDelayMs;
-				idleReconnects = 0;
-				yield event;
-				if (!caughtUp && tailIndex !== void 0 && startIndex > tailIndex) {
-					caughtUp = true;
-					input.onCaughtUp?.();
-				}
-				if (event.type === "session.failed" || event.type === "session.completed") return;
-				if (input.follow === false && tailIndex !== void 0 && startIndex > tailIndex) return;
-			}
-		} catch (error) {
-			if (!isStreamDisconnectError(error)) throw error;
-		} finally {
-			connection.close();
-		}
-		idleRetryPolicy = resolvePolicy().streamIdleReconnectPolicy;
-		if (input.signal?.aborted || input.startIndex < 0 || idleRetryPolicy.maxAttempts === 0) return;
-		if (leaseEnded) continue;
-		if (!deliveredEvent && !initialConnection && (idleReconnects += 1) >= idleRetryPolicy.maxAttempts) return;
-		initialConnection = false;
-		await sleep(reconnectDelayMs, input.signal);
-		if (input.signal?.aborted) return;
-		reconnectDelayMs = Math.min(reconnectDelayMs * 2, idleRetryPolicy.maxDelayMs);
-	}
-}
-async function openStreamBody(input) {
-	const retryPolicy = input.retryPolicy ?? resolveStreamReconnectPolicy(input.streamReconnectPolicy, input.keepAlive);
-	const openRetryPolicy = retryPolicy.streamOpenReconnectPolicy;
-	let lastStatus;
-	let lastBody;
-	let lastHeaders;
-	let retryDelayMs = openRetryPolicy.baseDelayMs;
-	const controlVersion = input.startIndex >= 0 && retryPolicy.streamIdleReconnectPolicy.maxAttempts > 0 ? "1" : void 0;
-	const searchParams = {};
-	if (controlVersion !== void 0) searchParams[EVE_STREAM_CONTROL_VERSION_QUERY] = controlVersion;
-	if (input.startIndex !== 0) searchParams.startIndex = String(input.startIndex);
-	if (input.requestTailIndex === true) searchParams.includeTailIndex = "1";
-	if (input.follow === false) searchParams.follow = "false";
-	for (let attempt = 0; attempt < openRetryPolicy.maxAttempts; attempt += 1) {
-		throwIfAborted(input.signal);
-		const url = createClientUrl(input.host, input.path, Object.keys(searchParams).length > 0 ? searchParams : void 0);
-		const headers = await input.resolveHeaders();
-		throwIfAborted(input.signal);
-		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
-			});
-		} catch (error) {
-			if (input.signal?.aborted || !isStreamDisconnectError(error) || attempt === openRetryPolicy.maxAttempts - 1) throw error;
-			await sleep(retryDelayMs, input.signal);
-			retryDelayMs = Math.min(retryDelayMs * 2, openRetryPolicy.maxDelayMs);
-			continue;
-		}
-		if (response.ok) {
-			if (!response.body) throw new ClientError(response.status, "Response body is null.", response.headers);
-			let closed = false;
-			return {
-				body: response.body,
-				close: () => {
-					if (closed) return;
-					closed = true;
-					response.body?.cancel().catch(() => {});
-					connectionController.abort();
-				},
-				controlVersion,
-				streamVersion: readMessageStreamVersion(response.headers),
-				tailIndex: parseTailIndexHeader(response.headers)
-			};
-		}
-		lastStatus = response.status;
-		lastBody = await response.text();
-		lastHeaders = response.headers;
-		const error = createClientError(response.status, lastBody, response.headers);
-		if (error instanceof ClientSessionStrandedError || !retryPolicy.retryableErrorStatuses.has(response.status)) throw error;
-		if (attempt < openRetryPolicy.maxAttempts - 1) {
-			await sleep(retryDelayMs, input.signal);
-			retryDelayMs = Math.min(retryDelayMs * 2, openRetryPolicy.maxDelayMs);
-		}
-	}
-	throw new ClientError(lastStatus ?? 0, lastBody ?? "Failed to open message stream.", lastHeaders);
-}
-function parseTailIndexHeader(headers) {
-	const raw = headers.get(EVE_STREAM_TAIL_INDEX_HEADER);
-	if (raw === null || !/^-?\d+$/.test(raw)) return;
-	const parsed = Number(raw);
-	return Number.isSafeInteger(parsed) ? parsed : void 0;
-}
-async function sleep(ms, signal) {
-	if (signal?.aborted) return;
-	await new Promise((resolve) => {
-		const onAbort = () => {
-			clearTimeout(timer);
-			resolve();
-		};
-		const timer = setTimeout(() => {
-			signal?.removeEventListener("abort", onAbort);
-			resolve();
-		}, ms);
-		signal?.addEventListener("abort", onAbort, { once: true });
-	});
-}
-
-//#endregion
-//#region src/client/agent-session.ts
-var ClientAgentSession = class {
-	name;
-	sessionId;
-	taskId;
-	#context;
-	#streamPath;
-	constructor(context, started) {
-		this.#context = context;
-		this.#streamPath = started.data.streamPath;
-		this.name = started.data.name;
-		this.sessionId = started.data.sessionId;
-		this.taskId = started.data.taskId;
-	}
-	stream(options) {
-		const startIndex = options?.startIndex ?? 0;
-		if (options?.follow === false && startIndex < 0) throw new Error("agent(started).stream({ follow: false }) requires a nonnegative startIndex; a tail-relative cursor cannot be bounded.");
-		return followStreamIterable({
-			follow: options?.follow,
-			host: this.#context.host,
-			path: this.#streamPath,
-			redirect: this.#context.redirect,
-			resolveHeaders: () => this.#context.resolveHeaders(),
-			signal: options?.signal,
-			startIndex,
-			streamReconnectPolicy: options?.streamReconnectPolicy
-		});
-	}
-};
-
-//#endregion
-//#region src/client/output-schema.ts
-function extractCompletedResult(events) {
-	let result;
-	for (const event of events) if (isResultCompletedEvent(event)) result = event.data.result;
-	return result;
-}
-function isResultCompletedEvent(event) {
-	return event.type === "result.completed";
-}
-
-//#endregion
-//#region src/client/message-response.ts
-const consumeResponse = Symbol("consumeMessageResponse");
-const acceptedDeliveryId = Symbol("acceptedDeliveryId");
-const sendReceipt = Symbol("sendReceipt");
-var MessageResponse = class {
-	sessionId;
-	[acceptedDeliveryId];
-	[sendReceipt];
-	#cancelTurn;
-	#cancellation;
-	#consumed = false;
-	#createStream;
-	#resumesTurn;
-	#settled = false;
-	#turnId = Promise.withResolvers();
-	constructor(input) {
-		this.#cancelTurn = input.cancelTurn;
-		this.sessionId = input.sessionId;
-		this[acceptedDeliveryId] = input.deliveryId;
-		this[sendReceipt] = input.receipt;
-		this.#createStream = input.createStream;
-		this.#resumesTurn = input.resumesTurn ?? false;
-	}
-	cancel() {
-		if (this.#settled) return Promise.resolve({ status: "no_active_turn" });
-		if (this.#cancellation !== void 0) return this.#cancellation;
-		const cancellation = this.#turnId.promise.then((turnId) => turnId === void 0 ? { status: "no_active_turn" } : this.#cancelTurn(turnId));
-		this.#cancellation = cancellation;
-		cancellation.catch(() => {
-			if (!this.#settled && this.#cancellation === cancellation) this.#cancellation = void 0;
-		});
-		return cancellation;
-	}
-	async result() {
-		const events = [];
-		for await (const event of this) events.push(event);
-		const summary = summarizeTurnEvents(events);
-		return {
-			data: extractCompletedResult(events),
-			events,
-			inputRequests: summary.inputRequests,
-			message: summary.message,
-			sessionId: this.sessionId,
-			status: summary.status
-		};
-	}
-	[Symbol.asyncIterator]() {
-		return this[consumeResponse]();
-	}
-	[consumeResponse](source) {
-		if (this.#consumed) throw new Error("MessageResponse has already been consumed.");
-		this.#consumed = true;
-		return this.#observeStream(source);
-	}
-	async *#observeStream(source) {
-		try {
-			for await (const event of this.#createStream(source)) {
-				if (event.type === "turn.started" || this.#resumesTurn && event.type === "input.resolved") this.#turnId.resolve(event.data.turnId);
-				else if (isCurrentTurnBoundaryEvent(event)) {
-					this.#settled = true;
-					this.#turnId.resolve(void 0);
-				}
-				yield event;
-			}
-		} finally {
-			this.#turnId.resolve(void 0);
-		}
-	}
-};
-function getMessageResponseDeliveryId(response) {
-	return response[acceptedDeliveryId];
-}
-function consumeMessageResponse(response, source) {
-	return response[consumeResponse](source);
-}
-
-//#endregion
-//#region src/protocol/prewarm-session.ts
-const PrewarmResponseSchema = z.object({
-	ok: z.literal(true),
-	status: z.enum([
-		"ready",
-		"accepted",
-		"unsupported",
-		"no_active_session"
-	])
-});
-
-//#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 prewarmClientSession(input) {
-	const { payload } = await postJson({
-		context: input.context,
-		operation: "Prewarm",
-		path: createEveSessionRoutePath(input.sessionId),
-		signal: input.signal
-	});
-	const result = PrewarmResponseSchema.safeParse(payload);
-	if (!result.success) throw new Error("Prewarm route returned an invalid response.");
-	return { status: result.data.status };
-}
-async function cancelClientSession(input) {
-	const { signal, ...body } = input.options ?? {};
-	const { payload, response } = await postJson({
-		body,
-		context: input.context,
-		operation: "Cancel",
-		path: createEveSessionCancelRoutePath(input.sessionId),
-		signal
-	});
-	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 { signal, ...body } = input.options ?? {};
-	const { payload } = await postJson({
-		body,
-		context: input.context,
-		operation: "Reset",
-		path: createEveSessionResetRoutePath(input.sessionId),
-		signal
-	});
-	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",
-		signal: input.signal
-	}, input.context.redirect));
-	const text = await response.text();
-	if (!response.ok) throw createClientError(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/errors.ts
-function toErrorMessage(error) {
-	if (error instanceof Error) return error.message;
-	if (typeof error === "string") return error;
-	if (error === null || error === void 0) return String(error);
-	if (isObject(error)) {
-		if (typeof error.message === "string" && error.message.length > 0) return error.message;
-		return safeJsonStringify(error);
-	}
-	return String(error);
-}
-function toError(raw) {
-	if (raw instanceof Error) return raw;
-	const error = new Error(toErrorMessage(raw));
-	if (!isObject(raw)) return error;
-	if (typeof raw.name === "string" && raw.name.length > 0) error.name = raw.name;
-	if (typeof raw.stack === "string" && raw.stack.length > 0) error.stack = raw.stack;
-	if ("cause" in raw && raw.cause !== void 0 && raw.cause !== raw) error.cause = raw.cause;
-	return error;
-}
-function safeJsonStringify(value) {
-	try {
-		return JSON.stringify(value) ?? String(value);
-	} catch {
-		return String(value);
-	}
-}
-
-//#endregion
-//#region src/shared/json.ts
-const INVALID_JSON_VALUE_CANDIDATE = Symbol("invalid-json-value-candidate");
-const JSON_VALUE_ERROR_MESSAGE = "Expected a JSON-serializable value.";
-const JSON_OBJECT_ERROR_MESSAGE = "Expected a JSON-serializable object.";
-function parseJsonValue(value) {
-	const normalized = normalizeJsonValueCandidate(value);
-	if (normalized === INVALID_JSON_VALUE_CANDIDATE) throw new TypeError(JSON_VALUE_ERROR_MESSAGE);
-	return normalized;
-}
-function parseJsonObject(value) {
-	const normalized = parseJsonValue(value);
-	if (!isJsonObjectValue(normalized)) throw new TypeError(JSON_OBJECT_ERROR_MESSAGE);
-	return normalized;
-}
-function normalizeJsonValueCandidate(value, seen = /* @__PURE__ */ new WeakSet()) {
-	if (value === null || typeof value === "boolean" || typeof value === "string") return value;
-	if (typeof value === "number") return Number.isFinite(value) ? value : INVALID_JSON_VALUE_CANDIDATE;
-	if (Array.isArray(value)) {
-		const normalizedItems = [];
-		for (const item of value) {
-			const normalizedItem = normalizeJsonValueCandidate(item, seen);
-			if (normalizedItem === INVALID_JSON_VALUE_CANDIDATE) return INVALID_JSON_VALUE_CANDIDATE;
-			normalizedItems.push(normalizedItem);
-		}
-		return normalizedItems;
-	}
-	if (typeof value !== "object" || value === void 0) return INVALID_JSON_VALUE_CANDIDATE;
-	if (!isPlainObject(value)) return INVALID_JSON_VALUE_CANDIDATE;
-	if (seen.has(value)) return INVALID_JSON_VALUE_CANDIDATE;
-	seen.add(value);
-	const normalized = {};
-	for (const [key, entry] of Object.entries(value)) {
-		if (entry === void 0) continue;
-		const normalizedEntry = normalizeJsonValueCandidate(entry, seen);
-		if (normalizedEntry === INVALID_JSON_VALUE_CANDIDATE) return INVALID_JSON_VALUE_CANDIDATE;
-		normalized[key] = normalizedEntry;
-	}
-	seen.delete(value);
-	return normalized;
-}
-function isJsonObjectValue(value) {
-	return value !== null && !Array.isArray(value) && typeof value === "object";
-}
-function isPlainObject(value) {
-	const prototype = Object.getPrototypeOf(value);
-	return prototype === null || Object.getPrototypeOf(prototype) === null;
-}
-
-//#endregion
-//#region src/tools/schema-emission.ts
-const JSON_SCHEMA_TARGET = "draft-07";
-function serializeOutputSchema(source) {
-	if (source === null || source === void 0) return source;
-	return emitJsonSchema(source, "output");
-}
-function emitJsonSchema(source, direction) {
-	const standard = getStandardSchemaProperties(source);
-	if (standard === void 0) return withoutSchemaVersion(parseJsonObject(source));
-	const emit = readJsonSchemaEmitter(standard, direction);
-	if (emit === void 0) throw new Error(describeMissingEmitter(standard));
-	return withoutSchemaVersion(parseJsonObject(emit({ target: JSON_SCHEMA_TARGET })));
-}
-function readJsonSchemaEmitter(standard, direction) {
-	const jsonSchema = standard.jsonSchema;
-	if (typeof jsonSchema !== "object" || jsonSchema === null) return void 0;
-	const emit = jsonSchema[direction];
-	return typeof emit === "function" ? emit : void 0;
-}
-function getStandardSchemaProperties(value) {
-	if (typeof value !== "object" || value === null || !("~standard" in value)) return void 0;
-	const standard = value["~standard"];
-	return typeof standard === "object" && standard !== null ? standard : void 0;
-}
-function describeMissingEmitter(standard) {
-	const vendor = typeof standard.vendor === "string" ? standard.vendor : "unknown";
-	if (vendor === "zod") return "Zod 3 cannot emit an output JSON Schema. Upgrade to Zod 4 or provide a plain JSON Schema object.";
-	return `Standard Schema vendor "${vendor}" does not support JSON Schema conversion. Provide a Standard Schema implementation with JSON Schema conversion or a plain JSON Schema object.`;
-}
-function withoutSchemaVersion(schema) {
-	const { $schema: _schemaVersion, ...canonical } = schema;
-	return canonical;
-}
-
-//#endregion
-//#region src/tools/schema.ts
-function defineJsonSchema(schema, check) {
-	const emit = () => structuredClone(schema);
-	const toolSchema = { "~standard": {
-		version: 1,
-		vendor: "eve",
-		validate: createJsonSchemaValidator(schema, check),
-		jsonSchema: {
-			input: emit,
-			output: emit
-		}
-	} };
-	plainJsonSchemas.add(toolSchema);
-	return toolSchema;
-}
-const plainJsonSchemas = /* @__PURE__ */ new WeakSet();
-const UNSPECIFIED_INPUT_SCHEMA = defineJsonSchema({});
-function createJsonSchemaValidator(schema, check) {
-	let validator;
-	let warned = false;
-	const passThrough = (value, reason) => {
-		if (!warned) {
-			warned = true;
-			console.warn(`[eve] Tool schema cannot validate values locally; passing them through unvalidated: ${reason}`);
-		}
-		return { value };
-	};
-	return (value) => {
-		if (validator === void 0) {
-			const built = buildValidator(schema);
-			if (typeof built === "string") {
-				validator = null;
-				return passThrough(value, built);
-			}
-			validator = built;
-		}
-		if (validator === null) return { value };
-		let result;
-		try {
-			result = validator.validate(value);
-		} catch (error) {
-			if (value === void 0) return { issues: [{ message: "Expected a JSON value." }] };
-			return passThrough(value, toErrorMessage(error));
-		}
-		if (!result.valid) return { issues: toIssues(result.errors) };
-		const filled = applyDefaults(schema, schema, value);
-		const message = check?.(filled);
-		return message === void 0 ? { value: filled } : { issues: [{ message }] };
-	};
-}
-function applyDefaults(root, schema, value) {
-	let result = value;
-	for (const node of followRefs(root, schema)) {
-		const { items, properties } = node;
-		if (isObject(result) && isObject(properties)) result = fillProperties(root, properties, result);
-		else if (Array.isArray(result) && isObject(items)) {
-			const list = result;
-			const next = list.map((item) => applyDefaults(root, items, item));
-			if (next.some((item, index) => item !== list[index])) result = next;
-		}
-	}
-	return result;
-}
-function fillProperties(root, properties, value) {
-	let result = value;
-	for (const [key, property] of Object.entries(properties)) {
-		const current = Object.hasOwn(value, key) ? value[key] : void 0;
-		const next = current === void 0 ? findDefault(root, property) : applyDefaults(root, property, current);
-		if (next === current) continue;
-		if (result === value) result = { ...value };
-		result[key] = next;
-	}
-	return result;
-}
-function findDefault(root, schema) {
-	for (const node of followRefs(root, schema)) if ("default" in node) return structuredClone(node.default);
-}
-function* followRefs(root, schema) {
-	const seen = /* @__PURE__ */ new Set();
-	let node = schema;
-	while (isObject(node) && !seen.has(node)) {
-		seen.add(node);
-		yield node;
-		node = resolveLocalRef(root, node.$ref);
-	}
-}
-function resolveLocalRef(root, ref) {
-	if (typeof ref !== "string" || ref !== "#" && !ref.startsWith("#/")) return void 0;
-	let node = root;
-	for (const segment of decodePointer(ref)) {
-		if (typeof node !== "object" || node === null || !Object.hasOwn(node, segment)) return;
-		node = node[segment];
-	}
-	return node;
-}
-function buildValidator(schema) {
-	try {
-		const copy = structuredClone(schema);
-		return prepareForValidation(copy) ?? new Validator(copy, "2020-12", false);
-	} catch (error) {
-		return toErrorMessage(error);
-	}
-}
-const JSON_TYPES = /* @__PURE__ */ new Set([
-	"array",
-	"boolean",
-	"integer",
-	"null",
-	"number",
-	"object",
-	"string"
-]);
-const EXCLUSIVE_BOUNDS = [["exclusiveMinimum", "minimum"], ["exclusiveMaximum", "maximum"]];
-const SUBSCHEMA_KEYWORDS = [
-	"additionalItems",
-	"additionalProperties",
-	"contains",
-	"else",
-	"if",
-	"not",
-	"propertyNames",
-	"then",
-	"unevaluatedItems",
-	"unevaluatedProperties"
-];
-const SUBSCHEMA_LIST_KEYWORDS = [
-	"allOf",
-	"anyOf",
-	"oneOf",
-	"prefixItems"
-];
-const SUBSCHEMA_MAP_KEYWORDS = [
-	"$defs",
-	"definitions",
-	"dependencies",
-	"dependentSchemas",
-	"patternProperties",
-	"properties"
-];
-function prepareForValidation(schema) {
-	if (typeof schema === "boolean") return void 0;
-	if (typeof schema !== "object" || schema === null || Array.isArray(schema)) return "a subschema is neither an object nor a boolean";
-	const node = schema;
-	delete node.format;
-	for (const [flag, bound] of EXCLUSIVE_BOUNDS) {
-		if (typeof node[flag] !== "boolean") continue;
-		if (node[flag] && typeof node[bound] === "number") {
-			node[flag] = node[bound];
-			delete node[bound];
-		} else delete node[flag];
-	}
-	const { enum: values, pattern, required, type } = node;
-	if (type !== void 0 && !(Array.isArray(type) ? type.every(isJsonType) : isJsonType(type))) return `unsupported type ${JSON.stringify(type)}`;
-	if (values !== void 0 && !Array.isArray(values)) return "`enum` is not an array";
-	if (required !== void 0 && !(Array.isArray(required) && required.every((key) => typeof key === "string"))) return "`required` is not an array of strings";
-	if (pattern !== void 0 && !isRegExpSource(pattern)) return `invalid pattern ${JSON.stringify(pattern)}`;
-	for (const keyword of SUBSCHEMA_KEYWORDS) if (keyword in node) {
-		const problem = prepareForValidation(node[keyword]);
-		if (problem !== void 0) return problem;
-	}
-	const items = node.items;
-	for (const subschema of Array.isArray(items) ? items : items === void 0 ? [] : [items]) {
-		const problem = prepareForValidation(subschema);
-		if (problem !== void 0) return problem;
-	}
-	for (const keyword of SUBSCHEMA_LIST_KEYWORDS) {
-		const list = node[keyword];
-		if (list === void 0) continue;
-		if (!Array.isArray(list)) return `\`${keyword}\` is not an array`;
-		for (const subschema of list) {
-			const problem = prepareForValidation(subschema);
-			if (problem !== void 0) return problem;
-		}
-	}
-	for (const keyword of SUBSCHEMA_MAP_KEYWORDS) {
-		const map = node[keyword];
-		if (map === void 0) continue;
-		if (typeof map !== "object" || map === null || Array.isArray(map)) return `\`${keyword}\` is not an object`;
-		for (const [key, subschema] of Object.entries(map)) {
-			if (keyword === "patternProperties" && !isRegExpSource(key)) return `invalid pattern ${JSON.stringify(key)}`;
-			if (keyword === "dependencies" && Array.isArray(subschema)) continue;
-			const problem = prepareForValidation(subschema);
-			if (problem !== void 0) return problem;
-		}
-	}
-}
-function isJsonType(value) {
-	return typeof value === "string" && JSON_TYPES.has(value);
-}
-function isRegExpSource(value) {
-	if (typeof value !== "string") return false;
-	try {
-		new RegExp(value, "u");
-		return true;
-	} catch {
-		return false;
-	}
-}
-const CLOSED_OBJECT_KEYWORD = /\/(?:additional|unevaluated)Properties$/;
-function toIssues(errors) {
-	const failures = [];
-	for (let index = 0; index < errors.length; index++) {
-		const unit = errors[index];
-		const rejected = errors[index + 1];
-		if (CLOSED_OBJECT_KEYWORD.test(unit.keywordLocation) && rejected?.keyword === "false") {
-			const key = decodePointer(rejected.instanceLocation).at(-1);
-			failures.push({
-				keyword: "false",
-				location: rejected.instanceLocation,
-				message: `Unrecognized key: ${JSON.stringify(key)}`,
-				object: unit.instanceLocation
-			});
-			index++;
-		} else failures.push({
-			keyword: unit.keyword,
-			location: unit.instanceLocation,
-			message: unit.error
-		});
-	}
-	const relevant = failures.filter((failure) => failure.object === void 0 || !failures.some((other) => other.object === void 0 && (other.location === failure.location || other.location.startsWith(`${failure.location}/`))));
-	return relevant.filter((failure, index) => {
-		const next = relevant[index + 1];
-		if (next === void 0) return true;
-		if (next.location.startsWith(`${failure.location}/`)) return false;
-		return !(failure.keyword === "$ref" && next.location === failure.location);
-	}).map(({ location, message, object }) => {
-		const path = decodePointer(object ?? location);
-		return path.length === 0 ? { message } : {
-			message,
-			path
-		};
-	});
-}
-function decodePointer(location) {
-	return location.split("/").slice(1).map((segment) => {
-		let decoded = segment;
-		try {
-			decoded = decodeURIComponent(segment);
-		} catch {}
-		return decoded.replaceAll("~1", "/").replaceAll("~0", "~");
-	});
-}
-
-//#endregion
-//#region src/client/session.ts
-const SESSION_SEND_RETRY_BASE_DELAY_MS = 250;
-const SESSION_SEND_RETRY_MAX_DELAY_MS = 2e3;
-const SESSION_SEND_READY_TIMEOUT_MS = 2e4;
-const followSession = Symbol("followClientSession");
-var ClientSession = class ClientSession {
-	#context;
-	#state;
-	constructor(context, state) {
-		this.#context = context;
-		this.#state = state;
-	}
-	static async create(context, input) {
-		const startedAt = Date.now();
-		const response = await postTurn(context, EVE_SESSION_ROUTE_PATH, input, true, input.stubs);
-		const acceptedAt = Date.now();
-		const { sessionId, deliveryId } = await readAcceptedMessage(response);
-		const session = new ClientSession(context, {
-			sessionId,
-			streamIndex: 0
-		});
-		const receipt = {
-			deliveryId,
-			startedAt,
-			notReadyMs: 0,
-			acceptedAt
-		};
-		return {
-			response: session.#messageResponse(response, input, 0, void 0, receipt),
-			session
-		};
-	}
-	static async prewarm(context, options = {}) {
-		const { sessionId } = await readAcceptedMessage(await postCreateSession(context, options));
-		return new ClientSession(context, {
-			sessionId,
-			streamIndex: 0
-		});
-	}
-	get state() {
-		return this.#state;
-	}
-	async snapshot(options) {
-		throwIfAborted(options?.signal);
-		const events = [];
-		for await (const event of this.#readStream({
-			follow: false,
-			signal: options?.signal,
-			startIndex: 0
-		})) events.push(event);
-		throwIfAborted(options?.signal);
-		return {
-			events,
-			session: {
-				sessionId: this.#state.sessionId,
-				streamIndex: events.length
-			}
-		};
-	}
-	async send(message, options = {}) {
-		return await this.#send({
-			...options,
-			message
-		}, true);
-	}
-	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
-		}, false);
-	}
-	async #send(input, retrySessionNotReady) {
-		const initialStreamIndex = this.#state.streamIndex;
-		const path = createEveSessionRoutePath(this.#state.sessionId);
-		const { response, timing } = await postSessionSend(this.#context, path, input, retrySessionNotReady);
-		const { sessionId: responseSessionId, deliveryId } = await readAcceptedMessage(response, this.#state.sessionId);
-		if (responseSessionId !== this.#state.sessionId) throw new Error("Message route returned a different session id.");
-		if (input.message !== void 0 && deliveryId === void 0) throw new Error("Message route did not return a delivery id. Update the server before sending with this client.");
-		return this.#messageResponse(response, input, initialStreamIndex, input.message === void 0 ? void 0 : deliveryId, {
-			...timing,
-			deliveryId
-		});
-	}
-	async prewarm(options) {
-		return await prewarmClientSession({
-			context: this.#context,
-			sessionId: this.#state.sessionId,
-			signal: options?.signal
-		});
-	}
-	async cancel(options) {
-		return await cancelClientSession({
-			context: this.#context,
-			options,
-			sessionId: this.#state.sessionId
-		});
-	}
-	async clear() {
-		return await clearClientSession({
-			context: this.#context,
-			sessionId: this.#state.sessionId
-		});
-	}
-	async compact() {
-		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) {
-		if (options?.follow === false && (options.startIndex ?? this.#state.streamIndex) < 0) throw new Error("stream({ follow: false }) requires a nonnegative startIndex; a tail-relative cursor cannot be bounded.");
-		return this.#streamAndAdvance(options);
-	}
-	agent(started) {
-		return new ClientAgentSession(this.#context, started);
-	}
-	[followSession](options) {
-		return this.#streamAndAdvance({
-			...options,
-			keepAlive: true
-		});
-	}
-	#messageResponse(response, input, initialStreamIndex, deliveryId, receipt) {
-		response.body?.cancel().catch(() => {});
-		return new MessageResponse({
-			cancelTurn: async (turnId) => await this.cancel({ turnId }),
-			createStream: (source) => this.#createEventStream(initialStreamIndex, input, deliveryId, source),
-			deliveryId,
-			receipt,
-			resumesTurn: input.inputResponses !== void 0,
-			sessionId: this.#state.sessionId
-		});
-	}
-	async *#createEventStream(initialStreamIndex, input, deliveryId, source) {
-		let eventCount = 0;
-		let started = deliveryId === void 0;
-		let reachedBoundary = false;
-		const segment = new TurnSegment({ followCallbacks: true });
-		try {
-			for await (const event of source ?? this.#readStream({
-				headers: input.headers,
-				keepAlive: true,
-				signal: input.signal,
-				startIndex: initialStreamIndex,
-				streamReconnectPolicy: input.streamReconnectPolicy
-			})) {
-				eventCount += 1;
-				if (deliveryId !== void 0) {
-					const matches = event.meta?.deliveryIds?.includes(deliveryId) === true;
-					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;
-					const attributed = event.meta?.deliveryIds !== void 0;
-					if (!terminal && attributed && !matches) continue;
-					started = true;
-				}
-				reachedBoundary = segment.observe(event);
-				yield event;
-				if (reachedBoundary) break;
-			}
-			if (deliveryId !== void 0 && !reachedBoundary && !input.signal?.aborted) throw new Error("The response stream ended before the accepted message reached its turn boundary.");
-		} finally {
-			this.#advanceStreamIndex(initialStreamIndex + eventCount);
-		}
-	}
-	async *#streamAndAdvance(options) {
-		const startIndex = options?.startIndex ?? this.#state.streamIndex;
-		let eventCount = 0;
-		for await (const event of this.#readStream({
-			follow: options?.follow,
-			headers: options?.headers,
-			keepAlive: options?.keepAlive,
-			onCaughtUp: options?.onCaughtUp,
-			resolveHeaders: options?.resolveHeaders,
-			resolveReconnectPolicy: options?.resolveReconnectPolicy,
-			signal: options?.signal,
-			startIndex,
-			streamReconnectPolicy: options?.streamReconnectPolicy
-		})) {
-			eventCount += 1;
-			if (startIndex >= 0) this.#advanceStreamIndex(startIndex + eventCount);
-			yield event;
-		}
-	}
-	#advanceStreamIndex(streamIndex) {
-		this.#state = {
-			sessionId: this.#state.sessionId,
-			streamIndex: Math.max(this.#state.streamIndex, streamIndex)
-		};
-	}
-	#readStream(input) {
-		return followStreamIterable({
-			onCaughtUp: input.onCaughtUp,
-			follow: input.follow,
-			host: this.#context.host,
-			keepAlive: input.keepAlive,
-			resolveHeaders: () => this.#context.resolveHeaders(input.resolveHeaders?.() ?? input.headers),
-			path: createEveSessionStreamRoutePath(this.#state.sessionId),
-			redirect: this.#context.redirect,
-			signal: input.signal,
-			startIndex: input.startIndex,
-			streamReconnectPolicy: input.streamReconnectPolicy,
-			resolveReconnectPolicy: input.resolveReconnectPolicy
-		});
-	}
-};
-function followClientSession(session, options) {
-	return session[followSession](options);
-}
-async function postSessionSend(context, path, input, retrySessionNotReady) {
-	const startedAt = Date.now();
-	const readyDeadline = startedAt + SESSION_SEND_READY_TIMEOUT_MS;
-	let retryDelayMs = SESSION_SEND_RETRY_BASE_DELAY_MS;
-	for (;;) {
-		const attemptAt = Date.now();
-		try {
-			return {
-				response: await postTurn(context, path, input, false),
-				timing: {
-					startedAt,
-					notReadyMs: attemptAt - startedAt,
-					acceptedAt: Date.now()
-				}
-			};
-		} catch (error) {
-			if (!retrySessionNotReady || !isSessionNotReady(error)) throw error;
-			const remainingMs = readyDeadline - Date.now();
-			if (remainingMs <= 0) throw error;
-			await sleep(Math.min(retryDelayMs, remainingMs), input.signal);
-		}
-		throwIfAborted(input.signal);
-		retryDelayMs = Math.min(retryDelayMs * 2, SESSION_SEND_RETRY_MAX_DELAY_MS);
-	}
-}
-async function postCreateSession(context, options) {
-	const headers = await context.resolveHeaders(options.headers);
-	const body = options.stubs === void 0 ? void 0 : JSON.stringify({ stubs: options.stubs });
-	if (body !== void 0) headers.set("content-type", "application/json");
-	const response = await fetch(createClientUrl(context.host, EVE_SESSION_ROUTE_PATH), {
-		body,
-		headers,
-		method: "POST",
-		redirect: context.redirect,
-		signal: options.signal ?? null
-	});
-	if (!response.ok) {
-		const responseBody = await response.text();
-		throw new ClientError(response.status, responseBody, response.headers);
-	}
-	return response;
-}
-function isSessionNotReady(error) {
-	return error instanceof ClientError && error.status === 409 && error.code === "session_not_ready";
-}
-async function postTurn(context, path, input, requireMessage, stubs) {
-	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.");
-	if (stubs !== void 0) body.stubs = stubs;
-	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 createClientError(response.status, responseBody, response.headers);
-	}
-	return response;
-}
-async function readAcceptedMessage(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,
-		deliveryId: typeof payload.deliveryId === "string" && payload.deliveryId.length > 0 ? payload.deliveryId : void 0
-	};
-}
-function createMessageBody(input, requireMessage) {
-	const body = {};
-	if (input.message !== void 0) body.message = input.message;
-	if (input.inputResponses !== void 0 && input.inputResponses.length > 0) body.inputResponses = input.inputResponses;
-	if (!requireMessage && input.message !== void 0 && input.turnPolicy !== void 0) body.turnPolicy = input.turnPolicy;
-	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;
-}
-
-//#endregion
-//#region src/client/sessions.ts
-var ClientSessions = class {
-	#context;
-	constructor(context) {
-		this.#context = context;
-	}
-	async create(input = {}) {
-		if ("message" in input) return await ClientSession.create(this.#context, input);
-		return { session: await ClientSession.prewarm(this.#context, input) };
-	}
-	attach(sessionId, options) {
-		if (sessionId.length === 0) throw new Error("sessionId must be a non-empty string.");
-		return new ClientSession(this.#context, {
-			sessionId,
-			streamIndex: options?.streamIndex ?? 0
-		});
-	}
-};
-
-//#endregion
-//#region src/client/types.ts
-const VERCEL_TRUSTED_OIDC_IDP_TOKEN_HEADER = "x-vercel-trusted-oidc-idp-token";
-
-//#endregion
-//#region src/client/client.ts
-var Client = class {
-	#auth;
-	#headers;
-	#host;
-	#redirect;
-	sessions;
-	constructor(options) {
-		this.#host = options.host;
-		this.#auth = options.auth;
-		this.#headers = options.headers;
-		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);
-		const headers = await this.#resolveHeaders();
-		const response = await fetch(url, withRedirectPolicy({ headers }, this.#redirect));
-		if (!response.ok) {
-			const body = await response.text();
-			throw new ClientError(response.status, body, response.headers);
-		}
-		let payload;
-		try {
-			payload = await response.json();
-		} catch {
-			throw new HealthResponseError();
-		}
-		const result = HealthResultSchema.safeParse(payload);
-		if (!result.success) throw new HealthResponseError(result.error.issues.slice(0, 5).map((issue) => {
-			const path = issue.path.join(".");
-			return path.length === 0 ? issue.message : `${path}: ${issue.message}`;
-		}));
-		return result.data;
-	}
-	async info(options = {}) {
-		const response = await this.fetch(EVE_INFO_ROUTE_PATH, options);
-		if (!response.ok) {
-			const body = await response.text();
-			throw new ClientError(response.status, body, response.headers);
-		}
-		let payload;
-		try {
-			payload = await response.json();
-		} catch {
-			throw new AgentInfoResponseError();
-		}
-		const result = AgentInfoResultSchema.safeParse(payload);
-		if (!result.success) throw new AgentInfoResponseError(result.error.issues.slice(0, 5).map((issue) => {
-			const path = issue.path.join(".");
-			return path.length === 0 ? issue.message : `${path}: ${issue.message}`;
-		}));
-		return result.data;
-	}
-	async fetch(path, init = {}) {
-		const url = createClientUrl(this.#host, path);
-		const headers = await this.#resolveHeaders(headersInitToRecord(init.headers));
-		return await fetch(url, withRedirectPolicy({
-			...init,
-			headers
-		}, this.#redirect));
-	}
-	async #resolveHeaders(perRequest) {
-		const headers = new Headers();
-		const [baseHeaders, authHeaders] = await Promise.all([resolveHeadersValue(this.#headers), this.#resolveAuthHeaders()]);
-		for (const [key, value] of Object.entries(baseHeaders)) headers.set(key, value);
-		for (const [key, value] of Object.entries(authHeaders)) headers.set(key, value);
-		if (perRequest) for (const [key, value] of Object.entries(perRequest)) headers.set(key, value);
-		return headers;
-	}
-	async #resolveAuthHeaders() {
-		const auth = this.#auth;
-		if (!auth) return {};
-		if ("vercelOidc" in auth) {
-			const token = (await resolveTokenValue(auth.vercelOidc.token)).trim();
-			if (token.length === 0) return {};
-			return {
-				authorization: `Bearer ${token}`,
-				[VERCEL_TRUSTED_OIDC_IDP_TOKEN_HEADER]: token
-			};
-		}
-		if ("bearer" in auth) {
-			const token = (await resolveTokenValue(auth.bearer)).trim();
-			return token.length === 0 ? {} : { authorization: `Bearer ${token}` };
-		}
-		if ("basic" in auth) {
-			const password = await resolveTokenValue(auth.basic.password);
-			return { authorization: `Basic ${encodeBasicCredentials(auth.basic.username, password)}` };
-		}
-		return {};
-	}
-};
-async function resolveTokenValue(value) {
-	return typeof value === "function" ? value() : value;
-}
-async function resolveHeadersValue(value) {
-	if (value === void 0) return {};
-	return typeof value === "function" ? await value() : value;
-}
-function headersInitToRecord(headers) {
-	if (headers === void 0) return {};
-	return Object.fromEntries(new Headers(headers).entries());
-}
-function withRedirectPolicy(init, redirect) {
-	return redirect === void 0 ? init : {
-		...init,
-		redirect
-	};
-}
-
-//#endregion
-//#region src/client/eve-agent-projection.ts
-var EveAgentProjection = class {
-	#reducer;
-	#events;
-	#data;
-	constructor(reducer, events) {
-		this.#reducer = reducer;
-		this.#events = [...events];
-		this.#data = this.#reduce();
-	}
-	get data() {
-		return this.#data;
-	}
-	get reducer() {
-		return this.#reducer;
-	}
-	reset() {
-		this.#events = [];
-		this.#data = this.#reducer.initial();
-	}
-	append(event) {
-		this.#events.push(event);
-		this.#data = this.#reducer.reduce(this.#data, event);
-	}
-	remove(predicate) {
-		this.#events = this.#events.filter((event) => !predicate(event));
-		this.#data = this.#reduce();
-	}
-	replace(predicate, replacement) {
-		const index = this.#events.findIndex(predicate);
-		if (index === -1) this.#events.push(replacement);
-		else this.#events[index] = replacement;
-		this.#data = this.#reduce();
-	}
-	#reduce() {
-		let data = this.#reducer.initial();
-		for (const event of this.#events) data = this.#reducer.reduce(data, event);
-		return data;
-	}
-};
-
-//#endregion
-//#region src/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 hasPendingAuthorizations(state) {
-	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];
-	return task?.kind === "agent" ? task : void 0;
-}
-function isAgentSessionCaughtUp(state, agent) {
-	if (agent.observation.status !== "following" && agent.observation.status !== "idle") return false;
-	const task = agentToolTask(state, agent);
-	if (task === void 0) return false;
-	const calls = Object.values(task.calls);
-	if (calls.some((call) => call.status === "working")) return false;
-	const child = agent.observation.conversation;
-	if (child.activeTurnId !== void 0) return false;
-	if (Object.values(child.inputs).some((input) => input.status !== "settled")) return false;
-	if (hasPendingAuthorizations(child)) return false;
-	return child.messages.filter((message) => message.role === "user").length >= calls.filter((call) => call.status === "completed").length;
-}
-
-//#endregion
-//#region src/client/eve-agent-store-helpers.ts
-function activeTurnForOptimisticFollowUp(events) {
-	const lastTurn = events.findLast((event) => event.type === "turn.started" || event.type === "turn.completed" || event.type === "turn.failed" || event.type === "turn.cancelled" || isCurrentTurnBoundaryEvent(event));
-	return lastTurn?.type === "turn.started" ? lastTurn.data.turnId : void 0;
-}
-function isResponseBoundary(event, conversation) {
-	return endsTurnSegment(event, {
-		callbacks: hasPendingAuthorizations(conversation),
-		requests: Object.values(conversation.inputs).some((input) => input.status !== "settled")
-	});
-}
-function settledStatus(error, conversation) {
-	if (error !== void 0) return "error";
-	return conversation.activeTurnId === void 0 ? "ready" : "streaming";
-}
-function isSettledSessionTail(events, conversation) {
-	const tail = events.at(-1);
-	return tail !== void 0 && isResponseBoundary(tail, conversation);
-}
-function assertAnswerable(input, conversation) {
-	for (const { requestId } of input.inputResponses ?? []) {
-		const status = conversation.inputs[requestId]?.status;
-		if (status !== void 0 && status !== "open") throw new Error(`Input request ${requestId} was already answered.`);
-	}
-}
-function assertInFlightFollowUp(input) {
-	if (input.inputResponses !== void 0) return;
-	if (input.message === void 0 || input.turnPolicy !== "steer") throw new Error("eve session is already processing a turn. Send a message with turnPolicy: \"steer\" to guide it at the next boundary, or answer an open input request.");
-}
-function validateFollowUp(input) {
-	assertExclusiveTurnInput(input);
-	assertInFlightFollowUp(input);
-	return input;
-}
-function assertExclusiveTurnInput(input) {
-	if (input.message !== void 0 === (input.inputResponses !== void 0)) throw new Error("A turn requires exactly one of message or inputResponses.");
-}
-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;
-}
-function createActiveTurn(cancel) {
-	const response = Promise.withResolvers();
-	const completion = Promise.withResolvers();
-	const turn = {
-		abortController: new AbortController(),
-		acceptedFollowUps: 0,
-		cancel: () => cancel(turn),
-		completion: completion.promise,
-		followUpDispatches: /* @__PURE__ */ new Set(),
-		receivedFollowUps: 0,
-		receivedFollowUpEvents: /* @__PURE__ */ new Map(),
-		followUpSubmissionIds: /* @__PURE__ */ new Set(),
-		resolveCompletion: completion.resolve,
-		response: response.promise,
-		resolveResponse: response.resolve
-	};
-	return turn;
-}
-function countFollowUpDeliveries(turn, reconciliation) {
-	let followed = 0;
-	for (const id of reconciliation.ids) if (turn.followUpSubmissionIds.delete(id)) followed += 1;
-	if (followed === 0) return;
-	if (reconciliation.alreadyProjected) turn.receivedFollowUps += followed;
-	else {
-		const previous = turn.receivedFollowUpEvents.get(reconciliation.event) ?? 0;
-		turn.receivedFollowUpEvents.set(reconciliation.event, previous + followed);
-	}
-}
-async function followSteeredTurns(turn, events, isActive) {
-	while (turn.followUpDispatches.size > 0) await Promise.allSettled(turn.followUpDispatches);
-	if (turn.receivedFollowUps >= turn.acceptedFollowUps) return;
-	const segment = new TurnSegment({ followCallbacks: true });
-	for await (const event of events) {
-		if (!isActive()) return;
-		turn.receivedFollowUps += turn.receivedFollowUpEvents.get(event) ?? 0;
-		turn.receivedFollowUpEvents.delete(event);
-		if (segment.observe(event)) {
-			while (turn.followUpDispatches.size > 0) await Promise.allSettled(turn.followUpDispatches);
-			if (turn.receivedFollowUps >= turn.acceptedFollowUps) return;
-		}
-	}
-}
-async function waitWithSignal(promise, signal) {
-	if (signal === void 0) return await promise;
-	const aborted = Promise.withResolvers();
-	const onAbort = () => aborted.reject(signal.reason);
-	signal.addEventListener("abort", onAbort, { once: true });
-	if (signal.aborted) onAbort();
-	try {
-		return await Promise.race([aborted.promise, promise]);
-	} finally {
-		signal.removeEventListener("abort", onAbort);
-	}
-}
-
-//#endregion
-//#region src/client/optimistic-message-submissions.ts
-var OptimisticMessageSubmissions = class {
-	#optimistic;
-	#projections;
-	#pending = [];
-	constructor(projections, optimistic) {
-		this.#projections = projections;
-		this.#optimistic = optimistic;
-	}
-	reset() {
-		this.#pending = [];
-	}
-	submit(input, eventStartIndex, turnId) {
-		if (input.message === void 0) return void 0;
-		const pending = {
-			createdAt: Date.now(),
-			eventStartIndex,
-			id: createSubmissionId(),
-			message: summarizeUserContent(input.message),
-			turnId,
-			requiresDeliveryId: true
-		};
-		this.#pending = [...this.#pending, pending];
-		if (this.#optimistic) for (const projection of this.#projections) projection.append({
-			data: {
-				createdAt: pending.createdAt,
-				message: pending.message,
-				submissionId: pending.id,
-				turnId
-			},
-			type: "client.message.submitted"
-		});
-		return pending.id;
-	}
-	resubmit(submissionId, input) {
-		const pending = this.#pending.find((candidate) => candidate.id === submissionId);
-		const message = input.message === void 0 ? void 0 : summarizeUserContent(input.message);
-		if (pending?.message === message) return submissionId;
-		if (pending !== void 0) this.#withdraw([pending.id]);
-		return this.submit(input, pending?.eventStartIndex ?? 0, pending?.turnId);
-	}
-	apply(event) {
-		if (event.type !== "message.received") {
-			for (const projection of this.#projections) projection.append(event);
-			return;
-		}
-		const matching = this.#matching(event);
-		if (matching.length === 0) {
-			for (const projection of this.#projections) projection.append(event);
-			return;
-		}
-		return this.#reconcile(matching, event, false);
-	}
-	correlate(submissionId, deliveryId, events) {
-		if (submissionId === void 0) return void 0;
-		this.#pending = this.#pending.map((pending) => pending.id === submissionId ? {
-			...pending,
-			deliveryId,
-			requiresDeliveryId: deliveryId !== void 0
-		} : pending);
-		const pending = this.#pending.find((candidate) => candidate.id === submissionId);
-		if (pending === void 0) return void 0;
-		for (const event of events.slice(pending.eventStartIndex)) {
-			if (event.type !== "message.received") continue;
-			const matching = this.#matching(event);
-			if (matching.some((candidate) => candidate.id === submissionId)) return this.#reconcile(matching, event, true);
-		}
-	}
-	fail(error, submissionId) {
-		const pending = submissionId === void 0 ? this.#pending[0] : this.#pending.find((candidate) => candidate.id === submissionId);
-		if (pending === void 0) return;
-		this.#pending = this.#pending.filter((candidate) => candidate.id !== pending.id);
-		for (const projection of this.#projections) projection.replace((event) => event.type === "client.message.submitted" && event.data.submissionId === pending.id, {
-			data: {
-				createdAt: pending.createdAt,
-				error: { message: error.message },
-				message: pending.message,
-				submissionId: pending.id,
-				turnId: pending.turnId
-			},
-			type: "client.message.failed"
-		});
-	}
-	failAll(error) {
-		for (const pending of this.#pending) this.fail(error, pending.id);
-	}
-	#matching(event) {
-		return this.#pending.filter((pending) => pending.deliveryId === void 0 ? !pending.requiresDeliveryId : event.meta.deliveryIds?.includes(pending.deliveryId) === true);
-	}
-	#reconcile(submissions, event, alreadyProjected) {
-		const ids = submissions.map((pending) => pending.id);
-		this.#withdraw(ids);
-		if (!alreadyProjected) for (const projection of this.#projections) projection.append(event);
-		return {
-			alreadyProjected,
-			event,
-			ids
-		};
-	}
-	#withdraw(ids) {
-		const idSet = new Set(ids);
-		this.#pending = this.#pending.filter((pending) => !idSet.has(pending.id));
-		for (const projection of this.#projections) projection.remove((candidate) => candidate.type === "client.message.submitted" && idSet.has(candidate.data.submissionId));
-	}
-};
-
-//#endregion
-//#region src/client/agent-stream-follower.ts
-const agentStreamReconnectPolicy = {
-	streamIdleReconnectPolicy: { maxAttempts: Infinity },
-	streamOpenReconnectPolicy: { maxAttempts: Infinity }
-};
-var AgentStreamFollower = class {
-	#options;
-	#started = /* @__PURE__ */ new Map();
-	#controllers = /* @__PURE__ */ new Map();
-	#failed = /* @__PURE__ */ new Set();
-	#disposed = false;
-	constructor(options) {
-		this.#options = options;
-	}
-	acceptParentEvent(event) {
-		if (event.type === "agent.started") this.#started.set(event.data.sessionId, event);
-	}
-	reconcile() {
-		if (this.#disposed) return;
-		const state = this.#options.getState();
-		for (const agent of Object.values(state.agents)) {
-			if (agentToolTask(state, agent) === void 0) continue;
-			const controller = this.#controllers.get(agent.sessionId);
-			const caughtUp = isAgentSessionCaughtUp(state, agent);
-			if (controller !== void 0 && caughtUp) {
-				this.#controllers.delete(agent.sessionId);
-				controller.abort();
-				this.#options.onIdle(agent.sessionId);
-			} else if (controller === void 0 && !caughtUp && !this.#failed.has(agent.sessionId)) this.#follow(agent.sessionId);
-		}
-	}
-	abortAll() {
-		this.#disposed = true;
-		for (const controller of this.#controllers.values()) controller.abort();
-		this.#controllers.clear();
-	}
-	#follow(sessionId) {
-		const started = this.#started.get(sessionId);
-		if (started === void 0) return;
-		const controller = new AbortController();
-		this.#controllers.set(sessionId, controller);
-		this.#options.onFollowing(sessionId);
-		const { cursors } = this.#options;
-		(async () => {
-			let cursor = cursors.get(sessionId) ?? 0;
-			try {
-				for await (const event of this.#options.session.agent(started).stream({
-					signal: controller.signal,
-					startIndex: cursor,
-					streamReconnectPolicy: agentStreamReconnectPolicy
-				})) {
-					if (controller.signal.aborted) return;
-					cursors.set(sessionId, ++cursor);
-					this.#options.onEvent(sessionId, event);
-					this.reconcile();
-				}
-			} catch {}
-			if (controller.signal.aborted || this.#controllers.get(sessionId) !== controller) return;
-			this.#controllers.delete(sessionId);
-			this.#failed.add(sessionId);
-			this.#options.onUnavailable(sessionId);
-		})();
-	}
-};
-
-//#endregion
-//#region src/client/authorization-message-parts.ts
-function createAuthorizationRequiredPart(event) {
-	const displayName = event.data.authorization?.displayName ?? formatAuthorizationDisplayName(event.data.name);
-	const part = {
-		authorization: event.data.authorization,
-		description: normalizeAuthorizationDescription(event.data.description, event.data.name, displayName),
-		displayName,
-		name: event.data.name,
-		state: "required",
-		stepIndex: event.data.stepIndex,
-		turnId: event.data.turnId,
-		type: "authorization"
-	};
-	if (event.data.attemptId !== void 0) part.attemptId = event.data.attemptId;
-	if (event.data.webhookUrl !== void 0) part.awaitsCallback = true;
-	return part;
-}
-function createAuthorizationCompletedPart(event, existing) {
-	const displayName = event.data.authorization?.displayName ?? existing?.displayName ?? formatAuthorizationDisplayName(event.data.name);
-	const part = {
-		authorization: existing?.authorization || event.data.authorization ? {
-			...existing?.authorization,
-			...event.data.authorization
-		} : void 0,
-		description: existing?.description ?? buildCompletedAuthorizationDescription(displayName, event.data.outcome, event.data.reason),
-		displayName,
-		name: event.data.name,
-		outcome: event.data.outcome,
-		state: "completed",
-		stepIndex: existing?.stepIndex ?? event.data.stepIndex,
-		turnId: existing?.turnId ?? event.data.turnId,
-		type: "authorization"
-	};
-	const attemptId = event.data.attemptId ?? existing?.attemptId;
-	if (attemptId !== void 0) part.attemptId = attemptId;
-	if (existing?.awaitsCallback) part.awaitsCallback = true;
-	if (event.data.reason !== void 0) part.reason = event.data.reason;
-	return part;
-}
-function buildCompletedAuthorizationDescription(displayName, outcome, reason) {
-	if (outcome === "authorized") return `${displayName} connected.`;
-	return `${displayName} authorization ${outcome}${reason !== void 0 ? ` (${reason})` : ""}.`;
-}
-function normalizeAuthorizationDescription(description, name, displayName) {
-	if (description === `Authorization required for ${name}`) return `Authorization required for ${displayName}`;
-	return description;
-}
-function formatAuthorizationDisplayName(name) {
-	if (name.length === 0) return name;
-	return `${name.charAt(0).toUpperCase()}${name.slice(1)}`;
-}
-
-//#endregion
-//#region src/protocol/catalog-tools.ts
-const SKILL_TOOL_NAME = "eve__skill";
-
-//#endregion
-//#region src/shared/action-request-name.ts
-function actionRequestName(action) {
-	switch (action.kind) {
-		case "load-skill": return action.name;
-		case "subagent-call": return action.subagentName;
-		case "remote-agent-call": return action.remoteAgentName;
-		case "tool-call":
-		case "workflow-tool-call": return action.toolName;
-	}
-}
-
-//#endregion
-//#region src/shared/display-name.ts
-function displayName(identifier) {
-	const words = lastSegment(identifier).replace(/([a-z0-9])([A-Z])/gu, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/gu, "$1 $2").split(SEPARATORS).filter((word) => word !== "").map((word) => word.length > 1 && word === word.toUpperCase() ? word : word.toLowerCase());
-	return words.length === 0 ? identifier : words.join(" ");
-}
-function displayTitle(identifier) {
-	return capitalize(displayName(identifier));
-}
-const SEPARATORS = /[\s_-]+/u;
-function lastSegment(identifier) {
-	return identifier.split("__").findLast((segment) => segment !== "") ?? identifier;
-}
-function capitalize(text) {
-	return text.charAt(0).toUpperCase() + text.slice(1);
-}
-
-//#endregion
-//#region src/client/message-action-parts.ts
-function toMessageInputRequest(request) {
-	return {
-		allowFreeform: request.allowFreeform,
-		display: request.display,
-		kind: request.kind,
-		options: request.options,
-		prompt: request.prompt,
-		requestId: request.requestId
-	};
-}
-function createToolMetadata(descriptor, extra) {
-	return { eve: {
-		inputRequest: extra?.inputRequest,
-		kind: descriptor.kind,
-		label: extra?.label,
-		name: descriptor.name
-	} };
-}
-function mergeToolMetadata(current, next) {
-	const kind = next.eve?.kind ?? current?.eve?.kind ?? "unknown";
-	const name = next.eve?.name ?? current?.eve?.name ?? "unknown";
-	return { eve: {
-		...current?.eve,
-		...next.eve,
-		inputRequest: next.eve?.inputRequest ?? current?.eve?.inputRequest,
-		inputResponse: next.eve?.inputResponse ?? current?.eve?.inputResponse,
-		kind,
-		label: next.eve?.label ?? current?.eve?.label,
-		name
-	} };
-}
-function normalizeActionRequest(action) {
-	const name = actionRequestName(action);
-	switch (action.kind) {
-		case "load-skill": return {
-			kind: "load-skill",
-			name,
-			toolName: SKILL_TOOL_NAME
-		};
-		case "tool-call":
-		case "workflow-tool-call": return {
-			kind: "tool-call",
-			name,
-			toolName: name
-		};
-		case "subagent-call":
-		case "remote-agent-call": return {
-			kind: "subagent-call",
-			name,
-			toolName: `eve:subagent:${name}`
-		};
-	}
-}
-function normalizeActionResult(result) {
-	switch (result.kind) {
-		case "load-skill-result": return {
-			kind: "load-skill",
-			name: result.name,
-			toolName: SKILL_TOOL_NAME
-		};
-		case "tool-result": return {
-			kind: "tool-call",
-			name: result.toolName,
-			toolName: result.toolName
-		};
-		case "subagent-result": return {
-			kind: "subagent-call",
-			name: result.subagentName,
-			toolName: `eve:subagent:${result.subagentName}`
-		};
-	}
-}
-function settledLabel(current, label, descriptor) {
-	return label ?? current?.eve?.label ?? displayTitle(descriptor.name);
-}
-function stringifyUnknown(value) {
-	if (typeof value === "string") return value;
-	try {
-		return JSON.stringify(value);
-	} catch {
-		return "Action failed.";
-	}
-}
-
-//#endregion
-//#region src/client/message-reducer-primitives.ts
-function projectReceivedParts(parts, message) {
-	return parts?.map((part) => part.type === "text" ? {
-		state: "done",
-		text: part.text,
-		type: "text"
-	} : {
-		filename: part.filename,
-		mediaType: part.mediaType,
-		size: part.size,
-		type: "file",
-		url: part.url
-	}) ?? [{
-		state: "done",
-		text: message,
-		type: "text"
-	}];
-}
-function partKey(part) {
-	switch (part.type) {
-		case "text": return `text:${part.stepIndex ?? 0}`;
-		case "reasoning": return `reasoning:${part.stepIndex ?? 0}`;
-		case "file": return `file:${part.stepIndex ?? 0}:${part.filename ?? part.url ?? part.mediaType}`;
-		case "step-start": return "step-start";
-		case "authorization": return part.attemptId === void 0 ? `authorization:${part.turnId}:${part.stepIndex}:${part.name}` : `authorization:${part.attemptId}`;
-		case "dynamic-tool": return `dynamic-tool:${part.toolCallId}`;
-	}
-}
-function upsertMessage(data, next, beforeAssistantTurnId) {
-	const index = data.messages.findIndex((message) => message.id === next.id);
-	if (index !== -1) return {
-		...data,
-		messages: [
-			...data.messages.slice(0, index),
-			next,
-			...data.messages.slice(index + 1)
-		]
-	};
-	const before = beforeAssistantTurnId === void 0 ? -1 : data.messages.findIndex((message) => message.role === "assistant" && message.metadata?.turnId === beforeAssistantTurnId);
-	if (before === -1) return {
-		...data,
-		messages: [...data.messages, next]
-	};
-	return {
-		...data,
-		messages: [
-			...data.messages.slice(0, before),
-			next,
-			...data.messages.slice(before)
-		]
-	};
-}
-function optimisticUserMessageId(submissionId) {
-	return `optimistic:${submissionId}:user`;
-}
-
-//#endregion
-//#region src/client/message-run-parts.ts
-function transition(message, input) {
-	const index = message.parts.findLastIndex((part) => part.type === input.type && part.stepIndex === input.stepIndex);
-	const previous = index === -1 ? void 0 : message.parts[index];
-	if (input.kind === "append" && !input.delta) return message;
-	const current = previous?.state === "streaming" ? previous : void 0;
-	const part = {
-		id: current?.id ?? input.id ?? `${message.id}:${input.type}:${message.parts.length}`,
-		state: input.kind === "append" ? "streaming" : "done",
-		stepIndex: input.stepIndex,
-		text: input.kind === "append" ? (current?.text ?? "") + input.delta : input.text,
-		type: input.type
-	};
-	const parts = current ? [
-		...message.parts.slice(0, index),
-		part,
-		...message.parts.slice(index + 1)
-	] : [...message.parts, part];
-	return {
-		...message,
-		metadata: {
-			...message.metadata,
-			status: input.type === "text" && part.state === "done" ? "complete" : "streaming"
-		},
-		parts
-	};
-}
-const messageRun = { transition };
-
-//#endregion
-//#region src/shared/action-label.ts
-function actionLabel(action, presentation) {
-	return presentation?.[action.callId]?.label ?? displayTitle(actionRequestName(action));
-}
-
-//#endregion
-//#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"
-	};
-	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 {
-			...base,
-			approval: approvedTrue,
-			output: task?.output ?? content.output,
-			state: "output-available"
-		};
-		case "failed": return {
-			...base,
-			approval: approvedTrue,
-			errorText: task?.error?.message ?? content.errorText ?? call.error?.message ?? (call.taskId === void 0 ? "Action failed." : "Task failed."),
-			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"
-			};
-	}
-}
-
-//#endregion
-//#region src/client/message-reducer.ts
-function receivedMessageEventId(event) {
-	return event.meta.id ?? `${event.data.turnId}:${event.data.sequence}`;
-}
-function defaultMessageReducer() {
-	return {
-		initial() {
-			return withConversationProjection({ messages: [] }, initialSessionProjection());
-		},
-		reduce(data, event) {
-			return reduceMessageData(data, event);
-		}
-	};
-}
-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, {
-			id: optimisticUserMessageId(event.data.submissionId),
-			metadata: {
-				optimistic: true,
-				status: event.type === "client.message.failed" ? "failed" : "submitted"
-			},
-			parts: [{
-				type: "text",
-				text: event.data.message
-			}],
-			role: "user"
-		}, event.data.turnId);
-		case "message.received": return upsertMessage(data, {
-			id: `${receivedMessageEventId(event)}:user`,
-			metadata: {
-				status: "complete",
-				turnId: event.data.turnId
-			},
-			parts: projectReceivedParts(event.data.parts, event.data.message),
-			role: "user"
-		}, event.data.turnId);
-		case "history.imported": return importHistory(data, event);
-		case "step.started": return updateAssistantMessage(data, event.data.turnId, (message) => ensureStepStartPart(message, event.data.stepIndex));
-		case "step.completed":
-			if (data.messages.find((message) => message.role === "assistant" && message.metadata?.turnId === event.data.turnId) === void 0) return data;
-			return updateAssistantMessage(data, event.data.turnId, (message) => ({
-				...message,
-				parts: closeStreamingRuns(message.parts, event.data.stepIndex)
-			}));
-		case "reasoning.appended": return updateAssistantMessage(data, event.data.turnId, (message) => messageRun.transition(ensureStepStartPart(message, event.data.stepIndex), {
-			kind: "append",
-			delta: event.data.reasoningDelta,
-			id: event.meta?.id,
-			stepIndex: event.data.stepIndex,
-			type: "reasoning"
-		}));
-		case "reasoning.completed": return updateAssistantMessage(data, event.data.turnId, (message) => messageRun.transition(ensureStepStartPart(message, event.data.stepIndex), {
-			kind: "complete",
-			stepIndex: event.data.stepIndex,
-			text: event.data.reasoning,
-			id: event.meta?.id,
-			type: "reasoning"
-		}));
-		case "action.input.appended": {
-			const existing = findToolPart(data, event.data.callId);
-			if (existing !== void 0 && existing.state !== "input-streaming") return data;
-			const inputText = (existing?.state === "input-streaming" ? existing.inputText : "") + event.data.inputTextDelta;
-			return upsertToolPart(data, event.data.turnId, event.data.stepIndex, {
-				input: void 0,
-				inputText,
-				state: "input-streaming",
-				stepIndex: event.data.stepIndex,
-				toolCallId: event.data.callId,
-				toolMetadata: existing?.toolMetadata ?? { eve: {
-					kind: "unknown",
-					name: event.data.toolName
-				} },
-				toolName: event.data.toolName,
-				type: "dynamic-tool"
-			});
-		}
-		case "actions.requested": {
-			let next = data;
-			for (const action of event.data.actions) {
-				const existing = findToolPart(next, action.callId);
-				if (existing !== void 0 && existing.state !== "input-streaming") continue;
-				const descriptor = normalizeActionRequest(action);
-				next = updateAssistantMessage(next, event.data.turnId, (message) => upsertPart(ensureStepStartPart(message, event.data.stepIndex), {
-					input: "input" in action ? action.input : void 0,
-					state: "input-available",
-					stepIndex: event.data.stepIndex,
-					toolCallId: action.callId,
-					toolMetadata: createToolMetadata(descriptor, { label: actionLabel(action, event.data.presentation) }),
-					toolName: descriptor.toolName,
-					type: "dynamic-tool"
-				}));
-			}
-			return next;
-		}
-		case "input.requested": {
-			let next = data;
-			for (const request of event.data.requests) {
-				const existing = findToolPart(next, request.action.callId);
-				if (existing?.approval?.id === request.requestId || existing !== void 0 && isSettledToolPart(existing)) continue;
-				const descriptor = normalizeActionRequest(request.action);
-				next = updateAssistantMessage(next, event.data.turnId, (message) => upsertPart(ensureStepStartPart(message, event.data.stepIndex), {
-					...existing,
-					approval: { id: request.requestId },
-					input: request.action.input,
-					state: "approval-requested",
-					stepIndex: existing?.stepIndex ?? event.data.stepIndex,
-					toolCallId: request.action.callId,
-					toolMetadata: createToolMetadata(descriptor, {
-						inputRequest: toMessageInputRequest(request),
-						label: existing?.toolMetadata?.eve?.label ?? actionLabel(request.action, void 0)
-					}),
-					toolName: descriptor.toolName,
-					type: "dynamic-tool"
-				}));
-			}
-			return next;
-		}
-		case "action.result": {
-			if (conversationProjection(data).calls[event.data.result.callId]?.taskId !== void 0) return data;
-			if (event.data.error?.code === "MODEL_CALL_ATTEMPT_RETRIED") return updateAssistantMessage(data, event.data.turnId, (message) => ({
-				...message,
-				parts: message.parts.filter((part) => part.type !== "dynamic-tool" || part.toolCallId !== event.data.result.callId)
-			}));
-			const existing = findToolPart(data, event.data.result.callId);
-			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: existing?.stepIndex ?? event.data.stepIndex,
-				toolCallId: event.data.result.callId,
-				toolMetadata: mergeToolMetadata(existing?.toolMetadata, createToolMetadata(descriptor, { label: settledLabel(existing?.toolMetadata, event.data.presentation?.[event.data.result.callId]?.label, descriptor) })),
-				toolName: existing?.toolName ?? descriptor.toolName,
-				type: "dynamic-tool"
-			};
-			const outcome = succeeded ? {
-				errorText: void 0,
-				output: event.data.result.output
-			} : {
-				errorText: event.data.error?.message ?? stringifyUnknown(event.data.result.output),
-				output: void 0
-			};
-			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);
-			return upsertToolPart(data, event.data.turnId, event.data.stepIndex, {
-				...existing,
-				input: existing?.input,
-				output: event.data.result.output,
-				partial: true,
-				state: "output-available",
-				stepIndex: existing?.stepIndex ?? event.data.stepIndex,
-				toolCallId: event.data.result.callId,
-				toolMetadata: mergeToolMetadata(existing?.toolMetadata, createToolMetadata(descriptor, { label: settledLabel(existing?.toolMetadata, event.data.presentation?.[event.data.result.callId]?.label, descriptor) })),
-				toolName: existing?.toolName ?? descriptor.toolName,
-				type: "dynamic-tool"
-			});
-		}
-		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;
-			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);
-		case "message.appended": return updateAssistantMessage(data, event.data.turnId, (message) => messageRun.transition(ensureStepStartPart(message, event.data.stepIndex), {
-			kind: "append",
-			delta: event.data.messageDelta,
-			id: event.meta?.id,
-			stepIndex: event.data.stepIndex,
-			type: "text"
-		}));
-		case "message.completed": return updateAssistantMessage(data, event.data.turnId, (message) => messageRun.transition(ensureStepStartPart(message, event.data.stepIndex), {
-			kind: "complete",
-			stepIndex: event.data.stepIndex,
-			text: event.data.message,
-			id: event.meta?.id,
-			type: "text"
-		}));
-		case "result.completed": return updateAssistantMessage(data, event.data.turnId, (message) => ({
-			...message,
-			metadata: {
-				...message.metadata,
-				result: event.data.result
-			}
-		}));
-		case "turn.completed":
-		case "turn.cancelled":
-		case "turn.failed":
-			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: {
-					...message.metadata,
-					status: "complete"
-				},
-				parts: removeUnsettledToolParts(closeStreamingRuns(message.parts), conversationProjection(data))
-			}));
-		default: return data;
-	}
-}
-function importHistory(data, event) {
-	const eventId = event.meta.id ?? `${event.data.turnId}:${event.data.sequence}`;
-	const imported = event.data.messages.map((message, index) => ({
-		id: `${eventId}:imported:${index}`,
-		metadata: message.id === void 0 ? {
-			imported: true,
-			status: "complete"
-		} : {
-			historyId: message.id,
-			imported: true,
-			status: "complete"
-		},
-		parts: [message.role === "assistant" ? {
-			state: "done",
-			text: message.text,
-			type: "text"
-		} : {
-			text: message.text,
-			type: "text"
-		}],
-		role: message.role
-	}));
-	const ids = new Set(imported.map((message) => message.id));
-	const messages = data.messages.filter((message) => !ids.has(message.id));
-	const before = messages.findIndex((message) => message.metadata?.optimistic === true || message.role === "assistant" && message.metadata?.turnId === event.data.turnId);
-	const at = before === -1 ? messages.length : before;
-	return {
-		...data,
-		messages: [
-			...messages.slice(0, at),
-			...imported,
-			...messages.slice(at)
-		]
-	};
-}
-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,
-		state: "done"
-	} : part);
-}
-function removeUnsettledToolParts(parts, projection) {
-	return parts.filter((part) => {
-		if (part.type !== "dynamic-tool") return true;
-		if (part.state === "input-streaming") return false;
-		if (part.state !== "input-available") return true;
-		const call = projection.calls[part.toolCallId];
-		return call === void 0 || call.taskId !== void 0 || reportedCallStatus(projection, call) !== "running";
-	});
-}
-function updateAssistantMessage(data, turnId, update) {
-	const message = data.messages.find((message) => message.role === "assistant" && message.metadata?.turnId === turnId) ?? createAssistantMessage(turnId);
-	return upsertMessage(data, update(message));
-}
-function createAssistantMessage(turnId) {
-	return {
-		id: `${turnId}:assistant`,
-		metadata: {
-			status: "streaming",
-			turnId
-		},
-		parts: [],
-		role: "assistant"
-	};
-}
-function ensureStepStartPart(message, stepIndex) {
-	const stepStartCount = message.parts.filter((part) => part.type === "step-start").length;
-	if (stepStartCount > stepIndex) return message;
-	const missingCount = stepIndex - stepStartCount + 1;
-	return {
-		...message,
-		parts: [...message.parts, ...Array.from({ length: missingCount }, () => ({ type: "step-start" }))]
-	};
-}
-function upsertPart(message, next) {
-	const index = message.parts.findIndex((part) => partKey(part) === partKey(next));
-	const parts = index === -1 ? [...message.parts, next] : [
-		...message.parts.slice(0, index),
-		next,
-		...message.parts.slice(index + 1)
-	];
-	return {
-		...message,
-		metadata: {
-			...message.metadata,
-			status: next.type === "text" && next.state === "done" ? "complete" : "streaming"
-		},
-		parts
-	};
-}
-function upsertToolPart(data, turnId, stepIndex, part) {
-	const updated = updateToolPart(data, part.toolCallId, part);
-	return updated !== data ? updated : updateAssistantMessage(data, turnId, (message) => upsertPart(ensureStepStartPart(message, stepIndex), part));
-}
-function updateToolPart(data, toolCallId, next) {
-	const message = data.messages.find((candidate) => candidate.role === "assistant" && candidate.parts.some((part) => part.type === "dynamic-tool" && part.toolCallId === toolCallId));
-	if (!message) return data;
-	return upsertMessage(data, upsertPart(message, next));
-}
-function replaceToolPart(data, next) {
-	const message = data.messages.find((candidate) => candidate.parts.some((part) => part.type === "dynamic-tool" && part.toolCallId === next.toolCallId));
-	if (message === void 0) return data;
-	return upsertMessage(data, {
-		...message,
-		parts: message.parts.map((part) => partKey(part) === partKey(next) ? next : part)
-	});
-}
-function completeAuthorization(data, event) {
-	const existing = findPendingAuthorizationPart(data, event.data.name, event.data.attemptId);
-	const next = createAuthorizationCompletedPart(event, existing);
-	return updateAssistantMessage(data, existing?.turnId ?? event.data.turnId, (message) => upsertPart(ensureStepStartPart(message, next.stepIndex), next));
-}
-function findToolPart(data, toolCallId) {
-	for (const message of data.messages) for (const part of message.parts) if (part.type === "dynamic-tool" && part.toolCallId === toolCallId) return part;
-}
-function isSettledToolPart(part) {
-	return part.state === "output-denied" || part.state === "output-error" || part.state === "output-available" && part.partial !== true;
-}
-function findPendingAuthorizationPart(data, name, attemptId) {
-	for (let messageIndex = data.messages.length - 1; messageIndex >= 0; messageIndex -= 1) {
-		const message = data.messages[messageIndex];
-		if (message?.role !== "assistant") continue;
-		for (let partIndex = message.parts.length - 1; partIndex >= 0; partIndex -= 1) {
-			const part = message.parts[partIndex];
-			if (part?.type === "authorization" && part.state === "required" && (attemptId === void 0 ? part.attemptId === void 0 && part.name === name : part.attemptId === attemptId)) return part;
-		}
-	}
-}
-function findToolPartByApprovalId(data, approvalId) {
-	for (const message of data.messages) for (const part of message.parts) if (part.type === "dynamic-tool" && part.approval?.id === approvalId) return part;
-}
-
-//#endregion
-//#region src/client/conversation-reducer.ts
-function initialConversationState() {
-	return withConversationProjection({
-		turns: {},
-		inputs: {},
-		tasks: {},
-		messages: [],
-		agents: {}
-	}, initialSessionProjection());
-}
-function updateObservation(state, sessionId, update) {
-	const agent = state.agents[sessionId];
-	if (agent === void 0) return state;
-	const observation = update(agent.observation);
-	if (observation === agent.observation) return state;
-	return {
-		...state,
-		agents: {
-			...state.agents,
-			[sessionId]: {
-				...agent,
-				observation
-			}
-		}
-	};
-}
-function observedConversation(observation) {
-	return observation.status === "not-followed" ? void 0 : observation.conversation;
-}
-function reduceConversationLifecycle(state, event) {
-	switch (event.type) {
-		case "agent.started": {
-			const { callId, name, sessionId, taskId, turnId } = event.data;
-			if (state.agents[sessionId] !== void 0) return state;
-			const agent = {
-				sessionId,
-				name,
-				callId,
-				turnId,
-				observation: { status: "not-followed" }
-			};
-			if (taskId !== void 0) agent.taskId = taskId;
-			return withConversationProjection({
-				...state,
-				agents: {
-					...state.agents,
-					[sessionId]: agent
-				}
-			}, conversationProjection(state));
-		}
-		case "client.input.responded": {
-			const inputs = { ...state.inputs };
-			for (const response of event.data.responses) {
-				const current = inputs[response.requestId];
-				if (current?.status !== "open") continue;
-				inputs[response.requestId] = {
-					...current,
-					response,
-					status: "responded"
-				};
-			}
-			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,
-					response,
-					status: "responded"
-				};
-			}
-			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",
-			conversation: observedConversation(observation) ?? initialConversationState()
-		});
-		case "client.agent.observed": return updateObservation(state, event.data.sessionId, (observation) => observation.status === "following" ? {
-			status: "following",
-			conversation: reduceConversation(observation.conversation, event.data.event)
-		} : observation);
-		case "client.agent.idle": return updateObservation(state, event.data.sessionId, (observation) => observation.status === "following" ? {
-			status: "idle",
-			conversation: observation.conversation
-		} : observation);
-		case "client.agent.unavailable": return updateObservation(state, event.data.sessionId, (observation) => {
-			const conversation = observedConversation(observation);
-			return conversation === void 0 ? { status: "unavailable" } : {
-				status: "unavailable",
-				conversation
-			};
-		});
-		default:
-			const 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 = {
-	initial: initialConversationState,
-	reduce: reduceConversation
-};
-const conversationReducer = canonicalConversationReducer;
-
-//#endregion
-//#region src/protocol/event-dedupe.ts
-function createEventDeduper() {
-	const seen = /* @__PURE__ */ new Set();
-	return {
-		admit(event) {
-			const id = event.meta?.id;
-			if (id === void 0) return true;
-			if (seen.has(id)) return false;
-			seen.add(id);
-			return true;
-		},
-		get size() {
-			return seen.size;
-		}
-	};
-}
-
-//#endregion
-//#region src/client/session-event-stream.ts
-var SessionEventStream = class {
-	#controller = new AbortController();
-	#readers = /* @__PURE__ */ new Set();
-	#caughtUp = Promise.withResolvers();
-	caughtUp = this.#caughtUp.promise;
-	#ended = false;
-	#error;
-	#headers;
-	#reconnectPolicy;
-	constructor(session, options) {
-		this.setOptions(options);
-		this.caughtUp.catch(() => {});
-		if (!options.catchUp) this.#caughtUp.resolve();
-		(async () => {
-			try {
-				for await (const event of followClientSession(session, {
-					signal: this.#controller.signal,
-					resolveHeaders: () => this.#headers,
-					resolveReconnectPolicy: () => this.#reconnectPolicy,
-					startIndex: options.startIndex,
-					onCaughtUp: options.catchUp ? () => this.#caughtUp.resolve() : void 0
-				})) {
-					if (this.#controller.signal.aborted) return;
-					options.onEvent(event);
-					for (const reader of this.#readers) reader.push(event);
-					if (event.type === "session.completed" || event.type === "session.failed") break;
-				}
-				this.#caughtUp.resolve();
-				this.#finish();
-			} catch (error) {
-				this.#caughtUp.reject(error);
-				this.#finish(error);
-				if (!this.#controller.signal.aborted) options.onError(error);
-			}
-		})();
-	}
-	subscribe(signal) {
-		const reader = new SessionEventReader(() => this.#readers.delete(reader), signal);
-		if (this.#ended) reader.end(this.#error);
-		else this.#readers.add(reader);
-		return reader;
-	}
-	get ended() {
-		return this.#ended;
-	}
-	setOptions(options) {
-		if ("headers" in options) this.#headers = options.headers;
-		if ("streamReconnectPolicy" in options) this.#reconnectPolicy = options.streamReconnectPolicy;
-	}
-	close() {
-		const error = new DOMException("Session stream was detached.", "AbortError");
-		this.#controller.abort(error);
-		this.#caughtUp.reject(error);
-		this.#finish(error);
-	}
-	#finish(error) {
-		if (this.#ended) return;
-		this.#ended = true;
-		this.#error = error;
-		for (const reader of this.#readers) reader.end(error);
-	}
-};
-var SessionEventReader = class {
-	#events = [];
-	#wake = Promise.withResolvers();
-	#ended = false;
-	#error;
-	#dispose;
-	constructor(unsubscribe, signal) {
-		const abort = () => this.end(signal?.reason);
-		signal?.addEventListener("abort", abort, { once: true });
-		this.#dispose = () => {
-			signal?.removeEventListener("abort", abort);
-			unsubscribe();
-		};
-		if (signal?.aborted) abort();
-	}
-	push(event) {
-		if (this.#ended) return;
-		this.#events.push(event);
-		this.#wake.resolve();
-	}
-	end(error) {
-		if (this.#ended) return;
-		this.#ended = true;
-		this.#error = error;
-		this.#wake.resolve();
-	}
-	[Symbol.dispose]() {
-		this.end();
-		this.#events = [];
-		this.#dispose();
-	}
-	discard() {
-		this.#events = [];
-	}
-	async *[Symbol.asyncIterator]() {
-		for (;;) {
-			while (this.#events.length > 0) yield this.#events.shift();
-			if (this.#ended) {
-				if (this.#error !== void 0) throw this.#error;
-				return;
-			}
-			this.#wake = Promise.withResolvers();
-			await this.#wake.promise;
-		}
-	}
-};
-
-//#endregion
-//#region src/client/conversation-client.ts
-var ConversationClient = class {
-	projection;
-	#conversation;
-	#cursors = /* @__PURE__ */ new Map();
-	#seenEvents = createEventDeduper();
-	#follower;
-	#stream;
-	#onChange;
-	#onConversationChange;
-	constructor(projection, onChange, onConversationChange) {
-		this.projection = projection;
-		this.#conversation = projection.reducer === conversationReducer ? projection : new EveAgentProjection(canonicalConversationReducer, []);
-		this.#onChange = onChange;
-		this.#onConversationChange = onConversationChange;
-	}
-	get data() {
-		return this.projection.data;
-	}
-	get conversation() {
-		return this.#conversation.data;
-	}
-	get projections() {
-		return this.#conversation === this.projection ? [this.projection] : [this.#conversation, this.projection];
-	}
-	get following() {
-		return this.#follower !== void 0;
-	}
-	append(event) {
-		const previous = this.data;
-		const previousConversation = this.conversation;
-		this.#appendRoot(event);
-		if (previous !== this.data) this.#onChange(this.data, previous);
-		else if (previousConversation !== this.conversation) this.#onConversationChange?.(this.conversation, previousConversation);
-	}
-	projectResponses(responses) {
-		if (!responses?.length) return void 0;
-		const event = {
-			data: {
-				createdAt: Date.now(),
-				responses
-			},
-			type: "client.input.responded"
-		};
-		this.append(event);
-		return () => this.#retract(event);
-	}
-	replaceResponses(retract, input) {
-		retract?.();
-		assertAnswerable(input, this.conversation);
-		return this.projectResponses(input.inputResponses);
-	}
-	#retract(event) {
-		const previous = this.data;
-		const previousConversation = this.conversation;
-		for (const projection of this.projections) projection.remove((entry) => entry === event);
-		if (previous !== this.data) this.#onChange(this.data, previous);
-		else if (previousConversation !== this.conversation) this.#onConversationChange?.(this.conversation, previousConversation);
-	}
-	observe(event, options = {}) {
-		if (!this.#seenEvents.admit(event)) return false;
-		options.onAccepted?.(event);
-		const previous = this.data;
-		const previousConversation = this.conversation;
-		if (options.project) options.project(event);
-		else this.#appendRoot(event);
-		if (options.notify !== false) {
-			if (previous !== this.data) this.#onChange(this.data, previous);
-			else if (previousConversation !== this.conversation) this.#onConversationChange?.(this.conversation, previousConversation);
-		}
-		this.#follower?.acceptParentEvent(event);
-		this.#follower?.reconcile();
-		return true;
-	}
-	hydrate(event) {
-		if (!this.#seenEvents.admit(event)) return false;
-		this.#appendRoot(event);
-		return true;
-	}
-	follow(session, events = []) {
-		this.#follower?.abortAll();
-		const follower = new AgentStreamFollower({
-			session,
-			cursors: this.#cursors,
-			getState: () => this.conversation,
-			onFollowing: (sessionId) => this.#appendChild({
-				type: "client.agent.following",
-				data: { sessionId }
-			}),
-			onEvent: (sessionId, event) => this.#appendChild({
-				type: "client.agent.observed",
-				data: {
-					sessionId,
-					event
-				}
-			}),
-			onIdle: (sessionId) => this.#appendChild({
-				type: "client.agent.idle",
-				data: { sessionId }
-			}),
-			onUnavailable: (sessionId) => this.#appendChild({
-				type: "client.agent.unavailable",
-				data: { sessionId }
-			})
-		});
-		this.#follower = follower;
-		for (const event of events) follower.acceptParentEvent(event);
-		follower.reconcile();
-	}
-	#appendRoot(event) {
-		for (const projection of this.projections) projection.append(event);
-	}
-	#appendChild(event) {
-		const previous = this.data;
-		const previousConversation = this.conversation;
-		this.#conversation.append(event);
-		if (previous !== this.data) this.#onChange(this.data, previous);
-		else if (previousConversation !== this.conversation) this.#onConversationChange?.(this.conversation, previousConversation);
-	}
-	stream(session, options) {
-		if (this.#stream !== void 0 && !this.#stream.ended) {
-			this.#stream.setOptions(options);
-			return this.#stream;
-		}
-		this.#stream = new SessionEventStream(session, options);
-		return this.#stream;
-	}
-	closeStream() {
-		this.#stream?.close();
-		this.#stream = void 0;
-	}
-	stop() {
-		this.#follower?.abortAll();
-		this.#follower = void 0;
-		this.closeStream();
-	}
-	reset() {
-		this.stop();
-		this.#cursors.clear();
-		this.#seenEvents = createEventDeduper();
-		for (const projection of this.projections) projection.reset();
-	}
-};
-
-//#endregion
-//#region src/client/session-turn-dispatch.ts
-async function dispatchSessionTurn(input) {
-	const { client, session, turn, beforeSend } = input;
-	if (session === void 0) {
-		if (client === void 0) throw new Error("An external eve session is required before sending.");
-		if (turn.message === void 0) throw new Error("Cannot answer an input request before the session starts.");
-		const created = await client.sessions.create({
-			...turn,
-			message: turn.message
-		});
-		throwIfAborted(turn.signal);
-		return {
-			...created,
-			created: true
-		};
-	}
-	beforeSend?.();
-	if (turn.inputResponses === void 0) {
-		const { message, ...options } = turn;
-		return {
-			session,
-			response: await session.send(message, options),
-			created: false
-		};
-	}
-	const { inputResponses, ...options } = turn;
-	return {
-		session,
-		response: await session.respond(inputResponses, options),
-		created: false
-	};
-}
-
-//#endregion
-//#region src/client/eve-agent-store.ts
-const detachStore = Symbol("detachEveAgentStore");
-const attachStore = Symbol("attachEveAgentStore");
-var EveAgentStore = class {
-	#client;
-	#autoPrewarm;
-	#attached = false;
-	#conversationClient;
-	#followChildStreams;
-	#followIdle;
-	#externalSession;
-	#subscribers = /* @__PURE__ */ new Set();
-	#activeTurn;
-	#callbacks = {};
-	#error;
-	#events;
-	#messageSubmissions;
-	#prewarmGeneration = 0;
-	#prewarmPromise;
-	#prewarmController;
-	#resumePromise;
-	#session;
-	#snapshot;
-	#status = "ready";
-	constructor(init) {
-		this.#autoPrewarm = init.prewarm ?? false;
-		this.#followChildStreams = init.followSubagents ?? false;
-		this.#followIdle = init.followIdle ?? true;
-		this.#externalSession = init.session !== void 0;
-		this.#client = this.#externalSession ? void 0 : init.client ?? new Client({
-			auth: init.auth,
-			headers: init.headers,
-			host: init.host ?? ""
-		});
-		this.#conversationClient = new ConversationClient(new EveAgentProjection(init.reducer, []), () => this.#publish(), () => this.#publish());
-		this.#events = (init.initialEvents ?? []).filter((event) => this.#conversationClient.hydrate(event));
-		this.#messageSubmissions = new OptimisticMessageSubmissions(this.#conversationClient.projections, init.optimistic ?? true);
-		this.#session = init.session ?? (init.initialSession === void 0 ? void 0 : this.#client?.sessions.attach(init.initialSession.sessionId, { streamIndex: init.initialSession.streamIndex }));
-		this.#snapshot = this.#createSnapshot();
-	}
-	get snapshot() {
-		return this.#snapshot;
-	}
-	setCallbacks(callbacks) {
-		this.#callbacks = callbacks;
-	}
-	subscribe(callback) {
-		this.#subscribers.add(callback);
-		return () => void this.#subscribers.delete(callback);
-	}
-	prewarm() {
-		if (this.#prewarmPromise !== void 0) return this.#prewarmPromise;
-		if (this.#session === void 0 && this.#externalSession) return Promise.resolve();
-		if (this.#activeTurn !== void 0 && this.#session === void 0) return this.#activeTurn.response.then((response) => {
-			if (response === void 0) throw this.#error ?? new DOMException("Session creation was aborted.", "AbortError");
-		});
-		const client = this.#client;
-		const session = this.#session;
-		if (client === void 0 && session === void 0) return Promise.reject(/* @__PURE__ */ new Error("This eve agent store does not own a session client."));
-		const generation = this.#prewarmGeneration;
-		const controller = new AbortController();
-		this.#prewarmController = controller;
-		const promise = (async () => {
-			try {
-				if (session !== void 0) {
-					await session.prewarm({ signal: controller.signal });
-					return;
-				}
-				const created = await client.sessions.create({ signal: controller.signal });
-				if (generation !== this.#prewarmGeneration) return;
-				this.#error = void 0;
-				if (this.#status === "error") this.#status = "ready";
-				this.#adoptSession(created.session);
-				if (this.#followIdle) this.#ensureStream();
-			} catch (error) {
-				if (session === void 0 && generation === this.#prewarmGeneration && this.#activeTurn === void 0 && this.#error === void 0) this.#fail(error);
-				throw error;
-			}
-		})();
-		this.#prewarmPromise = promise;
-		const clear = () => {
-			if (this.#prewarmPromise === promise) {
-				this.#prewarmPromise = void 0;
-				this.#prewarmController = void 0;
-			}
-		};
-		promise.then(clear, clear);
-		return promise;
-	}
-	async send(input) {
-		return await this.#submit(input, this.#callbacks.prepareSend);
-	}
-	async #submit(input, prepareSend) {
-		assertAnswerable(input, this.#conversationClient.conversation);
-		if (this.#activeTurn !== void 0) {
-			if (this.#status === "resuming") throw new Error("eve session is resuming.");
-			return await this.#sendFollowUp(this.#activeTurn, input, prepareSend);
-		}
-		const turn = createActiveTurn((turn) => turn.acceptedFollowUps > 0 && this.#session !== void 0 ? this.#session.cancel() : turn.response.then((response) => response === void 0 ? { status: "no_active_turn" } : response.cancel()));
-		this.#activeTurn = turn;
-		this.#error = void 0;
-		this.#status = "submitted";
-		let reader;
-		let submissionId;
-		let retractResponses;
-		try {
-			assertExclusiveTurnInput(input);
-			submissionId = this.#messageSubmissions.submit(input, this.#events.length);
-			retractResponses = this.#conversationClient.projectResponses(input.inputResponses);
-			this.#publish();
-			const preparedInput = await (prepareSend === void 0 ? input : waitWithSignal(Promise.resolve(prepareSend(input)), createAbortSignal(input.signal, turn.abortController.signal)));
-			assertExclusiveTurnInput(preparedInput);
-			if (!this.#isActiveTurn(turn)) return;
-			if (preparedInput !== input) {
-				submissionId = this.#messageSubmissions.resubmit(submissionId, preparedInput);
-				retractResponses = this.#conversationClient.replaceResponses(retractResponses, preparedInput);
-				this.#publish();
-			}
-			const turnInput = {
-				...preparedInput,
-				signal: createAbortSignal(preparedInput.signal, turn.abortController.signal)
-			};
-			const dispatched = await this.#dispatchTurn(turnInput);
-			retractResponses = void 0;
-			const response = dispatched.response;
-			reader = dispatched.reader;
-			if (!this.#isActiveTurn(turn)) return;
-			turn.resolveResponse(response);
-			this.#correlate(submissionId, response);
-			for await (const event of consumeMessageResponse(response, reader)) {
-				if (!this.#isActiveTurn(turn)) return;
-				turn.receivedFollowUps += turn.receivedFollowUpEvents.get(event) ?? 0;
-				turn.receivedFollowUpEvents.delete(event);
-			}
-			if (!this.#isActiveTurn(turn)) return;
-			await followSteeredTurns(turn, reader, () => this.#isActiveTurn(turn));
-			if (!this.#isActiveTurn(turn)) return;
-			this.#status = settledStatus(this.#error, this.#conversationClient.conversation);
-		} catch (error) {
-			if (!this.#isActiveTurn(turn)) return;
-			retractResponses?.();
-			if (isAbortError(error)) {
-				this.#status = "ready";
-				this.#messageSubmissions.fail(toError(error), submissionId);
-			} else {
-				const reported = this.#error !== void 0;
-				this.#error ??= toError(error);
-				this.#status = "error";
-				this.#messageSubmissions.fail(this.#error, submissionId);
-				if (!reported) this.#callbacks.onError?.(this.#error);
-			}
-		} finally {
-			reader?.[Symbol.dispose]();
-			this.#finishTurn(turn);
-		}
-	}
-	resume() {
-		if (this.#resumePromise !== void 0) return this.#resumePromise;
-		const promise = this.#resume();
-		this.#resumePromise = promise;
-		const clear = () => {
-			if (this.#resumePromise === promise) this.#resumePromise = void 0;
-		};
-		promise.then(clear, clear);
-		return promise;
-	}
-	async #resume() {
-		if (this.#status !== "ready" && this.#status !== "error") throw new Error("eve session is already processing a turn.");
-		if (this.#session === void 0) throw new Error("An eve session is required before resuming.");
-		const session = this.#session;
-		const turn = createActiveTurn(() => session.cancel());
-		this.#activeTurn = turn;
-		turn.resolveResponse(void 0);
-		this.#error = void 0;
-		this.#status = "resuming";
-		this.#publish();
-		let reader;
-		try {
-			const stream = this.#ensureStream({
-				catchUp: true,
-				startIndex: this.#events.length === session.state.streamIndex ? session.state.streamIndex : 0
-			});
-			reader = stream.subscribe(turn.abortController.signal);
-			await stream.caughtUp;
-			if (!this.#isActiveTurn(turn)) return;
-			reader.discard();
-			const tail = this.#events.at(-1);
-			if (tail !== void 0) this.#applyTerminalStreamFailure(tail);
-			if (tail && !this.#error && !isSettledSessionTail(this.#events, this.#conversationClient.conversation)) {
-				this.#status = "streaming";
-				this.#publish();
-				for await (const event of reader) {
-					if (!this.#isActiveTurn(turn)) return;
-					turn.receivedFollowUps += turn.receivedFollowUpEvents.get(event) ?? 0;
-					turn.receivedFollowUpEvents.delete(event);
-					if (isResponseBoundary(event, this.#conversationClient.conversation)) break;
-				}
-			}
-			await followSteeredTurns(turn, reader, () => this.#isActiveTurn(turn));
-			if (this.#isActiveTurn(turn)) this.#status = settledStatus(this.#error, this.#conversationClient.conversation);
-		} catch (error) {
-			if (!this.#isActiveTurn(turn)) return;
-			if (isAbortError(error)) this.#status = "ready";
-			else {
-				this.#error = toError(error);
-				this.#status = "error";
-				this.#callbacks.onError?.(this.#error);
-			}
-		} finally {
-			reader?.[Symbol.dispose]();
-			this.#finishTurn(turn);
-		}
-	}
-	cancel() {
-		const turn = this.#activeTurn;
-		if (turn === void 0) return this.#status === "streaming" && this.#session !== void 0 ? this.#session.cancel() : Promise.resolve({ status: "no_active_turn" });
-		return turn.cancel();
-	}
-	async compact() {
-		return await this.#session?.compact() ?? { status: "no_active_session" };
-	}
-	async clear() {
-		return await this.#session?.clear() ?? { status: "no_active_session" };
-	}
-	async retire() {
-		if (this.#externalSession) throw new Error("retire() needs a store-owned session. Call reset() on the session you supplied, then create a new store for the next session.");
-		const result = await this.#session?.reset() ?? { status: "no_active_session" };
-		this.reset();
-		return result;
-	}
-	[attachStore]() {
-		this.#attached = true;
-		if (this.#followChildStreams && !this.#conversationClient.following) this.#followSubagents();
-		if (this.#autoPrewarm && this.#session === void 0) this.prewarm().catch(() => {});
-	}
-	[detachStore]() {
-		this.#attached = false;
-		this.#conversationClient.stop();
-		this.#activeTurn?.abortController.abort();
-		this.#resetPrewarm();
-		this.#resumePromise = void 0;
-	}
-	reset() {
-		this.#conversationClient.stop();
-		const turn = this.#activeTurn;
-		this.#activeTurn = void 0;
-		turn?.resolveResponse(void 0);
-		turn?.resolveCompletion();
-		turn?.abortController.abort();
-		this.#resetPrewarm();
-		this.#resumePromise = void 0;
-		if (!this.#externalSession) this.#session = void 0;
-		this.#events = [];
-		this.#conversationClient.reset();
-		this.#messageSubmissions.reset();
-		if (this.#followChildStreams && this.#attached) this.#followSubagents();
-		this.#error = void 0;
-		this.#status = "ready";
-		this.#callbacks.onSessionChange?.(this.#session?.state);
-		this.#publish();
-		if (this.#autoPrewarm && this.#attached) this.prewarm().catch(() => {});
-	}
-	async #sendFollowUp(turn, input, prepareSend) {
-		assertInFlightFollowUp(input);
-		const generation = this.#prewarmGeneration;
-		const signal = createAbortSignal(input.signal, turn.abortController.signal);
-		let retractResponses = this.#conversationClient.projectResponses(input.inputResponses);
-		const preparedInput = await waitWithSignal(Promise.resolve(prepareSend?.(input)), signal).then((prepared) => {
-			const next = validateFollowUp(prepared ?? input);
-			if (next === input) return next;
-			retractResponses = this.#conversationClient.replaceResponses(retractResponses, next);
-			return next;
-		}).catch((error) => {
-			retractResponses?.();
-			throw error;
-		});
-		if (generation !== this.#prewarmGeneration) return;
-		if (!this.#isActiveTurn(turn)) {
-			retractResponses?.();
-			return await this.#submit(preparedInput);
-		}
-		const submissionId = this.#messageSubmissions.submit(preparedInput, this.#events.length, activeTurnForOptimisticFollowUp(this.#events));
-		if (submissionId !== void 0) turn.followUpSubmissionIds.add(submissionId);
-		this.#publish();
-		let dispatch;
-		dispatch = (async () => {
-			try {
-				const signal = createAbortSignal(preparedInput.signal, turn.abortController.signal);
-				await waitWithSignal(turn.response, signal);
-				if (!this.#isActiveTurn(turn) || this.#session === void 0) throw new Error("The active eve turn ended before the follow-up could be sent.");
-				this.#ensureStream({
-					headers: preparedInput.headers,
-					streamReconnectPolicy: preparedInput.streamReconnectPolicy
-				});
-				const response = (await dispatchSessionTurn({
-					session: this.#session,
-					turn: {
-						...preparedInput,
-						signal
-					}
-				})).response;
-				retractResponses = void 0;
-				if (preparedInput.message === void 0) return;
-				turn.acceptedFollowUps += 1;
-				this.#correlate(submissionId, response);
-			} catch (error) {
-				if (this.#isActiveTurn(turn)) {
-					this.#messageSubmissions.fail(toError(error), submissionId);
-					retractResponses?.();
-					this.#publish();
-				}
-				throw error;
-			} finally {
-				turn.followUpDispatches.delete(dispatch);
-			}
-		})();
-		turn.followUpDispatches.add(dispatch);
-		await dispatch;
-		await turn.completion;
-	}
-	async #dispatchTurn(input) {
-		const streamOptions = {
-			headers: input.headers,
-			streamReconnectPolicy: input.streamReconnectPolicy
-		};
-		if (this.#session === void 0 && this.#prewarmPromise !== void 0) {
-			await waitWithSignal(this.#prewarmPromise.catch((error) => {
-				if (this.#session !== void 0) throw error;
-			}), input.signal);
-			throwIfAborted(input.signal);
-		}
-		const session = this.#session;
-		let reader;
-		try {
-			const dispatched = await dispatchSessionTurn({
-				client: this.#client,
-				session,
-				turn: input,
-				beforeSend: () => {
-					reader = this.#ensureStream(streamOptions).subscribe(input.signal);
-				}
-			});
-			if (dispatched.created) {
-				this.#adoptSession(dispatched.session);
-				reader = this.#ensureStream(streamOptions).subscribe(input.signal);
-			}
-			return {
-				response: dispatched.response,
-				reader
-			};
-		} catch (error) {
-			reader?.[Symbol.dispose]();
-			throw error;
-		}
-	}
-	#ensureStream(options = {}) {
-		if (this.#session === void 0) throw new Error("A session is required before opening its stream.");
-		const generation = this.#prewarmGeneration;
-		if (this.#followChildStreams && !this.#conversationClient.following) this.#followSubagents();
-		return this.#conversationClient.stream(this.#session, {
-			...options,
-			onEvent: (event) => {
-				if (generation === this.#prewarmGeneration) this.#acceptServerEvent(event);
-			},
-			onError: (error) => {
-				if (generation !== this.#prewarmGeneration || this.#activeTurn !== void 0) return;
-				this.#fail(error);
-			}
-		});
-	}
-	#adoptSession(session) {
-		this.#session = session;
-		if (this.#followChildStreams && this.#attached) this.#followSubagents();
-		this.#callbacks.onSessionChange?.(session.state);
-		this.#publish();
-	}
-	#fail(error) {
-		this.#error = toError(error);
-		this.#status = "error";
-		this.#callbacks.onError?.(this.#error);
-		this.#publish();
-	}
-	#followSubagents() {
-		if (this.#session) this.#conversationClient.follow(this.#session, this.#events);
-	}
-	#resetPrewarm() {
-		this.#prewarmGeneration += 1;
-		this.#prewarmController?.abort();
-		this.#prewarmController = void 0;
-		this.#prewarmPromise = void 0;
-	}
-	#finishTurn(turn) {
-		if (!this.#isActiveTurn(turn)) return;
-		turn.resolveResponse(void 0);
-		this.#activeTurn = void 0;
-		this.#closeStreamWhenIdle();
-		try {
-			this.#callbacks.onSessionChange?.(this.#session?.state);
-			this.#publish();
-			this.#callbacks.onFinish?.(this.#snapshot);
-		} finally {
-			turn.resolveCompletion();
-		}
-	}
-	#isActiveTurn(turn) {
-		return this.#activeTurn === turn;
-	}
-	#acceptServerEvent(event) {
-		const wasStreaming = this.#status === "streaming";
-		if (!this.#conversationClient.observe(event, {
-			onAccepted: () => {
-				this.#events = [...this.#events, event];
-			},
-			project: (accepted) => {
-				this.#handleReconciliation(this.#messageSubmissions.apply(accepted));
-			},
-			notify: false
-		})) return false;
-		this.#callbacks.onEvent?.(event);
-		this.#applyTerminalStreamFailure(event);
-		const { conversation } = this.#conversationClient;
-		const settled = isSettledSessionTail(this.#events, conversation) && conversation.activeTurnId === void 0;
-		if (this.#status !== "resuming" && this.#error === void 0) {
-			if ("data" in event && event.data !== void 0 && "turnId" in event.data) this.#status = "streaming";
-			if (this.#activeTurn === void 0 && settled) this.#status = "ready";
-		}
-		this.#callbacks.onSessionChange?.(this.#session?.state);
-		if (this.#status !== "resuming") this.#publish();
-		if (this.#activeTurn === void 0 && wasStreaming && settled) this.#callbacks.onFinish?.(this.#snapshot);
-		if (this.#activeTurn === void 0) this.#closeStreamWhenIdle();
-		return true;
-	}
-	#closeStreamWhenIdle() {
-		if (this.#followIdle) return;
-		const { conversation } = this.#conversationClient;
-		if (conversation.activeTurnId !== void 0) return;
-		if (this.#events.length > 0 && !isSettledSessionTail(this.#events, conversation)) return;
-		if (!Object.values(conversation.tasks).some((task) => Object.values(task.calls).some((call) => call.status === "working"))) this.#conversationClient.closeStream();
-	}
-	#correlate(submissionId, response) {
-		const deliveryId = getMessageResponseDeliveryId(response);
-		const reconciled = this.#messageSubmissions.correlate(submissionId, deliveryId, this.#events);
-		if (this.#handleReconciliation(reconciled)) this.#publish();
-	}
-	#handleReconciliation(reconciliation) {
-		if (reconciliation === void 0) return false;
-		if (this.#activeTurn !== void 0) countFollowUpDeliveries(this.#activeTurn, reconciliation);
-		return true;
-	}
-	#applyTerminalStreamFailure(event) {
-		const error = toTerminalStreamFailureError(event);
-		if (error === void 0) return;
-		this.#status = "error";
-		this.#messageSubmissions.failAll(error);
-		if (this.#error === void 0) {
-			this.#error = error;
-			this.#callbacks.onError?.(error);
-		}
-	}
-	#createSnapshot() {
-		return {
-			data: this.#conversationClient.data,
-			conversation: this.#conversationClient.conversation,
-			error: this.#error,
-			events: this.#events,
-			session: this.#session?.state,
-			status: this.#status
-		};
-	}
-	#publish() {
-		this.#snapshot = this.#createSnapshot();
-		for (const subscriber of this.#subscribers) subscriber();
-	}
-};
-function detachEveAgentStore(store) {
-	store[detachStore]();
-}
-function attachEveAgentStore(store) {
-	store[attachStore]();
-}
-
-//#endregion
-//#region src/client/agent-host.ts
-const AGENT_NAME_PATTERN = /^[a-z0-9][a-z0-9_-]*$/;
-const EVE_NAMED_AGENT_ROUTE_PREFIX = "/eve";
-function resolveEveAgentHost(input) {
-	if (input.agent === void 0) return input.host ?? "";
-	if (input.host !== void 0) throw new Error("useEveAgent cannot combine agent and host. Use one target option.");
-	assertValidAgentName(input.agent);
-	return `${EVE_NAMED_AGENT_ROUTE_PREFIX}/${input.agent}`;
-}
-function assertValidAgentName(name) {
-	if (!AGENT_NAME_PATTERN.test(name)) throw new Error(`eve agent name ${JSON.stringify(name)} is invalid. Use lowercase letters, numbers, underscores, or hyphens, starting with a letter or number.`);
-}
-
-//#endregion
-//#region src/vue/use-eve-agent.ts
-function useEveAgent(options = {}) {
-	if (options.resume && options.initialSession === void 0 && options.session === void 0) throw new Error("useEveAgent({ resume: true }) requires initialSession or session.");
-	const reducer = options.reducer ?? conversationReducer;
-	const store = new EveAgentStore({
-		auth: options.auth,
-		headers: options.headers,
-		host: resolveEveAgentHost({
-			agent: options.agent,
-			host: options.host
-		}),
-		initialEvents: options.initialEvents,
-		initialSession: options.initialSession,
-		optimistic: options.optimistic,
-		followSubagents: options.followSubagents,
-		followIdle: options.followIdle,
-		prewarm: options.prewarm,
-		reducer,
-		session: options.session
-	});
-	store.setCallbacks({
-		onError: options.onError,
-		onEvent: options.onEvent,
-		onFinish: options.onFinish,
-		onSessionChange: options.onSessionChange,
-		prepareSend: options.prepareSend
-	});
-	const snapshot = shallowRef(store.snapshot);
-	if ("window" in globalThis) {
-		const unsubscribe = store.subscribe(() => {
-			snapshot.value = store.snapshot;
-		});
-		attachEveAgentStore(store);
-		if (options.resume) store.resume();
-		onScopeDispose(() => {
-			unsubscribe();
-			detachEveAgentStore(store);
-		});
-	}
-	return {
-		cancel: () => store.cancel(),
-		data: computed(() => snapshot.value.data),
-		conversation: computed(() => snapshot.value.conversation),
-		error: computed(() => snapshot.value.error),
-		events: computed(() => snapshot.value.events),
-		prewarm: () => store.prewarm(),
-		reset: () => store.reset(),
-		respond: (inputResponses, options) => store.send({
-			...options,
-			inputResponses
-		}),
-		resume: () => store.resume(),
-		send: (message, options) => store.send({
-			...options,
-			message
-		}),
-		session: computed(() => snapshot.value.session),
-		status: computed(() => snapshot.value.status)
-	};
-}
-
-//#endregion
-export { conversationProjection as a, openConversationInputs as i, conversationReducer as n, callStatus as o, defaultMessageReducer as r, useEveAgent as t };