agents 0.27.0 → 0.28.1

package/dist/harness/opencode/index.js

@@ -1,7 +1,7 @@
 import { i as _classPrivateFieldInitSpec, n as _classPrivateFieldSet2, r as _assertClassBrand, t as _classPrivateFieldGet2 } from "../../classPrivateFieldGet2-DZBYAB34.js";
 import { t as _classPrivateMethodInitSpec } from "../../classPrivateMethodInitSpec-qMjJ6sHQ.js";
-import { t as LifecycleCapability } from "../../capability-B4WbF81e.js";
-import "../../lifecycle-CFu6OV03.js";
+import { t as LifecycleCapability } from "../../capability-DBAKc6UZ.js";
+import "../../lifecycle-DGorpAmA.js";
 //#region src/harness/table-prefix.ts
 /**
 * A view of `storage` whose SQL is rewritten into `prefix`'s namespace.
@@ -284,6 +284,268 @@ function closing(sql, start, close) {
 	return sql.length;
 }
 //#endregion
+//#region src/harness/opencode/operation-id.ts
+const OPERATION_ID = /^[A-Za-z0-9._~-]+$/;
+/** OpenCode's id for the user message an operation submits. */
+function messageIdOf(operationId) {
+	if (!OPERATION_ID.test(operationId)) throw new TypeError(`Invalid operation id ${JSON.stringify(operationId)}: use letters, digits, ".", "_", "~" and "-"`);
+	return `msg_${operationId}`;
+}
+/** The operation id of a message or inbox item, the inverse of `messageIdOf`. */
+function operationIdOf(messageId) {
+	return messageId.startsWith("msg_") ? messageId.slice(4) : messageId;
+}
+//#endregion
+//#region src/harness/opencode/events.ts
+/** The text parts of a tool's result, joined. */
+function toolText(content) {
+	return (content ?? []).map((part) => "text" in part ? part.text : "").join("\n");
+}
+/** The session an OpenCode event belongs to, if it belongs to one. */
+function sessionIdOf(event) {
+	const data = event.data;
+	return typeof data === "object" && data !== null && "sessionID" in data && typeof data.sessionID === "string" ? data.sessionID : void 0;
+}
+function answerOf(message) {
+	if (message.type !== "assistant") return void 0;
+	const text = /* @__PURE__ */ new Map();
+	for (const part of message.content) if (part.type === "text") text.set(text.size, part.text);
+	return {
+		id: message.id,
+		text,
+		error: message.error?.message
+	};
+}
+var _session = /* @__PURE__ */ new WeakMap();
+var _toolNames = /* @__PURE__ */ new WeakMap();
+var _answering = /* @__PURE__ */ new WeakMap();
+var _ended = /* @__PURE__ */ new WeakMap();
+var _answered = /* @__PURE__ */ new WeakMap();
+var _answer = /* @__PURE__ */ new WeakMap();
+var _SessionEventProjector_brand = /* @__PURE__ */ new WeakSet();
+/**
+* Translates one session's OpenCode events into `OpenCodeSessionEvent`s.
+*
+* OpenCode's events leave out some of what the translated ones carry, so
+* the projector keeps it: tool names (`session.tool.called` has only the
+* call id), and which inputs the current answer is for, so it can report
+* `operation_end`. It starts from the stream's snapshot, so a stream opened
+* mid-run knows the run's inputs and tools.
+*
+* `operation_end` follows the rule `wait()` uses on the transcript: an
+* input's answer ends at the next input that joins after an assistant
+* message, or at the end of the run.
+*
+* Events that arrive while the snapshot is read are projected after it, so
+* some repeat what the snapshot shows. Projection is idempotent for those:
+* an input the projector already knows is not started or ended again.
+*/
+var SessionEventProjector = class {
+	constructor(snapshot) {
+		_classPrivateMethodInitSpec(this, _SessionEventProjector_brand);
+		_classPrivateFieldInitSpec(this, _session, void 0);
+		_classPrivateFieldInitSpec(this, _toolNames, /* @__PURE__ */ new Map());
+		_classPrivateFieldInitSpec(this, _answering, []);
+		_classPrivateFieldInitSpec(this, _ended, /* @__PURE__ */ new Set());
+		_classPrivateFieldInitSpec(this, _answered, false);
+		_classPrivateFieldInitSpec(this, _answer, void 0);
+		_classPrivateFieldSet2(_session, this, snapshot.session);
+		for (const message of snapshot.messages) {
+			if (message.type !== "assistant") continue;
+			for (const part of message.content) if (part.type === "tool") _classPrivateFieldGet2(_toolNames, this).set(part.id, part.name);
+		}
+		_classPrivateFieldSet2(_answering, this, snapshot.pending.filter((operation) => operation.status === "running").map((operation) => operation.operationId));
+		if (_classPrivateFieldGet2(_answering, this).length > 0) {
+			const last = snapshot.messages.at(-1);
+			_classPrivateFieldSet2(_answer, this, last === void 0 ? void 0 : answerOf(last));
+			_classPrivateFieldSet2(_answered, this, _classPrivateFieldGet2(_answer, this) !== void 0);
+		}
+	}
+	/** The translated events for one OpenCode event; often none. */
+	project(event) {
+		switch (event.type) {
+			case "session.inbox.enqueued": return event.data.item.type === "user" ? [{
+				type: "operation_queued",
+				operationId: operationIdOf(event.data.inboxID)
+			}] : [];
+			case "session.inbox.cancelled": return [{
+				type: "operation_withdrawn",
+				operationId: operationIdOf(event.data.inboxID)
+			}];
+			case "session.inbox.delivered": {
+				const operationId = operationIdOf(event.data.inboxID);
+				if (_classPrivateFieldGet2(_answering, this).includes(operationId) || _classPrivateFieldGet2(_ended, this).has(operationId)) return [];
+				const ended = _classPrivateFieldGet2(_answered, this) ? _assertClassBrand(_SessionEventProjector_brand, this, _settle).call(this, "succeeded") : [];
+				_classPrivateFieldGet2(_answering, this).push(operationId);
+				return [...ended, {
+					type: "operation_start",
+					operationId
+				}];
+			}
+			case "session.execution.started":
+				if (_classPrivateFieldGet2(_answering, this).length === 0) {
+					_classPrivateFieldSet2(_answer, this, void 0);
+					_classPrivateFieldSet2(_answered, this, false);
+				}
+				return [{ type: "run_start" }];
+			case "session.execution.succeeded": return [..._assertClassBrand(_SessionEventProjector_brand, this, _settle).call(this, "succeeded"), runEnd("succeeded")];
+			case "session.execution.failed": return [..._assertClassBrand(_SessionEventProjector_brand, this, _settle).call(this, "failed", event.data.error.message), runEnd("failed", event.data.error.message)];
+			case "session.execution.interrupted": return [..._assertClassBrand(_SessionEventProjector_brand, this, _settle).call(this, "interrupted"), runEnd("interrupted")];
+			case "session.step.started":
+				_classPrivateFieldSet2(_answered, this, true);
+				_classPrivateFieldSet2(_answer, this, {
+					id: event.data.assistantMessageID,
+					text: /* @__PURE__ */ new Map(),
+					error: void 0
+				});
+				return [{
+					type: "message_start",
+					messageId: event.data.assistantMessageID,
+					agent: event.data.agent,
+					model: {
+						providerID: event.data.model.providerID,
+						id: event.data.model.id
+					}
+				}];
+			case "session.step.ended": return [{
+				type: "message_end",
+				messageId: event.data.assistantMessageID,
+				finish: event.data.finish
+			}];
+			case "session.step.failed":
+				if (_classPrivateFieldGet2(_answer, this)?.id === event.data.assistantMessageID) _classPrivateFieldGet2(_answer, this).error = event.data.error.message;
+				return [{
+					type: "message_end",
+					messageId: event.data.assistantMessageID,
+					finish: "error",
+					error: event.data.error.message
+				}];
+			case "session.text.delta":
+			case "session.reasoning.delta": return [{
+				type: event.type === "session.text.delta" ? "text_delta" : "reasoning_delta",
+				messageId: event.data.assistantMessageID,
+				ordinal: event.data.ordinal,
+				delta: event.data.delta
+			}];
+			case "session.text.ended":
+				if (_classPrivateFieldGet2(_answer, this)?.id === event.data.assistantMessageID) _classPrivateFieldGet2(_answer, this).text.set(event.data.ordinal, event.data.text);
+				return [{
+					type: "text_end",
+					messageId: event.data.assistantMessageID,
+					ordinal: event.data.ordinal,
+					text: event.data.text
+				}];
+			case "session.reasoning.ended": return [{
+				type: "reasoning_end",
+				messageId: event.data.assistantMessageID,
+				ordinal: event.data.ordinal,
+				text: event.data.text
+			}];
+			case "session.tool.input.started":
+				_classPrivateFieldGet2(_toolNames, this).set(event.data.id, event.data.name);
+				return [];
+			case "session.tool.called": return [{
+				type: "tool_start",
+				messageId: event.data.assistantMessageID,
+				toolCallId: event.data.id,
+				name: _classPrivateFieldGet2(_toolNames, this).get(event.data.id) ?? "",
+				input: event.data.input
+			}];
+			case "session.tool.success": return [{
+				type: "tool_end",
+				messageId: event.data.assistantMessageID,
+				toolCallId: event.data.id,
+				name: _classPrivateFieldGet2(_toolNames, this).get(event.data.id) ?? "",
+				error: false,
+				output: toolText(event.data.content)
+			}];
+			case "session.tool.failed": return [{
+				type: "tool_end",
+				messageId: event.data.assistantMessageID,
+				toolCallId: event.data.id,
+				name: _classPrivateFieldGet2(_toolNames, this).get(event.data.id) ?? "",
+				error: true,
+				output: event.data.error.message
+			}];
+			case "session.retry.scheduled": return [{
+				type: "retry_scheduled",
+				messageId: event.data.assistantMessageID,
+				attempt: event.data.attempt,
+				at: event.data.at,
+				error: event.data.error.message
+			}];
+			case "session.compaction.started": return [{
+				type: "compaction_start",
+				reason: event.data.reason
+			}];
+			case "session.compaction.ended": return [{
+				type: "transcript_reset",
+				reason: "compaction"
+			}];
+			case "session.compaction.failed": return [{
+				type: "fault",
+				code: "compaction_failed",
+				message: event.data.error.message
+			}];
+			case "permission.asked": return [{
+				type: "permission_asked",
+				permission: {
+					id: event.data.id,
+					session: event.data.sessionID,
+					action: event.data.action,
+					resources: event.data.resources,
+					...event.data.message === void 0 ? {} : { message: event.data.message }
+				}
+			}];
+			case "permission.replied": return [{
+				type: "permission_replied",
+				permissionId: event.data.requestID,
+				reply: event.data.reply
+			}];
+			default: return [];
+		}
+	}
+};
+/** End every input the latest answer was for. */
+function _settle(outcome, runError) {
+	const answer = _classPrivateFieldGet2(_answer, this);
+	const text = [...(answer?.text ?? /* @__PURE__ */ new Map()).entries()].sort(([a], [b]) => a - b).map(([, part]) => part).join("");
+	const error = answer?.error ?? runError;
+	const ended = _classPrivateFieldGet2(_answering, this).map((operationId) => {
+		_classPrivateFieldGet2(_ended, this).add(operationId);
+		return {
+			type: "operation_end",
+			result: resultOf(_classPrivateFieldGet2(_session, this), operationId, outcome, text, error)
+		};
+	});
+	_classPrivateFieldSet2(_answering, this, []);
+	_classPrivateFieldSet2(_answered, this, false);
+	_classPrivateFieldSet2(_answer, this, void 0);
+	return ended;
+}
+function runEnd(outcome, error) {
+	return {
+		type: "run_end",
+		outcome,
+		...error === void 0 ? {} : { error }
+	};
+}
+/** The result `wait()` would return for the same ending. */
+function resultOf(session, operationId, outcome, text, error) {
+	if (outcome === "succeeded" && error === void 0) return {
+		operationId,
+		session,
+		status: "done",
+		text
+	};
+	return {
+		operationId,
+		session,
+		status: "unanswered",
+		reason: outcome === "interrupted" ? "interrupted" : error ?? "failed"
+	};
+}
+//#endregion
 //#region src/harness/opencode/harness.ts
 /** The root session's id. OpenCode session ids start with `ses`. */
 const ROOT_SESSION = "ses_root";
@@ -319,16 +581,6 @@ function wakeJobId(session) {
 function sessionOfJob(payload) {
 	return typeof payload === "object" && payload !== null && "session" in payload && typeof payload.session === "string" ? payload.session : void 0;
 }
-const OPERATION_ID = /^[A-Za-z0-9._~-]+$/;
-/** OpenCode's id for the user message an operation submits. */
-function messageIdOf(operationId) {
-	if (!OPERATION_ID.test(operationId)) throw new TypeError(`Invalid operation id ${JSON.stringify(operationId)}: use letters, digits, ".", "_", "~" and "-"`);
-	return `msg_${operationId}`;
-}
-/** The operation id of a message or inbox item, the inverse of `messageIdOf`. */
-function operationIdOf(messageId) {
-	return messageId.startsWith("msg_") ? messageId.slice(4) : messageId;
-}
 /** Whether an OpenCode client error is the tagged error `tag`. */
 function isTagged(error, tag) {
 	return typeof error === "object" && error !== null && "_tag" in error && error._tag === tag;
@@ -343,11 +595,6 @@ function textOf(message) {
 	if (message?.type !== "assistant") return "";
 	return message.content.map((part) => part.type === "text" ? part.text : "").join("");
 }
-function sessionIdOf(event) {
-	if (!("data" in event)) return void 0;
-	const data = event.data;
-	return typeof data === "object" && data !== null && "sessionID" in data && typeof data.sessionID === "string" ? data.sessionID : void 0;
-}
 var _options = /* @__PURE__ */ new WeakMap();
 var _waits = /* @__PURE__ */ new WeakMap();
 var _admitting = /* @__PURE__ */ new WeakMap();
@@ -910,6 +1157,7 @@ function delay(ms, signal) {
 	});
 }
 var _harness = /* @__PURE__ */ new WeakMap();
+var _OpenCodeSession_brand = /* @__PURE__ */ new WeakSet();
 /** One OpenCode session, addressed through the harness. */
 var OpenCodeSession = class {
 	/**
@@ -917,6 +1165,7 @@ var OpenCodeSession = class {
 	* @param id - The session's id.
 	*/
 	constructor(harness, id) {
+		_classPrivateMethodInitSpec(this, _OpenCodeSession_brand);
 		_classPrivateFieldInitSpec(this, _harness, void 0);
 		_classPrivateFieldSet2(_harness, this, harness);
 		this.id = id;
@@ -1001,18 +1250,79 @@ var OpenCodeSession = class {
 		});
 	}
 	/**
-	* OpenCode's events for this session as they happen, durable and live
-	* (text deltas, tool input), until `signal` aborts. Read the transcript
-	* with `messages()` first for a snapshot; use `log()` to resume from a
-	* durable position instead.
+	* The session's state now, then everything that happens to it after, as
+	* `OpenCodeSessionEvent`s: the same kinds of event `PiHarness` reports,
+	* live text deltas included. The stream holds OpenCode open until
+	* `stop()`. For OpenCode's own events, durable and resumable by sequence
+	* number, use `log()`.
 	*/
-	async *events(signal) {
+	async events() {
 		const release = _classPrivateFieldGet2(_harness, this).lease();
+		const controller = new AbortController();
+		const early = [];
+		const pending = [];
+		let projector;
+		let listener;
+		let stopped = false;
+		const deliver = (events) => {
+			if (events.length === 0 || stopped) return;
+			if (listener === void 0) pending.push(...events);
+			else listener(events);
+		};
+		let attached;
+		const subscribed = new Promise((resolve) => {
+			attached = resolve;
+		});
+		let pump = Promise.resolve();
 		try {
 			const opencode = await _classPrivateFieldGet2(_harness, this).opencode();
-			for await (const event of opencode.events.subscribe(signal ? { signal } : {})) if (sessionIdOf(event) === this.id) yield event;
-		} finally {
+			pump = (async () => {
+				try {
+					for await (const event of opencode.events.subscribe({ signal: controller.signal })) {
+						if (event.type === "server.connected") attached();
+						if (sessionIdOf(event) !== this.id) continue;
+						if (projector === void 0) early.push(event);
+						else deliver(projector.project(event));
+					}
+				} catch (error) {
+					if (!controller.signal.aborted) deliver([{
+						type: "fault",
+						code: "events_failed",
+						message: describe(error)
+					}]);
+				} finally {
+					attached();
+				}
+			})();
+			await subscribed;
+			const snapshot = await _assertClassBrand(_OpenCodeSession_brand, this, _snapshot).call(this, opencode);
+			projector = new SessionEventProjector(snapshot);
+			for (const event of early.splice(0)) deliver(projector.project(event));
+			let stopping;
+			return {
+				snapshot,
+				start: (next) => {
+					if (listener !== void 0) throw new Error("OpenCodeEventStream.start() was already called");
+					if (stopping !== void 0) return;
+					listener = next;
+					deliver(pending.splice(0));
+				},
+				stop: () => {
+					stopping ??= (async () => {
+						stopped = true;
+						pending.length = 0;
+						controller.abort();
+						await pump;
+						await release();
+					})();
+					return stopping;
+				}
+			};
+		} catch (error) {
+			controller.abort();
+			await pump;
 			await release();
+			throw error;
 		}
 	}
 	/**
@@ -1040,6 +1350,27 @@ var OpenCodeSession = class {
 		return _classPrivateFieldGet2(_harness, this).use(async (opencode) => sessionBusy(opencode, this.id, await opencode.sessions.active()));
 	}
 };
+async function _snapshot(opencode) {
+	const [messages, busy, pending, permissions] = await Promise.all([
+		this.history(),
+		this.busy(),
+		_classPrivateFieldGet2(_harness, this).pending({ session: this.id }),
+		opencode.permission.list({ sessionID: this.id })
+	]);
+	return {
+		session: this.id,
+		messages,
+		busy,
+		pending,
+		permissions: permissions.map((request) => ({
+			id: request.id,
+			session: request.sessionID,
+			action: request.action,
+			resources: request.resources,
+			...request.message === void 0 ? {} : { message: request.message }
+		}))
+	};
+}
 var _harness2 = /* @__PURE__ */ new WeakMap();
 /** Every OpenCode session in this object. */
 var OpenCodeSessions = class {