eve 0.67.2 → 0.69.0

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

@@ -1,6 +1,6 @@
 import { computed, onScopeDispose, shallowRef } from "vue";
 import { z } from "#compiled/zod/index.js";
-import { asSchema } from "ai";
+import "ai";
 import { Validator } from "#compiled/@cfworker/json-schema/index.js";
 
 //#region src/protocol/routes.ts
@@ -23,8 +23,6 @@ const EVE_DEV_RUNTIME_ARTIFACTS_SUSPEND_ROUTE_PATH = `${EVE_DEV_RUNTIME_ARTIFACT
 const EVE_DEV_RUNTIME_ARTIFACTS_RESUME_ROUTE_PATH = `${EVE_DEV_RUNTIME_ARTIFACTS_ROUTE_PATH}/resume`;
 const EVE_CONNECTION_CALLBACK_ROUTE_PATTERN = `${EVE_ROUTE_PREFIX}/connections/:name/callback/:attemptId/:token`;
 const EVE_CALLBACK_ROUTE_PATTERN = `${EVE_ROUTE_PREFIX}/callback/:token`;
-const EVE_TASK_INPUT_ROUTE_PATTERN = `${EVE_ROUTE_PREFIX}/task-input/:token`;
-const EVE_ACTIVITY_ROUTE_PATTERN = `${EVE_ROUTE_PREFIX}/activity/:token`;
 function createEveSessionRoutePath(sessionId) {
 	return `${EVE_SESSION_ROUTE_PATH}/${encodeURIComponent(sessionId)}`;
 }
@@ -84,6 +82,10 @@ function encodeBasicCredentials(username, password) {
 	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", [
@@ -94,6 +96,7 @@ const owner = z.discriminatedUnion("kind", [
 	}).strict(),
 	z.object({
 		kind: z.literal("extension"),
+		mountId: mountIdSchema.optional(),
 		namespace: z.string(),
 		packageName: z.string()
 	}).strict()
@@ -105,10 +108,12 @@ const moduleBacking = z.discriminatedUnion("kind", [z.object({
 		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(),
@@ -315,13 +320,9 @@ const remoteAgent = entry.extend({
 	url: z.string().optional()
 }).strict();
 const kernelEffect = z.object({
-	action: z.enum([
-		"subagent-call",
-		"task-cancel",
-		"workflow-tool-call"
-	]).optional(),
-	audience: z.array(z.enum(["root-session", "delegated-task-child"])),
-	kind: z.enum(["dispatch", "provider-tool"]),
+	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({
@@ -687,11 +688,14 @@ function summarizeTurnEvents(events) {
 	let failure;
 	let message;
 	const inputRequests = [];
+	const pendingInputRequests = /* @__PURE__ */ new Set();
 	const pendingAuthorizations = /* @__PURE__ */ new Map();
 	for (const event of events) {
-		if (isCurrentTurnBoundaryEvent(event)) boundary = event;
+		updatePendingInputRequests(pendingInputRequests, event);
+		if (isTurnSegmentBoundary(event, pendingInputRequests)) boundary = event;
 		if (isTurnFailureEvent(event)) failure = event;
 		if (isFinalMessageCompleted(event)) message = event.data.message ?? void 0;
+		if (event.type === "turn.waiting") message = void 0;
 		if (event.type === "input.requested") inputRequests.push(...event.data.requests);
 		if (event.type === "authorization.required") pendingAuthorizations.set(event.data.name, event.data);
 		if (event.type === "authorization.completed") pendingAuthorizations.delete(event.data.name);
@@ -702,9 +706,22 @@ function summarizeTurnEvents(events) {
 		inputRequests,
 		message,
 		pendingAuthorizations: [...pendingAuthorizations.values()],
-		status: boundary?.type === "session.waiting" ? "waiting" : boundary?.type === "session.failed" ? "failed" : "completed"
+		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 isTurnSegmentBoundary(event, pendingInputRequests) {
+	if (event.type === "turn.waiting") return pendingInputRequests.size > 0;
+	return isCurrentTurnBoundaryEvent(event);
+}
+function updatePendingInputRequests(pending, event) {
+	if (event.type === "input.requested") for (const request of event.data.requests) pending.add(request.requestId);
+	else if (event.type === "input.resolved") for (const resolution of event.data.resolutions) pending.delete(resolution.requestId);
+}
 function isFinalMessageCompleted(event) {
 	return event.type === "message.completed" && event.data.finishReason !== "tool-calls";
 }
@@ -713,89 +730,6 @@ function updatePendingAuthorizations(pending, event) {
 	else if (event.type === "authorization.completed") pending.delete(event.data.name);
 }
 
-//#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");
-var MessageResponse = class {
-	sessionId;
-	[acceptedDeliveryId];
-	#cancelTurn;
-	#cancellation;
-	#consumed = false;
-	#createStream;
-	#settled = false;
-	#turnId = Promise.withResolvers();
-	constructor(input) {
-		this.#cancelTurn = input.cancelTurn;
-		this.sessionId = input.sessionId;
-		this[acceptedDeliveryId] = input.deliveryId;
-		this.#createStream = input.createStream;
-	}
-	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.#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/message-version.ts
 function normalizeMessageStreamEvent(version, event) {
@@ -804,7 +738,8 @@ function normalizeMessageStreamEvent(version, event) {
 		case "22":
 		case "23":
 		case "24": return normalizeLegacyMessageStreamEvent(version, event);
-		case "25": return validateCurrentMessageStreamEvent(event);
+		case "25":
+		case "26": return validateDeltaMessageStreamEvent(version, event);
 		default: return assertNever(version);
 	}
 }
@@ -853,26 +788,26 @@ function normalizeLegacyMessageStreamEvent(version, event) {
 	}
 	return event;
 }
-function validateCurrentMessageStreamEvent(event) {
+function validateDeltaMessageStreamEvent(version, event) {
 	if (event.type === "message.appended") {
-		assertCurrentAppendDelta(event.data.messageDelta, "message");
-		assertUnsupportedAppendField(event.data, "messageOffset", "message");
-		assertUnsupportedAppendField(event.data, "messageSoFar", "message");
+		assertAppendDelta(event.data.messageDelta, "message", version);
+		assertUnsupportedAppendField(event.data, "messageOffset", "message", version);
+		assertUnsupportedAppendField(event.data, "messageSoFar", "message", version);
 	} else if (event.type === "reasoning.appended") {
-		assertCurrentAppendDelta(event.data.reasoningDelta, "reasoning");
-		assertUnsupportedAppendField(event.data, "reasoningOffset", "reasoning");
-		assertUnsupportedAppendField(event.data, "reasoningSoFar", "reasoning");
+		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") {
-		assertCurrentAppendDelta(event.data.inputTextDelta, "action input");
-		assertUnsupportedAppendField(event.data, "inputTextOffset", "action input");
+		assertAppendDelta(event.data.inputTextDelta, "action input", version);
+		assertUnsupportedAppendField(event.data, "inputTextOffset", "action input", version);
 	}
 	return event;
 }
-function assertCurrentAppendDelta(delta, stream) {
-	if (typeof delta !== "string") throw new TypeError(`Invalid ${stream} append delta for stream version 25.`);
+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) {
-	if (field in data) throw new TypeError(`Invalid ${stream} append shape for stream version 25.`);
+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)}.`);
@@ -973,7 +908,8 @@ const supportedMessageStreamVersions = {
 	"22": true,
 	"23": true,
 	"24": true,
-	"25": true
+	"25": true,
+	"26": true
 };
 function readMessageStreamVersion(headers) {
 	const version = headers.get(EVE_STREAM_VERSION_HEADER);
@@ -1255,6 +1191,120 @@ async function sleep(ms, signal) {
 	});
 }
 
+//#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");
+var MessageResponse = class {
+	sessionId;
+	[acceptedDeliveryId];
+	#cancelTurn;
+	#cancellation;
+	#consumed = false;
+	#createStream;
+	#settled = false;
+	#turnId = Promise.withResolvers();
+	constructor(input) {
+		this.#cancelTurn = input.cancelTurn;
+		this.sessionId = input.sessionId;
+		this[acceptedDeliveryId] = input.deliveryId;
+		this.#createStream = input.createStream;
+	}
+	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.#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/cancel-turn.ts
 const CancelTurnResponseSchema = z.discriminatedUnion("status", [z.strictObject({
@@ -1436,11 +1486,42 @@ function isPlainObject(value) {
 }
 
 //#endregion
-//#region src/tools/schema.ts
+//#region src/tools/schema-emission.ts
 const JSON_SCHEMA_TARGET = "draft-07";
 function serializeOutputSchema(source) {
-	return serializeSchema(source, "output");
+	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": {
@@ -1457,32 +1538,6 @@ function defineJsonSchema(schema, check) {
 }
 const plainJsonSchemas = /* @__PURE__ */ new WeakSet();
 const UNSPECIFIED_INPUT_SCHEMA = defineJsonSchema({});
-function serializeSchema(source, direction) {
-	if (source === null || source === void 0) return source;
-	return toJsonObject(source, direction);
-}
-function toJsonObject(source, direction) {
-	const standard = getStandardSchemaProperties(source);
-	const jsonSchema = standard?.jsonSchema;
-	const emit = typeof jsonSchema === "object" && jsonSchema !== null ? jsonSchema[direction] : void 0;
-	const vendor = typeof standard?.vendor === "string" ? standard.vendor : "unknown";
-	if (standard !== void 0 && typeof emit !== "function" && vendor === "zod") {
-		if (direction === "input") {
-			const schema = asSchema(source);
-			const { $schema: _schemaVersion, ...canonical } = parseJsonObject(schema.jsonSchema);
-			return canonical;
-		}
-		throw new Error("Zod 3 cannot emit an output JSON Schema. Upgrade to Zod 4 or provide a plain JSON Schema object.");
-	}
-	if (standard !== void 0 && typeof emit !== "function") throw new Error(`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.`);
-	const { $schema: _schemaVersion, ...canonical } = standard === void 0 ? parseJsonObject(source) : parseJsonObject(emit({ target: JSON_SCHEMA_TARGET }));
-	return canonical;
-}
-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 createJsonSchemaValidator(schema, check) {
 	let validator;
 	let warned = false;
@@ -1813,21 +1868,8 @@ var ClientSession = class ClientSession {
 		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);
 	}
-	streamSubagent(called, options) {
-		if (called.data.sessionId !== this.#state.sessionId) throw new Error(`streamSubagent() requires a subagent.called event from session ${this.#state.sessionId}, but it came from session ${called.data.sessionId}.`);
-		if (typeof called.data.childStreamPath !== "string") throw new Error(`streamSubagent() requires a subagent.called event with childStreamPath, but call ${called.data.callId} has none. The event was recorded by an older eve version.`);
-		const startIndex = options?.startIndex ?? 0;
-		if (options?.follow === false && startIndex < 0) throw new Error("streamSubagent({ follow: false }) requires a nonnegative startIndex; a tail-relative cursor cannot be bounded.");
-		return followStreamIterable({
-			follow: options?.follow,
-			host: this.#context.host,
-			path: called.data.childStreamPath,
-			redirect: this.#context.redirect,
-			resolveHeaders: () => this.#context.resolveHeaders(),
-			signal: options?.signal,
-			startIndex,
-			streamReconnectPolicy: options?.streamReconnectPolicy
-		});
+	agent(started) {
+		return new ClientAgentSession(this.#context, started);
 	}
 	[followSession](options) {
 		return this.#streamAndAdvance({
@@ -1849,6 +1891,7 @@ var ClientSession = class ClientSession {
 		let started = deliveryId === void 0;
 		let reachedBoundary = false;
 		const pendingAuthorizations = /* @__PURE__ */ new Set();
+		const pendingInputRequests = /* @__PURE__ */ new Set();
 		try {
 			for await (const event of source ?? this.#readStream({
 				headers: input.headers,
@@ -1867,7 +1910,8 @@ var ClientSession = class ClientSession {
 					started = true;
 				}
 				updatePendingAuthorizations(pendingAuthorizations, event);
-				reachedBoundary = isCurrentTurnBoundaryEvent(event) && (event.type !== "session.waiting" || pendingAuthorizations.size === 0);
+				updatePendingInputRequests(pendingInputRequests, event);
+				reachedBoundary = isTurnSegmentBoundary(event, pendingInputRequests) && (event.type !== "session.waiting" || pendingAuthorizations.size === 0);
 				yield event;
 				if (reachedBoundary) break;
 			}
@@ -1985,7 +2029,6 @@ function createMessageBody(input, requireMessage) {
 	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.message !== void 0 && input.taskDeliveryPolicy !== void 0) body.taskDeliveryPolicy = input.taskDeliveryPolicy;
 	if (input.clientContext !== void 0) body.clientContext = input.clientContext;
 	const outputSchema = serializeOutputSchema(input.outputSchema);
 	if (outputSchema !== void 0) body.outputSchema = outputSchema;
@@ -2286,12 +2329,14 @@ var EveAgentProjection = class {
 //#region src/client/eve-agent-store-helpers.ts
 function isSettledSessionTail(events) {
 	const tail = events.at(-1);
-	return tail !== void 0 && isCurrentTurnBoundaryEvent(tail) && (tail.type !== "session.waiting" || collectPendingAuthorizations(events).size === 0);
-}
-function collectPendingAuthorizations(events) {
-	const pending = /* @__PURE__ */ new Set();
-	for (const event of events) updatePendingAuthorizations(pending, event);
-	return pending;
+	if (tail === void 0) return false;
+	const pendingAuthorizations = /* @__PURE__ */ new Set();
+	const pendingInputRequests = /* @__PURE__ */ new Set();
+	for (const event of events) {
+		updatePendingAuthorizations(pendingAuthorizations, event);
+		updatePendingInputRequests(pendingInputRequests, event);
+	}
+	return isTurnSegmentBoundary(tail, pendingInputRequests) && (tail.type !== "session.waiting" || pendingAuthorizations.size === 0);
 }
 function assertExclusiveTurnInput(input) {
 	if (input.message !== void 0 === (input.inputResponses !== void 0)) throw new Error("A turn requires exactly one of message or inputResponses.");
@@ -2343,11 +2388,13 @@ function createActiveTurn(cancel) {
 async function followSteeredTurns(turn, events, isActive) {
 	while (turn.followUpDispatches.size > 0) await Promise.allSettled(turn.followUpDispatches);
 	if (turn.receivedFollowUps >= turn.acceptedFollowUps) return;
+	const pendingInputRequests = /* @__PURE__ */ new Set();
 	for await (const event of events) {
 		if (!isActive()) return;
 		turn.receivedFollowUps += turn.receivedFollowUpEvents.get(event) ?? 0;
 		turn.receivedFollowUpEvents.delete(event);
-		if (isCurrentTurnBoundaryEvent(event)) {
+		updatePendingInputRequests(pendingInputRequests, event);
+		if (isTurnSegmentBoundary(event, pendingInputRequests)) {
 			while (turn.followUpDispatches.size > 0) await Promise.allSettled(turn.followUpDispatches);
 			if (turn.receivedFollowUps >= turn.acceptedFollowUps) return;
 		}
@@ -2404,10 +2451,6 @@ var OptimisticMessageSubmissions = class {
 			this.#projection.append(event);
 			return;
 		}
-		if (event.data.kind === "execution.background_task") {
-			this.#projection.append(event);
-			return;
-		}
 		const matching = this.#matching(event);
 		if (matching.length === 0) {
 			this.#projection.append(event);
@@ -2425,7 +2468,7 @@ var OptimisticMessageSubmissions = class {
 		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" || event.data.kind === "execution.background_task") continue;
+			if (event.type !== "message.received") continue;
 			const matching = this.#matching(event);
 			if (matching.some((candidate) => candidate.id === submissionId)) return this.#reconcile(matching, event, true);
 		}
@@ -2495,6 +2538,7 @@ var EveAgentStore = class {
 	#attached = false;
 	#stream;
 	#pendingAuthorizations = /* @__PURE__ */ new Set();
+	#pendingInputRequests = /* @__PURE__ */ new Set();
 	#externalSession;
 	#optimistic;
 	#projection;
@@ -2523,7 +2567,7 @@ var EveAgentStore = class {
 		const initialEvents = [];
 		for (const event of init.initialEvents ?? []) {
 			if (this.#seenEvents.admit(event)) initialEvents.push(event);
-			updatePendingAuthorizations(this.#pendingAuthorizations, event);
+			this.#trackPendingRequests(event);
 		}
 		this.#events = initialEvents;
 		this.#projection = new EveAgentProjection(init.reducer, this.#events);
@@ -2681,7 +2725,7 @@ var EveAgentStore = class {
 					if (!this.#isActiveTurn(turn)) return;
 					turn.receivedFollowUps += turn.receivedFollowUpEvents.get(event) ?? 0;
 					turn.receivedFollowUpEvents.delete(event);
-					if (isCurrentTurnBoundaryEvent(event) && this.#pendingAuthorizations.size === 0) break;
+					if (this.#isSettledAt(event)) break;
 				}
 			}
 			await followSteeredTurns(turn, reader, () => this.#isActiveTurn(turn));
@@ -2720,6 +2764,7 @@ var EveAgentStore = class {
 		this.#stream?.close();
 		this.#stream = void 0;
 		this.#pendingAuthorizations.clear();
+		this.#pendingInputRequests.clear();
 		const turn = this.#activeTurn;
 		this.#activeTurn = void 0;
 		turn?.resolveResponse(void 0);
@@ -2886,12 +2931,12 @@ var EveAgentStore = class {
 	#acceptServerEvent(event) {
 		if (!this.#seenEvents.admit(event)) return;
 		const wasStreaming = this.#status === "streaming";
-		updatePendingAuthorizations(this.#pendingAuthorizations, event);
+		this.#trackPendingRequests(event);
 		this.#events = [...this.#events, event];
 		this.#handleReconciliation(this.#messageSubmissions.apply(event));
 		this.#callbacks.onEvent?.(event);
 		this.#applyTerminalStreamFailure(event);
-		const settled = isCurrentTurnBoundaryEvent(event) && this.#pendingAuthorizations.size === 0;
+		const settled = this.#isSettledAt(event);
 		if (this.#status !== "resuming" && this.#error === void 0) {
 			if ("data" in event && "turnId" in event.data) this.#status = "streaming";
 			if (this.#activeTurn === void 0 && settled) this.#status = "ready";
@@ -2900,6 +2945,13 @@ var EveAgentStore = class {
 		if (this.#status !== "resuming") this.#publish();
 		if (this.#activeTurn === void 0 && wasStreaming && settled) this.#callbacks.onFinish?.(this.#snapshot);
 	}
+	#trackPendingRequests(event) {
+		updatePendingAuthorizations(this.#pendingAuthorizations, event);
+		updatePendingInputRequests(this.#pendingInputRequests, event);
+	}
+	#isSettledAt(event) {
+		return isTurnSegmentBoundary(event, this.#pendingInputRequests) && this.#pendingAuthorizations.size === 0;
+	}
 	#handleReconciliation(reconciliation) {
 		if (reconciliation === void 0) return false;
 		let followed = 0;
@@ -3004,6 +3056,18 @@ function formatAuthorizationDisplayName(name) {
 	return `${name.charAt(0).toUpperCase()}${name.slice(1)}`;
 }
 
+//#endregion
+//#region src/shared/action-request-name.ts
+function actionRequestName(action) {
+	switch (action.kind) {
+		case "load-skill": return "load_skill";
+		case "subagent-call": return action.subagentName;
+		case "remote-agent-call": return action.remoteAgentName;
+		case "tool-call":
+		case "workflow-tool-call": return action.toolName;
+	}
+}
+
 //#endregion
 //#region src/client/message-action-parts.ts
 function toMessageInputRequest(request) {
@@ -3045,27 +3109,24 @@ function approvedApproval(part) {
 	};
 }
 function normalizeActionRequest(action) {
+	const name = actionRequestName(action);
 	switch (action.kind) {
 		case "load-skill": return {
 			kind: "load-skill",
-			name: "load_skill",
+			name,
 			toolName: "eve:load-skill"
 		};
 		case "tool-call":
 		case "workflow-tool-call": return {
 			kind: "tool-call",
-			name: action.toolName,
-			toolName: action.toolName
-		};
-		case "subagent-call": return {
-			kind: "subagent-call",
-			name: action.subagentName,
-			toolName: `eve:subagent:${action.subagentName}`
+			name,
+			toolName: name
 		};
+		case "subagent-call":
 		case "remote-agent-call": return {
 			kind: "subagent-call",
-			name: action.remoteAgentName,
-			toolName: `eve:subagent:${action.remoteAgentName}`
+			name,
+			toolName: `eve:subagent:${name}`
 		};
 	}
 }
@@ -3193,6 +3254,37 @@ const messageRun = {
 	upsert
 };
 
+//#endregion
+//#region src/client/message-task-parts.ts
+function createSettledTaskPart(existing, event) {
+	const settledPartBase = {
+		approval: approvedApproval(existing),
+		input: existing.input,
+		stepIndex: existing.stepIndex,
+		toolCallId: existing.toolCallId,
+		toolMetadata: existing.toolMetadata,
+		toolName: existing.toolName,
+		type: "dynamic-tool"
+	};
+	switch (event.data.status) {
+		case "completed": return {
+			...settledPartBase,
+			output: event.data.output,
+			state: "output-available"
+		};
+		case "failed": return {
+			...settledPartBase,
+			errorText: event.data.error?.message ?? "Task failed.",
+			state: "output-error"
+		};
+		case "cancelled": return {
+			...settledPartBase,
+			errorText: "Task was cancelled.",
+			state: "output-error"
+		};
+	}
+}
+
 //#endregion
 //#region src/client/message-reducer.ts
 function receivedMessageEventId(event) {
@@ -3239,17 +3331,15 @@ function reduceMessageData(data, event) {
 			for (const resolution of event.data.resolutions) next = resolveInputRequest(next, resolution);
 			return next;
 		}
-		case "message.received":
-			if (event.data.kind === "execution.background_task") return data;
-			return upsertMessage(data, {
-				id: `${receivedMessageEventId(event)}:user`,
-				metadata: {
-					status: "complete",
-					turnId: event.data.turnId
-				},
-				parts: projectReceivedParts(event.data.parts, event.data.message),
-				role: "user"
-			});
+		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"
+		});
 		case "step.started": return updateAssistantMessage(data, event.data.turnId, (message) => ensureStepStartPart(message, event.data.stepIndex));
 		case "reasoning.appended": return updateAssistantMessage(data, event.data.turnId, (message) => messageRun.append(ensureStepStartPart(message, event.data.stepIndex), {
 			delta: event.data.reasoningDelta,
@@ -3406,6 +3496,11 @@ function reduceMessageData(data, event) {
 			if (existing !== void 0) return updateToolPart(data, event.data.result.callId, nextPart);
 			return updateAssistantMessage(data, event.data.turnId, (message) => upsertPart(ensureStepStartPart(message, event.data.stepIndex), nextPart));
 		}
+		case "task.settled": {
+			const existing = findToolPart(data, event.data.callId);
+			if (existing === void 0) return data;
+			return replaceToolPart(data, createSettledTaskPart(existing, event));
+		}
 		case "authorization.required": return updateAssistantMessage(data, event.data.turnId, (message) => upsertPart(ensureStepStartPart(message, event.data.stepIndex), createAuthorizationRequiredPart(event)));
 		case "authorization.completed": return completeAuthorization(data, event);
 		case "message.appended": return updateAssistantMessage(data, event.data.turnId, (message) => messageRun.append(ensureStepStartPart(message, event.data.stepIndex), {
@@ -3414,7 +3509,6 @@ function reduceMessageData(data, event) {
 			type: "text"
 		}));
 		case "message.completed": return updateAssistantMessage(data, event.data.turnId, (message) => {
-			if (event.data.message === null) return removeTextPart(message, event.data.stepIndex);
 			return messageRun.upsert(ensureStepStartPart(message, event.data.stepIndex), {
 				state: "done",
 				stepIndex: event.data.stepIndex,
@@ -3534,23 +3628,19 @@ function upsertPart(message, next) {
 		parts
 	};
 }
-function removeTextPart(message, stepIndex) {
-	const parts = message.parts.filter((part) => part.type !== "text" || part.stepIndex !== stepIndex);
-	if (parts.length === message.parts.length) return message;
-	return {
-		...message,
-		metadata: {
-			...message.metadata,
-			status: "complete"
-		},
-		parts
-	};
-}
 function updateToolPart(data, toolCallId, next) {
 	const message = data.messages.find((candidate) => candidate.role === "assistant" && candidate.parts.some((part) => part.type === "dynamic-tool" && part.toolCallId === toolCallId));
 	if (!message) return data;
 	return upsertMessage(data, upsertPart(message, next));
 }
+function replaceToolPart(data, next) {
+	const message = data.messages.find((candidate) => candidate.parts.some((part) => part.type === "dynamic-tool" && part.toolCallId === next.toolCallId));
+	if (message === void 0) return data;
+	return upsertMessage(data, {
+		...message,
+		parts: message.parts.map((part) => partKey(part) === partKey(next) ? next : part)
+	});
+}
 function completeAuthorization(data, event) {
 	const existing = findLatestPendingAuthorizationPart(data, event.data.name);
 	const next = createAuthorizationCompletedPart(event, existing);