@nhtio/adk 0.1.0-master-f0aa531d

package/turn_runner-y7eyEcJH.mjs

@@ -0,0 +1,603 @@
+import { a as validateOrThrow, i as passesSchema } from "./exceptions-NrzIHw_R.mjs";
+import { c as isObject, o as isError, s as isInstanceOf, t as ToolRegistry } from "./tool_registry-DqLOyGyG.mjs";
+import { O as E_TURN_GATE_ABORTED, T as E_PIPELINE_SHORT_CIRCUITED, _ as E_INVALID_TURN_GATE_RESOLUTION, f as E_INVALID_INITIAL_TURN_GATE_VALUE, k as E_TURN_GATE_TIMEOUT, n as E_INPUT_PIPELINE_ERROR, v as E_INVALID_TURN_RUNNER_CONFIG, w as E_OUTPUT_PIPELINE_ERROR } from "./runtime-CrEPIFgr.mjs";
+import { t as Tool } from "./tool-D2WB1EA1.mjs";
+import { r as TurnContext, t as DispatchRunner } from "./dispatch_runner-9j6bXHL3.mjs";
+import { validator } from "@nhtio/validation";
+import { DateTime } from "luxon";
+import { Middleware } from "@nhtio/middleware";
+import { TypedEventEmitter } from "@nhtio/tiny-typed-emitter";
+//#region src/lib/classes/turn_gate.ts
+/**
+* Validator schema used to validate a {@link RawTurnGate} before constructing a {@link TurnGate}.
+*
+* @remarks
+* - `schema` and `abortSignal` are validated as opaque passthrough values.
+* - `timeout` must be a positive integer when provided.
+*/
+var rawTurnGateSchema = validator.object({
+	id: validator.string().required(),
+	turnId: validator.string().required(),
+	reason: validator.string().required(),
+	payload: validator.any().required(),
+	schema: validator.any().custom((value, helpers) => {
+		if (value === void 0 || value === null) return void 0;
+		if (typeof value.validate === "function") return value;
+		return helpers.error("any.invalid");
+	}).optional(),
+	timeout: validator.number().integer().min(1).optional(),
+	abortSignal: validator.any().custom((value, helpers) => {
+		if (value === void 0 || value === null) return void 0;
+		if (typeof AbortSignal !== "undefined" && value instanceof AbortSignal) return value;
+		if (isObject(value) && typeof value.aborted === "boolean" && typeof value.addEventListener === "function") return value;
+		return helpers.error("any.invalid");
+	}).optional(),
+	createdAt: validator.datetime().required()
+});
+/**
+* A cooperative suspension gate that blocks a turn's middleware pipeline until resolved, rejected,
+* aborted, or timed out.
+*
+* @typeParam T - The expected type of the resolution value.
+*
+* @remarks
+* Created exclusively via `ctx.waitFor()` — middleware never constructs a gate directly.
+* The gate emits `turnGateOpen` on the runner's observability bus at creation time and
+* `turnGateClosed` when it settles.
+*
+* Resolution is validated against an optional schema before the internal promise is settled.
+* A validation failure throws {@link @nhtio/adk!E_INVALID_TURN_GATE_RESOLUTION} **synchronously in the
+* caller's context** — the promise is NOT settled and the gate remains open.
+*/
+var TurnGate = class TurnGate {
+	/**
+	* Validator schema that accepts a {@link RawTurnGate} object.
+	*
+	* @remarks
+	* Reusable fragment for any schema that needs to validate or nest a gate entry.
+	*/
+	static schema = rawTurnGateSchema;
+	/**
+	* Returns `true` if `value` is a {@link TurnGate} instance.
+	*
+	* @remarks
+	* Uses {@link @nhtio/adk!isInstanceOf} for cross-realm safety.
+	*
+	* @param value - The value to test.
+	* @returns `true` when `value` is a {@link TurnGate} instance.
+	*/
+	static isTurnGate(value) {
+		return isInstanceOf(value, "TurnGate", TurnGate);
+	}
+	#id;
+	#turnId;
+	#reason;
+	#payload;
+	#createdAt;
+	#settled;
+	#schema;
+	#controller;
+	#resolve;
+	#reject;
+	#promise;
+	/**
+	* @param raw - The raw gate input validated against `rawTurnGateSchema`.
+	* @throws {@link @nhtio/adk!E_INVALID_INITIAL_TURN_GATE_VALUE} when `raw` does not satisfy the schema.
+	*/
+	constructor(raw) {
+		let resolved;
+		try {
+			resolved = validateOrThrow(rawTurnGateSchema, raw, true);
+		} catch (err) {
+			throw new E_INVALID_INITIAL_TURN_GATE_VALUE({ cause: isError(err) ? err : void 0 });
+		}
+		this.#id = resolved.id;
+		this.#turnId = resolved.turnId;
+		this.#reason = resolved.reason;
+		this.#payload = resolved.payload;
+		this.#createdAt = resolved.createdAt;
+		this.#settled = false;
+		this.#schema = resolved.schema;
+		this.#controller = new AbortController();
+		this.#promise = new Promise((resolve, reject) => {
+			this.#resolve = resolve;
+			this.#reject = reject;
+		});
+		const onAbort = () => {
+			if (!this.#settled) {
+				this.#settled = true;
+				this.#reject(new E_TURN_GATE_ABORTED());
+			}
+		};
+		this.#controller.signal.addEventListener("abort", onAbort, { once: true });
+		if (resolved.abortSignal) if (resolved.abortSignal.aborted) queueMicrotask(() => onAbort());
+		else {
+			resolved.abortSignal.addEventListener("abort", onAbort, { once: true });
+			this.#promise.then(() => resolved.abortSignal.removeEventListener("abort", onAbort), () => resolved.abortSignal.removeEventListener("abort", onAbort));
+		}
+		if (resolved.timeout !== void 0) {
+			const timer = setTimeout(() => {
+				if (!this.#settled) {
+					this.#settled = true;
+					this.#reject(new E_TURN_GATE_TIMEOUT());
+				}
+			}, resolved.timeout);
+			this.#promise.then(() => clearTimeout(timer), () => clearTimeout(timer));
+		}
+		Object.defineProperties(this, {
+			id: {
+				get: () => this.#id,
+				enumerable: true,
+				configurable: false
+			},
+			turnId: {
+				get: () => this.#turnId,
+				enumerable: true,
+				configurable: false
+			},
+			reason: {
+				get: () => this.#reason,
+				enumerable: true,
+				configurable: false
+			},
+			payload: {
+				get: () => this.#payload,
+				enumerable: true,
+				configurable: false
+			},
+			createdAt: {
+				get: () => this.#createdAt,
+				enumerable: true,
+				configurable: false
+			},
+			isSettled: {
+				get: () => this.#settled,
+				enumerable: true,
+				configurable: false
+			}
+		});
+	}
+	/**
+	* Resolves the gate with `value`, unblocking the awaiting middleware.
+	*
+	* @remarks
+	* If a schema was provided at construction, `value` is validated synchronously before the
+	* promise is settled. A validation failure throws {@link @nhtio/adk!E_INVALID_TURN_GATE_RESOLUTION}
+	* in the caller's context — the promise is NOT settled and the gate remains open.
+	*
+	* No-ops if the gate is already settled.
+	*
+	* @param value - The resolution value. Must satisfy the gate's schema when one was provided.
+	* @throws {@link @nhtio/adk!E_INVALID_TURN_GATE_RESOLUTION} when `value` fails schema validation.
+	*/
+	resolve(value) {
+		if (this.#settled) return;
+		if (this.#schema !== void 0) try {
+			value = validateOrThrow(this.#schema, value, true);
+		} catch (err) {
+			throw new E_INVALID_TURN_GATE_RESOLUTION({ cause: isError(err) ? err : void 0 });
+		}
+		this.#settled = true;
+		this.#resolve(value);
+	}
+	/**
+	* Rejects the gate with `error`, unblocking the awaiting middleware with a rejection.
+	*
+	* @remarks
+	* No-ops if the gate is already settled.
+	*
+	* @param error - The rejection reason.
+	*/
+	reject(error) {
+		if (this.#settled) return;
+		this.#settled = true;
+		this.#reject(error);
+	}
+	/**
+	* Aborts the gate by firing the internal `AbortController`, which rejects the promise with
+	* {@link @nhtio/adk!E_TURN_GATE_ABORTED}.
+	*
+	* @remarks
+	* No-ops if the gate is already settled. Distinct from the turn-level abort signal — this
+	* allows callers to cancel a specific gate without aborting the whole turn.
+	*/
+	abort() {
+		if (this.#settled) return;
+		this.#controller.abort();
+	}
+	/**
+	* Returns the internal promise. Called by `ctx.waitFor()` to block the middleware pipeline.
+	*
+	* @internal
+	*/
+	_promise() {
+		return this.#promise;
+	}
+};
+//#endregion
+//#region src/lib/contracts/turn_runner_config.ts
+/**
+* Validator schema used to validate a {@link TurnRunnerConfig} at {@link @nhtio/adk!TurnRunner} construction time.
+*
+* @remarks
+* Validates that all callbacks are functions of the correct arity, and that `tools` — when
+* provided — is an array of valid {@link @nhtio/adk!Tool} instances. Defaults `tools` to `[]`.
+*
+* Throws {@link @nhtio/adk!E_INVALID_TURN_RUNNER_CONFIG} (via the {@link @nhtio/adk!TurnRunner} constructor) when
+* validation fails.
+*/
+var turnRunnerConfigSchema = validator.object({
+	executorCallback: validator.function().required(),
+	fetchMemoriesCallback: validator.function().arity(1).required(),
+	fetchMessagesCallback: validator.function().arity(1).required(),
+	fetchThoughtsCallback: validator.function().arity(1).required(),
+	fetchToolCallsCallback: validator.function().arity(1).required(),
+	fetchToolsCallback: validator.function().arity(1).required(),
+	refreshStandingInstructionsCallback: validator.function().arity(1).required(),
+	storeStandingInstructionCallback: validator.function().arity(2).required(),
+	mutateStandingInstructionCallback: validator.function().arity(2).required(),
+	deleteStandingInstructionCallback: validator.function().arity(2).required(),
+	storeMemoryCallback: validator.function().arity(2).required(),
+	mutateMemoryCallback: validator.function().arity(2).required(),
+	deleteMemoryCallback: validator.function().arity(2).required(),
+	fetchRetrievablesCallback: validator.function().arity(1).required(),
+	storeRetrievableCallback: validator.function().arity(2).required(),
+	mutateRetrievableCallback: validator.function().arity(2).required(),
+	deleteRetrievableCallback: validator.function().arity(2).required(),
+	storeMessageCallback: validator.function().arity(2).required(),
+	mutateMessageCallback: validator.function().arity(2).required(),
+	deleteMessageCallback: validator.function().arity(2).required(),
+	storeThoughtCallback: validator.function().arity(2).required(),
+	mutateThoughtCallback: validator.function().arity(2).required(),
+	deleteThoughtCallback: validator.function().arity(2).required(),
+	storeToolCallCallback: validator.function().arity(2).required(),
+	mutateToolCallCallback: validator.function().arity(2).required(),
+	deleteToolCallCallback: validator.function().arity(2).required(),
+	tools: validator.array().items(validator.any().custom((value, helpers) => {
+		if (Tool.isTool(value)) return value;
+		return helpers.error("any.invalid");
+	})).default([]),
+	turnInputPipeline: validator.array().items(validator.function()).default([]),
+	turnOutputPipeline: validator.array().items(validator.function()).default([]),
+	dispatchInputPipeline: validator.array().items(validator.function()).default([]),
+	dispatchOutputPipeline: validator.array().items(validator.function()).default([])
+});
+//#endregion
+//#region src/lib/turn_runner.ts
+/**
+* Executes a single agent turn through paired input and output middleware pipelines.
+*
+* @remarks
+* Construction validates `config` eagerly and throws {@link @nhtio/adk!E_INVALID_TURN_RUNNER_CONFIG} if it
+* does not satisfy the schema — fail-fast so misconfiguration surfaces before any turn runs.
+*
+* Each call to {@link TurnRunner.run} threads a {@link @nhtio/adk!TurnContext} through the input pipeline,
+* invokes the model, then threads the result through the output pipeline. Middleware on each side
+* can read and mutate the context for pre- and post-processing (e.g. message normalisation, tool
+* call dispatch, response filtering).
+*
+* **Two event buses:**
+* - Functional bus (`on` / `off` / `once`): `message`, `thought`, `toolCall` — pipeline-affecting
+*   events that middleware raises throughout turn execution.
+* - Observability bus (`observe` / `unobserve` / `observeOnce`): `turnStart`, `turnEnd`,
+*   `turnGateOpen`, `turnGateClosed`, `error` — instrumentation-only events that monitor execution
+*   without participating in it.
+*
+* Streaming content is surfaced via `message` and `thought` events; tool call lifecycle via
+* `toolCall`; non-fatal pipeline errors via the observability `error` event; gate lifecycle via
+* `turnGateOpen` and `turnGateClosed` — all throughout execution.
+*
+* @example
+* ```ts
+* const runner = new TurnRunner({
+*   fetchMemoriesCallback: async (ctx) => memoryStore.query(ctx),
+*   fetchMessagesCallback: async (ctx) => messageStore.history(ctx),
+*   fetchThoughtsCallback: async (ctx) => thoughtStore.history(ctx),
+*   fetchToolCallsCallback: async (ctx) => toolCallStore.history(ctx),
+* })
+* // Functional bus — pipeline events
+* runner.on('message', (chunk) => process.stdout.write(chunk.aDelta))
+* // Observability bus — instrumentation
+* runner.observe('error', (err) => console.error(err.toString()))
+* runner.observe('turnStart', ({ turnId }) => console.log('turn started', turnId))
+* runner.observe('turnGateOpen', (gate) => {
+*   if (gate.reason === 'tool_approval') {
+*     gate.resolve(true) // approve immediately for this example
+*   }
+* })
+* await runner.run({
+*   turnAbortController: new AbortController(),
+*   systemPrompt: 'You are a helpful assistant.',
+*   standingInstructions: [],
+* })
+* ```
+*/
+var TurnRunner = class TurnRunner {
+	/**
+	* Returns `true` if `value` is a {@link TurnRunner} instance.
+	*
+	* @remarks
+	* Uses {@link @nhtio/adk!isInstanceOf} for cross-realm safety.
+	*
+	* @param value - The value to test.
+	* @returns `true` when `value` is a {@link TurnRunner} instance.
+	*/
+	static isTurnRunner(value) {
+		return isInstanceOf(value, "TurnRunner", TurnRunner);
+	}
+	#config;
+	#inputRunner;
+	#outputRunner;
+	#functionalEmitter;
+	#observabilityEmitter;
+	/**
+	* @param config - Construction-time configuration validated against {@link turnRunnerConfigSchema}.
+	* @throws {@link @nhtio/adk!E_INVALID_TURN_RUNNER_CONFIG} when `config` does not satisfy the schema.
+	*/
+	constructor(config) {
+		if (!passesSchema(turnRunnerConfigSchema, config)) throw new E_INVALID_TURN_RUNNER_CONFIG();
+		this.#config = validateOrThrow(turnRunnerConfigSchema, config, true);
+		const turnInputPipeline = new Middleware();
+		const turnOutputPipeline = new Middleware();
+		const wrap = (fn) => (ctx, next) => {
+			if (ctx.aborted) return next();
+			return fn(ctx, next);
+		};
+		for (const fn of this.#config.turnInputPipeline) turnInputPipeline.add(wrap(fn));
+		for (const fn of this.#config.turnOutputPipeline) turnOutputPipeline.add(wrap(fn));
+		this.#inputRunner = turnInputPipeline.runner();
+		this.#outputRunner = turnOutputPipeline.runner();
+		this.#functionalEmitter = new TypedEventEmitter();
+		this.#observabilityEmitter = new TypedEventEmitter();
+	}
+	/**
+	* Removes a previously registered functional listener for `event`.
+	*
+	* @param event - The event to stop listening to.
+	* @param listener - The listener function to remove.
+	* @returns `this` for chaining.
+	*/
+	off(event, listener) {
+		this.#functionalEmitter.off(event, listener);
+		return this;
+	}
+	/**
+	* Registers a persistent functional listener for `event`.
+	*
+	* @param event - The event to listen to.
+	* @param listener - The function to call on each emission.
+	* @returns `this` for chaining.
+	*/
+	on(event, listener) {
+		this.#functionalEmitter.on(event, listener);
+		return this;
+	}
+	/**
+	* Registers a one-time functional listener for `event` that is automatically removed after the
+	* first emission.
+	*
+	* @param event - The event to listen to.
+	* @param listener - The function to call on the next emission.
+	* @returns `this` for chaining.
+	*/
+	once(event, listener) {
+		this.#functionalEmitter.once(event, listener);
+		return this;
+	}
+	/**
+	* Removes a previously registered observability listener for `event`.
+	*
+	* @param event - The event to stop observing.
+	* @param listener - The listener function to remove.
+	* @returns `this` for chaining.
+	*/
+	unobserve(event, listener) {
+		this.#observabilityEmitter.off(event, listener);
+		return this;
+	}
+	/**
+	* Registers a persistent observability listener for `event`.
+	*
+	* @remarks
+	* Use the observability bus (`observe` / `unobserve` / `observeOnce`) for instrumentation:
+	* turn lifecycle, gate lifecycle, and non-fatal errors. Use the functional bus (`on` / `off` /
+	* `once`) for pipeline-affecting events: `message`, `thought`, `toolCall`.
+	*
+	* @param event - The event to observe.
+	* @param listener - The function to call on each emission.
+	* @returns `this` for chaining.
+	*/
+	observe(event, listener) {
+		this.#observabilityEmitter.on(event, listener);
+		return this;
+	}
+	/**
+	* Registers a one-time observability listener for `event` that is automatically removed after
+	* the first emission.
+	*
+	* @param event - The event to observe once.
+	* @param listener - The function to call on the next emission.
+	* @returns `this` for chaining.
+	*/
+	observeOnce(event, listener) {
+		this.#observabilityEmitter.once(event, listener);
+		return this;
+	}
+	/**
+	* Executes a single agent turn against the provided raw context.
+	*
+	* @remarks
+	* Returns `Promise<void>` intentionally — all meaningful output surfaces via events, not return
+	* values. Register listeners before calling `run`: observability events (`turnStart`, `turnEnd`)
+	* bracket execution; functional events (`message`, `thought`, `toolCall`) fire throughout;
+	* observability `error` carries non-fatal pipeline failures; `turnGateOpen` and `turnGateClosed`
+	* fire when middleware suspends via `ctx.waitFor()`. Awaiting this method only tells you the
+	* pipeline has finished, not what it produced.
+	*
+	* Constructs a validated {@link @nhtio/adk!TurnContext} from `context` (throwing
+	* {@link @nhtio/adk!E_INVALID_TURN_CONTEXT} on failure), then runs the input middleware pipeline.
+	* Abort signals are silently swallowed.
+	*
+	* @param context - Raw input validated and wrapped into a {@link @nhtio/adk!TurnContext} before execution.
+	* @throws {@link @nhtio/adk!E_INVALID_TURN_CONTEXT} when `context` does not satisfy the schema.
+	*/
+	async run(context) {
+		const abortController = context.turnAbortController ?? new AbortController();
+		let turnContextId;
+		const openGate = (raw) => {
+			const gate = new TurnGate({
+				...raw,
+				turnId: turnContextId,
+				abortSignal: abortController.signal
+			});
+			this.#observabilityEmitter.emit("turnGateOpen", gate);
+			const promise = gate._promise();
+			promise.then(() => {
+				this.#observabilityEmitter.emit("turnGateClosed", {
+					gateId: gate.id,
+					turnId: gate.turnId,
+					result: "resolved",
+					settledAt: DateTime.now()
+				});
+			}, (err) => {
+				let result = "rejected";
+				if (isInstanceOf(err, "E_TURN_GATE_ABORTED")) result = "aborted";
+				else if (isInstanceOf(err, "E_TURN_GATE_TIMEOUT")) result = "timeout";
+				this.#observabilityEmitter.emit("turnGateClosed", {
+					gateId: gate.id,
+					turnId: gate.turnId,
+					result,
+					settledAt: DateTime.now()
+				});
+			});
+			return promise;
+		};
+		const tools = new ToolRegistry(this.#config.tools);
+		const turnContext = new TurnContext({
+			...context,
+			turnAbortController: abortController
+		}, {
+			fetchMemories: this.#config.fetchMemoriesCallback,
+			fetchMessages: this.#config.fetchMessagesCallback,
+			fetchThoughts: this.#config.fetchThoughtsCallback,
+			fetchToolCalls: this.#config.fetchToolCallsCallback,
+			fetchTools: this.#config.fetchToolsCallback,
+			refreshStandingInstructions: this.#config.refreshStandingInstructionsCallback,
+			storeStandingInstruction: this.#config.storeStandingInstructionCallback,
+			mutateStandingInstruction: this.#config.mutateStandingInstructionCallback,
+			deleteStandingInstruction: this.#config.deleteStandingInstructionCallback,
+			storeMemory: this.#config.storeMemoryCallback,
+			mutateMemory: this.#config.mutateMemoryCallback,
+			deleteMemory: this.#config.deleteMemoryCallback,
+			fetchRetrievables: this.#config.fetchRetrievablesCallback,
+			storeRetrievable: this.#config.storeRetrievableCallback,
+			mutateRetrievable: this.#config.mutateRetrievableCallback,
+			deleteRetrievable: this.#config.deleteRetrievableCallback,
+			storeMessage: this.#config.storeMessageCallback,
+			mutateMessage: this.#config.mutateMessageCallback,
+			deleteMessage: this.#config.deleteMessageCallback,
+			storeThought: this.#config.storeThoughtCallback,
+			mutateThought: this.#config.mutateThoughtCallback,
+			deleteThought: this.#config.deleteThoughtCallback,
+			storeToolCall: this.#config.storeToolCallCallback,
+			mutateToolCall: this.#config.mutateToolCallCallback,
+			deleteToolCall: this.#config.deleteToolCallCallback,
+			emitMessage: (content) => this.#functionalEmitter.emit("message", content),
+			emitThought: (content) => this.#functionalEmitter.emit("thought", content),
+			emitToolCall: (content) => this.#functionalEmitter.emit("toolCall", content),
+			emitToolExecutionStart: (event) => this.#observabilityEmitter.emit("toolExecutionStart", event),
+			emitToolExecutionEnd: (event) => this.#observabilityEmitter.emit("toolExecutionEnd", event),
+			openGate,
+			tools
+		});
+		turnContextId = turnContext.id;
+		const startedAt = DateTime.now();
+		this.#observabilityEmitter.emit("turnStart", {
+			turnId: turnContext.id,
+			startedAt
+		});
+		const emitTurnEnd = () => {
+			const endedAt = DateTime.now();
+			this.#observabilityEmitter.emit("turnEnd", {
+				turnId: turnContext.id,
+				startedAt,
+				endedAt,
+				durationMs: endedAt.diff(startedAt).milliseconds
+			});
+		};
+		let inputFailed = false;
+		let inputReached = false;
+		await this.#inputRunner.errorHandler(async (error) => {
+			if (!isError(error) || !isInstanceOf(error, "AbortError")) {
+				inputFailed = true;
+				const err = new E_INPUT_PIPELINE_ERROR({ cause: isError(error) ? error : void 0 });
+				this.#observabilityEmitter.emit("error", err);
+			}
+		}).finalHandler(async () => {
+			inputReached = true;
+		}).run((fn, next) => Promise.resolve(fn(turnContext, next)));
+		if (!inputReached && !inputFailed && !turnContext.aborted) {
+			inputFailed = true;
+			const err = new E_PIPELINE_SHORT_CIRCUITED(["turn-input"]);
+			this.#observabilityEmitter.emit("error", err);
+		}
+		if (inputFailed || turnContext.aborted) {
+			emitTurnEnd();
+			return;
+		}
+		let dispatchFailed = false;
+		try {
+			await DispatchRunner.dispatch({
+				source: turnContext,
+				executor: this.#config.executorCallback,
+				turnInputPipeline: this.#config.dispatchInputPipeline,
+				turnOutputPipeline: this.#config.dispatchOutputPipeline,
+				observers: {
+					dispatchStart: [(e) => {
+						this.#observabilityEmitter.emit("dispatchStart", e);
+					}],
+					dispatchEnd: [(e) => {
+						this.#observabilityEmitter.emit("dispatchEnd", e);
+					}],
+					iterationStart: [(e) => {
+						this.#observabilityEmitter.emit("iterationStart", e);
+					}],
+					iterationEnd: [(e) => {
+						this.#observabilityEmitter.emit("iterationEnd", e);
+					}],
+					log: [(e) => {
+						this.#observabilityEmitter.emit("log", e);
+					}]
+				}
+			});
+		} catch (err) {
+			dispatchFailed = true;
+			const wrapped = isInstanceOf(err, "BaseException") ? err : err;
+			this.#observabilityEmitter.emit("error", wrapped);
+		}
+		if (dispatchFailed || turnContext.aborted) {
+			emitTurnEnd();
+			return;
+		}
+		let outputFailed = false;
+		let outputReached = false;
+		await this.#outputRunner.errorHandler(async (error) => {
+			if (!isError(error) || !isInstanceOf(error, "AbortError")) {
+				outputFailed = true;
+				const err = new E_OUTPUT_PIPELINE_ERROR({ cause: isError(error) ? error : void 0 });
+				this.#observabilityEmitter.emit("error", err);
+			}
+		}).finalHandler(async () => {
+			outputReached = true;
+		}).run((fn, next) => Promise.resolve(fn(turnContext, next)));
+		if (!outputReached && !outputFailed && !turnContext.aborted) {
+			const err = new E_PIPELINE_SHORT_CIRCUITED(["turn-output"]);
+			this.#observabilityEmitter.emit("error", err);
+		}
+		emitTurnEnd();
+	}
+};
+//#endregion
+export { TurnGate as n, TurnRunner as t };
+
+//# sourceMappingURL=turn_runner-y7eyEcJH.mjs.map