@stackstackstack/dsh-agent-loop 0.1.5

package/lib/index.js

@@ -0,0 +1,1295 @@
+import { Service } from "@deepseek-ai/cordis";
+import { randomUUID } from "node:crypto";
+import z from "@deepseek-ai/schemastery";
+import { Inbox, agentEvents, assembleContextFor, emitAgentEvent } from "@stackstackstack/dsh-agent";
+import { BlockAssembler, LlmError, assertNever, createAssistantMessage, createToolResultMessage, createUserMessage, deepFreeze, errorChain, markAgentLoopRequest } from "@stackstackstack/dsh-llm";
+import { installSettingsSection, settingsNamespace } from "@stackstackstack/dsh-settings";
+import { SessionId, SessionPreparation, canonicalHeader, headerEquals, isReplacementSurfaceEvent } from "@stackstackstack/dsh-session";
+import { createScope } from "@stackstackstack/dsh-scope";
+import { joinContextSections, renderContextSections, renderPrompt } from "@stackstackstack/dsh-system-prompt";
+import { TOOL_ABORTED_BEFORE_DISPATCH, TOOL_RUNTIME_SCHEDULER } from "@stackstackstack/dsh-tools";
+//#region lib/types/runtime-context.js
+/**
+* Durable projection state for dynamic runtime context.
+* @module @stackstackstack/dsh-agent-loop/runtime-context
+*/
+const SOURCE = "@stackstackstack/dsh-system-prompt";
+const CLEARED = "Current runtime context: none. Earlier runtime-context snapshots no longer apply.";
+function isOwned(message) {
+	return message.source.kind === "plugin" && message.source.plugin === SOURCE;
+}
+function textOf(message) {
+	const [block] = message.content;
+	return message.content.length === 1 && block?.type === "text" ? block.text : void 0;
+}
+/** Tracks the last retained runtime-context snapshot without owning its commit. */
+var RuntimeContextProjection = class {
+	/** `undefined` means no snapshot ever existed; `null` means none is retained. */
+	retained;
+	/**
+	* Restore projection state once, then follow authoritative session events.
+	* @param ctx - agent-scoped event context.
+	* @param session - session receiving projected messages.
+	*/
+	constructor(ctx, session) {
+		const surface = new Set(session.surface.nodes);
+		for (let index = session.events.length - 1; index >= 0; index -= 1) {
+			const event = session.events[index];
+			if (event?.type !== "user/message" || !isOwned(event.data)) continue;
+			this.retained ??= null;
+			if (surface.has(event.seq)) {
+				this.retained = {
+					seq: event.seq,
+					text: textOf(event.data)
+				};
+				break;
+			}
+		}
+		ctx.on("session/event", (subject, event) => {
+			if (subject !== session) return;
+			if (event.type === "user/message" && isOwned(event.data)) this.retained = {
+				seq: event.seq,
+				text: textOf(event.data)
+			};
+			else if (this.retained && isReplacementSurfaceEvent(event) && event.sourceEventSeqs?.includes(this.retained.seq) === true) this.retained = null;
+		});
+	}
+	/**
+	* Create an uncommitted snapshot only when the retained value differs.
+	* @param current - fully rendered dynamic context.
+	* @param sections - named contributions that formed the current snapshot.
+	* @returns a candidate user message, or `undefined` when no update is needed.
+	*/
+	project(current, sections) {
+		if (this.retained === void 0 && current.length === 0) return;
+		const snapshot = current.length === 0 ? CLEARED : current;
+		if (this.retained?.text === snapshot) return;
+		return createUserMessage({
+			content: [{
+				type: "text",
+				text: snapshot
+			}],
+			source: sections.length === 0 ? {
+				kind: "plugin",
+				plugin: SOURCE
+			} : {
+				kind: "plugin",
+				plugin: SOURCE,
+				form: "snapshot",
+				sections
+			}
+		});
+	}
+};
+//#endregion
+//#region lib/types/tool-calls.js
+/**
+* Schedules one assistant step's tool calls. Exclusive calls form barriers;
+* parallel calls use a bounded rolling pool and are reclassified before start.
+* Dispatch may overlap, while policy, results, and result context remain
+* model-ordered. Abort or an internal scheduler failure stops replenishment
+* and drains started calls.
+*
+* Abort records synthetic error results for skipped calls so replay stays
+* valid. A terminal scheduler failure preserves already-recorded `tool/call`
+* events without fabricating results.
+* @module dsh-agent-loop/tool-calls
+*/
+/**
+* Schedule one assistant step's tool calls by their live concurrency mode.
+* Ordinary completion and abort commit started-call results in order. Abort
+* drains them, records synthetic results for unstarted calls, and returns with
+* the signal still aborted after accepting started-call context through the
+* caller-supplied acceptor (the machine stages it in its next-step inbox for the
+* step boundary). An internal scheduler failure stops new dispatches, drains
+* already-started dispatches, and rejects with the first failure without
+* fabricating tool results.
+* The committed step's AgentLoop driver boundary supplies the initiating Agent
+* that becomes each explicit {@link ToolExecutionInput.agent}.
+*
+* @param ctx - loop context that owns the tool registry and carries the initiating Agent.
+* @param turn - current turn number.
+* @param step - current step number.
+* @param toolCalls - assistant calls in model order.
+* @param signal - abort signal shared by the step.
+* @param acceptContext - accepts committed result context for the next step boundary.
+*/
+async function executeToolCalls(ctx, turn, step, toolCalls, signal, acceptContext) {
+	const agent = ctx.agents.requireInitiator();
+	const { session } = agent;
+	const planned = toolCalls.map((block) => ({
+		block,
+		exec: {
+			callId: block.id,
+			name: block.name,
+			arguments: parseArguments(block.arguments),
+			agent,
+			signal
+		}
+	}));
+	let next = 0;
+	let concluded = false;
+	while (next < planned.length) {
+		const first = planned[next];
+		const mode = ctx.tools.executionMode(first.exec).kind;
+		const outcome = await runGroup(ctx, turn, step, mode === "parallel" ? planned.slice(next) : [first], mode, signal, acceptContext);
+		next += outcome.consumed;
+		concluded ||= outcome.concluded;
+		if (outcome.aborted) {
+			for (const call of planned.slice(next)) appendSkippedToolCall(session, turn, step, call.block);
+			return { concluded };
+		}
+	}
+	return { concluded };
+}
+/** Parse model arguments, preserving invalid JSON as text and mapping empty input to `{}`. */
+function parseArguments(raw) {
+	try {
+		return raw ? JSON.parse(raw) : {};
+	} catch {
+		return raw;
+	}
+}
+/**
+* Run one exclusive barrier or parallel pool. Later calls are reclassified
+* before start; an exclusive reclassification waits for the current pool to
+* drain and remains for the caller's next barrier. Results and contexts commit
+* in model order. Abort stops starts, drains and commits started calls, accepts
+* their contexts into the owning batch, records results for skipped calls, and
+* returns an aborted outcome. Scheduler failure drains dispatches without
+* committing synthetic recovery results.
+*/
+async function runGroup(ctx, turn, step, group, mode, signal, acceptContext) {
+	const { session } = ctx.agents.requireInitiator();
+	const { maxParallelToolCalls } = ctx.agentLoop.config;
+	const slots = group.map(() => void 0);
+	const callSeqs = group.map(() => -1);
+	let nextToStart = 0;
+	let committed = 0;
+	let started = 0;
+	let aborted = signal.aborted;
+	let concluded = false;
+	let schedulerFailure;
+	const throwSchedulerFailure = () => {
+		if (schedulerFailure !== void 0) throw schedulerFailure.error;
+	};
+	const commitReady = async () => {
+		while (committed < group.length) {
+			const slot = slots[committed];
+			if (slot === void 0) break;
+			const call = group[committed];
+			const result = slot.needsPost ? await ctx.tools[TOOL_RUNTIME_SCHEDULER].finalize(slot.exec, slot.result) : ctx.tools[TOOL_RUNTIME_SCHEDULER].finish(slot.exec, slot.result);
+			appendToolResult(session, turn, step, call.block, result, callSeqs[committed]);
+			for (const context of result.additionalContexts ?? []) acceptContext(context);
+			concluded ||= result.concludesTurn === true;
+			committed++;
+		}
+	};
+	const inFlight = /* @__PURE__ */ new Map();
+	const startCall = async (index) => {
+		const call = group[index];
+		callSeqs[index] = appendToolCall(session, turn, step, call.block);
+		started++;
+		const prepared = await ctx.tools[TOOL_RUNTIME_SCHEDULER].prepare(call.exec);
+		throwSchedulerFailure();
+		switch (prepared.kind) {
+			case "dispatch": {
+				const promise = ctx.tools[TOOL_RUNTIME_SCHEDULER].dispatch(prepared.exec).then((outcome) => {
+					slots[index] = {
+						exec: prepared.exec,
+						result: outcome.result,
+						needsPost: outcome.kind === "post-result"
+					};
+					return index;
+				}, (error) => {
+					schedulerFailure ??= { error };
+					return index;
+				});
+				inFlight.set(index, promise);
+				break;
+			}
+			case "post-result":
+				slots[index] = {
+					exec: prepared.exec,
+					result: prepared.result,
+					needsPost: true
+				};
+				break;
+			case "final-result":
+				slots[index] = {
+					exec: prepared.exec,
+					result: prepared.result,
+					needsPost: false
+				};
+				break;
+			/* v8 ignore next -- closed-union exhaustiveness guard */
+			default: assertNever(prepared, "tool-call scheduler prepare result");
+		}
+	};
+	const fillPool = async () => {
+		while (!aborted && nextToStart < group.length && inFlight.size < maxParallelToolCalls) {
+			const nextCall = group[nextToStart];
+			if (nextToStart > 0 && mode === "parallel" && ctx.tools.executionMode(nextCall.exec).kind !== "parallel") break;
+			await startCall(nextToStart);
+			nextToStart++;
+			throwSchedulerFailure();
+			await commitReady();
+			throwSchedulerFailure();
+			if (signal.aborted) aborted = true;
+		}
+	};
+	try {
+		await fillPool();
+		while (inFlight.size > 0) {
+			const settledIndex = await Promise.race(inFlight.values());
+			inFlight.delete(settledIndex);
+			throwSchedulerFailure();
+			await commitReady();
+			throwSchedulerFailure();
+			if (signal.aborted) aborted = true;
+			await fillPool();
+		}
+	} catch (error) {
+		schedulerFailure ??= { error };
+		await Promise.allSettled(inFlight.values());
+		throw schedulerFailure.error;
+	}
+	if (aborted) {
+		for (const call of group.slice(started)) appendSkippedToolCall(session, turn, step, call.block);
+		return {
+			consumed: group.length,
+			aborted: true,
+			concluded
+		};
+	}
+	/* v8 ignore next -- unreachable: a non-aborted group commits every started call */
+	if (committed !== started) throw new Error("tool-call scheduler: uncommitted settled calls");
+	return {
+		consumed: started,
+		aborted: false,
+		concluded
+	};
+}
+/** Append the durable call/result pair for a model call skipped after cancellation. */
+function appendSkippedToolCall(session, turn, step, block) {
+	const callSeq = appendToolCall(session, turn, step, block);
+	appendToolResult(session, turn, step, block, {
+		content: [{
+			type: "text",
+			text: "Error: tool call aborted before dispatch"
+		}],
+		isError: true,
+		error: {
+			message: "tool call aborted before dispatch",
+			info: {
+				name: "AbortError",
+				code: TOOL_ABORTED_BEFORE_DISPATCH
+			}
+		}
+	}, callSeq);
+}
+/** Append a started call and return the event seq that its result must cite. */
+function appendToolCall(session, turn, step, block) {
+	return session.append("tool/call", {
+		turn,
+		step,
+		callId: block.id,
+		name: block.name,
+		arguments: block.arguments
+	}).seq;
+}
+/** Append a model-ordered result linked to its call event. */
+function appendToolResult(session, turn, step, block, result, callSeq) {
+	const message = createToolResultMessage({
+		callId: block.id,
+		content: result.content,
+		isError: result.isError
+	});
+	session.append("tool/result", {
+		turn,
+		step,
+		message,
+		...result.error?.info ? { error: result.error.info } : {},
+		...result.meta !== void 0 ? { meta: result.meta } : {}
+	}, {
+		surfaceOp: "append",
+		sourceEventSeqs: [callSeq]
+	});
+}
+//#endregion
+//#region lib/types/agent.js
+/**
+* Default Agent driver over queued turns and step-boundary input. Every request
+* is derived from the session log.
+* @module dsh-agent-loop/agent
+*/
+/** Remove adapter-derived values before plugins propose the next request config. */
+function requestProposal(header) {
+	if (header.adapterDefaults === void 0) return header.config;
+	const proposal = { ...header.config };
+	if (header.adapterDefaults.reasoningEffort === true) delete proposal.reasoningEffort;
+	if (header.adapterDefaults.maxTokens === true) delete proposal.maxTokens;
+	return proposal;
+}
+/** Drives one session through turn and step boundaries. */
+var ReactLoopAgent = class {
+	loopCtx;
+	id;
+	options;
+	session;
+	inbox;
+	phase;
+	activityDone = Promise.resolve();
+	/** The agent-scoped registration boundary; the lifecycle owner unwinds it after the driver exits. */
+	scope;
+	ctx;
+	/** Fused dispatcher, built once in the constructor so hot-path dispatches never allocate. */
+	dispatch;
+	/** Whether this loop instance has appended its initial/resume request anchor. */
+	requestHeaderLogged = false;
+	runtimeContext;
+	constructor(loopCtx, id, options, session) {
+		this.loopCtx = loopCtx;
+		this.id = id;
+		this.options = options;
+		this.session = session;
+		this.dispatch = agentEvents(loopCtx, this);
+		this.inbox = new Inbox(session, {
+			inserted: (message) => {
+				this.dispatch.emit("agent/inbox/inserted", { message });
+			},
+			discarded: (message) => {
+				this.dispatch.emit("agent/inbox/discarded", { message });
+			},
+			claimed: (message, turn) => {
+				this.dispatch.emit("agent/inbox/claimed", {
+					message,
+					turn
+				});
+			}
+		});
+		const lastTurn = session.events.findLast((event) => event.type === "turn/start")?.data.turn ?? 0;
+		this.phase = {
+			kind: "idle",
+			lastTurn
+		};
+		this.scope = createScope(loopCtx, this);
+		this.ctx = this.scope.ctx.extend({ agent: this });
+		this.runtimeContext = new RuntimeContextProjection(this.ctx, session);
+	}
+	get status() {
+		return this.phase.kind === "idle" || this.phase.kind === "maintenance" ? "idle" : "running";
+	}
+	/** Commit a phase and publish its externally visible status transition. */
+	setPhase(next) {
+		const previousStatus = this.status;
+		this.phase = next;
+		const status = this.status;
+		if (status !== previousStatus) this.dispatch.emit("agent/status", { status });
+	}
+	send(message, target, wakeup) {
+		const wakingAfterAbort = wakeup && this.phase.kind !== "idle" && this.phase.abort.signal.aborted;
+		const resolvedTarget = wakingAfterAbort ? "next-turn" : target;
+		this.inbox.splice(resolvedTarget, Infinity, 0, [message]);
+		if (wakeup) this.wakeDriver(wakingAfterAbort);
+	}
+	followup(input) {
+		this.send(input, "next-turn", true);
+	}
+	steer(input) {
+		this.send(input, "next-step", true);
+	}
+	inject(input) {
+		this.send(input, "next-step", false);
+	}
+	cancel(cause, options = {}) {
+		if (!options.keepInbox) {
+			this.inbox.clear();
+			if (this.phase.kind !== "idle") this.phase.wakeRequested = false;
+		}
+		if (this.phase.kind !== "idle") this.phase.abort.abort(cause);
+	}
+	runMaintenance(job) {
+		if (this.phase.kind !== "idle") throw new Error(`agent "${this.id}" already has active work`);
+		const done = Promise.withResolvers();
+		const maintenance = {
+			kind: "maintenance",
+			abort: new AbortController(),
+			lastTurn: this.phase.lastTurn,
+			wakeRequested: false
+		};
+		this.setPhase(maintenance);
+		this.activityDone = done.promise;
+		return (async () => {
+			try {
+				return await job(maintenance.abort.signal);
+			} finally {
+				this.setPhase({
+					kind: "idle",
+					lastTurn: maintenance.lastTurn
+				});
+				if (maintenance.wakeRequested && this.inbox.hasPending) this.wakeDriver();
+				done.resolve();
+			}
+		})();
+	}
+	/**
+	* Start one driver, or latch its wake behind maintenance or an aborted
+	* activity. A wake sent while idle always opens its turn boundary, even
+	* when its message was cleared; only a latched replay is suppressed when
+	* the queue no longer holds the wake.
+	* @param wakeAfterAbort - the {@link send} classification, captured before
+	*   the inbox insertion so a reentrant cancel cannot reclassify it.
+	*/
+	wakeDriver(wakeAfterAbort = false) {
+		if (this.phase.kind !== "idle") {
+			if (this.phase.abort.signal.reason?.kind !== "disposed" && (this.phase.kind === "maintenance" || wakeAfterAbort)) this.phase.wakeRequested = true;
+			return;
+		}
+		const driver = Promise.withResolvers();
+		this.activityDone = driver.promise;
+		this.setPhase({
+			kind: "running",
+			abort: new AbortController(),
+			turn: this.phase.lastTurn,
+			step: 0,
+			wakeRequested: false
+		});
+		this.loopCtx.agents.withInitiator(this, () => this.kick()).then(driver.resolve, driver.reject);
+	}
+	async whenIdle() {
+		let activity;
+		do
+			await (activity = this.activityDone);
+		while (activity !== this.activityDone);
+	}
+	/** Report one failure at its live boundary, then preserve it for driver containment. */
+	throwError(error) {
+		const turn = this.phase.kind === "running" ? this.phase.turn : this.phase.lastTurn;
+		const step = this.phase.kind === "running" ? this.phase.step : 0;
+		this.dispatch.emit("agent/error", {
+			turn,
+			step,
+			error
+		});
+		throw error;
+	}
+	async kick() {
+		try {
+			while (await this.turn());
+		} catch (_error) {} finally {
+			/* v8 ignore next -- kick owns a running phase until this driver boundary */
+			if (this.phase.kind === "running") {
+				const { turn, wakeRequested } = this.phase;
+				this.setPhase({
+					kind: "idle",
+					lastTurn: turn
+				});
+				if (wakeRequested && this.inbox.hasPending) this.wakeDriver();
+			}
+		}
+	}
+	async preStep(target, position) {
+		/* v8 ignore next -- private callers establish the running phase before proposing a step */
+		if (this.phase.kind !== "running") throw new Error(`agent "${this.id}": pre-step outside running phase`);
+		const signal = this.phase.abort.signal;
+		const claimed = this.inbox.claim(target, position.turn);
+		const assembly = await this.loopCtx.systemPrompt.assemble(assembleContextFor(this, signal));
+		signal.throwIfAborted();
+		const sections = renderContextSections(assembly);
+		const context = this.runtimeContext.project(joinContextSections(sections), sections);
+		const decision = await this.dispatch.waterfall("agent/pre-step", {
+			messages: claimed,
+			...position,
+			signal
+		}, () => Promise.resolve({
+			kind: "enter",
+			messages: context === void 0 ? claimed : [...claimed, context]
+		}));
+		signal.throwIfAborted();
+		return decision.kind === "reject" ? decision : {
+			...decision,
+			assembly
+		};
+	}
+	/** Open one turn before claiming its first proposed step. */
+	async turn() {
+		if (this.phase.kind !== "running") this.throwError(/* @__PURE__ */ new Error(`agent "${this.id}": turn without driver reservation`));
+		const phase = this.phase;
+		const { signal } = phase.abort;
+		signal.throwIfAborted();
+		const turn = phase.turn + 1;
+		try {
+			this.session.append("turn/start", { turn });
+		} catch (error) {
+			this.throwError(error);
+		}
+		phase.turn = turn;
+		let turnEnds = null;
+		let target = "next-turn";
+		try {
+			while (true) {
+				signal.throwIfAborted();
+				const step = phase.step + 1;
+				const decision = await this.preStep(target, {
+					turn,
+					step
+				});
+				if (decision.kind === "reject") {
+					turnEnds = { kind: "blocked" };
+					return false;
+				}
+				if (turnEnds && decision.messages.length === 0) break;
+				if (phase.step === 0 && decision.messages.length === 0) {
+					turnEnds = { kind: "completed" };
+					return false;
+				}
+				signal.throwIfAborted();
+				this.session.append("step/start", {
+					turn,
+					step
+				});
+				phase.step = step;
+				try {
+					for (const message of decision.messages) this.session.append("user/message", message, { surfaceOp: "append" });
+					const stepEnd = await this.step(decision.assembly);
+					if (turnEnds === null || turnEnds.kind !== "max-tokens") turnEnds = stepEnd;
+				} finally {
+					this.session.append("step/end", {
+						turn,
+						step
+					});
+				}
+				signal.throwIfAborted();
+				if (turnEnds && this.inbox.nextStep.length === 0) {
+					await this.dispatch.serial("agent/turn-stopping", {
+						turn,
+						signal
+					});
+					signal.throwIfAborted();
+				}
+				if (turnEnds && this.inbox.nextStep.length === 0) break;
+				target = "next-step";
+			}
+		} catch (error) {
+			if (signal.aborted) {
+				turnEnds = {
+					kind: "aborted",
+					reason: signal.reason
+				};
+				throw error;
+			}
+			turnEnds = {
+				kind: "error",
+				error: error instanceof LlmError ? error.failure : {
+					message: errorChain(error),
+					code: "UNKNOWN"
+				}
+			};
+			this.throwError(error);
+		} finally {
+			try {
+				this.session.append("turn/end", {
+					turn,
+					reason: turnEnds
+				});
+			} catch (error) {
+				this.throwError(error);
+			}
+		}
+		if (!this.inbox.hasPending) return false;
+		phase.abort = new AbortController();
+		phase.wakeRequested = false;
+		phase.step = 0;
+		return true;
+	}
+	async step(assembly) {
+		/* v8 ignore next -- private callers establish the running phase before executing a step */
+		if (this.phase.kind !== "running") throw new Error(`agent "${this.id}": step outside running phase`);
+		const { turn, step, abort: { signal } } = this.phase;
+		signal.throwIfAborted();
+		const system = renderPrompt(assembly);
+		while (true) {
+			const { request, preparedCall } = await this.buildRequest(turn, step, assembly.tools, system, this.session.deriveMessages(), signal);
+			const assembler = new BlockAssembler();
+			const chunkSeqs = [];
+			const stream = preparedCall?.stream(request) ?? this.loopCtx.llm.stream(request);
+			signal.throwIfAborted();
+			for await (const chunk of stream) {
+				signal.throwIfAborted();
+				chunkSeqs.push(this.session.append("assistant/chunk", {
+					turn,
+					step,
+					chunk
+				}).seq);
+				assembler.push(chunk);
+			}
+			signal.throwIfAborted();
+			const finish = assembler.finish;
+			if (finish.kind === "error" || finish.kind === "aborted") {
+				const action = await this.dispatch.waterfall("agent/request-error", {
+					turn,
+					step,
+					provider: request.provider,
+					failure: finish.failure,
+					retryPolicy: preparedCall?.retryPolicy,
+					signal
+				}, () => Promise.resolve(void 0));
+				signal.throwIfAborted();
+				if (action?.kind !== "retry") throw new LlmError(finish.failure.message, finish.failure.code, finish.failure);
+				continue;
+			}
+			const message = createAssistantMessage({
+				content: assembler.blocks(),
+				source: {
+					provider: request.provider,
+					model: request.model,
+					...assembler.replayState !== void 0 ? { replayState: assembler.replayState } : {}
+				}
+			});
+			this.session.append("assistant/message", {
+				turn,
+				step,
+				message,
+				...assembler.usage === void 0 ? {} : { usage: assembler.usage }
+			}, {
+				surfaceOp: "append",
+				sourceEventSeqs: chunkSeqs
+			});
+			if (finish.kind === "max-tokens") return { kind: "max-tokens" };
+			const toolCalls = message.content.filter((block) => block.type === "tool-call");
+			if (toolCalls.length === 0) return { kind: "completed" };
+			const { concluded } = await executeToolCalls(this.loopCtx, turn, step, toolCalls, signal, (context) => this.inbox.splice("next-step", this.inbox.nextStep.length, 0, [context]));
+			return concluded ? { kind: "completed" } : null;
+		}
+	}
+	/**
+	* Compose one frozen request and bind it to the adapter registration that
+	* resolved its exact-model defaults.
+	*/
+	async buildRequest(turn, step, tools, system, boundaryMessages, signal) {
+		const { session } = this;
+		const persistedHeader = session.requestHeader();
+		const persistedConfig = persistedHeader?.config;
+		const route = {
+			provider: this.options.provider ?? "",
+			model: this.options.model ?? ""
+		};
+		const reasoningEffort = persistedConfig?.provider === route.provider && persistedConfig.model === route.model && persistedHeader?.adapterDefaults?.reasoningEffort !== true ? persistedConfig.reasoningEffort : void 0;
+		const maxTokens = this.options.maxTokens;
+		const seedConfig = deepFreeze(structuredClone(this.requestHeaderLogged ? requestProposal(persistedHeader) : {
+			...route,
+			...reasoningEffort === void 0 ? {} : { reasoningEffort },
+			...maxTokens === void 0 ? {} : { maxTokens }
+		}));
+		const proposedConfig = await this.dispatch.waterfall("agent/request", {
+			turn,
+			step,
+			signal
+		}, () => Promise.resolve(seedConfig));
+		signal.throwIfAborted();
+		if (!proposedConfig.provider || !proposedConfig.model) throw new Error(`agent "${this.id}" has no provider/model: set AgentOptions.provider and AgentOptions.model or supply both via the agent/request waterfall`);
+		let config;
+		let preparedCall;
+		try {
+			preparedCall = await this.loopCtx.llm.prepareCall(proposedConfig, signal);
+			config = preparedCall.config;
+		} catch (error) {
+			if (!(error instanceof LlmError) || error.code !== "NO_ADAPTER") throw error;
+			config = proposedConfig;
+		}
+		signal.throwIfAborted();
+		const header = canonicalHeader({
+			config,
+			...preparedCall === void 0 ? {} : { adapterDefaults: preparedCall.adapterDefaults },
+			...system ? { system } : {},
+			...tools.length > 0 ? { tools } : {}
+		});
+		const baseline = this.session.requestHeader();
+		if (!this.requestHeaderLogged) {
+			this.session.append("request/header", {
+				header,
+				reason: baseline === void 0 ? "initial" : "resume"
+			});
+			this.requestHeaderLogged = true;
+		} else if (baseline === void 0 || !headerEquals(baseline, header)) this.session.append("request/header", {
+			header,
+			reason: "change"
+		});
+		const contextWindow = preparedCall?.context?.contextWindow;
+		const requestContext = {
+			provider: config.provider,
+			model: config.model,
+			...contextWindow === void 0 ? {} : { contextWindow }
+		};
+		const previousContext = session.requestContext();
+		if (previousContext?.provider !== requestContext.provider || previousContext.model !== requestContext.model || previousContext.contextWindow !== requestContext.contextWindow) session.append("request/context", requestContext);
+		signal.throwIfAborted();
+		return {
+			request: markAgentLoopRequest(deepFreeze({
+				...header.config,
+				messages: boundaryMessages,
+				...header.system !== void 0 ? { system: header.system } : {},
+				...header.tools !== void 0 ? { tools: header.tools } : {},
+				sessionId: this.session.id,
+				signal
+			})),
+			...preparedCall === void 0 ? {} : { preparedCall }
+		};
+	}
+};
+//#endregion
+//#region lib/types/constants.js
+/** Shared agent-loop scheduler defaults.
+* @module dsh-agent-loop/constants
+*/
+/** Default maximum in-flight parallel-safe calls per agent step. */
+const DEFAULT_MAX_PARALLEL_TOOL_CALLS = 10;
+//#endregion
+//#region lib/types/index.js
+/**
+* Concrete agent-loop plugin: creates scoped ReactLoopAgents, publishes them
+* through the agent/session registries, and owns their ordered teardown.
+*
+* @module @stackstackstack/dsh-agent-loop
+*/
+var __addDisposableResource = function(env, value, async) {
+	if (value !== null && value !== void 0) {
+		if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+		var dispose, inner;
+		if (async) {
+			if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+			dispose = value[Symbol.asyncDispose];
+		}
+		if (dispose === void 0) {
+			if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+			dispose = value[Symbol.dispose];
+			if (async) inner = dispose;
+		}
+		if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+		if (inner) dispose = function() {
+			try {
+				inner.call(this);
+			} catch (e) {
+				return Promise.reject(e);
+			}
+		};
+		env.stack.push({
+			value,
+			dispose,
+			async
+		});
+	} else if (async) env.stack.push({ async: true });
+	return value;
+};
+var __disposeResources = (function(SuppressedError) {
+	return function(env) {
+		function fail(e) {
+			env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+			env.hasError = true;
+		}
+		var r, s = 0;
+		function next() {
+			while (r = env.stack.pop()) try {
+				if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+				if (r.dispose) {
+					var result = r.dispose.call(r.value);
+					if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+						fail(e);
+						return next();
+					});
+				} else s |= 1;
+			} catch (e) {
+				fail(e);
+			}
+			if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+			if (env.hasError) throw env.error;
+		}
+		return next();
+	};
+})(typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+	var e = new Error(message);
+	return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+/** Fiber states that cannot own or serve a new lifecycle. */
+const INACTIVE_STATES = new Set([
+	5,
+	4,
+	3
+]);
+/** Factory-level ownership: live agent teardowns plus config startup work. */
+var FactoryOwnership = class {
+	fiber;
+	accepting = true;
+	teardown = new AbortController();
+	inactive = Promise.withResolvers();
+	liveAgents = /* @__PURE__ */ new Set();
+	startupTasks = /* @__PURE__ */ new Set();
+	constructor(fiber) {
+		this.fiber = fiber;
+	}
+	/** Aborts (reason: `agent loop is not active` error) when factory teardown begins. */
+	get signal() {
+		return this.teardown.signal;
+	}
+	isActive() {
+		return this.accepting && !INACTIVE_STATES.has(this.fiber.state);
+	}
+	/** Track one live agent's shared teardown until it has run. */
+	track(dispose) {
+		this.liveAgents.add(dispose);
+		return () => {
+			this.liveAgents.delete(dispose);
+		};
+	}
+	/** Join config startup work that begins before an agent exists. */
+	trackStartup(job) {
+		this.startupTasks.add(job);
+		const forget = () => {
+			this.startupTasks.delete(job);
+		};
+		job.then(forget, forget);
+	}
+	/** Join one public create/resume continuation; factory dispose awaits its settlement. */
+	trackWrapper(job) {
+		this.trackStartup(job.then(() => void 0, () => void 0));
+	}
+	/** Resolve `task`, or stop waiting when factory teardown begins. */
+	async waitWhileActive(job) {
+		await Promise.race([job, this.inactive.promise]);
+	}
+	async dispose() {
+		this.accepting = false;
+		this.teardown.abort(/* @__PURE__ */ new Error("agent loop is not active"));
+		this.inactive.resolve();
+		await Promise.all([...[...this.liveAgents].map((dispose) => dispose()), ...this.startupTasks]);
+	}
+};
+/** Await `operation`, or throw the signal's reason as soon as it aborts. */
+async function raceAbort(operation, signal, id) {
+	const toAbortError = () => signal.reason instanceof Error ? signal.reason : new Error(`agent "${id}" creation aborted`, { cause: signal.reason });
+	if (signal.aborted) throw toAbortError();
+	const aborted = Promise.withResolvers();
+	const listener = () => {
+		aborted.reject(toAbortError());
+	};
+	signal.addEventListener("abort", listener, { once: true });
+	try {
+		return await Promise.race([Promise.resolve(operation), aborted.promise]);
+	} finally {
+		signal.removeEventListener("abort", listener);
+	}
+}
+/** Start an abortable operation and release a value that arrives after cancellation. */
+async function raceAbortCall(operation, signal, id, releaseAbandoned) {
+	if (signal.aborted) throw signal.reason instanceof Error ? signal.reason : new Error(`agent "${id}" creation aborted`, { cause: signal.reason });
+	const pending = Promise.resolve().then(operation);
+	try {
+		return await raceAbort(pending, signal, id);
+	} catch (error) {
+		if (signal.aborted && releaseAbandoned !== void 0) pending.then(releaseAbandoned, () => void 0);
+		throw error;
+	}
+}
+/** Resolve the deployment-wide scheduler cap at the owning config boundary. */
+function resolveMaxParallelToolCalls(value) {
+	const maxParallelToolCalls = value ?? 10;
+	if (!Number.isInteger(maxParallelToolCalls) || maxParallelToolCalls < 1) throw new Error("maxParallelToolCalls must be a positive integer");
+	return maxParallelToolCalls;
+}
+/** Reject an output-token cap that cannot be represented exactly on the request wire. */
+function assertAgentOptions(options) {
+	if (options.maxTokens !== void 0 && (!Number.isSafeInteger(options.maxTokens) || options.maxTokens <= 0)) throw new TypeError("agent maxTokens must be a positive safe integer");
+}
+/**
+* Context key a launcher sets before any Loader entry mounts
+* (`ctx.provide(CONFIGURED_AGENT_IDENTITIES_KEY, identities)`) to fix
+* configured agents' session identities without a config key, so an overlay
+* repointing the row's model route cannot drop them.
+*/
+const CONFIGURED_AGENT_IDENTITIES_KEY = "configuredAgentIdentities";
+/**
+* Apply launcher-owned identities over the configured agents, replacing both
+* identity keys for every entry the launcher named so a config-supplied
+* identity can never survive alongside a launcher-supplied one.
+* @param agents - the configured agent entries.
+* @param identities - launcher identities keyed by configured agent `id`, or `undefined`.
+* @returns the entries with launcher-owned identities applied.
+*/
+function applyLauncherIdentities(agents, identities) {
+	if (identities === void 0) return agents;
+	return agents.map((agent) => {
+		const identity = identities[agent.id];
+		if (identity === void 0) return agent;
+		const { sessionId: _sessionId, resumeSessionId: _resumeSessionId, ...rest } = agent;
+		return identity.resume ? {
+			...rest,
+			resumeSessionId: identity.id
+		} : {
+			...rest,
+			sessionId: identity.id
+		};
+	});
+}
+/** Settings namespace carrying the tool-call parallelism a user owns. */
+const AGENT_LOOP_SETTINGS_NAMESPACE = settingsNamespace("agent-loop");
+/** Schema of the agent-loop settings section. */
+const AGENT_LOOP_SETTINGS_SCHEMA = z.object({ maxParallelToolCalls: z.number().step(1).min(1).default(10) });
+/** Reject self-contained identity conflicts before any configured agent starts. */
+function validateConfiguredAgents(agents) {
+	const exactIdentities = /* @__PURE__ */ new Map();
+	for (const { id, sessionId, resumeSessionId } of agents) {
+		const hasResumeId = resumeSessionId !== void 0 && resumeSessionId !== "";
+		if (sessionId !== void 0 && hasResumeId) throw new Error(`agent "${id}": sessionId and resumeSessionId are mutually exclusive`);
+		const exactIdentity = hasResumeId ? resumeSessionId : sessionId;
+		if (exactIdentity === void 0) continue;
+		const firstId = exactIdentities.get(exactIdentity);
+		if (firstId !== void 0) throw new Error(`agents "${firstId}" and "${id}" use duplicate exact session identity "${exactIdentity}"`);
+		exactIdentities.set(exactIdentity, id);
+	}
+}
+/** Concrete agent factory and driver service. */
+var AgentLoop = class extends Service {
+	static inject = [
+		"agents",
+		"sessions",
+		"llm",
+		"tools",
+		"systemPrompt"
+	];
+	/** Runtime schema for declarative agents. */
+	static Config = z.object({
+		maxParallelToolCalls: z.number().step(1).min(1).default(10),
+		agents: z.array(z.object({
+			id: z.string().required(),
+			sessionId: z.string().min(1),
+			provider: z.string(),
+			model: z.string(),
+			maxTokens: z.number().step(1).min(1).max(Number.MAX_SAFE_INTEGER),
+			cwd: z.string(),
+			resumeSessionId: z.string()
+		})).default([])
+	});
+	/** Validated configuration owned by the agent-loop service. */
+	config;
+	ownership;
+	/** Plain holder prevents Cordis from re-tracing the factory's dependency context through a caller shadow. */
+	runtime;
+	constructor(ctx, config) {
+		super(ctx, "agentLoop");
+		const entry = { maxParallelToolCalls: resolveMaxParallelToolCalls(config.maxParallelToolCalls) };
+		let source = () => entry;
+		this.config = {
+			...config,
+			agents: applyLauncherIdentities(config.agents, ctx.get(CONFIGURED_AGENT_IDENTITIES_KEY)),
+			get maxParallelToolCalls() {
+				return source().maxParallelToolCalls;
+			}
+		};
+		installSettingsSection(ctx, AGENT_LOOP_SETTINGS_NAMESPACE, AGENT_LOOP_SETTINGS_SCHEMA, entry, {
+			validate: (value) => void resolveMaxParallelToolCalls(value.maxParallelToolCalls),
+			setSource: (current) => {
+				source = current;
+			},
+			onChange: () => {}
+		});
+		validateConfiguredAgents(this.config.agents);
+		this.ownership = new FactoryOwnership(ctx.fiber);
+		this.runtime = { ctx };
+		ctx.effect(() => () => this.ownership.dispose(), "agentLoop.transactions()");
+		ctx.effect(() => ctx.agents.setFactory(this), "agentLoop.setFactory()");
+		ctx.systemPrompt.variable("provider", (context) => context.agent?.options.provider);
+		ctx.systemPrompt.variable("model", (context) => context.agent?.options.model);
+		ctx.systemPrompt.variable("cwd", (context) => context.agent?.session.header.cwd);
+		for (const { id, sessionId, cwd, resumeSessionId, ...options } of this.config.agents) {
+			const meta = cwd === void 0 ? {} : { cwd };
+			if (resumeSessionId === void 0 || resumeSessionId === "") {
+				const configuredId = sessionId ?? SessionId(`${id}-session-${randomUUID()}`);
+				const persistence = sessionId === void 0 ? void 0 : ctx.get("sessionPersistence");
+				if (persistence === void 0) this.create(configuredId, options, meta);
+				else {
+					const startup = this.restoreOrCreateConfigured(ctx, persistence, configuredId, options, meta).catch((error) => {
+						this.reportConfiguredStartupFailure(id, "restore", configuredId, error);
+					});
+					this.ownership.trackStartup(startup);
+				}
+				continue;
+			}
+			ctx.effect(() => {
+				return ctx.inject(["sessionPersistence"], (childCtx) => {
+					this.resumeWith(ctx, childCtx.sessionPersistence, {
+						resumeSessionId,
+						agentOptions: options
+					}).catch((error) => {
+						this.reportConfiguredStartupFailure(id, "resume", resumeSessionId, error);
+					});
+				}).dispose;
+			}, `agentLoop.resume(${id})`);
+		}
+	}
+	/** Report a contained declarative-start failure to identity-bound consumers. */
+	reportConfiguredStartupFailure(configId, action, sessionId, error) {
+		if (!this.ownership.isActive()) return;
+		this.ctx.logger.warn(`agent "${configId}": config-driven ${action} of "${sessionId}" failed: ${errorChain(error)}`);
+		const args = ["agent-loop/config-start-failed", {
+			sessionId,
+			error
+		}];
+		for (const callback of this.ctx.events.dispatch("emit", args)) try {
+			const returned = callback(...args);
+			Promise.resolve(returned).catch((listenerError) => {
+				this.ctx.logger.warn(`agent "${configId}": config-start-failed listener rejected: ${errorChain(listenerError)}`);
+			});
+		} catch (listenerError) {
+			this.ctx.logger.warn(`agent "${configId}": config-start-failed listener threw: ${errorChain(listenerError)}`);
+		}
+	}
+	/** Restore a materialized exact config identity on remount, or create it on first use. */
+	async restoreOrCreateConfigured(ownerCtx, persistence, sessionId, agentOptions, meta) {
+		await this.waitForDrainingConfiguredIdentity(ownerCtx, sessionId);
+		if (!this.ownership.isActive()) return;
+		try {
+			await this.resumeWith(ownerCtx, persistence, {
+				resumeSessionId: sessionId,
+				agentOptions
+			});
+			return;
+		} catch (error) {
+			if (!this.ownership.isActive()) return;
+			if ((await persistence.list()).some((header) => header.id === sessionId)) throw error;
+		}
+		this.create(sessionId, agentOptions, meta);
+	}
+	/** Wait for a draining same-id lifecycle to finish registry teardown. */
+	async waitForDrainingConfiguredIdentity(ownerCtx, sessionId) {
+		if (ownerCtx.agents.get(sessionId) === void 0 && ownerCtx.sessions.get(sessionId) === void 0) return;
+		const released = Promise.withResolvers();
+		const checkReleased = () => {
+			if (ownerCtx.agents.get(sessionId) === void 0 && ownerCtx.sessions.get(sessionId) === void 0) released.resolve();
+		};
+		const disposeAgentListener = ownerCtx.on("agent/disposed", () => {
+			checkReleased();
+		});
+		const disposeSessionListener = ownerCtx.on("session/disposed", checkReleased);
+		try {
+			checkReleased();
+			await this.ownership.waitWhileActive(released.promise);
+		} finally {
+			disposeAgentListener();
+			disposeSessionListener();
+		}
+	}
+	/**
+	* Construct the driver, scope, and one memoized reverse teardown for a new
+	* agent. The teardown is registered with the factory and the owner fiber
+	* BEFORE publication, so a mid-setup unload rolls everything back; `signal`
+	* fuses caller cancellation with lifecycle teardown for setup awaits.
+	*/
+	prepare(ownerCtx, id, options, session, callerSignal) {
+		assertAgentOptions(options);
+		ownerCtx.fiber.assertActive();
+		/* v8 ignore next -- unreachable backstop, see above */
+		if (!this.ownership.isActive()) throw new Error("agent loop is not active");
+		if (callerSignal?.aborted) throw callerSignal.reason instanceof Error ? callerSignal.reason : new Error(`agent "${id}" creation aborted`, { cause: callerSignal.reason });
+		const loopCtx = this.runtime.ctx;
+		const abort = new AbortController();
+		const onCallerAbort = () => {
+			abort.abort(callerSignal?.reason instanceof Error ? callerSignal.reason : new Error(`agent "${id}" creation aborted`, { cause: callerSignal?.reason }));
+		};
+		const onFactoryTeardown = () => {
+			abort.abort(this.ownership.signal.reason);
+		};
+		callerSignal?.addEventListener("abort", onCallerAbort, { once: true });
+		this.ownership.signal.addEventListener("abort", onFactoryTeardown, { once: true });
+		let machine;
+		let detachSession;
+		let detachAgent;
+		let disposing;
+		const machineReady = Promise.withResolvers();
+		const dispose = (ownerTriggered = false) => disposing ??= (async () => {
+			abort.abort(/* @__PURE__ */ new Error(`agent "${id}" lifecycle disposed`));
+			callerSignal?.removeEventListener("abort", onCallerAbort);
+			this.ownership.signal.removeEventListener("abort", onFactoryTeardown);
+			try {
+				if (machine === void 0) await machineReady.promise;
+				if (machine !== void 0) {
+					machine.cancel({ kind: "disposed" });
+					await machine.whenIdle();
+					await machine.scope.dispose();
+				}
+			} finally {
+				try {
+					detachAgent?.();
+					detachSession?.();
+				} finally {
+					untrack();
+					if (!ownerTriggered) await unfollowOwner();
+				}
+			}
+		})();
+		const untrack = this.ownership.track(dispose);
+		let unfollowOwner;
+		try {
+			unfollowOwner = ownerCtx.effect(() => () => {
+				if (disposing !== void 0) return;
+				abort.abort(/* @__PURE__ */ new Error(`agent "${id}" setup aborted: owner disposed during setup`));
+				return dispose(true);
+			}, `agentLoop.lifecycle(${id})`);
+		} catch (error) {
+			untrack();
+			callerSignal?.removeEventListener("abort", onCallerAbort);
+			this.ownership.signal.removeEventListener("abort", onFactoryTeardown);
+			throw error;
+		}
+		/* v8 ignore stop */
+		const assertLive = () => {
+			if (!abort.signal.aborted) return;
+			/* v8 ignore next -- unreachable String() arm, see above */
+			throw abort.signal.reason instanceof Error ? abort.signal.reason : new Error(String(abort.signal.reason));
+		};
+		try {
+			const agent = machine = new ReactLoopAgent(loopCtx, id, options, session);
+			machineReady.resolve();
+			assertLive();
+			return {
+				agent,
+				signal: abort.signal,
+				publish: (source) => {
+					assertLive();
+					detachSession = agent.ctx.sessions.enter(session);
+					detachAgent = loopCtx.agents.enter(agent, ownerCtx.agent);
+					agent.ctx.sessions.announce(session);
+					assertLive();
+					loopCtx.agents.announce(agent);
+					assertLive();
+					emitAgentEvent(loopCtx, agent, "agent/session-start", { source });
+					assertLive();
+					return {
+						agent,
+						dispose
+					};
+				},
+				dispose
+			};
+		} catch (error) {
+			machineReady.resolve();
+			dispose();
+			throw error;
+		}
+	}
+	/**
+	* Create an agent and session under one caller-supplied identity, owned by
+	* the accessing fiber. Constructor-driven config calls mint a fresh combined
+	* id before entering this boundary.
+	* @param id - shared agent/session identity.
+	* @param options - concrete loop options.
+	* @param meta - optional fresh-session workspace metadata.
+	* @returns the published running agent.
+	*/
+	create(id, options = {}, meta = {}) {
+		const env_1 = {
+			stack: [],
+			error: void 0,
+			hasError: false
+		};
+		try {
+			const preparation = __addDisposableResource(env_1, SessionPreparation.create(this.runtime.ctx.sessions.prepare(id, { meta })), false);
+			const prepared = this.prepare(this.ctx, id, options, preparation.session);
+			try {
+				return prepared.publish("startup").agent;
+			} catch (error) {
+				prepared.dispose();
+				throw error;
+			}
+		} catch (e_1) {
+			env_1.error = e_1;
+			env_1.hasError = true;
+		} finally {
+			__disposeResources(env_1);
+		}
+	}
+	/**
+	* Create an owned agent on a caller-supplied session id.
+	* @param ownerCtx - caller context that structurally owns the lifecycle.
+	* @param options - identities, session seed/metadata, loop options, setup, and cancellation.
+	* @returns the published handle.
+	*/
+	async createAgent(ownerCtx, options) {
+		const preparation = SessionPreparation.create(this.runtime.ctx.sessions.prepare(options.sessionId, {
+			...options.seed === void 0 ? {} : { seed: options.seed },
+			...options.meta === void 0 ? {} : { meta: options.meta }
+		}));
+		const published = this.setupAndPublish(ownerCtx, options.sessionId, preparation, options.agentOptions ?? {}, options.setup, options.signal, "startup");
+		this.ownership.trackWrapper(published);
+		return published;
+	}
+	/** Prepare one Agent around an acquired Session, run setup, and publish it. */
+	async setupAndPublish(ownerCtx, id, preparation, agentOptions, setup, signal, source) {
+		const env_2 = {
+			stack: [],
+			error: void 0,
+			hasError: false
+		};
+		try {
+			const session = __addDisposableResource(env_2, preparation, false).session;
+			const prepared = this.prepare(ownerCtx, id, agentOptions, session, signal);
+			try {
+				(await raceAbort(setup?.(prepared.agent.ctx), prepared.signal, id))?.commit();
+				return prepared.publish(source);
+			} catch (error) {
+				await prepared.dispose();
+				throw error;
+			}
+		} catch (e_2) {
+			env_2.error = e_2;
+			env_2.hasError = true;
+		} finally {
+			__disposeResources(env_2);
+		}
+	}
+	/**
+	* Resume an owned agent from the configured persistence service.
+	* @param ownerCtx - caller context that owns load, setup, and the live lifecycle.
+	* @param options - persisted identity, loop options, setup, and cancellation.
+	* @returns the published handle.
+	*/
+	async resume(ownerCtx, options) {
+		const persistence = this.runtime.ctx.get("sessionPersistence");
+		if (persistence === void 0) throw new Error("cannot resume: session persistence is not configured (load a dsh-session-persistence backend)");
+		return this.resumeWith(ownerCtx, persistence, options);
+	}
+	/** Resume through an explicit persistence handle used by the deferred config path. */
+	resumeWith(ownerCtx, persistence, options) {
+		const id = options.resumeSessionId;
+		const published = (async () => {
+			const ownerAbort = new AbortController();
+			const unfollowOwner = ownerCtx.effect(() => () => {
+				ownerAbort.abort(/* @__PURE__ */ new Error(`agent "${id}" setup aborted: owner disposed during setup`));
+			}, `agentLoop.resume-load(${id})`);
+			const fused = AbortSignal.any([
+				...options.signal === void 0 ? [] : [options.signal],
+				ownerAbort.signal,
+				this.ownership.signal
+			]);
+			let preparation;
+			try {
+				try {
+					preparation = await raceAbortCall(() => persistence.prepare(id, fused), fused, id, (abandoned) => {
+						abandoned[Symbol.dispose]();
+					});
+				} finally {
+					await unfollowOwner();
+				}
+				ownerCtx.fiber.assertActive();
+				if (!this.ownership.isActive()) throw new Error("agent loop is not active");
+				return await this.setupAndPublish(ownerCtx, id, preparation, options.agentOptions ?? {}, options.setup, options.signal, "resume");
+			} finally {
+				preparation?.[Symbol.dispose]();
+			}
+		})();
+		this.ownership.trackWrapper(published);
+		return published;
+	}
+};
+//#endregion
+export { AGENT_LOOP_SETTINGS_NAMESPACE, AGENT_LOOP_SETTINGS_SCHEMA, AgentLoop, AgentLoop as default, CONFIGURED_AGENT_IDENTITIES_KEY, DEFAULT_MAX_PARALLEL_TOOL_CALLS };