@agimon-ai/doompi-core 0.0.1-alpha.70

package/dist/server/directHarnessRuntime.mjs

@@ -0,0 +1,976 @@
+import { createHistoryCreationFileSystem } from "../services/historyCreationFileSystem/index.mjs";
+import { preserveHistoryBeforeOpen } from "../history-import.mjs";
+import { openSqliteSessionStorage } from "../sqlite-session-storage.mjs";
+import fs from "node:fs";
+import path from "node:path";
+import { JSONL_STORAGE_VERSION, JsonlSessionRepo, laneState } from "@earendil-works/pi-agent-core/harness/session";
+import { BACKGROUND_CONTEXT } from "@earendil-works/pi-agent-core/harness/context";
+import { AgentHarness, HarnessFault } from "@earendil-works/pi-agent-core";
+import { NodeExecutionEnv } from "@earendil-works/pi-agent-core/node";
+import { createAssistantMessageEventStream, createModels, getSupportedThinkingLevels } from "@earendil-works/pi-ai";
+//#region src/server/directHarnessRuntime.ts
+const DEFAULT_LANE = "main";
+const DEFAULT_SESSION_ROOT = ".pi/sessions";
+const FRAME_ERROR = "error";
+const EVENT_TYPES = [
+	"run_start",
+	"run_resume",
+	"run_suspend",
+	"operation_abort",
+	"run_end",
+	"fault",
+	"handler_error",
+	"turn_start",
+	"turn_end",
+	"retry_scheduled",
+	"retry_start",
+	"retry_end",
+	"message_start",
+	"message_update",
+	"message_end",
+	"tool_start",
+	"tool_update",
+	"tool_end",
+	"entry_added",
+	"queue_update",
+	"value_update",
+	"config_update",
+	"compaction_start",
+	"compaction_end",
+	"navigation_start",
+	"navigation_end",
+	"usage",
+	"lane_created"
+];
+const STORAGE_ERROR_CODES = /* @__PURE__ */ new Set([
+	"EACCES",
+	"EBUSY",
+	"EIO",
+	"EMFILE",
+	"ENFILE",
+	"ENOSPC",
+	"EPERM",
+	"EROFS"
+]);
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringValue(value) {
+	return typeof value === "string" ? value : void 0;
+}
+/** Run one prompt and return only the assistant text appended by that prompt. */
+async function promptForAssistantText(runtime, text) {
+	const previousEntryIds = new Set((await runtime.readEntries()).entries.map((entry) => entry.id));
+	await runtime.prompt(text);
+	const { entries } = await runtime.readEntries();
+	for (let index = entries.length - 1; index >= 0; index--) {
+		const entry = entries[index];
+		if (!entry || previousEntryIds.has(entry.id)) continue;
+		if (entry.type !== "message" || entry.message.role !== "assistant") continue;
+		return entry.message.content.flatMap((part) => part.type === "text" ? [part.text] : []).join("\n").trim() || void 0;
+	}
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : typeof error === "string" ? error : "Direct harness operation failed";
+}
+function modelReference(model, models) {
+	if (model !== void 0 && "api" in model) return model;
+	const requested = model;
+	const resolved = requested === void 0 ? models.getModels()[0] : models.getModel(requested.provider, requested.id);
+	if (resolved === void 0) {
+		const identity = requested === void 0 ? "the first configured model" : `${requested.provider}/${requested.id}`;
+		throw new Error(`Direct harness could not resolve ${identity}`);
+	}
+	return resolved;
+}
+function readDirectHarnessSessionMetadata(filePath) {
+	const absolute = fs.realpathSync(filePath);
+	const firstLine = fs.readFileSync(absolute, "utf8").split("\n", 1)[0];
+	let header;
+	try {
+		const parsed = JSON.parse(firstLine ?? "");
+		if (!isRecord(parsed)) throw new Error("header is not an object");
+		header = parsed;
+	} catch (error) {
+		throw new Error(`Invalid JSONL session header: ${absolute}`, { cause: error });
+	}
+	if (header.kind !== "header" || header.v !== 4) throw new Error(`Session is not an upstream v4 JSONL file: ${absolute}`);
+	const id = stringValue(header.id);
+	const cwd = stringValue(header.cwd);
+	const createdAt = header.createdAt;
+	if (!id || !cwd || typeof createdAt !== "number" || !Number.isFinite(createdAt)) throw new Error(`Invalid JSONL session identity: ${absolute}`);
+	const stat = fs.statSync(absolute);
+	return {
+		id,
+		createdAt,
+		storageVersion: typeof header.storageVersion === "number" ? header.storageVersion : JSONL_STORAGE_VERSION,
+		cwd,
+		path: absolute,
+		modifiedAt: stat.mtimeMs,
+		...typeof header.parentSessionId === "string" ? { parentSessionId: header.parentSessionId } : {},
+		...typeof header.legacyParentSessionPath === "string" ? { legacyParentSessionPath: header.legacyParentSessionPath } : {}
+	};
+}
+function isV3File(filePath) {
+	let firstLine;
+	try {
+		firstLine = fs.readFileSync(path.resolve(filePath), "utf8").split("\n", 1)[0] ?? "";
+	} catch (error) {
+		if (isRecord(error) && error.code === "ENOENT") return false;
+		throw error;
+	}
+	try {
+		const header = JSON.parse(firstLine);
+		return isRecord(header) && header.type === "session" && header.version === 3;
+	} catch {
+		return false;
+	}
+}
+async function acquireHistoryLease(owner, filePath) {
+	const lease = await owner.acquire(filePath);
+	try {
+		await lease.assertQuiescent();
+		return lease;
+	} catch (error) {
+		await Promise.resolve(lease.release()).catch(() => void 0);
+		throw error;
+	}
+}
+async function closeStorage(storage, context) {
+	const failures = [];
+	try {
+		await storage.session?.close(context);
+	} catch (error) {
+		failures.push(error);
+	}
+	try {
+		await storage.repository?.close(context);
+	} catch (error) {
+		failures.push(error);
+	}
+	try {
+		await storage.environment?.cleanup(context);
+	} catch (error) {
+		failures.push(error);
+	}
+	try {
+		await storage.historyLease?.release();
+	} catch (error) {
+		failures.push(error);
+	}
+	storage.historyLease = void 0;
+	if (failures.length) throw new AggregateError(failures, "Direct harness storage cleanup failed");
+}
+async function openStorage(options, context) {
+	if (options.session !== void 0) return {
+		session: options.session,
+		...options.sessionPath === void 0 ? {} : { sessionFile: path.resolve(options.sessionPath) }
+	};
+	if (options.storage === "sqlite") return openSqliteSessionStorage(options, context);
+	const sessionPath = options.sessionPath === void 0 ? void 0 : path.resolve(options.sessionPath);
+	const legacyPath = options.legacySessionPath === void 0 ? sessionPath : path.resolve(options.legacySessionPath);
+	let importedPath = sessionPath;
+	if (legacyPath !== void 0 && isV3File(legacyPath)) throw new Error("Legacy v3 history cannot be opened for writing. Stop Pi, run doompi history-import <v3-source> <v4-destination> --confirm-offline, then open the v4 destination.");
+	const environment = new NodeExecutionEnv({ cwd: options.cwd });
+	const sessionsRoot = path.resolve(options.sessionsRoot ?? (importedPath === void 0 ? path.join(options.cwd, DEFAULT_SESSION_ROOT) : path.dirname(importedPath)));
+	let metadata;
+	if (importedPath === void 0 && options.sessionId !== void 0) {
+		const discovery = new JsonlSessionRepo({
+			fileSystem: environment,
+			sessionsRoot,
+			now: () => Date.now()
+		});
+		try {
+			metadata = (await discovery.list({ cwd: options.cwd }, context)).find((candidate) => candidate.id === options.sessionId);
+			importedPath = metadata?.path;
+		} finally {
+			await discovery.close(context);
+		}
+	}
+	let historyLease;
+	let session;
+	const fileSystem = importedPath === void 0 ? createHistoryCreationFileSystem(environment, async (destinationPath) => {
+		const owner = options.historyOwnership;
+		if (owner === void 0) throw new Error("Creating a writable session requires explicit HistoryOwnership");
+		historyLease = await acquireHistoryLease(owner, destinationPath);
+	}) : environment;
+	const repository = new JsonlSessionRepo({
+		fileSystem,
+		sessionsRoot,
+		now: () => Date.now()
+	});
+	try {
+		if (importedPath !== void 0) {
+			const owner = options.historyOwnership;
+			if (owner === void 0) throw new Error("Opening an existing session requires explicit HistoryOwnership");
+			historyLease = await acquireHistoryLease(owner, importedPath);
+			metadata ??= readDirectHarnessSessionMetadata(importedPath);
+			if (options.sessionId !== void 0 && options.sessionId !== metadata.id) throw new Error(`Session id mismatch: expected ${options.sessionId}, found ${metadata.id}`);
+			await preserveHistoryBeforeOpen(metadata.path, historyLease);
+			session = await repository.open(metadata, context);
+		} else {
+			if (options.historyOwnership === void 0) throw new Error("Creating a writable session requires explicit HistoryOwnership");
+			const created = await repository.create({
+				id: options.sessionId,
+				cwd: options.cwd,
+				...options.parentSessionId === void 0 ? {} : { parentSessionId: options.parentSessionId }
+			}, context);
+			session = created;
+			importedPath = created.metadata.path;
+			if (historyLease === void 0) throw new Error("New history was not admitted before publication");
+		}
+		return {
+			session,
+			sessionFile: importedPath,
+			repository,
+			environment,
+			historyLease
+		};
+	} catch (error) {
+		await closeStorage({
+			session,
+			repository,
+			environment,
+			historyLease
+		}, context);
+		throw error;
+	}
+}
+function configureModels(options) {
+	if (options.models !== void 0) {
+		if (options.providers !== void 0 && "setProvider" in options.models) for (const provider of options.providers) options.models.setProvider(provider);
+		return options.models;
+	}
+	if (options.providers === void 0 || options.providers.length === 0) throw new Error("Direct harness requires a public Models registry or at least one Provider");
+	const models = options.credentials === void 0 ? createModels() : createModels({ credentials: options.credentials });
+	for (const provider of options.providers) models.setProvider(provider);
+	return models;
+}
+function textContent(value) {
+	if (typeof value === "string") return value;
+	if (!Array.isArray(value)) return "";
+	return value.filter(isRecord).filter((part) => part.type === "text").map((part) => stringValue(part.text) ?? "").join("");
+}
+function queueText(item) {
+	if (!isRecord(item) || item.type !== "message" || !isRecord(item.message)) return void 0;
+	return textContent(item.message.content);
+}
+function mapQueueUpdate(event) {
+	const queues = Array.isArray(event.queues) ? event.queues : [];
+	const steering = [];
+	const followUp = [];
+	for (const item of queues) {
+		if (!isRecord(item)) continue;
+		const text = queueText(item);
+		if (text === void 0) continue;
+		if (item.kind === "steer") steering.push(text);
+		else if (item.kind === "followUp" || item.kind === "nextRun") followUp.push(text);
+	}
+	return {
+		type: "queue_update",
+		queues,
+		steering,
+		followUp
+	};
+}
+function stateModel(model) {
+	if (!isRecord(model)) return void 0;
+	const provider = stringValue(model.provider);
+	const id = stringValue(model.id) ?? stringValue(model.modelId);
+	return provider && id ? {
+		provider,
+		id
+	} : void 0;
+}
+function mapHarnessEvent(event) {
+	const value = event;
+	switch (event.type) {
+		case "run_start": return [{
+			type: "agent_start",
+			runId: value.runId,
+			startedAt: value.startedAt
+		}];
+		case "run_resume": return [{
+			type: "agent_start",
+			runId: value.runId,
+			resumed: true
+		}];
+		case "run_suspend": return [{
+			type: "run_suspend",
+			runId: value.runId,
+			reason: value.reason,
+			deferred: value.deferred
+		}];
+		case "operation_abort": return [{
+			type: "operation_abort",
+			operationId: value.operationId,
+			steer: value.steer,
+			followUp: value.followUp
+		}];
+		case "run_end": return [{
+			type: "agent_end",
+			runId: value.runId,
+			status: value.status,
+			...value.error === void 0 ? {} : { error: value.error }
+		}, {
+			type: "agent_settled",
+			runId: value.runId,
+			timestamp: value.endedAt
+		}];
+		case "fault": return [{
+			type: FRAME_ERROR,
+			error: value.message,
+			code: value.code
+		}];
+		case "handler_error": return [{
+			type: "handler_error",
+			kind: value.kind,
+			hook: value.hook,
+			event: value.event,
+			error: value.error,
+			stack: value.stack
+		}];
+		case "turn_start": return [{
+			type: "turn_start",
+			runId: value.runId,
+			turnId: value.turnId
+		}];
+		case "turn_end": return [{
+			type: "turn_end",
+			runId: value.runId,
+			turnId: value.turnId,
+			message: value.message,
+			toolResults: value.toolResults
+		}];
+		case "retry_scheduled": return [{
+			type: "auto_retry_start",
+			runId: value.runId,
+			attempt: value.attempt,
+			maxAttempts: value.maxAttempts,
+			error: value.errorMessage
+		}];
+		case "retry_start": return [{
+			type: "auto_retry_start",
+			runId: value.runId,
+			attempt: value.attempt
+		}];
+		case "retry_end": return [{
+			type: "auto_retry_end",
+			runId: value.runId,
+			attempt: value.attempt,
+			success: value.success,
+			error: value.finalError
+		}];
+		case "message_start": return [{
+			type: "message_start",
+			runId: value.runId,
+			message: value.message
+		}];
+		case "message_update": return [{
+			type: "message_update",
+			runId: value.runId,
+			message: value.message,
+			assistantMessageEvent: value.event,
+			...value.frame === void 0 ? {} : { assistantMessageFrame: value.frame }
+		}];
+		case "message_end": return [{
+			type: "message_end",
+			runId: value.runId,
+			message: value.message,
+			entryId: value.entryId
+		}];
+		case "tool_start": return [{
+			type: "tool_execution_start",
+			runId: value.runId,
+			turnId: value.turnId,
+			toolCallId: value.toolCallId,
+			toolName: value.toolName,
+			args: value.args
+		}];
+		case "tool_update": return [{
+			type: "tool_execution_update",
+			runId: value.runId,
+			turnId: value.turnId,
+			toolCallId: value.toolCallId,
+			toolName: value.toolName,
+			partialResult: value.partialResult
+		}];
+		case "tool_end": return [{
+			type: "tool_execution_end",
+			runId: value.runId,
+			turnId: value.turnId,
+			toolCallId: value.toolCallId,
+			toolName: value.toolName,
+			result: value.result,
+			isError: value.isError,
+			terminate: value.terminate
+		}];
+		case "entry_added": return [{
+			type: "entry_appended",
+			entry: value.entry
+		}];
+		case "queue_update": return [mapQueueUpdate(value)];
+		case "value_update":
+			if (value.value === "session_name") return [{
+				type: "session_info_changed",
+				name: value.name
+			}];
+			return [{
+				type: "entry_label_changed",
+				targetId: value.targetId,
+				label: value.label
+			}];
+		case "config_update":
+			if (value.property === "thinkingLevel") return [{
+				type: "thinking_level_changed",
+				level: value.value
+			}];
+			if (value.property === "model") {
+				const model = stateModel(value.value);
+				return model === void 0 ? [] : [{
+					type: "response",
+					command: "get_state",
+					success: true,
+					data: { model }
+				}];
+			}
+			return [{
+				type: "config_update",
+				property: value.property,
+				value: value.value,
+				previous: value.previous
+			}];
+		case "compaction_start": return [{
+			type: "compaction_start",
+			runId: value.runId,
+			reason: value.reason
+		}];
+		case "compaction_end": return [{
+			type: "compaction_end",
+			runId: value.runId,
+			reason: value.reason,
+			status: value.status,
+			entryId: value.entryId
+		}];
+		case "navigation_start": return [{
+			type: "navigation_start",
+			runId: value.runId,
+			targetId: value.targetId
+		}];
+		case "navigation_end": return [{
+			type: "navigation_end",
+			runId: value.runId,
+			status: value.status
+		}];
+		case "usage": return [{
+			type: "usage",
+			lane: value.lane,
+			row: value.row,
+			totals: value.totals
+		}];
+		case "lane_created": return [{
+			type: "lane_created",
+			at: value.at
+		}];
+	}
+}
+function isStorageFailure(error) {
+	if (error instanceof HarnessFault) return true;
+	if (isRecord(error) && typeof error.code === "string" && STORAGE_ERROR_CODES.has(error.code)) return true;
+	return /(?:storage|session|jsonl|journal|commit|mutation).*(?:fail|error|fault|write|invariant)|(?:fail|error|fault|write|invariant).*(?:storage|session|jsonl|journal|commit|mutation)/iu.test(errorMessage(error));
+}
+function resultError(value) {
+	if (isRecord(value) && value.ok === false) throw value.error;
+	throw value;
+}
+async function entriesForLane(lane, context) {
+	return lane.findEntries({ order: "oldestFirst" }, context);
+}
+/**
+* Creates a same-process AgentHarness and the legacy framed compatibility
+* facade expected by doompi-server. No child process, RPC launcher, or Pi UI
+* runtime is created.
+*/
+async function createDirectHarnessRuntime(options) {
+	const context = options.context ?? BACKGROUND_CONTEXT;
+	const laneName = options.lane ?? DEFAULT_LANE;
+	let disposed = false;
+	let storageQuarantined = false;
+	let requestPreparationFailure;
+	let turnPreparationFailure;
+	let contextPreparationFailure;
+	let payloadPreparationFailure;
+	let toolsReady = true;
+	let activeToolNames = new Set(options.activeToolNames ?? options.tools?.map((tool) => tool.name) ?? []);
+	const storage = await openStorage(options, context);
+	let models;
+	let harnessResult;
+	try {
+		const registry = configureModels(options);
+		const dispatchMethods = /* @__PURE__ */ new Set([
+			"stream",
+			"complete",
+			"streamSimple",
+			"completeSimple",
+			"streamDeferred",
+			"fetchDeferred"
+		]);
+		models = new Proxy(registry, { get(target, key) {
+			const value = Reflect.get(target, key, target);
+			if (typeof value !== "function") return value;
+			if (!dispatchMethods.has(key)) return value.bind(target);
+			return (...args) => {
+				try {
+					if (disposed || storageQuarantined || !toolsReady) throw new Error("Direct harness model dispatch is blocked");
+					if (key !== "streamDeferred" && key !== "fetchDeferred") {
+						if (args[1].tools?.some((tool) => !activeToolNames.has(tool.name))) throw new Error("Model request contains a tool disabled after generation preparation");
+					}
+					if (contextPreparationFailure !== void 0) throw contextPreparationFailure.error;
+					if (turnPreparationFailure !== void 0) throw turnPreparationFailure.error;
+					if (requestPreparationFailure !== void 0) throw requestPreparationFailure.error;
+					options.guardModelRequest?.();
+				} catch {
+					const model = args[0];
+					const blocked = {
+						role: "assistant",
+						content: [],
+						api: model.api,
+						provider: model.provider,
+						model: model.id,
+						timestamp: Date.now(),
+						stopReason: "error",
+						errorMessage: "Model request blocked: headless capability preparation is not ready.",
+						usage: {
+							input: 0,
+							output: 0,
+							cacheRead: 0,
+							cacheWrite: 0,
+							totalTokens: 0,
+							cost: {
+								input: 0,
+								output: 0,
+								cacheRead: 0,
+								cacheWrite: 0,
+								total: 0
+							}
+						}
+					};
+					if (key === "complete" || key === "completeSimple" || key === "fetchDeferred") return Promise.resolve(blocked);
+					const stream = createAssistantMessageEventStream();
+					stream.push({
+						type: "error",
+						reason: "error",
+						error: blocked
+					});
+					return stream;
+				}
+				const requestOptions = args[2];
+				if (isRecord(requestOptions) && typeof requestOptions.onPayload === "function") {
+					const onPayload = requestOptions.onPayload;
+					args[2] = {
+						...requestOptions,
+						onPayload: async (payload, requestModel) => {
+							payloadPreparationFailure = void 0;
+							const transformed = await onPayload(payload, requestModel);
+							const failure = payloadPreparationFailure;
+							if (failure !== void 0) throw failure.error;
+							return transformed;
+						}
+					};
+				}
+				return Reflect.apply(value, target, args);
+			};
+		} });
+		harnessResult = await AgentHarness.create({
+			session: storage.session,
+			models,
+			model: modelReference(options.model, models),
+			...options.thinkingLevel === void 0 ? {} : { thinkingLevel: options.thinkingLevel },
+			...options.activeToolNames === void 0 ? {} : { activeToolNames: options.activeToolNames },
+			...options.tools === void 0 ? {} : { tools: options.tools },
+			...options.resources === void 0 ? {} : { resources: options.resources },
+			...options.toolContext === void 0 ? {} : { toolContext: options.toolContext },
+			...options.systemPrompt === void 0 ? {} : { systemPrompt: options.systemPrompt },
+			...options.streamOptions === void 0 ? {} : { streamOptions: options.streamOptions },
+			...options.retry === void 0 ? {} : { retry: options.retry },
+			...options.compaction === void 0 ? {} : { compaction: options.compaction },
+			...options.steeringMode === void 0 ? {} : { steeringMode: options.steeringMode },
+			...options.followUpMode === void 0 ? {} : { followUpMode: options.followUpMode },
+			...options.toolExecution === void 0 ? {} : { toolExecution: options.toolExecution },
+			...options.toProviderMessages === void 0 ? {} : { toProviderMessages: options.toProviderMessages },
+			...options.entryProjectors === void 0 ? {} : { entryProjectors: options.entryProjectors }
+		}, context);
+	} catch (error) {
+		await closeStorage(storage, context);
+		throw error;
+	}
+	const harness = harnessResult.harness;
+	const sessionId = storage.session.metadata.id;
+	const harnessId = options.harnessId ?? `${sessionId}:${laneName}`;
+	const listeners = /* @__PURE__ */ new Set();
+	const lifecycleListeners = /* @__PURE__ */ new Set();
+	let resolveExited;
+	const exited = new Promise((resolve) => {
+		resolveExited = resolve;
+	});
+	let exitResolved = false;
+	let lane;
+	const emitFrame = (frame) => {
+		for (const listener of Array.from(listeners)) try {
+			listener(frame);
+		} catch {}
+	};
+	const emitLifecycle = async (event, eventContext) => {
+		await Promise.all([...lifecycleListeners].map(async (listener) => {
+			try {
+				await listener(event, eventContext);
+			} catch (error) {
+				emitFrame({
+					type: "handler_error",
+					kind: "event",
+					event: event.type,
+					error: errorMessage(error)
+				});
+			}
+		}));
+	};
+	let settledEvents = Promise.resolve();
+	let toolsThisRun = 0;
+	const deliverHarnessEvent = async (event, eventContext) => {
+		if (event.type === "run_start") toolsThisRun = 0;
+		if (event.type === "tool_start") toolsThisRun += 1;
+		if (event.type === "run_end" && options.storage === "sqlite") {
+			const record = event;
+			const latest = await lane.findEntry({
+				type: "custom",
+				customType: "doompi.agent-settled",
+				order: "newestFirst"
+			}, eventContext);
+			if ((latest?.type === "custom" && isRecord(latest.data) ? latest.data : void 0)?.runId !== record.runId) await lane.appendCustomEntry("doompi.agent-settled", {
+				runId: String(record.runId),
+				timestamp: Number(record.endedAt),
+				tools: toolsThisRun
+			}, eventContext);
+		}
+		await emitLifecycle(event, eventContext);
+		if (event.type === "fault") markStorageFailure(event);
+		for (const frame of mapHarnessEvent(event)) emitFrame(frame);
+	};
+	const handleHarnessEvent = async (event, eventContext) => {
+		if (event.type === "run_end") {
+			settledEvents = settledEvents.then(() => deliverHarnessEvent(event, eventContext));
+			return;
+		}
+		await deliverHarnessEvent(event, eventContext);
+	};
+	const unsubscribe = EVENT_TYPES.map((type) => harness.events.on(type, handleHarnessEvent));
+	const guardLive = () => {
+		if (disposed) throw new Error("The direct harness runtime is disposed");
+	};
+	const guardWritable = () => {
+		guardLive();
+		if (storageQuarantined) throw new Error("Direct harness writes are quarantined after a storage failure");
+	};
+	const markStorageFailure = (error) => {
+		if (!isStorageFailure(error)) return;
+		storageQuarantined = true;
+		emitFrame({
+			type: FRAME_ERROR,
+			code: "storage_quarantined",
+			error: errorMessage(error)
+		});
+	};
+	const writable = async (operation) => {
+		guardWritable();
+		try {
+			await storage.historyLease?.assertQuiescent();
+			return await operation();
+		} catch (error) {
+			markStorageFailure(error);
+			throw error;
+		}
+	};
+	const unsubscribeHooks = [];
+	if (options.transformContext !== void 0) unsubscribeHooks.push(harness.hooks.on("before_run", () => {
+		contextPreparationFailure = void 0;
+	}));
+	if (options.beforeModelRequest !== void 0) unsubscribeHooks.push(harness.hooks.on("before_run", async (event, hookContext) => {
+		turnPreparationFailure = void 0;
+		requestPreparationFailure = void 0;
+		try {
+			await options.beforeModelRequest?.({
+				phase: "turn",
+				prompt: event.prompt,
+				resources: event.resources
+			}, hookContext);
+		} catch (error) {
+			turnPreparationFailure = { error };
+			throw error;
+		}
+	}), harness.hooks.on("before_request", async (event, hookContext) => {
+		try {
+			await options.beforeModelRequest?.({
+				phase: "request",
+				model: event.model,
+				resources: await harness.getResources(hookContext)
+			}, hookContext);
+			requestPreparationFailure = void 0;
+		} catch (error) {
+			requestPreparationFailure = { error };
+			throw error;
+		}
+	}));
+	if (options.transformContext !== void 0) unsubscribeHooks.push(harness.hooks.on("transform_context", async (event, hookContext) => {
+		try {
+			return await options.transformContext(event, hookContext);
+		} catch (error) {
+			contextPreparationFailure = { error };
+			throw error;
+		}
+	}));
+	if (options.beforePayload !== void 0) unsubscribeHooks.push(harness.hooks.on("before_payload", async (event, hookContext) => {
+		try {
+			return await options.beforePayload(event, hookContext);
+		} catch (error) {
+			payloadPreparationFailure = { error };
+			throw error;
+		}
+	}));
+	if (options.beforeTool !== void 0) unsubscribeHooks.push(harness.hooks.on("before_tool", options.beforeTool));
+	if (options.afterTool !== void 0) unsubscribeHooks.push(harness.hooks.on("after_tool", options.afterTool));
+	if (options.beforeCompaction !== void 0) unsubscribeHooks.push(harness.hooks.on("before_compaction", options.beforeCompaction));
+	try {
+		lane = await harness.lane(laneName, context);
+		if (options.sessionName !== void 0) await writable(() => harness.setName(options.sessionName, context));
+	} catch (error) {
+		for (const unsubscribeHook of unsubscribeHooks) unsubscribeHook();
+		for (const unsubscribeEvent of unsubscribe) unsubscribeEvent();
+		await harness.close(context).catch(() => void 0);
+		await closeStorage(storage, context);
+		throw error;
+	}
+	const settleExit = (code) => {
+		if (exitResolved) return;
+		exitResolved = true;
+		resolveExited(code);
+	};
+	const drive = async (operationId) => {
+		const result = await writable(() => lane.drive({
+			operationId,
+			waitForRetry: true
+		}, context));
+		await settledEvents;
+		if (!result.ok) resultError(result);
+		if (result.value.kind === "waiting" && result.value.reason === "retry") throw new Error(`Direct harness returned an unexpected retry wait for ${operationId}`);
+	};
+	const admitPrompt = async (text, images, streamingBehavior) => {
+		if ((await lane.inspectExecution(context)).current !== null && streamingBehavior !== void 0) {
+			const queued = streamingBehavior === "steer" ? await writable(() => lane.steer(text, images, context)) : await writable(() => lane.followUp(text, images, context));
+			if (!queued.ok) resultError(queued);
+			return { settled: Promise.resolve() };
+		}
+		const admission = await writable(() => lane.accept({
+			kind: "prompt",
+			prompt: text,
+			...images === void 0 ? {} : { images }
+		}, context));
+		if (!admission.ok) resultError(admission);
+		return { settled: drive(admission.value.operationId) };
+	};
+	const replaceTools = async (tools) => {
+		toolsReady = false;
+		await writable(async () => {
+			await harness.setTools(tools, context);
+			await lane.setActiveTools(tools.map((tool) => tool.name), context);
+			activeToolNames = new Set(tools.map((tool) => tool.name));
+			toolsReady = true;
+		});
+	};
+	const replaceResources = async (resources) => {
+		await writable(() => harness.setResources(resources, context));
+	};
+	const readResources = async () => {
+		guardLive();
+		return harness.getResources(context);
+	};
+	const appendCustomEntry = async (customType, data) => writable(() => lane.appendCustomEntry(customType, data, context));
+	const recordUsage = async (usage, options) => {
+		const result = await writable(() => lane.recordUsage(usage, options, context));
+		if (!result.ok) resultError(result);
+		return result.value.usageId;
+	};
+	const submitPrompt = async (text, images) => {
+		if (await options.dispatchCommand?.(text)) return {
+			settled: Promise.resolve(),
+			handledCommand: true
+		};
+		return admitPrompt(text, images);
+	};
+	const prompt = async (text, images) => {
+		await (await submitPrompt(text, images)).settled;
+	};
+	const steer = async (text, images) => {
+		const result = await writable(() => lane.steer(text, images, context));
+		if (!result.ok) resultError(result);
+	};
+	const followUp = async (text, images) => {
+		const result = await writable(() => lane.followUp(text, images, context));
+		if (!result.ok) resultError(result);
+	};
+	const abort = async () => {
+		const result = await writable(() => lane.abort(context));
+		if (!result.ok) resultError(result);
+	};
+	const compact = async (customInstructions) => {
+		const result = await writable(() => lane.compact(customInstructions === void 0 ? void 0 : { customInstructions }, context));
+		if (!result.ok) resultError(result);
+	};
+	const resume = async () => {
+		const result = await writable(() => lane.resume(context));
+		if (!result.ok) resultError(result);
+	};
+	const readState = async () => {
+		const [execution, persisted, stats, thinking] = await Promise.all([
+			lane.inspectExecution(context),
+			storage.session.getValue(laneState(laneName), context),
+			storage.session.getStats(context),
+			lane.getThinkingLevel(context)
+		]);
+		const configuredModel = await lane.getModel(context);
+		const name = await harness.getName(context);
+		return {
+			model: configuredModel === void 0 ? void 0 : {
+				provider: configuredModel.provider,
+				id: configuredModel.id
+			},
+			thinkingLevel: thinking,
+			isStreaming: execution.current?.kind === "run",
+			isCompacting: execution.current?.kind === "compaction",
+			steeringMode: await harness.getSteeringMode(context),
+			followUpMode: await harness.getFollowUpMode(context),
+			sessionFile: storage.sessionFile,
+			sessionId,
+			...name === void 0 ? {} : { sessionName: name },
+			autoCompactionEnabled: (await harness.getCompactionSettings(context)).enabled,
+			messageCount: stats.messageCount,
+			pendingMessageCount: persisted?.value.inbox.length ?? 0
+		};
+	};
+	const readEntries = async () => ({
+		entries: await entriesForLane(lane, context),
+		leafId: await lane.getTipId(context)
+	});
+	const listCommands = () => [...options.listCommands?.() ?? []];
+	const setModel = async (model) => {
+		if (models.getModel(model.provider, model.id) === void 0) throw new Error(`Model not found: ${model.provider}/${model.id}`);
+		await writable(() => lane.setModel({
+			provider: model.provider,
+			modelId: model.id
+		}, context));
+	};
+	const availableModels = () => models.getAvailable();
+	const availableThinkingLevels = async () => {
+		const model = await lane.getModel(context);
+		if (!model) throw new Error("No model is selected");
+		return getSupportedThinkingLevels(model);
+	};
+	const setThinkingLevel = (level) => writable(() => lane.setThinkingLevel(level, context));
+	const setSteeringMode = (mode) => writable(() => harness.setSteeringMode(mode, context));
+	const setFollowUpMode = (mode) => writable(() => harness.setFollowUpMode(mode, context));
+	const navigateTree = async (targetId, navigationOptions) => {
+		const result = await writable(() => lane.navigateTree(targetId, navigationOptions, context));
+		if (!result.ok) resultError(result);
+		return {
+			cancelled: result.value.navigation.status !== "completed",
+			entries: await entriesForLane(lane, context)
+		};
+	};
+	const clearQueue = async () => {
+		const queued = (await storage.session.getValue(laneState(laneName), context))?.value.inbox ?? [];
+		for (const item of queued) {
+			const result = await writable(() => lane.cancelQueued(item.entryId, context));
+			if (!result.ok) resultError(result);
+		}
+		return {
+			steering: [],
+			followUp: []
+		};
+	};
+	const setName = (name) => writable(() => harness.setName(name, context));
+	const getSessionStats = () => storage.session.getStats(context);
+	const dispose = async () => {
+		if (disposed) return;
+		disposed = true;
+		for (const unsubscribeEvent of unsubscribe) unsubscribeEvent();
+		for (const unsubscribeHook of unsubscribeHooks) unsubscribeHook();
+		let failure;
+		try {
+			await harness.close(context);
+		} catch (error) {
+			failure = error;
+			markStorageFailure(error);
+		}
+		try {
+			await closeStorage(storage, context);
+		} catch (error) {
+			failure ??= error;
+			markStorageFailure(error);
+		}
+		settleExit(failure === void 0 ? 0 : 1);
+		if (failure !== void 0) throw failure;
+	};
+	return {
+		sessionId,
+		laneName,
+		harnessId,
+		completeModel: models.complete?.bind(models),
+		session: storage.session,
+		harness,
+		lane,
+		exited,
+		get storageQuarantined() {
+			return storageQuarantined;
+		},
+		onPresentationFrame(listener) {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		},
+		onEvent(listener) {
+			lifecycleListeners.add(listener);
+			return () => lifecycleListeners.delete(listener);
+		},
+		stop() {
+			abort().catch(() => void 0).finally(() => dispose().catch(() => void 0));
+		},
+		readState,
+		readEntries,
+		listCommands,
+		setModel,
+		availableModels,
+		availableThinkingLevels,
+		setThinkingLevel,
+		setSteeringMode,
+		setFollowUpMode,
+		navigateTree,
+		clearQueue,
+		setName,
+		getSessionStats,
+		replaceTools,
+		replaceResources,
+		readResources,
+		appendCustomEntry,
+		recordUsage,
+		submitPrompt,
+		prompt,
+		steer,
+		followUp,
+		abort,
+		compact,
+		resume,
+		dispose
+	};
+}
+//#endregion
+export { createDirectHarnessRuntime, promptForAssistantText, readDirectHarnessSessionMetadata };
+
+//# sourceMappingURL=directHarnessRuntime.mjs.map