agents 0.28.0 → 0.29.0

package/dist/harness/opencode/index.d.ts

@@ -30,7 +30,10 @@ type OpenCodeInput =
 type OpenCodeMessage = Awaited<
   ReturnType<OpenCode["sessions"]["context"]>
 >[number];
-/** One of OpenCode's events: durable transcript events and live deltas. */
+/**
+ * One of OpenCode's own events: durable transcript events and live deltas.
+ * `session.events()` translates these into `OpenCodeSessionEvent`s.
+ */
 type OpenCodeEvent =
   ReturnType<OpenCode["events"]["subscribe"]> extends AsyncIterable<infer E>
     ? E
@@ -101,6 +104,173 @@ type OpenCodeSessionInfo = {
   readonly title?: string /** Running, input waiting, or a turn a restart cut off, about to resume. */;
   readonly busy: boolean;
 };
+/** A permission OpenCode asked for, waiting on a reply. */
+type OpenCodePermission = {
+  readonly id: string;
+  readonly session: OpenCodeSessionId /** What OpenCode wants to do, such as `edit` or `webfetch`. */;
+  readonly action: string /** What the action applies to, such as paths or URLs. */;
+  readonly resources: readonly string[];
+  readonly message?: string;
+};
+/** How an assistant message's step ended, as OpenCode reports it. */
+type OpenCodeFinish =
+  | "stop"
+  | "length"
+  | "tool-calls"
+  | "content-filter"
+  | "error"
+  | "unknown";
+/**
+ * One event on a session's stream, translated from OpenCode's events into
+ * the same kinds of event `PiHarness` and `ContainerHarness` report.
+ * `messageId` is OpenCode's assistant message id. Text and reasoning are
+ * addressed by `ordinal`, their position among the message's parts of the
+ * same kind.
+ */
+type OpenCodeSessionEvent =
+  /**
+   * An input is in OpenCode's inbox. Every input goes through it, so this
+   * comes before `operation_start` even when the session is idle.
+   */
+  | {
+      readonly type: "operation_queued";
+      readonly operationId: string;
+    } /** A queued input was withdrawn before it ran. */
+  | {
+      readonly type: "operation_withdrawn";
+      readonly operationId: string;
+    } /** An input joined the transcript; the next assistant message answers it. */
+  | {
+      readonly type: "operation_start";
+      readonly operationId: string;
+    } /** An input has its answer: the same result `wait()` returns. */
+  | {
+      readonly type: "operation_end";
+      readonly result: OpenCodeOperationResult;
+    } /** OpenCode started a run. One run answers every input it drains. */
+  | {
+      readonly type: "run_start";
+    }
+  | {
+      readonly type: "run_end";
+      readonly outcome: "succeeded" | "failed" | "interrupted";
+      readonly error?: string;
+    }
+  | {
+      readonly type: "message_start";
+      readonly messageId: string;
+      readonly agent: string;
+      readonly model: {
+        readonly providerID: string;
+        readonly id: string;
+      };
+    }
+  | {
+      readonly type: "text_delta";
+      readonly messageId: string;
+      readonly ordinal: number;
+      readonly delta: string;
+    } /** A text part is complete; `text` is the whole part. */
+  | {
+      readonly type: "text_end";
+      readonly messageId: string;
+      readonly ordinal: number;
+      readonly text: string;
+    }
+  | {
+      readonly type: "reasoning_delta";
+      readonly messageId: string;
+      readonly ordinal: number;
+      readonly delta: string;
+    }
+  | {
+      readonly type: "reasoning_end";
+      readonly messageId: string;
+      readonly ordinal: number;
+      readonly text: string;
+    } /** The model called a tool and OpenCode has its whole input. */
+  | {
+      readonly type: "tool_start";
+      readonly messageId: string;
+      readonly toolCallId: string;
+      readonly name: string;
+      readonly input: Readonly<Record<string, unknown>>;
+    }
+  | {
+      readonly type: "tool_end";
+      readonly messageId: string;
+      readonly toolCallId: string;
+      readonly name: string;
+      readonly error: boolean /** The tool's text output, or its error message. */;
+      readonly output: string;
+    }
+  | {
+      readonly type: "message_end";
+      readonly messageId: string;
+      readonly finish: OpenCodeFinish;
+      readonly error?: string;
+    } /** A model call failed and OpenCode will try again at `at`. */
+  | {
+      readonly type: "retry_scheduled";
+      readonly messageId: string;
+      readonly attempt: number;
+      readonly at: number;
+      readonly error: string;
+    }
+  | {
+      readonly type: "compaction_start";
+      readonly reason: "auto" | "manual";
+    }
+  /**
+   * OpenCode compacted the session: `messages()` is now shorter, and
+   * `history()` has a compaction message. Read the transcript again.
+   */
+  | {
+      readonly type: "transcript_reset";
+      readonly reason: "compaction";
+    }
+  | {
+      readonly type: "permission_asked";
+      readonly permission: OpenCodePermission;
+    }
+  | {
+      readonly type: "permission_replied";
+      readonly permissionId: string;
+      readonly reply: "once" | "always" | "reject";
+    }
+  /**
+   * Something went wrong outside a model step: `compaction_failed`, or
+   * `events_failed` when OpenCode's event stream ended with an error. No
+   * more events follow `events_failed`; open a new stream.
+   */
+  | {
+      readonly type: "fault";
+      readonly code: "compaction_failed" | "events_failed";
+      readonly message: string;
+    };
+/** A session's state when its event stream opens. */
+type OpenCodeSessionSnapshot = {
+  readonly session: OpenCodeSessionId /** The whole transcript, compacted messages included: `history()`. */;
+  readonly messages: readonly OpenCodeMessage[];
+  readonly pending: readonly OpenCodePendingOperation[];
+  readonly busy: boolean /** Permissions OpenCode is waiting on. */;
+  readonly permissions: readonly OpenCodePermission[];
+};
+/**
+ * A session's events: the snapshot taken when the stream opened, then every
+ * event after it, in batches, including any that arrived before `start()`.
+ * An event may repeat what the snapshot already shows; messages are keyed
+ * by id. Live: events reach listeners in the isolate that runs the harness,
+ * and the stream holds OpenCode open until `stop()`. Call `stop()` when
+ * done, started or not.
+ */
+type OpenCodeEventStream = {
+  readonly snapshot: OpenCodeSessionSnapshot /** Start delivering events. Call once. */;
+  start(
+    listener: (events: readonly OpenCodeSessionEvent[]) => void
+  ): void /** Stop delivering events and release OpenCode. */;
+  stop(): Promise<void>;
+};
 //#endregion
 //#region src/harness/opencode/harness.d.ts
 /** The root session's id. OpenCode session ids start with `ses`. */
@@ -304,12 +474,13 @@ declare class OpenCodeSession {
    */
   history(): Promise<OpenCodeMessage[]>;
   /**
-   * 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()`.
    */
-  events(signal?: AbortSignal): AsyncIterable<OpenCodeEvent>;
+  events(): Promise<OpenCodeEventStream>;
   /**
    * The session's durable events after sequence number `after` (from the
    * start by default), then, with `follow`, new ones as they are committed,
@@ -344,6 +515,8 @@ declare class OpenCodeSessions {
 export {
   type OpenCode,
   type OpenCodeEvent,
+  type OpenCodeEventStream,
+  type OpenCodeFinish,
   OpenCodeHarness,
   type OpenCodeHarnessContext,
   type OpenCodeHarnessFactory,
@@ -354,13 +527,16 @@ export {
   type OpenCodeModel,
   type OpenCodeOperationResult,
   type OpenCodePendingOperation,
+  type OpenCodePermission,
   type OpenCodePromptResponse,
   type OpenCodeReceipt,
   OpenCodeSession,
   type OpenCodeSessionDefaults,
+  type OpenCodeSessionEvent,
   type OpenCodeSessionId,
   type OpenCodeSessionInfo,
   type OpenCodeSessionOptions,
+  type OpenCodeSessionSnapshot,
   OpenCodeSessions,
   type OpenCodeSubmitOptions,
   type OpenCodeWhenBusy,

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-DBAKc6UZ.js";
-import "../../lifecycle-DGorpAmA.js";
+import "../../lifecycle-ClT4DmF2.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 {