@rivus/agent 0.11.0 → 0.12.4

package/README.md

@@ -911,7 +911,7 @@ const daemon = createFeishuAgentDaemon({
 });
 ```
 
-The daemon converts Feishu text and rich-text Post messages into prompt commands, preferring Post `content_v2` and flattening its textual paragraphs. It consumes harness `AgentRunUpdate` values and emits `update_text`, `finish`, `fail`, or `cancel` actions from projected run state. It accepts `/new` and `/reset` to advance a persisted session generation for the current Feishu conversation, so the next prompt starts with a fresh transcript; `/new /skill:<name> ...` combines the reset and the first prompt. The reset command replies with a short confirmation and does not invoke the model. It also accepts `/cancel <runId>` as a daemon command; the intake attaches the message's stable `sessionKey`, and the daemon calls `harness.forSession(sessionKey).cancelRun(runId, "Feishu cancel command")` so a cancel message from another chat cannot cancel the active run. `/cancel` without an exact run id is rejected at intake instead of being sent to the model. `card.action.trigger` can cancel through the same exact path or resolve a persisted Human Interaction using only the trusted Feishu operator identity. Card-action tokens are process-locally deduplicated. Interaction decisions are persisted before the callback returns a toast and updated raw card; resolved cards contain no stale buttons. `prepareRun` is called on `agent_run_accepted`, before any stream action is published, so adapters can create a card and bind `runId` to `{ cardId, elementId }`. Publish effects are awaited in update order, and terminal publication replaces the entire card with a completed, failed, or cancelled projection. When daemon-level `dedupe` is enabled, a failed run releases its message-id marker so a retried delivery can run again; runtime-level queues treat `AgentRunCancelled` as terminal and do not retry cancelled messages.
+The daemon converts Feishu text and rich-text Post messages into prompt commands, preferring Post `content_v2` and flattening its textual paragraphs. It consumes harness `AgentRunUpdate` values and emits `update_text`, `finish`, `fail`, or `cancel` actions from projected run state. It accepts `/new` and `/reset` to stop any active run in the same conversation and advance a persisted session generation, so the next prompt starts with a fresh transcript; `/new /skill:<name> ...` combines the reset and the first prompt. A bare reset replies immediately and does not invoke the model. `/cancel` immediately cancels the active run in the current Feishu session, while `/cancel <runId>` keeps the stale-safe exact form used by running cards and callbacks. Both forms bypass the durable prompt queue, remain session-bound, and reply with an explicit stopped/no-active acknowledgement. `card.action.trigger` can cancel through the same exact path or resolve a persisted Human Interaction using only the trusted Feishu operator identity. Card-action tokens are process-locally deduplicated. Interaction decisions are persisted before the callback returns a toast and updated raw card; resolved cards contain no stale buttons. `prepareRun` is called on `agent_run_accepted`, before any stream action is published, so adapters can create a card and bind `runId` to `{ cardId, elementId }`. Publish effects are awaited in update order, and terminal publication replaces the entire card with a completed, failed, or cancelled projection. When daemon-level `dedupe` is enabled, a failed run releases its message-id marker so a retried delivery can run again; runtime-level queues treat `AgentRunCancelled` as terminal and do not retry cancelled messages.
 
 For Feishu's 3-second event handling requirement, put a queue in front of the daemon:
 
@@ -926,7 +926,7 @@ await Effect.runPromise(queue.accept(payload)); // return/ack quickly
 await Effect.runPromise(queue.drainOne()); // run agent work outside the ack path
 ```
 
-For the Feishu Node SDK, register the handler map returned by `createFeishuEventHandlers({ queue, cardActions })` and keep worker draining outside the SDK callback. Subscribe to both `im.message.receive_v1` and `card.action.trigger` when using interactive run or Human Interaction cards. The callback handler returns Feishu response JSON rather than the daemon's internal result; Human Interaction responses include both `toast` and `{ card: { type: "raw", data } }` so the clicked card reaches its terminal projection immediately.
+For the Feishu Node SDK, register the handler map returned by `createFeishuEventHandlers({ queue, cardActions })` and keep worker draining outside the SDK callback. An HTTP webhook can subscribe to both `im.message.receive_v1` and `card.action.trigger`; Feishu's long-connection WebSocket transport supports event subscriptions only, so it cannot deliver card callbacks. Long-connection deployments therefore omit the running-card callback button and show the exact `/cancel <runId>` command instead. The HTTP callback handler returns Feishu response JSON rather than the daemon's internal result; Human Interaction responses include both `toast` and `{ card: { type: "raw", data } }` so the clicked card reaches its terminal projection immediately.
 If queued message handling fails, `drainOne()` leaves the message pending and fails the effect so the worker loop can report the error and retry on a later pass instead of silently dropping accepted work.
 
 For the common local-daemon path, use the runtime factory to keep that wiring in one place:
@@ -1071,7 +1071,7 @@ const bootstrap = await Effect.runPromise(
 );
 ```
 
-The configured preparation helper creates a blue streaming CardKit entity, replies to the inbound Feishu message, and binds the run to the card target before any stream action is published. The running card includes a “Stop generating” button carrying `{ rivus_action: "cancel_run", run_id, session_key }`; completed, failed, and cancelled cards remove it. The configured publisher coalesces consecutive `update_text` actions by run, flushes the latest text before a terminal action, and exposes `flush(runId?)` for explicit worker-driven flushing. `createConfiguredRivusDaemonBootstrap` flushes pending text at `config.feishu.streamMinIntervalMs` by default; pass `flushIntervalMs` only to override that cadence. It also adds the event log, history restore helper, status reporter, optional status transport, WebSocket transport, worker loop, and managed process around those same pieces; `restoreConfiguredRivusDaemonBootstrap` first replays that event log as restored harness events so read models and same-session loop input are hydrated after restart. Local tests can use `createInMemoryFeishuCardTargetRegistry`; daemon processes should prefer `createJsonFileFeishuCardTargetRegistry` so run-to-card bindings survive restarts and malformed registry files fail loudly instead of being treated as empty state.
+The configured preparation helper creates a blue streaming CardKit entity, replies to the inbound Feishu message, and binds the run to the card target before any stream action is published. HTTP-callback deployments may include a “Stop generating” button carrying `{ rivus_action: "cancel_run", run_id, session_key }`; the WebSocket bootstrap omits that callback-only button and shows the exact `/cancel <runId>` command instead. Completed, failed, and cancelled cards remove active controls. The configured publisher coalesces consecutive `update_text` actions by run, flushes the latest text before a terminal action, and exposes `flush(runId?)` for explicit worker-driven flushing. `createConfiguredRivusDaemonBootstrap` flushes pending text at `config.feishu.streamMinIntervalMs` by default; pass `flushIntervalMs` only to override that cadence. It also adds the event log, history restore helper, status reporter, optional status transport, WebSocket transport, worker loop, and managed process around those same pieces; `restoreConfiguredRivusDaemonBootstrap` first replays that event log as restored harness events so read models and same-session loop input are hydrated after restart. Local tests can use `createInMemoryFeishuCardTargetRegistry`; daemon processes should prefer `createJsonFileFeishuCardTargetRegistry` so run-to-card bindings survive restarts and malformed registry files fail loudly instead of being treated as empty state.
 
 ## Design Notes
 

package/dist/acp.d.ts

@@ -18,11 +18,15 @@ interface AcpPromptResult {
   readonly stopReason: string;
 }
 interface AcpAgentSession {
-  cancel(): Promise<void> | void;
+  cancel(options?: {
+    readonly preserveSession?: boolean;
+  }): Promise<void> | void;
   prompt(text: string, onUpdate: (update: AcpSessionUpdate) => void): Promise<AcpPromptResult>;
   dispose?(): Promise<void> | void;
+  invalidate?(): Promise<void> | void;
 }
 interface AcpAgentLoopOptions {
+  readonly cancellationSettleTimeoutMs?: number;
   readonly disposeSessionAfterRun?: boolean;
   readonly resolveSession: (input: AgentLoopInput) => Promise<AcpAgentSession> | AcpAgentSession;
 }
@@ -82,6 +86,7 @@ interface AcpSessionRecord {
   readonly sessionId: string;
 }
 interface AcpSessionStore {
+  delete(sessionKey: string): Promise<void>;
   load(sessionKey: string): Promise<AcpSessionRecord | undefined>;
   save(sessionKey: string, record: AcpSessionRecord): Promise<void>;
 }

package/dist/acp.js

@@ -8,51 +8,128 @@ import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
 //#region src/infrastructure/acp/acp-agent-loop.ts
 function createAcpAgentLoop(options) {
-	return createAsyncIterableAgentLoop({ run: (input) => runAcpSession(input, options) });
+	const loop = createAsyncIterableAgentLoop({ run: (input) => runAcpSession(input, options) });
+	return {
+		run: (input) => loop.run(input),
+		supportsSteering: true
+	};
 }
 async function* runAcpSession(input, options) {
 	const session = await options.resolveSession(input);
 	const updates = [];
 	const tools = /* @__PURE__ */ new Map();
 	let wake;
-	let completed = false;
-	let failure;
+	let abortCancellation;
+	let abortFailure;
+	let abortSettled = false;
+	let aborted = false;
+	let currentTurn = startAcpTurn(input.text, session, input, updates, tools, () => {
+		wake?.();
+		wake = void 0;
+	});
 	const onAbort = () => {
-		Promise.resolve(session.cancel()).catch((error) => {
-			failure = error;
-			completed = true;
+		aborted = true;
+		abortCancellation ??= settleCancelledTurn(session, currentTurn.promise, options.cancellationSettleTimeoutMs ?? 5e3);
+		abortCancellation.then(() => {
+			abortSettled = true;
+			wake?.();
+			wake = void 0;
+		}, (error) => {
+			abortFailure = error;
 			wake?.();
 			wake = void 0;
 		});
 	};
 	input.abortSignal.addEventListener("abort", onAbort, { once: true });
-	const prompt = session.prompt(input.text, (update) => {
-		updates.push(...mapAcpSessionUpdate(update, tools));
-		wake?.();
-		wake = void 0;
-	}).catch((error) => {
-		if (!input.abortSignal.aborted) failure = error;
-	}).finally(() => {
-		completed = true;
-		wake?.();
-		wake = void 0;
-	});
+	let steering = input.steering?.next();
 	try {
 		if (input.abortSignal.aborted) onAbort();
-		while (!completed || updates.length > 0) {
+		while (!currentTurn.completed || updates.length > 0) {
+			if (abortFailure !== void 0) throw abortFailure;
+			if (aborted && abortSettled) break;
 			const event = updates.shift();
 			if (event) yield event;
-			else await new Promise((resolve) => {
-				wake = resolve;
-			});
+			else {
+				const signal = await Promise.race([
+					new Promise((resolve) => {
+						wake = () => resolve({ type: "wake" });
+					}),
+					...steering ? [steering.then((text) => ({
+						text,
+						type: "steer"
+					}))] : [],
+					currentTurn.promise.then(() => ({ type: "turn_completed" }), () => ({ type: "turn_completed" }))
+				]);
+				if (signal.type === "steer") {
+					await Promise.resolve(session.cancel({ preserveSession: true }));
+					await currentTurn.promise;
+					currentTurn = startAcpTurn(createSteeringTurnPrompt(signal.text), session, input, updates, tools, () => {
+						wake?.();
+						wake = void 0;
+					});
+					steering = input.steering?.next();
+				}
+				if (signal.type === "turn_completed" && currentTurn.completed) break;
+				if (signal.type === "wake") wake = void 0;
+			}
+		}
+		if (!aborted) {
+			await currentTurn.promise;
+			if (currentTurn.failure !== void 0) throw currentTurn.failure;
 		}
-		if (failure !== void 0) throw failure;
-		await prompt;
 	} finally {
 		input.abortSignal.removeEventListener("abort", onAbort);
+		if (abortCancellation) await abortCancellation;
 		if (options.disposeSessionAfterRun !== false) await session.dispose?.();
 	}
 }
+async function settleCancelledTurn(session, currentTurn, timeoutMs) {
+	await Promise.resolve(session.cancel({ preserveSession: false }));
+	if (await settlesWithin(currentTurn, timeoutMs)) return;
+	if (session.invalidate) await session.invalidate();
+	else await session.dispose?.();
+}
+async function settlesWithin(promise, timeoutMs) {
+	let timeout;
+	try {
+		return await Promise.race([promise.then(() => true), new Promise((resolve) => {
+			timeout = setTimeout(() => resolve(false), timeoutMs);
+		})]);
+	} finally {
+		if (timeout) clearTimeout(timeout);
+	}
+}
+function createSteeringTurnPrompt(text) {
+	return [
+		"用户刚刚在当前任务执行期间发送了一条 steering 消息。",
+		"请先直接回答这条消息；如果它是关于当前任务的进度或概念问题，先给出清晰解释。",
+		"只有消息明确要求改变任务时才执行动作；不要把用户自然语言当作 shell 命令。",
+		"回答后基于当前会话已有状态继续任务；不得重放最初指令或重复已经完成的步骤。",
+		"用户消息：",
+		text
+	].join("\n");
+}
+function startAcpTurn(text, session, input, updates, tools, notify) {
+	let completed = false;
+	let failure;
+	return {
+		promise: session.prompt(text, (update) => {
+			updates.push(...mapAcpSessionUpdate(update, tools));
+			notify();
+		}).then(() => void 0).catch((error) => {
+			if (!input.abortSignal.aborted) failure = error;
+		}).finally(() => {
+			completed = true;
+			notify();
+		}),
+		get completed() {
+			return completed;
+		},
+		get failure() {
+			return failure;
+		}
+	};
+}
 function mapAcpSessionUpdate(update, tools) {
 	if (update.sessionUpdate === "agent_message_chunk") {
 		const text = readTextContent(update.content);
@@ -365,7 +442,7 @@ function createAcpStdioAgentLoop(options) {
 					current.dispose();
 					processConnection.sessions.delete(input.sessionKey);
 				}
-				const session = new SdkAcpAgentSession(await buildAcpSession(processConnection, options, input), processConnection.connection.agent, options.sessionStore !== void 0);
+				const session = new SdkAcpAgentSession(await buildAcpSession(processConnection, options, input), processConnection.connection.agent, input.sessionKey, options.sessionStore);
 				sessionKeys.set(session.sessionId, input.sessionKey);
 				processConnection.sessions.set(input.sessionKey, session);
 				return session;
@@ -376,12 +453,14 @@ function createAcpStdioAgentLoop(options) {
 var SdkAcpAgentSession = class {
 	session;
 	agent;
-	preserveOnCancel;
+	sessionKey;
+	sessionStore;
 	reusable = true;
-	constructor(session, agent, preserveOnCancel) {
+	constructor(session, agent, sessionKey, sessionStore) {
 		this.session = session;
 		this.agent = agent;
-		this.preserveOnCancel = preserveOnCancel;
+		this.sessionKey = sessionKey;
+		this.sessionStore = sessionStore;
 	}
 	get sessionId() {
 		return this.session.sessionId;
@@ -389,14 +468,19 @@ var SdkAcpAgentSession = class {
 	get isReusable() {
 		return this.reusable;
 	}
-	cancel() {
-		if (!this.preserveOnCancel) this.reusable = false;
+	cancel(options) {
+		if (options?.preserveSession !== true) this.reusable = false;
 		return this.agent.notify(acp.methods.agent.session.cancel, { sessionId: this.session.sessionId });
 	}
 	dispose() {
 		this.reusable = false;
 		this.session.dispose();
 	}
+	async invalidate() {
+		this.reusable = false;
+		this.session.dispose();
+		await this.sessionStore?.delete(this.sessionKey);
+	}
 	async prompt(text, onUpdate) {
 		const failure = this.session.prompt(text).then(() => new Promise(() => void 0), (error) => Promise.reject(error));
 		for (;;) {
@@ -615,6 +699,14 @@ function createJsonAcpSessionStore(options) {
 		await rename(temporaryPath, options.filePath);
 	};
 	return {
+		delete: async (sessionKey) => {
+			writeChain = writeChain.then(async () => {
+				const current = await records();
+				if (!current.delete(sessionKey)) return;
+				await persist(current);
+			});
+			await writeChain;
+		},
 		load: async (sessionKey) => (await records()).get(sessionKey),
 		save: async (sessionKey, record) => {
 			writeChain = writeChain.then(async () => {

package/dist/agent-loop.d.ts

@@ -315,10 +315,15 @@ interface AgentLoopInput {
   readonly messages?: ReadonlyArray<AgentTranscriptMessage>;
   readonly runId: AgentRunId;
   readonly sessionKey: SessionKey;
+  /** Optional mailbox for user steering while the run is active. */
+  readonly steering?: AgentSteeringChannel;
   readonly text: string;
   readonly previousSessionState?: AgentRunState;
   readonly previousSessionTranscript?: AgentTranscript;
 }
+interface AgentSteeringChannel {
+  next(): Promise<string>;
+}
 type AgentLoopEvent = AgentLoopTextDelta | AgentLoopThinkingDelta | AgentLoopModelExecutionStart | AgentLoopModelExecutionEnd | AgentLoopSkillExecutionStart | AgentLoopSkillExecutionEnd | AgentLoopToolExecutionStart | AgentLoopToolExecutionUpdate | AgentLoopToolExecutionEnd;
 type AgentLoopEventLike = AgentLoopEvent | string;
 interface AgentLoopTextDelta {
@@ -391,6 +396,8 @@ interface AgentLoopToolExecutionEnd {
 }
 interface AgentLoop {
   run(input: AgentLoopInput): Stream.Stream<AgentLoopEvent, unknown>;
+  /** Provider adapters opt in only when they can consume steering safely. */
+  readonly supportsSteering?: boolean;
 }
 type AgentLoopCallbackOutput = Iterable<AgentLoopEventLike> | AsyncIterable<AgentLoopEventLike> | Stream.Stream<AgentLoopEventLike, unknown>;
 type AgentLoopCallbackResult = AgentLoopCallbackOutput | PromiseLike<AgentLoopCallbackOutput> | Effect.Effect<AgentLoopCallbackOutput, unknown>;
@@ -427,4 +434,4 @@ declare function createAgentLoopFromCallback(run: AgentLoopCallback): AgentLoop;
 declare function createTextAgentLoop(options: TextAgentLoopOptions): AgentLoop;
 declare function createTextAgentLoopFromCallback(generate: TextAgentLoopCallback): AgentLoop;
 //#endregion
-export { createAgentTranscriptTurn as $, createAgentLoopModelExecutionStart as A, AssistantThinkingDelta as At, createTextAgentLoop as B, AgentLoopToolExecutionUpdateOptions as C, AgentToolExecutionEnded as Ct, TextAgentLoopOptions as D, AgentTurnCompleted as Dt, TextAgentLoopCallback as E, AgentToolExecutionUpdated as Et, createAgentLoopToolExecutionEnd as F, isAssistantThinkingDeltaEvent as Ft, LocalCliAgentInvocationOrigin as G, AgentInvocationOrigin as H, createAgentLoopToolExecutionStart as I, isTerminalAgentDomainEvent as It, AgentTranscriptMessage as J, AgentConversationMessagesOptions as K, createAgentLoopToolExecutionUpdate as L, createAgentLoopSkillExecutionStart as M, TerminalAgentDomainEvent as Mt, createAgentLoopTextDelta as N, isAgentToolExecutionEvent as Nt, createAgentLoopFromCallback as O, AgentTurnStarted as Ot, createAgentLoopThinkingDelta as P, isAssistantTextDeltaEvent as Pt, createAgentTranscriptMessages as Q, createAsyncIterableAgentLoop as R, AgentLoopToolExecutionUpdate as S, AgentSkillExecutionStarted as St, EventAgentLoopOptions as T, AgentToolExecutionStarted as Tt, AutomationAgentInvocationOrigin as U, createTextAgentLoopFromCallback as V, FeishuAgentInvocationOrigin as W, AgentTranscriptTurn as X, AgentTranscriptMessageRole as Y, createAgentConversationMessages as Z, AgentLoopThinkingDelta as _, AgentRunCancelled as _t, AgentLoopEvent as a, AgentRunPhase as at, AgentLoopToolExecutionStart as b, AgentRunId as bt, AgentLoopModelExecutionEnd as c, evolveAgentRun as ct, AgentLoopModelExecutionStartOptions as d, AgentDomainEvent as dt, replayAgentTranscript as et, AgentLoopSkillExecutionEnd as f, AgentModelExecutionEnded as ft, AgentLoopTextDelta as g, AgentRunAccepted as gt, AgentLoopSkillExecutionStartOptions as h, AgentModelUsage as ht, AgentLoopCallbackResult as i, replayAgentHistory as it, createAgentLoopSkillExecutionEnd as j, SessionKey as jt, createAgentLoopModelExecutionEnd as k, AssistantTextDelta as kt, AgentLoopModelExecutionEndOptions as l, initialAgentRunState as lt, AgentLoopSkillExecutionStart as m, AgentModelExecutionStarted as mt, AgentLoopCallback as n, AgentRunSummary as nt, AgentLoopEventLike as o, AgentRunState as ot, AgentLoopSkillExecutionEndOptions as p, AgentModelExecutionEvent as pt, AgentTranscript as q, AgentLoopCallbackOutput as r, AgentSessionSummary as rt, AgentLoopInput as s, AgentSkillExecutionState as st, AgentLoop as t, AgentHistory as tt, AgentLoopModelExecutionStart as u, isTerminalAgentRunPhase as ut, AgentLoopToolExecutionEnd as v, AgentRunCompleted as vt, AsyncIterableAgentLoopOptions as w, AgentToolExecutionEvent as wt, AgentLoopToolExecutionStartOptions as x, AgentSkillExecutionEnded as xt, AgentLoopToolExecutionEndOptions as y, AgentRunFailed as yt, createEventAgentLoop as z };
+export { createAgentTranscriptMessages as $, createAgentLoopModelExecutionEnd as A, AssistantTextDelta as At, createEventAgentLoop as B, AgentLoopToolExecutionUpdateOptions as C, AgentSkillExecutionStarted as Ct, TextAgentLoopCallback as D, AgentToolExecutionUpdated as Dt, EventAgentLoopOptions as E, AgentToolExecutionStarted as Et, createAgentLoopThinkingDelta as F, isAssistantTextDeltaEvent as Ft, FeishuAgentInvocationOrigin as G, createTextAgentLoopFromCallback as H, createAgentLoopToolExecutionEnd as I, isAssistantThinkingDeltaEvent as It, AgentTranscript as J, LocalCliAgentInvocationOrigin as K, createAgentLoopToolExecutionStart as L, isTerminalAgentDomainEvent as Lt, createAgentLoopSkillExecutionEnd as M, SessionKey as Mt, createAgentLoopSkillExecutionStart as N, TerminalAgentDomainEvent as Nt, TextAgentLoopOptions as O, AgentTurnCompleted as Ot, createAgentLoopTextDelta as P, isAgentToolExecutionEvent as Pt, createAgentConversationMessages as Q, createAgentLoopToolExecutionUpdate as R, AgentLoopToolExecutionUpdate as S, AgentSkillExecutionEnded as St, AsyncIterableAgentLoopOptions as T, AgentToolExecutionEvent as Tt, AgentInvocationOrigin as U, createTextAgentLoop as V, AutomationAgentInvocationOrigin as W, AgentTranscriptMessageRole as X, AgentTranscriptMessage as Y, AgentTranscriptTurn as Z, AgentLoopThinkingDelta as _, AgentRunAccepted as _t, AgentLoopEvent as a, replayAgentHistory as at, AgentLoopToolExecutionStart as b, AgentRunFailed as bt, AgentLoopModelExecutionEnd as c, AgentSkillExecutionState as ct, AgentLoopModelExecutionStartOptions as d, isTerminalAgentRunPhase as dt, createAgentTranscriptTurn as et, AgentLoopSkillExecutionEnd as f, AgentDomainEvent as ft, AgentLoopTextDelta as g, AgentModelUsage as gt, AgentLoopSkillExecutionStartOptions as h, AgentModelExecutionStarted as ht, AgentLoopCallbackResult as i, AgentSessionSummary as it, createAgentLoopModelExecutionStart as j, AssistantThinkingDelta as jt, createAgentLoopFromCallback as k, AgentTurnStarted as kt, AgentLoopModelExecutionEndOptions as l, evolveAgentRun as lt, AgentLoopSkillExecutionStart as m, AgentModelExecutionEvent as mt, AgentLoopCallback as n, AgentHistory as nt, AgentLoopEventLike as o, AgentRunPhase as ot, AgentLoopSkillExecutionEndOptions as p, AgentModelExecutionEnded as pt, AgentConversationMessagesOptions as q, AgentLoopCallbackOutput as r, AgentRunSummary as rt, AgentLoopInput as s, AgentRunState as st, AgentLoop as t, replayAgentTranscript as tt, AgentLoopModelExecutionStart as u, initialAgentRunState as ut, AgentLoopToolExecutionEnd as v, AgentRunCancelled as vt, AgentSteeringChannel as w, AgentToolExecutionEnded as wt, AgentLoopToolExecutionStartOptions as x, AgentRunId as xt, AgentLoopToolExecutionEndOptions as y, AgentRunCompleted as yt, createAsyncIterableAgentLoop as z };