@agentium/harness 4.5.0 → 4.6.0

package/CONVERSATIONAL-RUNS.md

@@ -0,0 +1,173 @@
+# Conversational runs (4.6)
+
+Questions, steering, public messages and compaction stay inside one live run.
+The runtime retains the session lease, Agent instance, transcript, provider
+continuations and remaining budgets. Waiting does not poll the model.
+
+## Ask and resume
+
+```ts
+import { openai } from "@agentium/core";
+import { agentDriver, HarnessRuntime, requestInputTool } from "@agentium/harness";
+
+const runtime = new HarnessRuntime({
+  driver: agentDriver({
+    name: "analyst",
+    model: openai("gpt-6-sol"),
+    instructions: "Analyze the available data. Ask the user when a necessary detail is missing.",
+  }, { stream: true }),
+  tools: [requestInputTool()],
+  grants: { toolIds: ["request_input"], modelRoles: ["main"] },
+  budgets: { maxModelCalls: 20, maxToolCalls: 30, maxTokens: 100_000 },
+  activeTimeoutMs: 120_000,
+  inputTimeoutMs: 15 * 60_000,
+});
+
+const handle = runtime.start("Prepare a report", {
+  identity: { tenantId: verifiedTenantId, userId: verifiedUserId },
+  sessionId: conversationId,
+});
+
+// In the application's event consumer:
+for await (const event of handle.events()) {
+  if (event.payload.type === "input.requested") {
+    showQuestion(event.payload.request); // Store its id with the form.
+  } else {
+    renderActivity(event);
+  }
+}
+
+// In a separate form submission handler:
+await handle.reply(requestIdFromForm, userAnswer);
+const result = await handle.result(); // Resolves once, after the live wait.
+```
+
+The model chooses when to call the granted question tool. A custom tool or driver
+can call `await services.requestInput({ question, choices?, timeoutMs? })`
+directly. The returned `InputReply` contains `requestId` and `input`.
+`choices` are presentation suggestions; the application may validate a richer
+answer before submitting it. This API does not invent a form schema or force a
+question on every run.
+
+`handle.state` is `running`, `awaiting_input`, `cancelling`, or `finished`.
+`handle.pendingInput` returns a cloned current question, useful when reconnecting
+after an event-history gap. Only one question can be pending per run.
+
+Replies claim the pending request synchronously. Duplicate, stale, wrong-run,
+malformed and post-completion replies reject with `HarnessInputError.code`.
+Messages are limited to 64KB; questions to 32KB. The application remains responsible
+for authenticating the actor before exposing a handle or submitting a reply.
+Events `input.requested`, `input.resolved`, and `run.resumed` share the request ID.
+
+| Timeout | Includes waiting? | Expiry reason code |
+| --- | --- | --- |
+| start option `deadline` (absolute timestamp) | Yes | `deadline_exceeded` |
+| runtime `activeTimeoutMs` | No | `active_timeout` |
+| runtime `inputTimeoutMs`, overridden per question | Only the current wait | `input_timeout` |
+
+Timeouts cancel the run cooperatively. `cancel()` also works during a question.
+Cleanup waits for already-started work to settle; external effects are not rolled
+back. Without an input timeout or deadline, a question can wait indefinitely.
+No new model calls may start while a question is pending; concurrent work already
+started before the question still has its usual cancellation/lifetime contract.
+
+For minor-version compatibility, a custom driver that **returns** legacy
+`status: "awaiting_input"`, or a completion policy returning `await_input`,
+still produces the old terminal hand-back. That path cannot resume its stack.
+Migrate live conversations to **awaiting `requestInput()`** inside the driver/tool;
+the new `awaiting_input` handle state is nonterminal.
+
+## Steer an active Agent
+
+```ts
+await handle.send("Only include last month", { mode: "steer" });
+```
+
+The built-in Agent driver now supports steering in both streaming modes. It
+appends input before the next model call, after the entire current tool-call/result
+group. Steering during a final model call is incorporated at the next complete
+boundary if budgets allow. Effects already completed are not repeated by the
+runtime. The model still decides its subsequent actions.
+
+`input.received` means queued. `input.applied` means inserted into the
+conversation at a safe boundary; both carry `inputId` and `mode`. Inputs within
+each mode preserve FIFO order. `follow_up` remains queued until the current
+driver turn completes; `steer` and `follow_up` have different scheduling semantics.
+The queue holds at most 32 inputs. Steering rejects once the Agent loop closes,
+including while a completion policy is still evaluating. Child agents cannot
+consume their parent's steering inbox.
+
+## Public communication
+
+Render these typed events by their stable item IDs:
+
+| Event | Meaning |
+| --- | --- |
+| `message.started` | Start an item; `phase: "pending"` is explicitly unclassified. |
+| `message.delta` | Append text to that item. |
+| `message.completed` | The item has phase `commentary`, `final`, or `reasoning_summary`. |
+| `message.failed` | A partial item was interrupted or cancelled. |
+
+A `final` message is a model answer, not a terminal runtime result: policies or
+queued input may still keep the run open. Only `run.terminal` closes the run.
+Standalone native commentary continues the same Agent loop under its existing
+budgets. No update schedule, artificial thinking, or progress tool is introduced.
+
+Large completed items use `artifactId` with an empty inline text field; the deltas
+remain complete. Retrieve the full `PublicMessage` with
+`runtime.getArtifact(identity, sessionId, artifactId)`. Event cursors and the
+existing bounded event store retain their normal semantics.
+
+Core consumers can use `RunOutput.publicMessages`, the `run.message` EventBus event,
+or opt into `Agent.stream(input, { publicMessageEvents: true })`. The default
+stream retains its existing text/finish sequence. Terminal usage and cost data
+remain on the final finish chunk, including with public lifecycle chunks enabled.
+Legacy `text.delta`, `thinking`, and `RunOutput.text` remain available; prefer
+public items when distinguishing progress from answers.
+
+`getCommunicationCapabilities(provider)` reports adapter support:
+
+| Adapter | Message phases | Public summaries |
+| --- | --- | --- |
+| OpenAI Responses and compatible endpoints implementing these fields | Native when present; otherwise inferred | Documented reasoning summary text |
+| Anthropic / AWS Claude with reasoning enabled | Inferred | Text requested with `display: "summarized"` |
+| Google / Vertex Gemini | Inferred | Documented thought summary text |
+| Other adapters without an explicit capability declaration | Inferred | Unsupported |
+
+`conditional` means support depends on the selected model, endpoint and request
+options. It is not a promise that the model emits a summary on every call.
+For providers without native phases, a complete response with tools is commentary;
+a complete response without tools is final. Unclassified streaming text remains
+pending until the response is complete.
+
+Raw reasoning, signatures, encrypted/redacted blocks and `providerExtras` are
+never used as public summaries. Opaque data remains in canonical conversation
+history for provider replay. Custom adapters should populate `publicMessages`,
+`message.phase`, and the corresponding streaming metadata explicitly.
+
+## Compact completed tool rounds
+
+```ts
+const contextPolicy = summaryContextPolicy({
+  modelRole: "summary",
+  maxContextTokens: 12_000,
+  grouping: "tool_roundtrip",
+  keepRecentTurns: 2, // Here: keep the two latest complete groups.
+});
+```
+
+Bind and grant the summary model role through `HarnessRuntime.models` and
+`grants.modelRoles` as usual. The default grouping remains whole user turns.
+The new option recognizes completed tool rounds within a long task, keeps the
+latest user request and complete retained tool/replay groups, and summarizes
+older groups through the existing summary policy. Applications do not insert
+synthetic user turns. Canonical session history is unchanged.
+
+`compaction.started`, `compaction.completed` and `compaction.failed` correlate by
+`compactionId` and `policyId`. The summary call shares the run's model/token
+budgets and cancellation signal. If an intact live group cannot fit, compaction
+fails rather than dropping required continuation data.
+
+Live continuation does not provide process-restart recovery. Events, pending
+promises and run handles remain in memory. A future recovery adapter must persist
+questions/checkpoints, establish ownership, and reconcile uncertain tool effects.

package/README.md

@@ -271,11 +271,19 @@ events; reconnect with `events({ after: cursor })`. Older cursors receive
 `HarnessEventGapError`. Large terminal outputs become scoped artifact references;
 retrieve them with `runtime.getArtifact(identity, sessionId, artifactId)`.
 
-Built-in drivers support queued `follow_up` input. Custom drivers may declare
-`steer` and consume it at boundaries with `services.takeInput()`. Unsupported
-controls throw `HarnessUnsupportedError`. Interrupt-and-replace, pause/resume,
-remote policy coverage, and durable recovery are rejected by this local runtime.
-In-memory events, artifacts, and sessions are explicitly non-durable.
+Built-in drivers support queued `follow_up` input. The built-in Agent driver also
+supports `steer` at complete tool-roundtrip boundaries. Custom drivers may declare
+`steer` and consume it with `services.takeInput()`. For live questions, use
+`requestInputTool()` or `await services.requestInput()`, then answer with
+`handle.reply(requestId, input)`. `handle.state === "awaiting_input"` is nonterminal;
+`result()` stays pending and budgets are preserved. Returning the old terminal
+`awaiting_input` status is a legacy hand-back, not live suspension.
+
+See [conversational runs](./CONVERSATIONAL-RUNS.md) for clocks, input events,
+public messages, provider capabilities, streaming compatibility and compaction.
+Unsupported controls throw `HarnessUnsupportedError`. Interrupt-and-replace,
+remote policy coverage, and durable recovery remain unsupported. In-memory
+events, artifacts, sessions and pending questions are explicitly non-durable.
 
 Host grants are upper bounds. Controllers select only approved tools/model roles;
 omitting required tools or selecting unsupported model options fails closed.

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() {