@minpeter/pss-runtime 0.1.0-next.0 → 0.1.0-next.2

package/dist/session/session-turn-processor.js

@@ -0,0 +1,135 @@
+import { ToolExecutionNeedsRecoveryError } from "../llm-tool-execution.js";
+import { closeRuntimeInput, withRuntimeInputWindow } from "./runtime-input.js";
+import { errorMessage } from "./session-errors.js";
+import { runAgentLoop } from "../agent-loop.js";
+import { startSessionExecutionRun } from "./session-execution.js";
+import { drainRuntimeInput } from "./session-runtime-drain.js";
+import { emitTurnErrorAfterRecovery } from "./session-turn-error.js";
+//#region src/session/session-turn-processor.ts
+async function processQueuedInput({ activate, deactivateRun, events, execution, item, llm, release, sessionKey, state }) {
+	const activeAbort = new AbortController();
+	const { initialEvents, input, preUserRuntimeInputs, run, runtimeInput } = item;
+	const turnId = crypto.randomUUID();
+	activate({
+		abort: activeAbort,
+		run,
+		runtimeInput,
+		turnId
+	});
+	const historySnapshot = state.modelSnapshot();
+	let executionRun;
+	try {
+		executionRun = await startSessionExecutionRun({
+			executionHost: execution.executionHost,
+			sessionKey,
+			state,
+			turnId
+		});
+		for (const event of initialEvents) await events.emitRunEvent(run, event);
+		await appendRuntimeInputsToHistory(state, preUserRuntimeInputs);
+		if (input) {
+			state.appendUserInput(input);
+			await state.commit();
+		}
+		await withRuntimeInputWindow(runtimeInput, "turn-start", async () => {
+			await events.emitRunBoundaryEvent(run, { type: "turn-start" });
+		});
+		await emitPreUserRuntimeInputs(events, run, preUserRuntimeInputs);
+		await drainRuntimeInput({
+			emit: (event) => events.emitRunEvent(run, event),
+			placement: "turn-start",
+			runtimeInput,
+			state
+		});
+		const result = await runAgentLoop({
+			emit: async (event) => emitTurnEvent({
+				event,
+				events,
+				run,
+				runtimeInput,
+				state
+			}),
+			history: state.history,
+			llm,
+			captureObserverEvents: (callback) => events.captureObserverEvents(run, callback),
+			signal: activeAbort.signal,
+			toolExecution: executionRun?.toolExecution
+		});
+		await state.commit();
+		await executionRun?.complete(executionStatusForResult(result));
+		await closeSuccessfulTurn({
+			deactivateRun,
+			events,
+			result,
+			run,
+			runtimeInput
+		});
+	} catch (error) {
+		const turnError = error instanceof Error ? error : new Error(String(error));
+		await executionRun?.complete(executionStatusForError(turnError));
+		await emitTurnErrorAfterRecovery({
+			error: turnError,
+			historySnapshot,
+			run,
+			runtimeInput,
+			state
+		});
+	} finally {
+		closeRuntimeInput(runtimeInput);
+		release();
+		run.close(void 0, runtimeInput.closedReason);
+	}
+}
+function executionStatusForResult(result) {
+	return result === "aborted" ? "cancelled" : "completed";
+}
+function executionStatusForError(error) {
+	return error instanceof ToolExecutionNeedsRecoveryError ? "needs-recovery" : "error";
+}
+async function appendRuntimeInputsToHistory(state, runtimeInputs) {
+	for (const runtimeInput of runtimeInputs) {
+		state.appendUserInput(runtimeInput.input);
+		await state.commit();
+	}
+}
+async function closeSuccessfulTurn({ deactivateRun, events, result, run, runtimeInput }) {
+	const terminalEvent = result === "aborted" ? "turn-abort" : "turn-end";
+	closeRuntimeInput(runtimeInput, terminalEvent);
+	deactivateRun();
+	try {
+		await events.emitRunEvent(run, { type: terminalEvent });
+	} catch (terminalError) {
+		run.emit({
+			type: "turn-error",
+			message: errorMessage(terminalError)
+		});
+		closeRuntimeInput(runtimeInput, "turn-error");
+	}
+}
+async function emitPreUserRuntimeInputs(events, run, runtimeInputs) {
+	for (const runtimeInput of runtimeInputs) await events.emitRunEvent(run, {
+		input: runtimeInput.input,
+		placement: runtimeInput.placement,
+		type: "runtime-input"
+	});
+}
+async function emitTurnEvent({ event, events, run, runtimeInput, state }) {
+	if (event.type !== "step-start" && event.type !== "step-end") {
+		await events.emitRunEvent(run, event);
+		return;
+	}
+	await withRuntimeInputWindow(runtimeInput, event.type, async () => {
+		await events.emitRunBoundaryEvent(run, event);
+	});
+	const runtimeInputAdded = await drainRuntimeInput({
+		emit: (runtimeInputEvent) => events.emitRunEvent(run, runtimeInputEvent),
+		placement: event.type,
+		runtimeInput,
+		state
+	});
+	return event.type === "step-end" ? { runtimeInputAdded } : void 0;
+}
+//#endregion
+export { processQueuedInput };
+
+//# sourceMappingURL=session-turn-processor.js.map

package/dist/session/session-turn-processor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-turn-processor.js","names":[],"sources":["../../src/session/session-turn-processor.ts"],"sourcesContent":["import { runAgentLoop } from \"../agent-loop\";\nimport type { RuntimeLlm } from \"../llm\";\nimport { ToolExecutionNeedsRecoveryError } from \"../llm-tool-execution\";\nimport type { AgentEvent } from \"./events\";\nimport type { BufferedAgentRun } from \"./run\";\nimport {\n  closeRuntimeInput,\n  type QueuedInput,\n  type QueuedRuntimeInput,\n  type RuntimeInputState,\n  withRuntimeInputWindow,\n} from \"./runtime-input\";\nimport { errorMessage } from \"./session-errors\";\nimport type { SessionEventDispatcher } from \"./session-events\";\nimport {\n  type SessionExecutionOptions,\n  type SessionExecutionRun,\n  type SessionExecutionTerminalStatus,\n  startSessionExecutionRun,\n} from \"./session-execution\";\nimport { drainRuntimeInput } from \"./session-runtime-drain\";\nimport type { SessionState } from \"./session-state\";\nimport { emitTurnErrorAfterRecovery } from \"./session-turn-error\";\n\ninterface ActiveTurn {\n  readonly abort: AbortController;\n  readonly run: BufferedAgentRun;\n  readonly runtimeInput: RuntimeInputState;\n  readonly turnId: string;\n}\n\ninterface ProcessQueuedInputOptions {\n  readonly activate: (turn: ActiveTurn) => void;\n  readonly deactivateRun: () => void;\n  readonly events: SessionEventDispatcher;\n  readonly execution: SessionExecutionOptions;\n  readonly item: QueuedInput;\n  readonly llm: RuntimeLlm;\n  readonly release: () => void;\n  readonly sessionKey: string;\n  readonly state: SessionState;\n}\n\nexport async function processQueuedInput({\n  activate,\n  deactivateRun,\n  events,\n  execution,\n  item,\n  llm,\n  release,\n  sessionKey,\n  state,\n}: ProcessQueuedInputOptions): Promise<void> {\n  const activeAbort = new AbortController();\n  const { initialEvents, input, preUserRuntimeInputs, run, runtimeInput } =\n    item;\n  const turnId = crypto.randomUUID();\n  activate({\n    abort: activeAbort,\n    run,\n    runtimeInput,\n    turnId,\n  });\n  const historySnapshot = state.modelSnapshot();\n  let executionRun: SessionExecutionRun | undefined;\n\n  try {\n    executionRun = await startSessionExecutionRun({\n      executionHost: execution.executionHost,\n      sessionKey,\n      state,\n      turnId,\n    });\n    for (const event of initialEvents) {\n      await events.emitRunEvent(run, event);\n    }\n    await appendRuntimeInputsToHistory(state, preUserRuntimeInputs);\n    if (input) {\n      state.appendUserInput(input);\n      await state.commit();\n    }\n    await withRuntimeInputWindow(runtimeInput, \"turn-start\", async () => {\n      await events.emitRunBoundaryEvent(run, { type: \"turn-start\" });\n    });\n    await emitPreUserRuntimeInputs(events, run, preUserRuntimeInputs);\n    await drainRuntimeInput({\n      emit: (event) => events.emitRunEvent(run, event),\n      placement: \"turn-start\",\n      runtimeInput,\n      state,\n    });\n\n    const result = await runAgentLoop({\n      emit: async (event) =>\n        emitTurnEvent({\n          event,\n          events,\n          run,\n          runtimeInput,\n          state,\n        }),\n      history: state.history,\n      llm,\n      captureObserverEvents: (callback) =>\n        events.captureObserverEvents(run, callback),\n      signal: activeAbort.signal,\n      toolExecution: executionRun?.toolExecution,\n    });\n\n    await state.commit();\n    await executionRun?.complete(executionStatusForResult(result));\n    await closeSuccessfulTurn({\n      deactivateRun,\n      events,\n      result,\n      run,\n      runtimeInput,\n    });\n  } catch (error) {\n    const turnError = error instanceof Error ? error : new Error(String(error));\n    await executionRun?.complete(executionStatusForError(turnError));\n    await emitTurnErrorAfterRecovery({\n      error: turnError,\n      historySnapshot,\n      run,\n      runtimeInput,\n      state,\n    });\n  } finally {\n    closeRuntimeInput(runtimeInput);\n    release();\n    run.close(undefined, runtimeInput.closedReason);\n  }\n}\n\nfunction executionStatusForResult(\n  result: \"aborted\" | \"completed\"\n): SessionExecutionTerminalStatus {\n  return result === \"aborted\" ? \"cancelled\" : \"completed\";\n}\n\nfunction executionStatusForError(error: Error): SessionExecutionTerminalStatus {\n  return error instanceof ToolExecutionNeedsRecoveryError\n    ? \"needs-recovery\"\n    : \"error\";\n}\n\nasync function appendRuntimeInputsToHistory(\n  state: SessionState,\n  runtimeInputs: readonly QueuedRuntimeInput[]\n): Promise<void> {\n  for (const runtimeInput of runtimeInputs) {\n    state.appendUserInput(runtimeInput.input);\n    await state.commit();\n  }\n}\n\nasync function closeSuccessfulTurn({\n  deactivateRun,\n  events,\n  result,\n  run,\n  runtimeInput,\n}: {\n  readonly deactivateRun: () => void;\n  readonly events: SessionEventDispatcher;\n  readonly result: \"aborted\" | \"completed\";\n  readonly run: BufferedAgentRun;\n  readonly runtimeInput: RuntimeInputState;\n}): Promise<void> {\n  const terminalEvent = result === \"aborted\" ? \"turn-abort\" : \"turn-end\";\n  closeRuntimeInput(runtimeInput, terminalEvent);\n  deactivateRun();\n  try {\n    await events.emitRunEvent(run, { type: terminalEvent });\n  } catch (terminalError) {\n    run.emit({ type: \"turn-error\", message: errorMessage(terminalError) });\n    closeRuntimeInput(runtimeInput, \"turn-error\");\n  }\n}\n\nasync function emitPreUserRuntimeInputs(\n  events: SessionEventDispatcher,\n  run: BufferedAgentRun,\n  runtimeInputs: readonly QueuedRuntimeInput[]\n): Promise<void> {\n  for (const runtimeInput of runtimeInputs) {\n    await events.emitRunEvent(run, {\n      input: runtimeInput.input,\n      placement: runtimeInput.placement,\n      type: \"runtime-input\",\n    });\n  }\n}\n\nasync function emitTurnEvent({\n  event,\n  events,\n  run,\n  runtimeInput,\n  state,\n}: {\n  readonly event: AgentEvent;\n  readonly events: SessionEventDispatcher;\n  readonly run: BufferedAgentRun;\n  readonly runtimeInput: RuntimeInputState;\n  readonly state: SessionState;\n}): Promise<{ readonly runtimeInputAdded: boolean } | undefined> {\n  if (event.type !== \"step-start\" && event.type !== \"step-end\") {\n    await events.emitRunEvent(run, event);\n    return;\n  }\n\n  await withRuntimeInputWindow(runtimeInput, event.type, async () => {\n    await events.emitRunBoundaryEvent(run, event);\n  });\n  const runtimeInputAdded = await drainRuntimeInput({\n    emit: (runtimeInputEvent) => events.emitRunEvent(run, runtimeInputEvent),\n    placement: event.type,\n    runtimeInput,\n    state,\n  });\n  return event.type === \"step-end\" ? { runtimeInputAdded } : undefined;\n}\n"],"mappings":"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"}

package/dist/session/session.js

@@ -1,135 +1,139 @@
-import { runWithAgentPluginScope } from "../plugins/scope.js";
-import { runAgentLoop } from "../agent-loop.js";
-import { ModelMessageHistory } from "./history.js";
-import { createRuntimeInputStepLifecycle, runPluginAfterTurnHandlers, runPluginBeforeTurnHandlers } from "./lifecycle.js";
-import { addRuntimeInput, closeRuntimeInput, createRuntimeInputState, normalizeAgentInput, shiftRuntimeInput } from "./runtime-input.js";
-import { SessionOverlayState } from "./overlay.js";
 import { BufferedAgentRun } from "./run.js";
-import { decodeStoredSessionSnapshot, encodeSessionSnapshot } from "./snapshot.js";
+import { normalizeAgentInput } from "./input-normalization.js";
+import { addSteeringInput, createRuntimeInputState, queueRuntimeInput } from "./runtime-input.js";
+import { sessionKilledError, sessionTerminalError } from "./session-errors.js";
+import { SessionEventDispatcher } from "./session-events.js";
+import { closeKilledRuntimeInputs } from "./session-kill.js";
+import { queueSessionNotification, startSessionQueueDrain } from "./session-notification.js";
+import { SessionState } from "./session-state.js";
+import { processQueuedInput } from "./session-turn-processor.js";
 //#region src/session/session.ts
 var AgentSession = class {
+	#events;
+	#execution;
 	#inputQueue = [];
-	#internalLlm;
 	#llm;
-	#onPluginError;
-	#persistence;
-	#plugins;
+	#pendingRuntimeInputs = [];
+	#sessionKey;
+	#state;
 	#activeAbort;
 	#activeRun;
 	#activeRuntimeInput;
-	#history = new ModelMessageHistory();
+	#activeTurnId;
+	#deletePromise;
 	#killed = false;
-	#loadPromise;
-	#loaded = false;
-	#pluginState = {};
-	#compactions = [];
-	#overlays = new SessionOverlayState();
 	#running = false;
-	#storeVersion;
-	constructor(llm, persistence, plugins, internalLlm = llm, onPluginError) {
-		this.#internalLlm = internalLlm;
-		this.#onPluginError = onPluginError;
-		this.#persistence = persistence;
-		this.#plugins = plugins;
+	#runToCloseOnKill;
+	constructor(llm, persistence, plugins = [], execution = {}) {
 		this.#llm = llm;
+		this.#execution = execution;
+		this.#sessionKey = persistence.key;
+		this.#state = new SessionState(persistence);
+		this.#events = new SessionEventDispatcher({
+			history: () => this.#state.modelSnapshot(),
+			plugins,
+			signal: () => this.#activeAbort?.signal
+		});
 	}
 	async send(input) {
-		if (this.#killed) throw sessionKilledError();
-		await this.#ensureLoaded();
-		if (this.#killed) throw sessionKilledError();
-		const runtimeInput = createRuntimeInputState();
+		if (this.#killed || this.#deletePromise) throw sessionTerminalError(this.#killed);
+		await this.#state.ensureLoaded();
+		if (this.#killed || this.#deletePromise) throw sessionTerminalError(this.#killed);
+		const runtimeInput = createRuntimeInputState(this.#pendingRuntimeInputs.splice(0));
 		const acceptedInput = normalizeAgentInput(input);
 		const run = new BufferedAgentRun();
-		run.emit(acceptedInput);
+		await this.#events.emitRunEvent(run, acceptedInput);
 		this.#inputQueue.push({
+			initialEvents: [],
 			input: structuredClone(acceptedInput),
+			preUserRuntimeInputs: [],
 			run,
 			runtimeInput
 		});
-		this.#drainInputQueue().catch((error) => {
-			run.emit({
-				type: "turn-error",
-				message: errorMessage(error)
-			});
-			run.close();
-		});
+		startSessionQueueDrain(run, () => this.#drainInputQueue());
 		return run;
 	}
+	async notify(input, options = {}) {
+		if (this.#killed || this.#deletePromise) throw sessionTerminalError(this.#killed);
+		await this.#state.ensureLoaded();
+		if (this.#killed || this.#deletePromise) throw sessionTerminalError(this.#killed);
+		return queueSessionNotification(input, options, {
+			activeRun: this.#activeRun,
+			activeRuntimeInput: this.#activeRuntimeInput,
+			drain: () => this.#drainInputQueue(),
+			inputQueue: this.#inputQueue,
+			pendingRuntimeInputs: this.#pendingRuntimeInputs
+		});
+	}
 	async steer(input) {
-		if (this.#killed) throw sessionKilledError();
+		if (this.#killed || this.#deletePromise) throw sessionTerminalError(this.#killed);
 		const runtimeInput = this.#activeRuntimeInput;
 		const run = this.#activeRun;
 		if (!(runtimeInput && run)) return this.send(input);
-		await addRuntimeInput(runtimeInput, input);
-		return run;
-	}
-	async overlay(input) {
-		if (this.#killed) throw sessionKilledError();
-		await this.#ensureLoaded();
-		if (this.#killed) throw sessionKilledError();
-		const activeRun = this.#activeRun;
-		if (activeRun) {
-			const placement = this.#activeRuntimeInput?.steerPlacement ?? this.#activeRuntimeInput?.placement ?? "step-end";
-			const entry = this.#overlays.appendActiveOverlay(input, placement);
-			if (!entry) throw new Error("Active overlay frame is unavailable.");
-			activeRun.emit({
-				input: entry.summary,
-				placement: entry.placement,
-				type: "overlay-accepted"
-			});
-			return activeRun;
-		}
-		const entry = this.#overlays.appendPendingOverlay(input);
-		const run = new BufferedAgentRun();
-		run.emit({
-			input: entry.summary,
-			placement: entry.placement,
-			type: "overlay-accepted"
-		});
-		run.close();
+		await addSteeringInput(runtimeInput, input);
 		return run;
 	}
 	interrupt() {
 		this.#activeAbort?.abort();
 	}
-	kill() {
-		if (this.#killed) return;
-		this.#killed = true;
-		this.#expireActiveOverlays("kill");
-		this.#activeAbort?.abort();
-		closeRuntimeInput(this.#activeRuntimeInput, sessionKilledError().message);
-		while (this.#inputQueue.length > 0) {
-			const item = this.#inputQueue.shift();
-			closeRuntimeInput(item?.runtimeInput, sessionKilledError().message);
-			item?.run.emit({
-				type: "turn-error",
-				message: sessionKilledError().message
+	currentTurnId() {
+		return this.#activeTurnId;
+	}
+	delete() {
+		if (!this.#deletePromise) {
+			this.kill();
+			this.#deletePromise = this.#state.delete().catch((error) => {
+				this.#deletePromise = void 0;
+				throw error;
 			});
-			item?.run.close(void 0, sessionKilledError().message);
 		}
+		return this.#deletePromise;
 	}
-	async #ensureLoaded() {
-		if (this.#loaded) return;
-		this.#loadPromise ??= this.#loadSessionState();
-		try {
-			await this.#loadPromise;
-		} catch (error) {
-			this.#loadPromise = void 0;
-			throw error;
+	enqueueRuntimeInput(input, placement = "turn-start") {
+		if (this.#killed) return;
+		const runtimeInput = this.#activeRuntimeInput;
+		if (runtimeInput && !runtimeInput.closedReason) {
+			if (placement === "turn-start" && runtimeInput.placement !== placement) {
+				this.#enqueuePendingRuntimeInput({
+					input,
+					placement
+				});
+				return;
+			}
+			queueRuntimeInput(runtimeInput, {
+				input,
+				placement
+			});
+			return;
 		}
+		this.#enqueuePendingRuntimeInput({
+			input,
+			placement
+		});
 	}
-	async #loadSessionState() {
-		if (this.#loaded) return;
-		await this.#replaceWithStoredSession();
-		this.#loaded = true;
+	emitObserverEvent(event) {
+		return this.#events.emitObserverEvent(this.#activeRun, event);
 	}
-	async #replaceWithStoredSession() {
-		const stored = await this.#persistence.store.load(this.#persistence.key);
-		this.#storeVersion = stored?.version;
-		const snapshot = decodeStoredSessionSnapshot(stored);
-		this.#history = new ModelMessageHistory(snapshot.history);
-		this.#pluginState = structuredClone(snapshot.pluginState);
-		this.#compactions = structuredClone(snapshot.compactions);
+	#enqueuePendingRuntimeInput(input) {
+		const queuedTurn = this.#inputQueue[0];
+		if (input.placement === "turn-start" && queuedTurn) {
+			queueRuntimeInput(queuedTurn.runtimeInput, input);
+			return;
+		}
+		this.#pendingRuntimeInputs.push(input);
+	}
+	kill() {
+		if (this.#killed) return;
+		this.#killed = true;
+		const killedError = sessionKilledError();
+		this.#pendingRuntimeInputs.length = 0;
+		this.#activeAbort?.abort();
+		closeKilledRuntimeInputs({
+			activeRuntimeInput: this.#activeRuntimeInput,
+			inputQueue: this.#inputQueue,
+			message: killedError.message,
+			runToClose: this.#runToCloseOnKill ?? this.#activeRun
+		});
 	}
 	async #drainInputQueue() {
 		if (this.#running) return;
@@ -137,250 +141,36 @@ var AgentSession = class {
 		try {
 			while (!this.#killed && this.#inputQueue.length > 0) {
 				const item = this.#inputQueue.shift();
-				if (item) await this.#processQueuedInput(item);
-			}
-		} finally {
-			this.#running = false;
-		}
-	}
-	async #processQueuedInput({ input, run, runtimeInput }) {
-		const activeAbort = new AbortController();
-		this.#activeAbort = activeAbort;
-		const historySnapshot = this.#history.modelSnapshot();
-		this.#overlays.startTurn(input, historySnapshot);
-		this.#activeRun = run;
-		this.#activeRuntimeInput = runtimeInput;
-		try {
-			await this.#withSteeringPlacement(runtimeInput, "turn-start", async () => {
-				await runPluginBeforeTurnHandlers(this.#pluginLifecycle(), {
-					input,
-					runtimeInput,
-					signal: activeAbort.signal
-				});
-			});
-			await this.#withRuntimeInputWindow(runtimeInput, "turn-start", async () => {
-				await run.emitBoundary({ type: "turn-start" });
-			});
-			this.#history.appendUserInput(input);
-			await this.#commitHistory();
-			await this.#drainRuntimeInput(run, runtimeInput, "turn-start");
-			const result = await runAgentLoop({
-				emit: async (event) => {
-					if (event.type === "step-start" || event.type === "step-end") {
-						await this.#withRuntimeInputWindow(runtimeInput, event.type, async () => {
-							await run.emitBoundary(event);
-						});
-						const overlayInputAdded = event.type === "step-end" && this.#overlays.consumeStepEndOverlayInputAdded();
-						const runtimeInputAdded = await this.#drainRuntimeInput(run, runtimeInput, event.type);
-						if (event.type === "step-end") return {
-							overlayInputAdded,
-							runtimeInputAdded
-						};
-						return;
-					}
-					run.emit(event);
-				},
-				history: this.#history,
-				stepLifecycle: createRuntimeInputStepLifecycle({
-					lifecycle: this.#pluginLifecycle(),
-					runtimeInput,
-					withSteeringPlacement: (placement, callback) => this.#withSteeringPlacement(runtimeInput, placement, callback)
-				}),
-				llm: (context) => this.#invokeLlm(context),
-				signal: activeAbort.signal
-			});
-			await this.#commitHistory();
-			const terminalEvent = result === "aborted" ? "turn-abort" : "turn-end";
-			closeRuntimeInput(runtimeInput, terminalEvent);
-			this.#expireActiveOverlays(terminalEvent);
-			this.#activeRuntimeInput = void 0;
-			this.#activeRun = void 0;
-			if (await runPluginAfterTurnHandlers(this.#pluginLifecycle(), {
-				input,
-				result,
-				signal: activeAbort.signal
-			})) await this.#commitHistory();
-			run.emit({ type: terminalEvent });
-		} catch (error) {
-			if (error instanceof SessionCommitConflictError) {
-				run.emit({
-					type: "turn-error",
-					message: error.message
+				if (item) await processQueuedInput({
+					activate: ({ abort, run, runtimeInput, turnId }) => {
+						this.#activeAbort = abort;
+						this.#activeRun = run;
+						this.#activeRuntimeInput = runtimeInput;
+						this.#activeTurnId = turnId;
+						this.#runToCloseOnKill = run;
+					},
+					deactivateRun: () => {
+						this.#activeRun = void 0;
+						this.#activeRuntimeInput = void 0;
+					},
+					events: this.#events,
+					execution: this.#execution,
+					item,
+					llm: this.#llm,
+					release: () => {
+						this.#activeAbort = void 0;
+						this.#activeRun = void 0;
+						this.#activeRuntimeInput = void 0;
+						this.#activeTurnId = void 0;
+						this.#runToCloseOnKill = void 0;
+					},
+					sessionKey: this.#sessionKey,
+					state: this.#state
 				});
-				closeRuntimeInput(runtimeInput, "a session commit conflict");
-				this.#expireActiveOverlays("turn-error");
-				this.#activeAbort = void 0;
-				return;
 			}
-			this.#history.rollback(historySnapshot);
-			try {
-				await this.#commitHistory();
-			} catch (rollbackError) {
-				run.emit({
-					type: "turn-error",
-					message: `${errorMessage(error)}; history rollback persistence failed: ${errorMessage(rollbackError)}`
-				});
-				closeRuntimeInput(runtimeInput, "turn-error");
-				this.#expireActiveOverlays("turn-error");
-				this.#activeAbort = void 0;
-				return;
-			}
-			run.emit({
-				type: "turn-error",
-				message: errorMessage(error)
-			});
-			closeRuntimeInput(runtimeInput, "turn-error");
-			this.#expireActiveOverlays("turn-error");
-		} finally {
-			closeRuntimeInput(runtimeInput);
-			this.#activeAbort = void 0;
-			this.#activeRun = void 0;
-			this.#activeRuntimeInput = void 0;
-			this.#overlays.resetActiveTurn();
-			run.close(void 0, runtimeInput.closedReason);
-		}
-	}
-	async #commitHistory() {
-		const result = await this.#persistence.store.commit(this.#persistence.key, { state: encodeSessionSnapshot({
-			compactions: this.#compactions,
-			history: this.#history.modelSnapshot(),
-			pluginState: this.#pluginState
-		}) }, { expectedVersion: this.#storeVersion ?? null });
-		if (!result.ok) {
-			await this.#replaceWithStoredSession();
-			throw new SessionCommitConflictError(this.#persistence.key);
-		}
-		this.#storeVersion = result.version;
-	}
-	#createPluginScope(signal) {
-		return {
-			eventHandlers: this.#plugins?.eventHandlers,
-			getCompactions: () => structuredClone(this.#compactions),
-			getPluginState: (pluginName) => this.#pluginState[pluginName],
-			history: () => this.#history.modelSnapshot(),
-			sessionKey: this.#persistence.key,
-			overlay: (input) => this.overlay(input),
-			setCompactions: (compactions) => {
-				this.#compactions = structuredClone([...compactions]);
-			},
-			setPluginState: (pluginName, state) => {
-				this.#pluginState = {
-					...this.#pluginState,
-					[pluginName]: structuredClone(state)
-				};
-			},
-			signal,
-			steer: (input) => this.steer(input),
-			summarize: (messages) => this.#summarizeForPlugins(messages, signal)
-		};
-	}
-	#pluginLifecycle() {
-		return {
-			createScope: (signal) => this.#createPluginScope(signal),
-			history: () => this.#history.modelSnapshot(),
-			onPluginError: this.#onPluginError,
-			plugins: this.#plugins,
-			sessionKey: this.#persistence.key,
-			overlaySession: (input) => this.overlay(input),
-			steerCurrentRun: async (runtimeInput, input) => {
-				await addRuntimeInput(runtimeInput, input);
-				if (!this.#activeRun) throw new Error("Agent plugin steering requires an active run.");
-				return this.#activeRun;
-			},
-			steerSession: (input) => this.steer(input)
-		};
-	}
-	#invokeLlm({ history, signal }) {
-		const activeSignal = signal ?? new AbortController().signal;
-		const invoke = async () => {
-			let transformedHistory = history;
-			for (const transform of this.#plugins?.contextTransforms ?? []) transformedHistory = await transform({
-				history: transformedHistory,
-				sessionKey: this.#persistence.key,
-				signal: activeSignal
-			});
-			const modelHistory = this.#overlays.compose(transformedHistory, history);
-			this.#overlays.markInferenceStarted();
-			return this.#llm({
-				history: modelHistory,
-				signal: activeSignal
-			});
-		};
-		return runWithAgentPluginScope(this.#createPluginScope(activeSignal), invoke);
-	}
-	async #summarizeForPlugins(messages, signal) {
-		return outputToText(await this.#internalLlm({
-			history: [{
-				content: "Summarize these earlier session messages for future model context.",
-				role: "system"
-			}, ...messages],
-			signal
-		})) || `Summarized ${messages.length} messages.`;
-	}
-	async #withRuntimeInputWindow(runtimeInput, placement, callback) {
-		const previousSteerPlacement = runtimeInput.steerPlacement;
-		runtimeInput.placement = placement;
-		runtimeInput.steerPlacement = placement;
-		try {
-			return await callback();
 		} finally {
-			runtimeInput.placement = void 0;
-			runtimeInput.steerPlacement = previousSteerPlacement;
-		}
-	}
-	async #withSteeringPlacement(runtimeInput, placement, callback) {
-		const previousSteerPlacement = runtimeInput.steerPlacement;
-		runtimeInput.steerPlacement = placement;
-		try {
-			return await callback();
-		} finally {
-			runtimeInput.steerPlacement = previousSteerPlacement;
-		}
-	}
-	async #drainRuntimeInput(run, runtimeInput, placement) {
-		let added = false;
-		let next = shiftRuntimeInput(runtimeInput, placement);
-		while (next) {
-			added = true;
-			run.emit({
-				type: "runtime-input",
-				input: next.input,
-				placement
-			});
-			this.#history.appendUserInput(next.input);
-			await this.#commitHistory();
-			next = shiftRuntimeInput(runtimeInput, placement);
-		}
-		return added;
-	}
-	#expireActiveOverlays(reason) {
-		const event = this.#overlays.expireActiveFrame(reason);
-		if (!event) return;
-		this.#activeRun?.emit(event);
-	}
-};
-function errorMessage(error) {
-	if (error instanceof Error) return error.message;
-	return String(error);
-}
-function outputToText(output) {
-	const parts = [];
-	for (const message of output) {
-		if (message.role !== "assistant") continue;
-		if (typeof message.content === "string") {
-			parts.push(message.content);
-			continue;
+			this.#running = false;
 		}
-		for (const part of message.content) if (part.type === "text") parts.push(part.text);
-	}
-	return parts.join("\n").trim();
-}
-function sessionKilledError() {
-	return /* @__PURE__ */ new Error("Session killed");
-}
-var SessionCommitConflictError = class extends Error {
-	constructor(key) {
-		super(`Session ${JSON.stringify(key)} commit conflict`);
 	}
 };
 //#endregion