@rivus/agent 0.13.2 → 0.14.0

package/dist/chunks/agent-loop.js

@@ -0,0 +1,1272 @@
+import { Deferred, Effect, Option, Queue, Stream } from "effect";
+//#region src/modules/agent-execution/application/loop/agent-loop.ts
+function createAgentLoopTextDelta(delta) {
+	return {
+		delta,
+		type: "assistant_text_delta"
+	};
+}
+function createAgentLoopTurnStart() {
+	return { type: "turn_start" };
+}
+function normalizeAgentLoopEvent(event) {
+	return typeof event === "string" ? createAgentLoopTextDelta(event) : event;
+}
+function createAgentLoopThinkingDelta(delta) {
+	return {
+		delta,
+		type: "assistant_thinking_delta"
+	};
+}
+function createAgentLoopModelExecutionStart(options) {
+	return {
+		...options,
+		type: "model_execution_start"
+	};
+}
+function createAgentLoopModelExecutionEnd(options) {
+	return {
+		...options,
+		type: "model_execution_end"
+	};
+}
+function createAgentLoopSkillExecutionStart(options) {
+	return {
+		...options,
+		type: "skill_execution_start"
+	};
+}
+function createAgentLoopSkillExecutionEnd(options) {
+	return {
+		...options,
+		type: "skill_execution_end"
+	};
+}
+function createAgentLoopToolExecutionStart(options) {
+	return {
+		input: options.input,
+		toolCallId: options.toolCallId,
+		toolName: options.toolName,
+		type: "tool_execution_start"
+	};
+}
+function createAgentLoopToolExecutionUpdate(options) {
+	return {
+		input: options.input,
+		partialResult: options.partialResult,
+		toolCallId: options.toolCallId,
+		toolName: options.toolName,
+		type: "tool_execution_update"
+	};
+}
+function createAgentLoopToolExecutionEnd(options) {
+	return {
+		isError: options.isError,
+		result: options.result,
+		toolCallId: options.toolCallId,
+		toolName: options.toolName,
+		type: "tool_execution_end"
+	};
+}
+function createTextAgentLoop$1(options) {
+	return { run: (input) => Stream.fromEffect(options.generate(input)).pipe(Stream.map((delta) => createAgentLoopTextDelta(delta))) };
+}
+//#endregion
+//#region src/modules/agent-execution/domain/run/agent-events.ts
+function isAssistantTextDeltaEvent(event) {
+	return event.type === "assistant_text_delta";
+}
+function isAssistantThinkingDeltaEvent(event) {
+	return event.type === "assistant_thinking_delta";
+}
+function isAgentToolExecutionEvent(event) {
+	return event.type === "agent_tool_execution_started" || event.type === "agent_tool_execution_updated" || event.type === "agent_tool_execution_ended";
+}
+function isTerminalAgentDomainEvent(event) {
+	return event.type === "agent_run_completed" || event.type === "agent_run_failed" || event.type === "agent_run_cancelled";
+}
+//#endregion
+//#region src/modules/agent-execution/domain/run/agent-run-state.ts
+const initialAgentRunState = {
+	finalText: "",
+	phase: "idle",
+	skillExecutions: {},
+	thinkingText: "",
+	toolExecutions: {}
+};
+function isTerminalAgentRunPhase(phase) {
+	return phase === "completed" || phase === "failed" || phase === "cancelled";
+}
+function evolveAgentRun(state, event) {
+	switch (event.type) {
+		case "agent_run_accepted": return {
+			...state,
+			finalText: "",
+			phase: "accepted",
+			prompt: event.prompt,
+			runId: event.runId,
+			sessionKey: event.sessionKey,
+			thinkingText: "",
+			skillExecutions: {},
+			toolExecutions: {}
+		};
+		case "agent_turn_started": return {
+			...state,
+			finalText: "",
+			thinkingText: "",
+			phase: "running"
+		};
+		case "assistant_text_delta": return {
+			...state,
+			finalText: `${state.finalText}${event.delta}`
+		};
+		case "assistant_thinking_delta": return {
+			...state,
+			thinkingText: `${state.thinkingText ?? ""}${event.delta}`
+		};
+		case "agent_model_execution_started": return {
+			...state,
+			finalText: ""
+		};
+		case "agent_model_execution_ended": return state;
+		case "agent_skill_execution_started": return {
+			...state,
+			skillExecutions: {
+				...state.skillExecutions,
+				[event.skillCallId]: {
+					skillCallId: event.skillCallId,
+					skillId: event.skillId,
+					status: "running"
+				}
+			}
+		};
+		case "agent_skill_execution_ended": return {
+			...state,
+			skillExecutions: {
+				...state.skillExecutions,
+				[event.skillCallId]: {
+					...state.skillExecutions[event.skillCallId],
+					...event.isError ? {} : {
+						contentLength: event.contentLength,
+						digest: event.digest,
+						title: event.title,
+						version: event.version
+					},
+					isError: event.isError,
+					skillCallId: event.skillCallId,
+					skillId: event.skillId,
+					status: "completed"
+				}
+			}
+		};
+		case "agent_tool_execution_started": return {
+			...state,
+			toolExecutions: {
+				...state.toolExecutions,
+				[event.toolCallId]: {
+					input: event.input,
+					status: "running",
+					toolCallId: event.toolCallId,
+					toolName: event.toolName
+				}
+			}
+		};
+		case "agent_tool_execution_updated": {
+			const current = state.toolExecutions[event.toolCallId];
+			return {
+				...state,
+				toolExecutions: {
+					...state.toolExecutions,
+					[event.toolCallId]: {
+						input: event.input,
+						status: current?.status ?? "running",
+						toolCallId: event.toolCallId,
+						toolName: event.toolName,
+						partialResult: event.partialResult,
+						result: current?.result,
+						...current?.isError === void 0 ? {} : { isError: current.isError }
+					}
+				}
+			};
+		}
+		case "agent_tool_execution_ended": return {
+			...state,
+			toolExecutions: {
+				...state.toolExecutions,
+				[event.toolCallId]: {
+					input: state.toolExecutions[event.toolCallId]?.input,
+					partialResult: state.toolExecutions[event.toolCallId]?.partialResult,
+					result: event.result,
+					isError: event.isError,
+					status: "completed",
+					toolCallId: event.toolCallId,
+					toolName: event.toolName
+				}
+			}
+		};
+		case "agent_turn_completed": return {
+			...state,
+			finalText: event.finalText
+		};
+		case "agent_run_completed": return {
+			...state,
+			finalText: event.finalText,
+			phase: "completed"
+		};
+		case "agent_run_failed": return {
+			...state,
+			errorMessage: event.errorMessage,
+			phase: "failed"
+		};
+		case "agent_run_cancelled": return {
+			...state,
+			...event.reason ? { cancellationReason: event.reason } : {},
+			phase: "cancelled"
+		};
+	}
+}
+//#endregion
+//#region src/modules/agent-execution/domain/history/agent-history.ts
+function replayAgentHistory(events) {
+	const runs = /* @__PURE__ */ new Map();
+	for (const event of events) {
+		const current = runs.get(event.runId) ?? createInitialRunSummary(event);
+		const next = updateRunSummary(current, event, evolveAgentRun(current.state, event));
+		runs.set(event.runId, next);
+	}
+	const runSummaries = [...runs.values()].map(toRunSummary);
+	return {
+		runs: runSummaries,
+		sessions: buildSessionSummaries(runSummaries),
+		totalEvents: events.length
+	};
+}
+function createInitialRunSummary(event) {
+	return {
+		eventCount: 0,
+		failedSkillExecutionCount: 0,
+		failedToolExecutionCount: 0,
+		finalText: "",
+		phase: "idle",
+		runId: event.runId,
+		state: initialAgentRunState,
+		thinkingText: "",
+		skillExecutionCount: 0,
+		toolExecutionCount: 0,
+		updatedAt: event.occurredAt
+	};
+}
+function updateRunSummary(current, event, state) {
+	const toolExecutions = Object.values(state.toolExecutions);
+	const skillExecutions = Object.values(state.skillExecutions);
+	const next = {
+		...current,
+		eventCount: current.eventCount + 1,
+		failedToolExecutionCount: toolExecutions.filter((tool) => tool.isError === true).length,
+		failedSkillExecutionCount: skillExecutions.filter((skill) => skill.isError === true).length,
+		finalText: state.finalText,
+		phase: state.phase,
+		state,
+		thinkingText: state.thinkingText ?? "",
+		skillExecutionCount: skillExecutions.length,
+		toolExecutionCount: toolExecutions.length,
+		updatedAt: event.occurredAt
+	};
+	switch (event.type) {
+		case "agent_run_accepted":
+			next.acceptedAt = event.occurredAt;
+			next.prompt = event.prompt;
+			next.sessionKey = event.sessionKey;
+			break;
+		case "agent_turn_started":
+			next.startedAt = event.occurredAt;
+			next.sessionKey ??= event.sessionKey;
+			break;
+		case "agent_run_completed":
+			next.completedAt = event.occurredAt;
+			break;
+		case "agent_run_failed":
+			next.errorMessage = event.errorMessage;
+			next.failedAt = event.occurredAt;
+			break;
+		case "agent_run_cancelled":
+			if (event.reason === void 0) delete next.cancellationReason;
+			else next.cancellationReason = event.reason;
+			next.cancelledAt = event.occurredAt;
+			break;
+	}
+	return next;
+}
+function toRunSummary(summary) {
+	return {
+		...summary.acceptedAt ? { acceptedAt: summary.acceptedAt } : {},
+		...summary.cancellationReason ? { cancellationReason: summary.cancellationReason } : {},
+		...summary.cancelledAt ? { cancelledAt: summary.cancelledAt } : {},
+		...summary.completedAt ? { completedAt: summary.completedAt } : {},
+		...summary.errorMessage ? { errorMessage: summary.errorMessage } : {},
+		eventCount: summary.eventCount,
+		failedSkillExecutionCount: summary.failedSkillExecutionCount,
+		failedToolExecutionCount: summary.failedToolExecutionCount,
+		...summary.failedAt ? { failedAt: summary.failedAt } : {},
+		finalText: summary.finalText,
+		phase: summary.phase,
+		...summary.prompt ? { prompt: summary.prompt } : {},
+		runId: summary.runId,
+		...summary.sessionKey ? { sessionKey: summary.sessionKey } : {},
+		...summary.startedAt ? { startedAt: summary.startedAt } : {},
+		state: summary.state,
+		thinkingText: summary.thinkingText,
+		skillExecutionCount: summary.skillExecutionCount,
+		toolExecutionCount: summary.toolExecutionCount,
+		updatedAt: summary.updatedAt
+	};
+}
+function buildSessionSummaries(runs) {
+	const sessions = /* @__PURE__ */ new Map();
+	for (const run of runs) {
+		if (!run.sessionKey) continue;
+		sessions.set(run.sessionKey, [...sessions.get(run.sessionKey) ?? [], run]);
+	}
+	return [...sessions.entries()].map(([sessionKey, sessionRuns]) => {
+		const latest = sessionRuns[sessionRuns.length - 1];
+		if (!latest) throw new Error(`session ${sessionKey} has no runs`);
+		return {
+			failedSkillExecutionCount: latest.failedSkillExecutionCount,
+			failedToolExecutionCount: latest.failedToolExecutionCount,
+			finalText: latest.finalText,
+			latestPhase: latest.phase,
+			latestRunId: latest.runId,
+			runCount: sessionRuns.length,
+			runIds: sessionRuns.map((run) => run.runId),
+			sessionKey,
+			skillExecutionCount: latest.skillExecutionCount,
+			thinkingText: latest.thinkingText,
+			toolExecutionCount: latest.toolExecutionCount,
+			updatedAt: latest.updatedAt
+		};
+	});
+}
+//#endregion
+//#region src/modules/agent-execution/domain/transcript/agent-transcript.ts
+function replayAgentTranscript(events, sessionKey) {
+	const turns = replayAgentHistory(events).runs.filter((run) => run.sessionKey === sessionKey).map(createAgentTranscriptTurn);
+	const latestTurn = turns.at(-1);
+	return {
+		...latestTurn ? { latestTurn } : {},
+		sessionKey,
+		turnCount: turns.length,
+		turns
+	};
+}
+function createAgentTranscriptTurn(summary) {
+	return {
+		...summary.acceptedAt ? { acceptedAt: summary.acceptedAt } : {},
+		assistantText: summary.finalText,
+		...summary.cancellationReason ? { cancellationReason: summary.cancellationReason } : {},
+		...summary.cancelledAt ? { cancelledAt: summary.cancelledAt } : {},
+		...summary.completedAt ? { completedAt: summary.completedAt } : {},
+		...summary.errorMessage ? { errorMessage: summary.errorMessage } : {},
+		...summary.failedAt ? { failedAt: summary.failedAt } : {},
+		failedToolExecutionCount: summary.failedToolExecutionCount,
+		phase: summary.phase,
+		runId: summary.runId,
+		sessionKey: summary.sessionKey,
+		thinkingText: summary.thinkingText,
+		toolExecutionCount: summary.toolExecutionCount,
+		updatedAt: summary.updatedAt,
+		userText: summary.prompt ?? ""
+	};
+}
+function createAgentTranscriptMessages(transcript) {
+	return transcript.turns.flatMap((turn) => {
+		const messages = [{
+			content: turn.userText,
+			role: "user"
+		}];
+		if (turn.assistantText) messages.push({
+			content: turn.assistantText,
+			role: "assistant"
+		});
+		return messages;
+	});
+}
+function createAgentConversationMessages(options) {
+	return [...options.transcript ? createAgentTranscriptMessages(options.transcript) : [], {
+		content: options.text,
+		role: "user"
+	}];
+}
+//#endregion
+//#region src/modules/agent-execution/application/contracts/agent-execution-errors.ts
+var AgentHarnessBusy = class {
+	activeRun;
+	activeState;
+	_tag = "AgentHarnessBusy";
+	activeRunId;
+	activeSessionKey;
+	constructor(activeRun, activeState) {
+		this.activeRun = activeRun;
+		this.activeState = activeState;
+		this.activeRunId = activeRun.runId;
+		this.activeSessionKey = activeRun.sessionKey;
+	}
+};
+var AgentLoopFailed = class {
+	runId;
+	errorMessage;
+	cause;
+	state;
+	_tag = "AgentLoopFailed";
+	constructor(runId, errorMessage, cause, state) {
+		this.runId = runId;
+		this.errorMessage = errorMessage;
+		this.cause = cause;
+		this.state = state;
+	}
+};
+var AgentEventSinkFailed = class {
+	runId;
+	eventType;
+	cause;
+	_tag = "AgentEventSinkFailed";
+	constructor(runId, eventType, cause) {
+		this.runId = runId;
+		this.eventType = eventType;
+		this.cause = cause;
+	}
+};
+var AgentEventHandlerFailed = class {
+	runId;
+	eventType;
+	cause;
+	state;
+	_tag = "AgentEventHandlerFailed";
+	constructor(runId, eventType, cause, state) {
+		this.runId = runId;
+		this.eventType = eventType;
+		this.cause = cause;
+		this.state = state;
+	}
+};
+var AgentRunCancelled = class {
+	runId;
+	reason;
+	state;
+	_tag = "AgentRunCancelled";
+	constructor(runId, reason, state) {
+		this.runId = runId;
+		this.reason = reason;
+		this.state = state;
+	}
+};
+//#endregion
+//#region src/modules/agent-execution/application/execution/agent-event-sink.ts
+function createAgentDomainEventSink(append) {
+	return { append };
+}
+//#endregion
+//#region src/modules/agent-execution/application/query/agent-event-notifications.ts
+function notifyListeners(listeners, event) {
+	for (const listener of listeners) try {
+		listener(event);
+	} catch {}
+}
+function notifyUpdateListeners(listeners, update) {
+	for (const listener of listeners) try {
+		listener(update);
+	} catch {}
+}
+//#endregion
+//#region src/modules/agent-execution/application/query/agent-run-projection.ts
+function toRunUpdate(event, state, previousState) {
+	return {
+		event,
+		...previousState ? { previousState } : {},
+		state
+	};
+}
+function replayRunUpdates(events) {
+	const updates = [];
+	let state = initialAgentRunState;
+	for (const event of events) {
+		const previousState = updates.length === 0 ? void 0 : state;
+		state = evolveAgentRun(state, event);
+		updates.push(toRunUpdate(event, state, previousState));
+	}
+	return updates;
+}
+function buildRunSnapshot(runId, events, updates, state, summary = replayAgentHistory(events).runs[0]) {
+	return {
+		events: [...events],
+		runId,
+		...state ? { state } : {},
+		summary,
+		updates: [...updates]
+	};
+}
+//#endregion
+//#region src/modules/agent-execution/application/query/agent-session-history.ts
+function projectAgentSessionHistory(events, runStates, sessionKey) {
+	const history = replayAgentHistory(events.filter((event) => runStates.get(event.runId)?.sessionKey === sessionKey));
+	const runs = history.runs;
+	const latestRunSummary = runs.at(-1);
+	const summary = history.sessions[0];
+	return {
+		history,
+		...latestRunSummary ? { latestRunSummary } : {},
+		runs,
+		...summary ? { summary } : {},
+		transcript: replayAgentTranscript(events, sessionKey)
+	};
+}
+function buildAgentSessionSnapshot(input) {
+	return {
+		availability: input.availability,
+		...input.view.latestRunSummary ? { latestRunSummary: input.view.latestRunSummary } : {},
+		runs: input.view.runs,
+		sessionKey: input.sessionKey,
+		...input.state ? { state: input.state } : {},
+		...input.view.summary ? { summary: input.view.summary } : {},
+		transcript: input.view.transcript
+	};
+}
+//#endregion
+//#region src/modules/agent-execution/application/query/agent-execution-query-store.ts
+function createAgentExecutionQueryStore(options = {}) {
+	const domainEvents = [];
+	const runEvents = /* @__PURE__ */ new Map();
+	const runStates = /* @__PURE__ */ new Map();
+	const sessionStates = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Set();
+	const updateListeners = /* @__PURE__ */ new Set();
+	let latestState = initialAgentRunState;
+	const recordEvent = (event, notify) => {
+		const previousEvents = runEvents.get(event.runId);
+		const previousState = previousEvents && previousEvents.length > 0 ? runStates.get(event.runId) : void 0;
+		domainEvents.push(event);
+		if (previousEvents) previousEvents.push(event);
+		else runEvents.set(event.runId, [event]);
+		const state = evolveAgentRun(previousState ?? initialAgentRunState, event);
+		const update = toRunUpdate(event, state, previousState);
+		latestState = state;
+		if (state.runId) runStates.set(state.runId, state);
+		if (state.sessionKey) sessionStates.set(state.sessionKey, state);
+		if (notify) {
+			notifyListeners(listeners, event);
+			notifyUpdateListeners(updateListeners, update);
+		}
+		return update;
+	};
+	for (const event of options.initialEvents ?? []) recordEvent(event, false);
+	for (const state of options.initialRunStates ?? []) {
+		if (state.runId) runStates.set(state.runId, state);
+		if (state.sessionKey && isTerminalAgentRunPhase(state.phase)) sessionStates.set(state.sessionKey, state);
+		latestState = state;
+	}
+	const getRunEvents = (runId) => {
+		const events = runEvents.get(runId);
+		return events ? [...events] : void 0;
+	};
+	const getRunSummary = (runId) => {
+		const events = runEvents.get(runId);
+		return events ? replayAgentHistory(events).runs[0] : void 0;
+	};
+	const getRunUpdates = (runId) => {
+		const events = runEvents.get(runId);
+		return events ? replayRunUpdates(events) : void 0;
+	};
+	const getRunSnapshot = (runId) => {
+		const events = getRunEvents(runId);
+		const summary = getRunSummary(runId);
+		return events && summary ? buildRunSnapshot(runId, events, getRunUpdates(runId) ?? [], runStates.get(runId), summary) : void 0;
+	};
+	const getSessionView = (sessionKey) => projectAgentSessionHistory(domainEvents, runStates, sessionKey);
+	const getSessionHistory = (sessionKey) => getSessionView(sessionKey).history;
+	const getSessionRuns = (sessionKey) => getSessionView(sessionKey).runs;
+	const getSessionLatestRunSummary = (sessionKey) => getSessionView(sessionKey).latestRunSummary;
+	const getSessionRunSnapshot = (sessionKey, runId) => runStates.get(runId)?.sessionKey === sessionKey ? getRunSnapshot(runId) : void 0;
+	const getSessionLatestRunSnapshot = (sessionKey) => {
+		const latestRunId = getSessionLatestRunSummary(sessionKey)?.runId;
+		return latestRunId ? getSessionRunSnapshot(sessionKey, latestRunId) : void 0;
+	};
+	const subscribe = (listener) => {
+		listeners.add(listener);
+		return () => listeners.delete(listener);
+	};
+	const subscribeUpdates = (listener) => {
+		updateListeners.add(listener);
+		return () => updateListeners.delete(listener);
+	};
+	return {
+		project: (event) => recordEvent(event, true),
+		getHistory: () => replayAgentHistory(domainEvents),
+		getLatestState: () => latestState,
+		getRunEvents,
+		getRunSnapshot,
+		getRunState: (runId) => runStates.get(runId),
+		getRunSummary,
+		getRunUpdates,
+		getSessionHistory,
+		getSessionLatestRunSnapshot,
+		getSessionLatestRunSummary,
+		getSessionRunEvents: (sessionKey, runId) => runStates.get(runId)?.sessionKey === sessionKey ? getRunEvents(runId) : void 0,
+		getSessionRunSnapshot,
+		getSessionRunState: (sessionKey, runId) => {
+			const state = runStates.get(runId);
+			return state?.sessionKey === sessionKey ? state : void 0;
+		},
+		getSessionRunSummary: (sessionKey, runId) => runStates.get(runId)?.sessionKey === sessionKey ? getRunSummary(runId) : void 0,
+		getSessionRunUpdates: (sessionKey, runId) => runStates.get(runId)?.sessionKey === sessionKey ? getRunUpdates(runId) : void 0,
+		getSessionRuns,
+		getSessionSnapshot: (sessionKey, availability) => {
+			const state = sessionStates.get(sessionKey);
+			return buildAgentSessionSnapshot({
+				availability,
+				sessionKey,
+				...state ? { state } : {},
+				view: getSessionView(sessionKey)
+			});
+		},
+		getSessionState: (sessionKey) => sessionStates.get(sessionKey),
+		getSessionSummary: (sessionKey) => getSessionView(sessionKey).summary,
+		getSessionTranscript: (sessionKey) => getSessionView(sessionKey).transcript,
+		subscribe,
+		subscribeRun: (runId, listener) => subscribe((event) => {
+			if (event.runId === runId) listener(event);
+		}),
+		subscribeRunUpdates: (runId, listener) => subscribeUpdates((update) => {
+			if (update.event.runId === runId) listener(update);
+		}),
+		subscribeSession: (sessionKey, listener) => subscribe((event) => {
+			if (runStates.get(event.runId)?.sessionKey === sessionKey) listener(event);
+		}),
+		subscribeSessionRun: (sessionKey, runId, listener) => subscribe((event) => {
+			if (event.runId === runId && runStates.get(runId)?.sessionKey === sessionKey) listener(event);
+		}),
+		subscribeSessionRunUpdates: (sessionKey, runId, listener) => subscribeUpdates((update) => {
+			if (update.event.runId === runId && update.state.sessionKey === sessionKey) listener(update);
+		}),
+		subscribeSessionUpdates: (sessionKey, listener) => subscribeUpdates((update) => {
+			if (update.state.sessionKey === sessionKey) listener(update);
+		}),
+		subscribeUpdates
+	};
+}
+//#endregion
+//#region src/modules/agent-execution/application/streaming/agent-run-streams.ts
+function createAgentRunStreams(runPrompt) {
+	return {
+		events: (command) => createProjectedRunStream(runPrompt, command, (event) => Option.some(event)),
+		text: (command) => createProjectedRunStream(runPrompt, command, (event) => event.type === "assistant_text_delta" ? Option.some(event.delta) : Option.none()),
+		updates: (command) => createProjectedRunStream(runPrompt, command, (event, state, previousState) => Option.some(toRunUpdate(event, state, previousState)))
+	};
+}
+function createProjectedRunStream(runPrompt, command, project) {
+	return Stream.asyncEffect((emit) => runPrompt(command, (event, state, previousState) => Option.match(project(event, state, previousState), {
+		onNone: () => Effect.void,
+		onSome: (value) => Effect.promise(() => emit.single(value))
+	}), "stream interrupted").pipe(Effect.flatMap(() => Effect.promise(() => emit.end())), Effect.catchAll((error) => Effect.promise(() => emit.fail(error)))));
+}
+//#endregion
+//#region src/modules/agent-execution/application/execution/agent-loop-event-mapper.ts
+function describeLoopError(error) {
+	if (error instanceof Error) return error.message;
+	if (typeof error === "string") return error;
+	try {
+		return JSON.stringify(error);
+	} catch {
+		return String(error);
+	}
+}
+function toDomainEvent(runId, sessionKey, event, occurredAt) {
+	switch (event.type) {
+		case "turn_start": return {
+			occurredAt,
+			runId,
+			sessionKey,
+			type: "agent_turn_started"
+		};
+		case "assistant_text_delta": return {
+			delta: event.delta,
+			occurredAt,
+			runId,
+			type: "assistant_text_delta"
+		};
+		case "assistant_thinking_delta": return {
+			delta: event.delta,
+			occurredAt,
+			runId,
+			type: "assistant_thinking_delta"
+		};
+		case "model_execution_start": return {
+			api: event.api,
+			model: event.model,
+			modelCallId: event.modelCallId,
+			occurredAt,
+			provider: event.provider,
+			runId,
+			type: "agent_model_execution_started"
+		};
+		case "model_execution_end": return {
+			api: event.api,
+			...event.errorMessage ? { errorMessage: event.errorMessage } : {},
+			model: event.model,
+			modelCallId: event.modelCallId,
+			occurredAt,
+			provider: event.provider,
+			...event.responseModel ? { responseModel: event.responseModel } : {},
+			runId,
+			stopReason: event.stopReason,
+			type: "agent_model_execution_ended",
+			usage: event.usage
+		};
+		case "skill_execution_start": return {
+			occurredAt,
+			runId,
+			skillCallId: event.skillCallId,
+			skillId: event.skillId,
+			type: "agent_skill_execution_started"
+		};
+		case "skill_execution_end": return event.isError ? {
+			isError: true,
+			occurredAt,
+			runId,
+			skillCallId: event.skillCallId,
+			skillId: event.skillId,
+			type: "agent_skill_execution_ended"
+		} : {
+			contentLength: event.contentLength,
+			digest: event.digest,
+			isError: false,
+			occurredAt,
+			runId,
+			skillCallId: event.skillCallId,
+			skillId: event.skillId,
+			title: event.title,
+			type: "agent_skill_execution_ended",
+			version: event.version
+		};
+		case "tool_execution_start": return {
+			input: event.input,
+			occurredAt,
+			runId,
+			toolCallId: event.toolCallId,
+			toolName: event.toolName,
+			type: "agent_tool_execution_started"
+		};
+		case "tool_execution_update": return {
+			input: event.input,
+			occurredAt,
+			partialResult: event.partialResult,
+			runId,
+			toolCallId: event.toolCallId,
+			toolName: event.toolName,
+			type: "agent_tool_execution_updated"
+		};
+		case "tool_execution_end": return {
+			isError: event.isError,
+			occurredAt,
+			result: event.result,
+			runId,
+			toolCallId: event.toolCallId,
+			toolName: event.toolName,
+			type: "agent_tool_execution_ended"
+		};
+	}
+}
+//#endregion
+//#region src/modules/agent-execution/application/execution/agent-harness.ts
+function createSteeringChannel() {
+	return Queue.unbounded().pipe(Effect.map((queue) => ({
+		next: () => Queue.take(queue),
+		push: (text) => Queue.offer(queue, text).pipe(Effect.asVoid)
+	})));
+}
+function createAgentHarness(options) {
+	if (options.runTimeoutMs !== void 0 && (!Number.isSafeInteger(options.runTimeoutMs) || options.runTimeoutMs < 1)) throw new Error("Agent run timeout must be a positive integer");
+	let activeRun;
+	let activeCancellation;
+	let activeRunState;
+	const queryStore = createAgentExecutionQueryStore({
+		...options.initialEvents ? { initialEvents: options.initialEvents } : {},
+		...options.initialRunStates ? { initialRunStates: options.initialRunStates } : {}
+	});
+	const getAvailability = () => {
+		if (!activeRun) return { busy: false };
+		return {
+			activeRun,
+			activeRunId: activeRun.runId,
+			activeSessionKey: activeRun.sessionKey,
+			...activeRunState ? { activeState: activeRunState } : {},
+			busy: true
+		};
+	};
+	const getSessionAvailability = (sessionKey) => {
+		if (!activeRun) return { busy: false };
+		if (activeRun.sessionKey !== sessionKey) return {
+			activeInSession: false,
+			busy: true
+		};
+		return {
+			activeInSession: true,
+			activeRun,
+			activeRunId: activeRun.runId,
+			...activeRunState ? { activeState: activeRunState } : {},
+			busy: true
+		};
+	};
+	const runPrompt = (command, emit, interruptionReason = "run interrupted") => Effect.gen(function* () {
+		if (activeRun !== void 0) return yield* Effect.fail(new AgentHarnessBusy(activeRun, activeRunState));
+		const runId = yield* options.runIds.next;
+		activeRun = {
+			runId,
+			sessionKey: command.sessionKey
+		};
+		const previousSessionState = queryStore.getSessionState(command.sessionKey);
+		const previousSessionTranscript = queryStore.getSessionTranscript(command.sessionKey);
+		const cancellation = {
+			abortController: new AbortController(),
+			deferred: yield* Deferred.make(),
+			steering: yield* createSteeringChannel()
+		};
+		activeCancellation = cancellation;
+		const events = [];
+		const updates = [];
+		let settled = false;
+		let state = initialAgentRunState;
+		const project = (event) => Effect.gen(function* () {
+			for (const sink of options.eventSinks ?? []) yield* Effect.try({
+				try: () => sink.append(event),
+				catch: (error) => error
+			}).pipe(Effect.flatMap((appendEffect) => appendEffect), Effect.catchAll((error) => Effect.fail(new AgentEventSinkFailed(event.runId, event.type, error))));
+			events.push(event);
+			const update = queryStore.project(event);
+			state = update.state;
+			updates.push(update);
+			if (activeRun?.runId === state.runId) activeRunState = state;
+			return update;
+		});
+		const record = (event) => Effect.gen(function* () {
+			const update = yield* project(event);
+			yield* emit(update.event, update.state, update.previousState).pipe(Effect.catchAll((error) => Effect.fail(new AgentEventHandlerFailed(event.runId, event.type, error, state))));
+		});
+		const recordWithoutEmit = (event) => project(event).pipe(Effect.asVoid);
+		const recordInterruptedRun = Effect.gen(function* () {
+			if (settled) return;
+			if (!cancellation.abortController.signal.aborted) cancellation.abortController.abort({
+				reason: interruptionReason,
+				runId,
+				sessionKey: command.sessionKey
+			});
+			const interruptedAt = yield* options.clock.now;
+			yield* recordWithoutEmit({
+				reason: cancellation.requested?.reason ?? interruptionReason,
+				occurredAt: interruptedAt,
+				runId,
+				type: "agent_run_cancelled"
+			}).pipe(Effect.catchAll(() => Effect.void));
+			settled = true;
+		});
+		return yield* Effect.gen(function* () {
+			const acceptedAt = yield* options.clock.now;
+			yield* record({
+				occurredAt: acceptedAt,
+				prompt: command.text,
+				runId,
+				sessionKey: command.sessionKey,
+				type: "agent_run_accepted"
+			});
+			const startedAt = yield* options.clock.now;
+			yield* record({
+				occurredAt: startedAt,
+				runId,
+				sessionKey: command.sessionKey,
+				type: "agent_turn_started"
+			});
+			const loopInput = {
+				abortSignal: cancellation.abortController.signal,
+				...command.invocation ? { invocation: command.invocation } : {},
+				messages: createAgentConversationMessages({
+					text: command.text,
+					transcript: previousSessionTranscript
+				}),
+				...previousSessionState ? { previousSessionState } : {},
+				...previousSessionTranscript.turnCount > 0 ? { previousSessionTranscript } : {},
+				runId,
+				sessionKey: command.sessionKey,
+				...options.loop.supportsSteering ? { steering: cancellation.steering } : {},
+				text: command.text
+			};
+			const loop = Effect.try({
+				try: () => options.loop.run(loopInput),
+				catch: (error) => error
+			}).pipe(Effect.flatMap((loopStream) => Stream.runForEach(loopStream.pipe(Stream.interruptWhenDeferred(cancellation.deferred)), (event) => Effect.gen(function* () {
+				const occurredAt = yield* options.clock.now;
+				yield* record(toDomainEvent(runId, command.sessionKey, event, occurredAt));
+			}))), Effect.catchAll((error) => {
+				if (error instanceof AgentEventSinkFailed || error instanceof AgentEventHandlerFailed) return Effect.fail(error);
+				return Effect.gen(function* () {
+					const occurredAt = yield* options.clock.now;
+					const errorMessage = describeLoopError(error);
+					yield* record({
+						errorMessage,
+						occurredAt,
+						runId,
+						type: "agent_run_failed"
+					});
+					settled = true;
+					return yield* Effect.fail(new AgentLoopFailed(runId, errorMessage, error, state));
+				});
+			}));
+			yield* options.runTimeoutMs === void 0 ? loop : Effect.raceFirst(loop, Effect.sleep(options.runTimeoutMs).pipe(Effect.flatMap(() => {
+				const request = {
+					reason: `run timed out after ${options.runTimeoutMs}ms`,
+					runId,
+					sessionKey: command.sessionKey
+				};
+				cancellation.requested = request;
+				cancellation.abortController.abort(request);
+				return Deferred.succeed(cancellation.deferred, request);
+			}), Effect.asVoid));
+			if (cancellation.requested) {
+				const cancelledAt = yield* options.clock.now;
+				yield* record({
+					...cancellation.requested.reason ? { reason: cancellation.requested.reason } : {},
+					occurredAt: cancelledAt,
+					runId,
+					type: "agent_run_cancelled"
+				});
+				settled = true;
+				return yield* Effect.fail(new AgentRunCancelled(runId, cancellation.requested.reason, state));
+			}
+			const turnCompletedAt = yield* options.clock.now;
+			yield* record({
+				finalText: state.finalText,
+				occurredAt: turnCompletedAt,
+				runId,
+				type: "agent_turn_completed"
+			});
+			const completedAt = yield* options.clock.now;
+			yield* record({
+				finalText: state.finalText,
+				occurredAt: completedAt,
+				runId,
+				type: "agent_run_completed"
+			});
+			settled = true;
+			const runSnapshot = buildRunSnapshot(runId, events, updates, state);
+			const turn = createAgentTranscriptTurn({
+				...runSnapshot.summary,
+				sessionKey: command.sessionKey
+			});
+			return {
+				events,
+				finalText: state.finalText,
+				runId,
+				runSnapshot,
+				snapshot: queryStore.getSessionSnapshot(command.sessionKey, { busy: false }),
+				state,
+				turn,
+				updates
+			};
+		}).pipe(Effect.onInterrupt(() => recordInterruptedRun), Effect.ensuring(Effect.sync(() => {
+			if (!settled && !cancellation.abortController.signal.aborted) cancellation.abortController.abort({
+				reason: interruptionReason,
+				runId,
+				sessionKey: command.sessionKey
+			});
+			activeRun = void 0;
+			activeCancellation = void 0;
+			activeRunState = void 0;
+		})));
+	});
+	const requestCancellation = (runId, reason) => Effect.gen(function* () {
+		if (!activeRun || activeRun.runId !== runId || !activeCancellation || activeCancellation.requested) return false;
+		const request = {
+			...reason ? { reason } : {},
+			runId: activeRun.runId,
+			sessionKey: activeRun.sessionKey
+		};
+		const completed = yield* Deferred.succeed(activeCancellation.deferred, request);
+		if (completed) {
+			activeCancellation.requested = request;
+			activeCancellation.abortController.abort(request);
+		}
+		return completed;
+	});
+	const requestSteering = (runId, text) => Effect.gen(function* () {
+		const normalized = text.trim();
+		if (!normalized || !options.loop.supportsSteering || !activeRun || activeRun.runId !== runId || !activeCancellation || activeCancellation.requested) return false;
+		yield* activeCancellation.steering.push(normalized);
+		return true;
+	});
+	const requestSessionCancellation = (sessionKey, runId, reason) => {
+		if (!activeRun || activeRun.sessionKey !== sessionKey) return Effect.succeed(false);
+		return requestCancellation(runId, reason);
+	};
+	const requestSessionSteering = (sessionKey, runId, text) => {
+		if (!activeRun || activeRun.sessionKey !== sessionKey) return Effect.succeed(false);
+		return requestSteering(runId, text);
+	};
+	const requestSessionActiveCancellation = (sessionKey, reason) => {
+		if (!activeRun || activeRun.sessionKey !== sessionKey) return Effect.succeed(false);
+		return requestCancellation(activeRun.runId, reason);
+	};
+	const getSessionActiveRun = (sessionKey) => activeRun?.sessionKey === sessionKey ? activeRun : void 0;
+	const getSessionActiveRunState = (sessionKey) => activeRun?.sessionKey === sessionKey ? activeRunState : void 0;
+	const getSessionSnapshot = (sessionKey) => queryStore.getSessionSnapshot(sessionKey, getSessionAvailability(sessionKey));
+	const streams = createAgentRunStreams(runPrompt);
+	return {
+		cancelActiveRun: (reason) => Effect.gen(function* () {
+			if (!activeRun) return false;
+			return yield* requestCancellation(activeRun.runId, reason);
+		}),
+		cancelRun: requestCancellation,
+		steerRun: requestSteering,
+		forSession: (sessionKey) => ({
+			cancelActiveRun: (reason) => requestSessionActiveCancellation(sessionKey, reason),
+			cancelRun: (runId, reason) => requestSessionCancellation(sessionKey, runId, reason),
+			steerRun: (runId, text) => requestSessionSteering(sessionKey, runId, text),
+			getActiveRun: () => getSessionActiveRun(sessionKey),
+			getActiveRunState: () => getSessionActiveRunState(sessionKey),
+			getAvailability: () => getSessionAvailability(sessionKey),
+			getHistory: () => queryStore.getSessionHistory(sessionKey),
+			getLatestRunSnapshot: () => queryStore.getSessionLatestRunSnapshot(sessionKey),
+			getLatestRunSummary: () => queryStore.getSessionLatestRunSummary(sessionKey),
+			getRunEvents: (runId) => queryStore.getSessionRunEvents(sessionKey, runId),
+			getRunSnapshot: (runId) => queryStore.getSessionRunSnapshot(sessionKey, runId),
+			getRunSummary: (runId) => queryStore.getSessionRunSummary(sessionKey, runId),
+			getRuns: () => queryStore.getSessionRuns(sessionKey),
+			getSnapshot: () => getSessionSnapshot(sessionKey),
+			getSummary: () => queryStore.getSessionSummary(sessionKey),
+			getTranscript: () => queryStore.getSessionTranscript(sessionKey),
+			getRunState: (runId) => queryStore.getSessionRunState(sessionKey, runId),
+			getRunUpdates: (runId) => queryStore.getSessionRunUpdates(sessionKey, runId),
+			getState: () => queryStore.getSessionState(sessionKey),
+			prompt: (text) => runPrompt({
+				sessionKey,
+				text
+			}, () => Effect.void),
+			promptRunSnapshot: (text) => runPrompt({
+				sessionKey,
+				text
+			}, () => Effect.void).pipe(Effect.map((result) => result.runSnapshot)),
+			promptSnapshot: (text) => runPrompt({
+				sessionKey,
+				text
+			}, () => Effect.void).pipe(Effect.map((result) => result.snapshot)),
+			promptText: (text) => runPrompt({
+				sessionKey,
+				text
+			}, () => Effect.void).pipe(Effect.map((result) => result.finalText)),
+			promptTurn: (text) => runPrompt({
+				sessionKey,
+				text
+			}, () => Effect.void).pipe(Effect.map((result) => result.turn)),
+			promptWithEvents: (text, onEvent) => runPrompt({
+				sessionKey,
+				text
+			}, (event) => onEvent(event)),
+			promptWithUpdates: (text, onUpdate) => runPrompt({
+				sessionKey,
+				text
+			}, (event, state, previousState) => onUpdate(toRunUpdate(event, state, previousState))),
+			stream: (text) => streams.events({
+				sessionKey,
+				text
+			}),
+			streamText: (text) => streams.text({
+				sessionKey,
+				text
+			}),
+			streamUpdates: (text) => streams.updates({
+				sessionKey,
+				text
+			}),
+			subscribe: (listener) => queryStore.subscribeSession(sessionKey, listener),
+			subscribeRun: (runId, listener) => queryStore.subscribeSessionRun(sessionKey, runId, listener),
+			subscribeRunUpdates: (runId, listener) => queryStore.subscribeSessionRunUpdates(sessionKey, runId, listener),
+			subscribeUpdates: (listener) => queryStore.subscribeSessionUpdates(sessionKey, listener),
+			sessionKey
+		}),
+		getActiveRun: () => activeRun,
+		getActiveRunId: () => activeRun?.runId,
+		getActiveRunState: () => activeRunState,
+		getAvailability,
+		getHistory: () => queryStore.getHistory(),
+		getRunEvents: (runId) => queryStore.getRunEvents(runId),
+		getRunSnapshot: (runId) => queryStore.getRunSnapshot(runId),
+		getRunSummary: (runId) => queryStore.getRunSummary(runId),
+		getRunState: (runId) => queryStore.getRunState(runId),
+		getRunUpdates: (runId) => queryStore.getRunUpdates(runId),
+		getSessionHistory: (sessionKey) => queryStore.getSessionHistory(sessionKey),
+		getSessionLatestRunSnapshot: (sessionKey) => queryStore.getSessionLatestRunSnapshot(sessionKey),
+		getSessionLatestRunSummary: (sessionKey) => queryStore.getSessionLatestRunSummary(sessionKey),
+		getSessionRuns: (sessionKey) => queryStore.getSessionRuns(sessionKey),
+		getSessionSnapshot,
+		getSessionSummary: (sessionKey) => queryStore.getSessionSummary(sessionKey),
+		getSessionTranscript: (sessionKey) => queryStore.getSessionTranscript(sessionKey),
+		getSessionState: (sessionKey) => queryStore.getSessionState(sessionKey),
+		getState: () => queryStore.getLatestState(),
+		prompt: (command) => runPrompt(command, () => Effect.void),
+		promptRunSnapshot: (command) => runPrompt(command, () => Effect.void).pipe(Effect.map((result) => result.runSnapshot)),
+		promptSnapshot: (command) => runPrompt(command, () => Effect.void).pipe(Effect.map((result) => result.snapshot)),
+		promptText: (command) => runPrompt(command, () => Effect.void).pipe(Effect.map((result) => result.finalText)),
+		promptTurn: (command) => runPrompt(command, () => Effect.void).pipe(Effect.map((result) => result.turn)),
+		promptWithEvents: (command, onEvent) => runPrompt(command, (event) => onEvent(event)),
+		promptWithUpdates: (command, onUpdate) => runPrompt(command, (event, state, previousState) => onUpdate(toRunUpdate(event, state, previousState))),
+		stream: (command) => streams.events(command),
+		streamText: (command) => streams.text(command),
+		streamUpdates: (command) => streams.updates(command),
+		subscribe: (listener) => queryStore.subscribe(listener),
+		subscribeRun: (runId, listener) => queryStore.subscribeRun(runId, listener),
+		subscribeRunUpdates: (runId, listener) => queryStore.subscribeRunUpdates(runId, listener),
+		subscribeUpdates: (listener) => queryStore.subscribeUpdates(listener)
+	};
+}
+//#endregion
+//#region src/modules/agent-execution/application/history/agent-history.ts
+function restoreAgentHistory(eventLog) {
+	return eventLog.readAll().pipe(Effect.map(replayAgentHistory));
+}
+//#endregion
+//#region src/modules/agent-execution/application/context/agent-context-assembler.ts
+var AgentContextBudgetExceeded = class extends Error {
+	name = "AgentContextBudgetExceeded";
+};
+function assembleAgentContext(input) {
+	const required = [
+		layer("host-safety", input.hostSafety),
+		layer("system-prompt", input.systemPrompt),
+		...input.managedInstructions ? [layer("managed-instructions", input.managedInstructions)] : [],
+		...input.toolSchemas.map((content) => layer("tool-schema", content)),
+		layer("current-input", input.currentInput)
+	];
+	let bytes = size(required);
+	if (bytes > input.maxBytes) throw new AgentContextBudgetExceeded("required context layers exceed byte budget");
+	const selected = [...required];
+	const optional = [
+		...(input.workspaceInstructions ?? []).map((content) => layer("workspace-instructions", content)),
+		...(input.skills ?? []).map((content) => layer("skill", content)),
+		...(input.memory ?? []).map((content) => layer("memory", content)),
+		...input.compaction ? [layer("compaction", input.compaction)] : [],
+		...(input.transcript ?? []).map((content) => layer("transcript", content))
+	];
+	const omitted = /* @__PURE__ */ new Set();
+	for (const candidate of optional) {
+		const candidateBytes = byteLength(candidate.content);
+		if (bytes + candidateBytes <= input.maxBytes) {
+			selected.push(candidate);
+			bytes += candidateBytes;
+		} else omitted.add(candidate.kind);
+	}
+	const order = [
+		"host-safety",
+		"system-prompt",
+		"managed-instructions",
+		"workspace-instructions",
+		"tool-schema",
+		"skill",
+		"memory",
+		"compaction",
+		"transcript",
+		"current-input"
+	];
+	selected.sort((a, b) => order.indexOf(a.kind) - order.indexOf(b.kind));
+	return Object.freeze({
+		bytes,
+		layers: Object.freeze(selected),
+		omittedKinds: Object.freeze(order.filter((kind) => omitted.has(kind)))
+	});
+}
+function layer(kind, content) {
+	return Object.freeze({
+		kind,
+		content
+	});
+}
+function size(layers) {
+	return layers.reduce((total, item) => total + byteLength(item.content), 0);
+}
+function byteLength(value) {
+	return new TextEncoder().encode(value).byteLength;
+}
+//#endregion
+//#region src/adapters/compatibility/agent-execution/loop/agent-loop.ts
+function createEventAgentLoop(options) {
+	return { run: (input) => {
+		const events = typeof options.events === "function" ? options.events(input) : options.events;
+		if (isPromiseLike(events)) return Stream.fromEffect(Effect.tryPromise({
+			try: () => events,
+			catch: (cause) => cause
+		})).pipe(Stream.flatMap((resolvedEvents) => Stream.fromIterable(resolvedEvents)), Stream.map(normalizeAgentLoopEvent));
+		return Stream.fromIterable(events).pipe(Stream.map(normalizeAgentLoopEvent));
+	} };
+}
+function createAsyncIterableAgentLoop(options) {
+	return { run: (input) => Stream.fromAsyncIterable(options.run(input), (error) => error).pipe(Stream.map(normalizeAgentLoopEvent)) };
+}
+function createAgentLoopFromCallback(run) {
+	return { run: (input) => Stream.fromEffect(Effect.try({
+		try: () => run(input),
+		catch: (cause) => cause
+	})).pipe(Stream.flatMap(streamFromAgentLoopCallbackResult)) };
+}
+function createTextAgentLoop(options) {
+	return fromEffectAgentLoop(createTextAgentLoop$1({ generate: (input) => options.generate(toCompatibilityAgentLoopInput(input)) }));
+}
+function createTextAgentLoopFromCallback(generate) {
+	return createTextAgentLoop({ generate: (input) => Effect.tryPromise({
+		try: async () => generate(input),
+		catch: (cause) => cause
+	}) });
+}
+function toEffectAgentLoop(loop) {
+	return {
+		run: (input) => loop.run(toCompatibilityAgentLoopInput(input)),
+		...loop.supportsSteering ? { supportsSteering: true } : {}
+	};
+}
+function fromEffectAgentLoop(loop) {
+	return {
+		run: (input) => loop.run(toEffectAgentLoopInput(input)),
+		...loop.supportsSteering ? { supportsSteering: true } : {}
+	};
+}
+function toEffectAgentLoopInput(input) {
+	const { steering, ...rest } = input;
+	return {
+		...rest,
+		...steering ? { steering: { next: () => Effect.promise(() => steering.next()) } } : {}
+	};
+}
+function toCompatibilityAgentLoopInput(input) {
+	const { steering, ...rest } = input;
+	return {
+		...rest,
+		...steering ? { steering: { next: () => Effect.runPromise(steering.next()) } } : {}
+	};
+}
+function isPromiseLike(value) {
+	return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
+}
+function streamFromAgentLoopCallbackResult(result) {
+	if (Effect.isEffect(result)) return Stream.fromEffect(result).pipe(Stream.flatMap(streamFromAgentLoopCallbackOutput));
+	if (isPromiseLike(result)) return Stream.fromEffect(Effect.tryPromise({
+		try: () => Promise.resolve(result),
+		catch: (cause) => cause
+	})).pipe(Stream.flatMap(streamFromAgentLoopCallbackOutput));
+	return streamFromAgentLoopCallbackOutput(result);
+}
+function streamFromAgentLoopCallbackOutput(output) {
+	if (isEffectStream(output)) return output.pipe(Stream.map(normalizeAgentLoopEvent));
+	return (isAsyncIterable(output) ? Stream.fromAsyncIterable(output, (error) => error) : Stream.fromIterable(output)).pipe(Stream.map(normalizeAgentLoopEvent));
+}
+function isAsyncIterable(value) {
+	return Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
+}
+function isEffectStream(value) {
+	return typeof value === "object" && value !== null && Stream.StreamTypeId in value;
+}
+//#endregion
+export { isAssistantThinkingDeltaEvent as A, createAgentLoopToolExecutionUpdate as B, replayAgentTranscript as C, isTerminalAgentRunPhase as D, initialAgentRunState as E, createAgentLoopSkillExecutionStart as F, createAgentLoopTextDelta as I, createAgentLoopThinkingDelta as L, createAgentLoopModelExecutionEnd as M, createAgentLoopModelExecutionStart as N, isAgentToolExecutionEvent as O, createAgentLoopSkillExecutionEnd as P, createAgentLoopToolExecutionEnd as R, createAgentTranscriptTurn as S, evolveAgentRun as T, createAgentLoopTurnStart as V, AgentHarnessBusy as _, createTextAgentLoopFromCallback as a, createAgentConversationMessages as b, toEffectAgentLoop as c, assembleAgentContext as d, restoreAgentHistory as f, AgentEventSinkFailed as g, AgentEventHandlerFailed as h, createTextAgentLoop as i, isTerminalAgentDomainEvent as j, isAssistantTextDeltaEvent as k, toEffectAgentLoopInput as l, createAgentDomainEventSink as m, createAsyncIterableAgentLoop as n, fromEffectAgentLoop as o, createAgentHarness as p, createEventAgentLoop as r, toCompatibilityAgentLoopInput as s, createAgentLoopFromCallback as t, AgentContextBudgetExceeded as u, AgentLoopFailed as v, replayAgentHistory as w, createAgentTranscriptMessages as x, AgentRunCancelled as y, createAgentLoopToolExecutionStart as z };