@agentium/harness 4.1.0 → 4.6.0

package/dist/{driver-Cr2BGG4h.cjs → driver-Bh_wLWCP.cjs}

@@ -71,7 +71,7 @@ async function projectHarnessContext(policy, history, ctx, entries = []) {
 		history: structuredClone(original),
 		entries: structuredClone(entries)
 	}, ctx);
-	(0, _agentium_core.validateConversationTransform)(original, result.messages);
+	(0, _agentium_core.validateConversationTransform)(original, result.messages, policy.grouping);
 	if (!Array.isArray(result.provenance) || result.provenance.some((item) => !item || typeof item.sourceId !== "string" || typeof item.included !== "boolean" || item.reason !== void 0 && typeof item.reason !== "string")) throw new Error("Context policy must return provenance");
 	return {
 		messages: structuredClone(result.messages),
@@ -397,6 +397,183 @@ var InMemoryHarnessEventStore = class {
 	}
 };
 //#endregion
+//#region src/runtime/input.ts
+var HarnessInputError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "HarnessInputError";
+	}
+};
+const text = zod_v3.z.object({
+	type: zod_v3.z.literal("text"),
+	text: zod_v3.z.string()
+}).strict();
+const media = zod_v3.z.discriminatedUnion("type", [
+	text,
+	zod_v3.z.object({
+		type: zod_v3.z.literal("image"),
+		data: zod_v3.z.string(),
+		mimeType: zod_v3.z.enum([
+			"image/png",
+			"image/jpeg",
+			"image/gif",
+			"image/webp"
+		]).optional()
+	}).strict(),
+	zod_v3.z.object({
+		type: zod_v3.z.literal("audio"),
+		data: zod_v3.z.string(),
+		mimeType: zod_v3.z.enum([
+			"audio/mp3",
+			"audio/wav",
+			"audio/ogg",
+			"audio/webm"
+		]).optional()
+	}).strict(),
+	zod_v3.z.object({
+		type: zod_v3.z.literal("file"),
+		data: zod_v3.z.string(),
+		mimeType: zod_v3.z.string(),
+		filename: zod_v3.z.string().optional()
+	}).strict()
+]);
+const message = zod_v3.z.union([zod_v3.z.string(), zod_v3.z.array(media).min(1)]);
+const question = zod_v3.z.object({
+	question: zod_v3.z.string().trim().min(1),
+	choices: zod_v3.z.array(zod_v3.z.string().min(1)).min(1).max(100).optional(),
+	timeoutMs: zod_v3.z.number().int().positive().safe().optional()
+}).strict();
+function validateRunInput(input) {
+	const parsed = message.safeParse(input);
+	if (!parsed.success || Buffer.byteLength(JSON.stringify(parsed.data)) > 65536) throw new HarnessInputError("invalid_input", "Input must be valid message content no larger than 64KB");
+	return parsed.data;
+}
+function validateTimeout(value) {
+	if (value !== void 0 && (!Number.isSafeInteger(value) || value <= 0)) throw new HarnessInputError("invalid_input", "Timeout must be a positive safe integer");
+}
+/** Owns live promises only; this is not a restart checkpoint. */
+var LiveInput = class {
+	runId;
+	signal;
+	timeouts;
+	emit;
+	expire;
+	pending;
+	resolved = /* @__PURE__ */ new Set();
+	timer;
+	activeTimer;
+	activeSince = Date.now();
+	activeRemaining;
+	closed = false;
+	onAbort = () => {
+		const pending = this.pending;
+		this.pending = void 0;
+		this.clearTimers();
+		pending?.reject(this.signal.reason);
+	};
+	constructor(runId, signal, timeouts, emit, expire) {
+		this.runId = runId;
+		this.signal = signal;
+		this.timeouts = timeouts;
+		this.emit = emit;
+		this.expire = expire;
+		this.activeRemaining = timeouts.activeTimeoutMs ?? Infinity;
+		signal.addEventListener("abort", this.onAbort, { once: true });
+		if (!signal.aborted) this.resumeClock();
+	}
+	get request() {
+		return this.pending && structuredClone(this.pending.request);
+	}
+	assertActive() {
+		if (this.closed || this.signal.aborted) throw new HarnessInputError("run_finished", "Run is no longer active");
+	}
+	assertNotWaiting() {
+		this.assertActive();
+		if (this.pending) throw new HarnessInputError("input_pending", "No model calls are allowed while waiting for input");
+	}
+	requestInput(options) {
+		this.assertNotWaiting();
+		const parsed = question.safeParse(options);
+		if (!parsed.success || Buffer.byteLength(JSON.stringify(parsed.data)) > 32768) throw new HarnessInputError("invalid_input", "Question must be valid and no larger than 32KB");
+		const request = {
+			...parsed.data,
+			id: `${this.runId}:${(0, node_crypto.randomUUID)()}`,
+			runId: this.runId
+		};
+		const promise = new Promise((resolve, reject) => {
+			this.pending = {
+				request,
+				resolve,
+				reject
+			};
+		});
+		if (this.activeTimer) clearTimeout(this.activeTimer);
+		this.activeRemaining -= Date.now() - this.activeSince;
+		const timeoutMs = request.timeoutMs ?? this.timeouts.inputTimeoutMs;
+		if (timeoutMs !== void 0) {
+			const deadline = Date.now() + timeoutMs;
+			const tick = () => {
+				if (Date.now() >= deadline) this.expire("input_timeout");
+				else this.timer = setTimeout(tick, Math.min(deadline - Date.now(), 2147483647));
+			};
+			tick();
+		}
+		this.emit({
+			type: "input.requested",
+			request
+		});
+		return promise;
+	}
+	reply(requestId, input) {
+		this.assertActive();
+		if (this.resolved.has(requestId)) throw new HarnessInputError("input_already_resolved", "Input request already resolved");
+		const pending = this.pending;
+		if (!pending) throw new HarnessInputError("input_not_pending", "There is no pending input request");
+		if (pending.request.id !== requestId) throw new HarnessInputError("input_mismatch", "Reply does not match the pending input request");
+		const value = validateRunInput(input);
+		this.resolved.add(requestId);
+		this.pending = void 0;
+		if (this.timer) clearTimeout(this.timer);
+		this.emit({
+			type: "input.resolved",
+			requestId
+		});
+		this.resumeClock();
+		this.emit({
+			type: "run.resumed",
+			requestId
+		});
+		pending.resolve({
+			requestId,
+			input: value
+		});
+	}
+	close() {
+		this.closed = true;
+		this.clearTimers();
+		this.signal.removeEventListener("abort", this.onAbort);
+		const pending = this.pending;
+		this.pending = void 0;
+		pending?.reject(new HarnessInputError("run_finished", "Run finished with unresolved input"));
+	}
+	resumeClock() {
+		this.activeSince = Date.now();
+		if (!Number.isFinite(this.activeRemaining)) return;
+		const tick = () => {
+			const remaining = this.activeRemaining - (Date.now() - this.activeSince);
+			if (remaining <= 0) this.expire("active_timeout");
+			else this.activeTimer = setTimeout(tick, Math.min(remaining, 2147483647));
+		};
+		tick();
+	}
+	clearTimers() {
+		if (this.timer) clearTimeout(this.timer);
+		if (this.activeTimer) clearTimeout(this.activeTimer);
+	}
+};
+//#endregion
 //#region src/runtime/runtime-registry.ts
 /** Registry resolution is static; it never initializes providers or executes drivers. */
 function resolveHarnessRuntime(definition) {
@@ -1222,6 +1399,7 @@ var HarnessRuntime = class {
 			})])),
 			contextPolicy: config.contextPolicy && Object.freeze({
 				id: config.contextPolicy.id,
+				grouping: config.contextPolicy.grouping,
 				project: config.contextPolicy.project.bind(config.contextPolicy)
 			}),
 			completionPolicy: config.completionPolicy && Object.freeze({
@@ -1269,6 +1447,8 @@ var HarnessRuntime = class {
 		} : config.grants;
 		if (grants.requiredToolIds?.some((id) => !grants.toolIds.includes(id))) throw new Error("Required tool omitted by grants");
 		if (options.deadline !== void 0 && !Number.isFinite(options.deadline)) throw new Error("Deadline must be finite");
+		validateTimeout(config.activeTimeoutMs);
+		validateTimeout(config.inputTimeoutMs);
 		const controller = new AbortController();
 		const runId = (0, node_crypto.randomUUID)();
 		const request = Object.freeze({
@@ -1358,6 +1538,7 @@ var HarnessRuntime = class {
 		const generateObserved = async (provider, messages, supplied) => {
 			const end = observeModel(provider);
 			try {
+				liveInput.assertNotWaiting();
 				const response = await provider.generate(messages, supplied);
 				end(!controller.signal.aborted, response.usage);
 				return response;
@@ -1367,6 +1548,9 @@ var HarnessRuntime = class {
 			}
 		};
 		let terminal = false;
+		let acceptingInput = true;
+		let acceptingSteering = true;
+		let cancellationCode = "cancelled";
 		const inbox = [];
 		const cancel = (reason = "Run cancelled") => {
 			if (!terminal && !controller.signal.aborted) {
@@ -1378,6 +1562,10 @@ var HarnessRuntime = class {
 				controller.abort(new Error(reason));
 			}
 		};
+		const liveInput = new LiveInput(runId, controller.signal, config, (event) => events.append(event), (code) => {
+			cancellationCode = code;
+			cancel(code === "input_timeout" ? "User input timeout exceeded" : "Active execution timeout exceeded");
+		});
 		const onAbort = () => cancel("Caller cancelled the run");
 		const callerSignal = options.signal;
 		callerSignal?.addEventListener("abort", onAbort, { once: true });
@@ -1386,8 +1574,10 @@ var HarnessRuntime = class {
 		const scheduleDeadline = () => {
 			if (request.deadline === void 0 || controller.signal.aborted) return;
 			const remaining = request.deadline - Date.now();
-			if (remaining <= 0) cancel("Run deadline exceeded");
-			else timer = setTimeout(scheduleDeadline, Math.min(remaining, 2147483647));
+			if (remaining <= 0) {
+				cancellationCode = "deadline_exceeded";
+				cancel("Run deadline exceeded");
+			} else timer = setTimeout(scheduleDeadline, Math.min(remaining, 2147483647));
 		};
 		scheduleDeadline();
 		const result = Promise.resolve().then(async () => {
@@ -1420,7 +1610,10 @@ var HarnessRuntime = class {
 				return operation;
 			};
 			const ensureActive = () => {
-				if (request.deadline !== void 0 && Date.now() >= request.deadline) cancel("Run deadline exceeded");
+				if (request.deadline !== void 0 && Date.now() >= request.deadline) {
+					cancellationCode = "deadline_exceeded";
+					cancel("Run deadline exceeded");
+				}
 				controller.signal.throwIfAborted();
 				if (!acceptingOperations) throw new Error("Run has finished accepting operations");
 			};
@@ -1508,6 +1701,7 @@ var HarnessRuntime = class {
 				}));
 				const prepare = async (provider, messages, supplied = {}, callCtx = ctx) => {
 					ensureActive();
+					liveInput.assertNotWaiting();
 					if (modelCalls >= (config.budgets?.maxModelCalls ?? Infinity) || usage.totalTokens >= (config.budgets?.maxTokens ?? Infinity)) throw new HarnessBudgetError("Aggregate model/token budget exhausted");
 					const index = modelCalls++;
 					const next = config.controller?.prepareStep ? await observeControl("prepareStep", () => config.controller.prepareStep({
@@ -1604,6 +1798,7 @@ var HarnessRuntime = class {
 					},
 					controlModel: (role, messages, options = {}) => track((async () => {
 						ensureActive();
+						liveInput.assertNotWaiting();
 						if (!request.grants.modelRoles.includes(role)) throw new Error("Ungranted control model role");
 						const binding = config.models?.[role];
 						if (!binding) throw new Error("Control model requires an explicit host binding");
@@ -1662,9 +1857,12 @@ var HarnessRuntime = class {
 							let amount = zero();
 							let reason = "stop";
 							let extras;
+							let publicMessages;
+							let phase;
 							const calls = [];
 							try {
 								ensureActive();
+								liveInput.assertNotWaiting();
 								stream = call.provider.stream(call.messages, call.options);
 								while (true) {
 									const next = await stream.next();
@@ -1673,6 +1871,8 @@ var HarnessRuntime = class {
 										finished = true;
 										reason = next.value.finishReason;
 										extras = next.value.providerExtras;
+										publicMessages = next.value.publicMessages;
+										phase = next.value.phase;
 										amount = next.value.usage ?? zero();
 										account(call.provider, amount);
 									}
@@ -1695,6 +1895,7 @@ var HarnessRuntime = class {
 									message: {
 										role: "assistant",
 										content: text || null,
+										...phase ? { phase } : {},
 										...calls.length ? { toolCalls: calls.map((item) => ({
 											id: item.id,
 											name: item.name,
@@ -1704,7 +1905,8 @@ var HarnessRuntime = class {
 									},
 									usage: amount,
 									finishReason: reason === "tool_calls" || reason === "length" || reason === "content_filter" ? reason : "stop",
-									raw: { streamed: true }
+									raw: { streamed: true },
+									...publicMessages ? { publicMessages } : {}
 								};
 								await runAfterModel(middleware, response, callCtx ?? ctx);
 								succeeded = true;
@@ -1808,14 +2010,47 @@ var HarnessRuntime = class {
 						canonical.push(...structuredClone(messages));
 					},
 					emit: (payload) => {
-						ensureActive();
+						if (payload.type !== "compaction.failed" || terminal) ensureActive();
 						if (Buffer.byteLength(JSON.stringify(payload)) > 65536) throw new Error("Generic event exceeds 64KB; store an artifact reference instead");
 						events.append(payload);
 					},
-					takeInput: () => {
+					finishInput: (context) => {
+						if (context.runId === request.runId) acceptingSteering = false;
+					},
+					publishMessage: (event) => {
+						if (terminal) return;
+						if (event.type === "message.completed" && Buffer.byteLength(JSON.stringify(event)) > 6e4) {
+							const artifactId = (0, node_crypto.randomUUID)();
+							this.artifacts.set(artifactId, {
+								owner: services.sessionKey,
+								value: structuredClone(event.message)
+							});
+							events.append({
+								...event,
+								message: {
+									...event.message,
+									text: ""
+								},
+								artifactId
+							});
+						} else events.append(event);
+					},
+					requestInput: (question) => {
+						ensureActive();
+						return track(liveInput.requestInput(question));
+					},
+					takeInput: (context) => {
 						ensureActive();
+						if (context && context.runId !== request.runId) return void 0;
 						const index = inbox.findIndex((item) => item.mode === "steer");
-						return index < 0 ? void 0 : inbox.splice(index, 1)[0];
+						if (index < 0) return void 0;
+						const item = inbox.splice(index, 1)[0];
+						events.append({
+							type: "input.applied",
+							inputId: item.id,
+							mode: "steer"
+						});
+						return item;
 					},
 					resource: (id, scope, initialize) => track((async () => {
 						ensureActive();
@@ -1847,7 +2082,9 @@ var HarnessRuntime = class {
 				let current = request;
 				while (true) {
 					ensureActive();
+					acceptingSteering = true;
 					final = await config.driver.start(current, services);
+					acceptingSteering = false;
 					if (streams.size) throw new Error("Driver returned with an unfinished model stream");
 					ensureActive();
 					if (!final || typeof final.text !== "string" || final.status !== void 0 && ![
@@ -1910,11 +2147,18 @@ var HarnessRuntime = class {
 					}
 					const followUp = inbox.findIndex((item) => item.mode === "follow_up");
 					if (followUp < 0) break;
+					const item = inbox.splice(followUp, 1)[0];
+					events.append({
+						type: "input.applied",
+						inputId: item.id,
+						mode: "follow_up"
+					});
 					current = {
 						...request,
-						input: inbox.splice(followUp, 1)[0].input
+						input: item.input
 					};
 				}
+				acceptingInput = false;
 				const rejected = (await Promise.allSettled([...owned])).find((entry) => entry.status === "rejected");
 				if (rejected?.status === "rejected") throw rejected.reason;
 				ensureActive();
@@ -1935,6 +2179,8 @@ var HarnessRuntime = class {
 					}
 				};
 			} finally {
+				acceptingInput = false;
+				liveInput.close();
 				acceptingOperations = false;
 				await Promise.allSettled([...streams].map((stream) => stream.return(void 0)));
 				await Promise.allSettled([...owned]);
@@ -1971,8 +2217,8 @@ var HarnessRuntime = class {
 				...final,
 				status: "cancelled",
 				reason: {
-					code: "cancelled",
-					message: "Cancellation acknowledged"
+					code: cancellationCode,
+					message: controller.signal.reason instanceof Error ? controller.signal.reason.message : "Cancellation acknowledged"
 				}
 			};
 			const terminalResult = {
@@ -2026,21 +2272,39 @@ var HarnessRuntime = class {
 		});
 		return {
 			runId,
+			get state() {
+				return terminal ? "finished" : controller.signal.aborted ? "cancelling" : liveInput.request ? "awaiting_input" : "running";
+			},
+			get pendingInput() {
+				return liveInput.request;
+			},
+			reply: async (requestId, input) => {
+				if (!acceptingInput) throw new HarnessInputError("run_finished", "Run is no longer active");
+				liveInput.reply(requestId, input);
+			},
 			events: (options) => events.events(options),
 			result: () => result.then((value) => structuredClone(value)),
 			cancel,
 			send: async (input, options) => {
-				if (terminal || controller.signal.aborted) throw new Error("Run is no longer active");
+				if (!acceptingInput || options.mode === "steer" && !acceptingSteering || terminal || controller.signal.aborted) throw new HarnessInputError("run_finished", "Run is no longer active");
 				if (!config.driver.capabilities.controls.includes(options.mode)) throw new HarnessUnsupportedError(options.mode);
 				if (inbox.length >= 32) throw new Error("Run input queue is full");
-				inbox.push({
-					input: structuredClone(input),
+				if (options.mode === "replace") throw new HarnessUnsupportedError(options.mode);
+				const item = {
+					id: (0, node_crypto.randomUUID)(),
+					input: validateRunInput(input),
 					mode: options.mode
-				});
+				};
+				inbox.push(item);
 				events.append({
 					type: "control",
 					operation: options.mode
 				});
+				events.append({
+					type: "input.received",
+					inputId: item.id,
+					mode: options.mode
+				});
 			}
 		};
 	}
@@ -2058,6 +2322,12 @@ Object.defineProperty(exports, "HarnessEventGapError", {
 		return HarnessEventGapError;
 	}
 });
+Object.defineProperty(exports, "HarnessInputError", {
+	enumerable: true,
+	get: function() {
+		return HarnessInputError;
+	}
+});
 Object.defineProperty(exports, "HarnessResourcePool", {
 	enumerable: true,
 	get: function() {