agents 0.26.0 → 0.28.0

package/dist/harness/opencode/index.js

@@ -0,0 +1,1072 @@
+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";
+//#region src/harness/table-prefix.ts
+/**
+* A view of `storage` whose SQL is rewritten into `prefix`'s namespace.
+* Everything other than `sql.exec` is the original storage, so transactions
+* and the rest of the API behave as before.
+*
+* @param storage - The Durable Object's storage.
+* @param prefix - The namespace, such as `opencode_`. Letters, digits and
+*   underscores, starting with a letter; never `_cf_`, which Durable Objects
+*   reserve.
+* @returns The same storage, with `sql.exec` rewritten.
+* @throws When `prefix` is not a valid prefix: a defect in the caller.
+*/
+function prefixTables(storage, prefix) {
+	const rewriter = new TablePrefixRewriter(storage.sql, prefix);
+	const sql = new Proxy(storage.sql, { get(target, property) {
+		if (property === "exec") return rewriter.exec;
+		const value = Reflect.get(target, property, target);
+		return typeof value === "function" ? value.bind(target) : value;
+	} });
+	return new Proxy(storage, { get(target, property) {
+		if (property === "sql") return sql;
+		const value = Reflect.get(target, property, target);
+		return typeof value === "function" ? value.bind(target) : value;
+	} });
+}
+/** Words after which an identifier names a table or index in DDL. */
+const DDL_KEYWORDS = /* @__PURE__ */ new Set([
+	"TABLE",
+	"INDEX",
+	"REFERENCES"
+]);
+/** Words after which an identifier names a table in DML. */
+const DML_KEYWORDS = /* @__PURE__ */ new Set([
+	"FROM",
+	"JOIN",
+	"INTO",
+	"UPDATE"
+]);
+/** Words that may follow `sqlite_master` without being its alias. */
+const CLAUSE_KEYWORDS = /* @__PURE__ */ new Set([
+	"WHERE",
+	"ORDER",
+	"GROUP",
+	"LIMIT",
+	"JOIN",
+	"LEFT",
+	"INNER",
+	"CROSS",
+	"ON",
+	"UNION",
+	"EXCEPT",
+	"INTERSECT",
+	"HAVING",
+	"WINDOW"
+]);
+const MASTER_TABLES = /* @__PURE__ */ new Set(["sqlite_master", "sqlite_schema"]);
+/** PRAGMAs whose argument is a table or index name. */
+const SCHEMA_PRAGMAS = /* @__PURE__ */ new Set([
+	"table_info",
+	"table_xinfo",
+	"index_list",
+	"index_info",
+	"index_xinfo",
+	"foreign_key_list",
+	"foreign_key_check",
+	"integrity_check",
+	"quick_check"
+]);
+/**
+* Bare words that follow a table keyword without naming a table:
+* `TABLE IF NOT EXISTS`, `INSERT OR REPLACE INTO`, `FROM (SELECT …)`.
+*/
+const NOT_NAMES = /* @__PURE__ */ new Set([
+	"IF",
+	"NOT",
+	"EXISTS",
+	"SELECT",
+	"VALUES",
+	"OR"
+]);
+var _sql = /* @__PURE__ */ new WeakMap();
+var _prefix = /* @__PURE__ */ new WeakMap();
+var _masterView = /* @__PURE__ */ new WeakMap();
+var _names = /* @__PURE__ */ new WeakMap();
+var _cache = /* @__PURE__ */ new WeakMap();
+var _TablePrefixRewriter_brand = /* @__PURE__ */ new WeakSet();
+var TablePrefixRewriter = class {
+	constructor(sql, prefix) {
+		_classPrivateMethodInitSpec(this, _TablePrefixRewriter_brand);
+		_classPrivateFieldInitSpec(this, _sql, void 0);
+		_classPrivateFieldInitSpec(this, _prefix, void 0);
+		_classPrivateFieldInitSpec(this, _masterView, void 0);
+		_classPrivateFieldInitSpec(this, _names, void 0);
+		_classPrivateFieldInitSpec(this, _cache, /* @__PURE__ */ new Map());
+		this.exec = (query, ...bindings) => _classPrivateFieldGet2(_sql, this).exec(this.rewrite(query), ...bindings);
+		if (!/^[A-Za-z][A-Za-z0-9_]*$/.test(prefix)) throw new Error(`Invalid table prefix ${JSON.stringify(prefix)}`);
+		if (prefix.toLowerCase().startsWith("_cf_")) throw new Error("A table prefix must not start with _cf_");
+		_classPrivateFieldSet2(_sql, this, sql);
+		_classPrivateFieldSet2(_prefix, this, prefix);
+		const length = prefix.length;
+		_classPrivateFieldSet2(_masterView, this, `(SELECT type, substr(name, ${length + 1}) AS name, substr(tbl_name, ${length + 1}) AS tbl_name, rootpage, sql FROM sqlite_master WHERE substr(name, 1, ${length}) = '${prefix}')`);
+	}
+	rewrite(query) {
+		const cached = _classPrivateFieldGet2(_cache, this).get(query);
+		if (cached !== void 0) return cached;
+		const names = _assertClassBrand(_TablePrefixRewriter_brand, this, _known$1).call(this);
+		const before = names.size;
+		const rewritten = _assertClassBrand(_TablePrefixRewriter_brand, this, _rewrite).call(this, tokenize(query), names);
+		if (names.size === before) _classPrivateFieldGet2(_cache, this).set(query, rewritten);
+		else _classPrivateFieldGet2(_cache, this).clear();
+		return rewritten;
+	}
+};
+function _known$1() {
+	if (_classPrivateFieldGet2(_names, this)) return _classPrivateFieldGet2(_names, this);
+	const rows = _classPrivateFieldGet2(_sql, this).exec("SELECT name FROM sqlite_master WHERE substr(name, 1, ?) = ?", _classPrivateFieldGet2(_prefix, this).length, _classPrivateFieldGet2(_prefix, this)).toArray();
+	_classPrivateFieldSet2(_names, this, new Set(rows.map((row) => row.name.slice(_classPrivateFieldGet2(_prefix, this).length).toLowerCase())));
+	return _classPrivateFieldGet2(_names, this);
+}
+function _rewrite(tokens, names) {
+	const significant = tokens.map((token, index) => ({
+		token,
+		index
+	})).filter(({ token }) => token.kind !== "space");
+	const out = tokens.map((token) => token.text);
+	const firstWord = upper(significant[0]?.token);
+	const isCreateIndex = firstWord === "CREATE" && significant.slice(1, 4).some(({ token }) => upper(token) === "INDEX");
+	for (let i = 0; i < significant.length; i++) {
+		const { token, index } = significant[i];
+		if (token.kind !== "word" && token.kind !== "quoted") continue;
+		if (token.kind === "word" && NOT_NAMES.has(token.text.toUpperCase())) continue;
+		const lower = (token.kind === "word" ? token.text : token.name).toLowerCase();
+		const previous = significant[i - 1]?.token;
+		const next = significant[i + 1]?.token;
+		if (previous?.text === ".") continue;
+		const position = tablePosition(significant, i, isCreateIndex);
+		if (position === "dml" && MASTER_TABLES.has(lower)) {
+			out[index] = upper(next) === "AS" || next !== void 0 && (next.kind === "word" || next.kind === "quoted") && !CLAUSE_KEYWORDS.has(upper(next)) ? _classPrivateFieldGet2(_masterView, this) : `${_classPrivateFieldGet2(_masterView, this)} AS ${token.text}`;
+			continue;
+		}
+		if (lower.startsWith("sqlite_")) continue;
+		if (position === "ddl") {
+			names.add(lower);
+			out[index] = _assertClassBrand(_TablePrefixRewriter_brand, this, _prefixed).call(this, token);
+			continue;
+		}
+		if (position === "dml" && names.has(lower)) {
+			out[index] = _assertClassBrand(_TablePrefixRewriter_brand, this, _prefixed).call(this, token);
+			continue;
+		}
+		if (next?.text === "." && significant[i + 2] !== void 0 && names.has(lower)) {
+			out[index] = _assertClassBrand(_TablePrefixRewriter_brand, this, _prefixed).call(this, token);
+			continue;
+		}
+		if (lower.startsWith("pragma_") && next?.text === "(") {
+			const argument = significant[i + 2];
+			if (argument?.token.kind === "string") {
+				const inner = argument.token.text.slice(1, -1);
+				if (names.has(inner.toLowerCase())) out[argument.index] = `'${_classPrivateFieldGet2(_prefix, this)}${inner}'`;
+			}
+		}
+		if (firstWord === "PRAGMA" && previous?.text === "(" && names.has(lower)) out[index] = _assertClassBrand(_TablePrefixRewriter_brand, this, _prefixed).call(this, token);
+	}
+	const pragma = significant[2]?.token.text === "." ? significant[3]?.token : significant[1]?.token;
+	const pragmaName = pragma?.kind === "word" ? pragma.text : pragma?.kind === "quoted" ? pragma.name : "";
+	if (firstWord === "PRAGMA" && SCHEMA_PRAGMAS.has(pragmaName.toLowerCase())) for (let i = 1; i < significant.length; i++) {
+		const { token, index } = significant[i];
+		if (token.kind !== "string" || significant[i - 1]?.token.text !== "(") continue;
+		const inner = token.text.slice(1, -1);
+		if (names.has(inner.toLowerCase())) out[index] = `'${_classPrivateFieldGet2(_prefix, this)}${inner}'`;
+	}
+	return out.join("");
+}
+function _prefixed(token) {
+	return token.kind === "word" ? `${_classPrivateFieldGet2(_prefix, this)}${token.text}` : `${token.open}${_classPrivateFieldGet2(_prefix, this)}${token.name}${token.close}`;
+}
+/** Whether the identifier at `i` names a table in DDL, DML, or neither. */
+function tablePosition(significant, i, isCreateIndex) {
+	let j = i - 1;
+	if (upper(significant[j]?.token) === "EXISTS") {
+		j -= 1;
+		if (upper(significant[j]?.token) === "NOT") j -= 1;
+		if (upper(significant[j]?.token) !== "IF") return void 0;
+		j -= 1;
+	}
+	const keyword = upper(significant[j]?.token);
+	if (DDL_KEYWORDS.has(keyword)) return "ddl";
+	if (keyword === "TO" && upper(significant[j - 1]?.token) === "RENAME") return "ddl";
+	if (keyword === "ON" && isCreateIndex) return "ddl";
+	if (DML_KEYWORDS.has(keyword)) return "dml";
+}
+function upper(token) {
+	return token?.kind === "word" ? token.text.toUpperCase() : "";
+}
+/**
+* Splits SQL into identifiers, literals, and everything else. Comments are
+* kept as whitespace so positions stay intact.
+*/
+function tokenize(sql) {
+	const tokens = [];
+	let i = 0;
+	while (i < sql.length) {
+		const char = sql[i];
+		if (/\s/.test(char)) {
+			let j = i + 1;
+			while (j < sql.length && /\s/.test(sql[j])) j++;
+			tokens.push({
+				kind: "space",
+				text: sql.slice(i, j)
+			});
+			i = j;
+		} else if (char === "-" && sql[i + 1] === "-") {
+			const end = sql.indexOf("\n", i);
+			const j = end === -1 ? sql.length : end;
+			tokens.push({
+				kind: "space",
+				text: sql.slice(i, j)
+			});
+			i = j;
+		} else if (char === "/" && sql[i + 1] === "*") {
+			const end = sql.indexOf("*/", i + 2);
+			const j = end === -1 ? sql.length : end + 2;
+			tokens.push({
+				kind: "space",
+				text: sql.slice(i, j)
+			});
+			i = j;
+		} else if (char === "'") {
+			const j = closing(sql, i, "'");
+			tokens.push({
+				kind: "string",
+				text: sql.slice(i, j)
+			});
+			i = j;
+		} else if (char === "\"" || char === "`" || char === "[") {
+			const close = char === "[" ? "]" : char;
+			const j = closing(sql, i, close);
+			const text = sql.slice(i, j);
+			const name = text.slice(1, -1).replaceAll(close === "]" ? "]]" : close + close, close);
+			tokens.push({
+				kind: "quoted",
+				text,
+				name,
+				open: char,
+				close
+			});
+			i = j;
+		} else if (/[A-Za-z_]/.test(char)) {
+			let j = i + 1;
+			while (j < sql.length && /[A-Za-z0-9_$]/.test(sql[j])) j++;
+			tokens.push({
+				kind: "word",
+				text: sql.slice(i, j)
+			});
+			i = j;
+		} else {
+			tokens.push({
+				kind: "punct",
+				text: char
+			});
+			i++;
+		}
+	}
+	return tokens;
+}
+/** The index just past the quote that closes the one at `start`. */
+function closing(sql, start, close) {
+	let j = start + 1;
+	while (j < sql.length) {
+		if (sql[j] === close) {
+			if (close !== "]" && sql[j + 1] === close) {
+				j += 2;
+				continue;
+			}
+			return j + 1;
+		}
+		j++;
+	}
+	return sql.length;
+}
+//#endregion
+//#region src/harness/opencode/harness.ts
+/** The root session's id. OpenCode session ids start with `ses`. */
+const ROOT_SESSION = "ses_root";
+/** Every table and index OpenCode creates is stored under this prefix. */
+const TABLE_PREFIX = "opencode_";
+/**
+* Longest one wake waits on OpenCode. It waits inside an alarm invocation,
+* which has a 15 minute wall-time limit, so a longer run is waited on across
+* several alarms.
+*/
+const WAIT_BUDGET_MS = 10 * 6e4;
+/**
+* The wake job's heartbeat while it waits. If the object is evicted, the job
+* is still due and its alarm restarts the object.
+*/
+const HEARTBEAT_MS = 3e4;
+/**
+* How long OpenCode stays open after the harness last used it. An open
+* OpenCode host runs periodic background work (catalog refreshes, local
+* provider discovery, cleanups) whose timers keep the object in memory, so
+* the harness closes it once nothing is running and reopens it on the next
+* call.
+*/
+const IDLE_CLOSE_MS = 3e4;
+/** Messages read per page when looking an operation up. */
+const MESSAGE_PAGE = 50;
+const WAKE_FN = "wake";
+const CLOSE_FN = "close";
+const CLOSE_JOB_ID = "opencode-close";
+function wakeJobId(session) {
+	return `opencode-wake:${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;
+}
+/** OpenCode's client errors are tagged objects; give them a message. */
+function describe(error) {
+	if (error instanceof Error) return error.message;
+	if (typeof error === "object" && error !== null) return `${"_tag" in error ? String(error._tag) : "Error"}${"message" in error && typeof error.message === "string" ? `: ${error.message}` : ""}`;
+	return String(error);
+}
+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();
+var _waitBudgetMs = /* @__PURE__ */ new WeakMap();
+var _heartbeatMs = /* @__PURE__ */ new WeakMap();
+var _idleCloseMs = /* @__PURE__ */ new WeakMap();
+var _leases = /* @__PURE__ */ new WeakMap();
+var _opening = /* @__PURE__ */ new WeakMap();
+var _OpenCodeHarness_brand = /* @__PURE__ */ new WeakSet();
+/**
+* OpenCode v2 hosted in a Durable Object, behind the same harness interface
+* as `PiHarness`: `harness.prompt()`, `harness.sessions`, `harness.session(id)`.
+* How a session reaches a client (sockets, SSE, RPC) is the host's glue,
+* built on `session.events()` and `session.log()`.
+*
+* OpenCode owns everything about a run: the transcript, the inbox of steers
+* and follow-ups, model and tool steps, retries, and crash recovery. It keeps
+* all of it in its own tables in this object's SQLite database, under the
+* `opencode_` prefix.
+*
+* What OpenCode cannot do on a Durable Object is wake itself: it resumes an
+* interrupted turn when it boots, but an evicted object does not boot until
+* something calls it. The harness is that wake, with one Lifecycle job per
+* session. Input goes to OpenCode once, in `submit()`, after the session's
+* job is scheduled. The job waits while the session runs, rescheduling itself
+* as a heartbeat, and completes when the session is idle with nothing left
+* to do. An eviction mid-run leaves the job due, so its alarm restarts the
+* object, OpenCode boots and resumes the turn, and the job waits again.
+*
+* @experimental The API may change between releases.
+*/
+var OpenCodeHarness = class extends LifecycleCapability {
+	/**
+	* @param options - How to open OpenCode, and what new sessions start with.
+	*/
+	constructor(options) {
+		super("opencode-harness");
+		_classPrivateMethodInitSpec(this, _OpenCodeHarness_brand);
+		_classPrivateFieldInitSpec(this, _options, void 0);
+		_classPrivateFieldInitSpec(this, _waits, /* @__PURE__ */ new Map());
+		_classPrivateFieldInitSpec(this, _admitting, /* @__PURE__ */ new Map());
+		_classPrivateFieldInitSpec(this, _waitBudgetMs, WAIT_BUDGET_MS);
+		_classPrivateFieldInitSpec(this, _heartbeatMs, HEARTBEAT_MS);
+		_classPrivateFieldInitSpec(this, _idleCloseMs, IDLE_CLOSE_MS);
+		_classPrivateFieldInitSpec(this, _leases, 0);
+		_classPrivateFieldInitSpec(this, _opening, void 0);
+		_classPrivateFieldSet2(_options, this, options);
+		this.sessions = new OpenCodeSessions(this);
+	}
+	/** Open OpenCode, which resumes interrupted turns, and wake running sessions. */
+	async onStart(_context) {
+		const opencode = await _assertClassBrand(_OpenCodeHarness_brand, this, _open).call(this);
+		for (const session of Object.keys(await opencode.sessions.active())) await _assertClassBrand(_OpenCodeHarness_brand, this, _wake).call(this, session);
+		await _assertClassBrand(_OpenCodeHarness_brand, this, _scheduleClose).call(this);
+	}
+	/** Run one step of a session's wake job. */
+	async onJob(context) {
+		if (context.job.fn === CLOSE_FN) return _assertClassBrand(_OpenCodeHarness_brand, this, _closeStep).call(this);
+		if (context.job.fn !== WAKE_FN) return;
+		const session = sessionOfJob(context.job.payload);
+		if (session !== void 0) return _assertClassBrand(_OpenCodeHarness_brand, this, _wakeStep).call(this, session);
+	}
+	/** Close OpenCode's in-memory resources. Durable state is untouched. */
+	async dispose() {
+		const opening = _classPrivateFieldGet2(_opening, this);
+		_classPrivateFieldSet2(_opening, this, void 0);
+		await (await opening?.catch(() => void 0))?.close();
+	}
+	/**
+	* A handle on one session. No I/O until you call it.
+	*
+	* @param id - The session; default the root session.
+	*/
+	session(id = ROOT_SESSION) {
+		return new OpenCodeSession(this, id);
+	}
+	/** Submit a prompt and wait for its answer. */
+	prompt(input, options = {}) {
+		return this.session(options.session).prompt(input, options);
+	}
+	/** Durably submit a prompt. Resolves before the model runs. */
+	submit(input, options = {}) {
+		return this.session(options.session).submit(input, options);
+	}
+	/** Stop one operation, or everything running in a session. */
+	abort(options = {}) {
+		return this.session(options.session).abort(options.operationId);
+	}
+	/** Wait for an operation to settle. Aborting `signal` stops only the wait. */
+	wait(operationId, options = {}) {
+		return this.session(options.session).wait(operationId, options.signal);
+	}
+	/** The session's active transcript, as OpenCode's messages. */
+	messages(options = {}) {
+		return this.session(options.session).messages();
+	}
+	/** Submissions OpenCode has not settled yet, oldest first. */
+	pending(options = {}) {
+		return this.use((opencode) => _assertClassBrand(_OpenCodeHarness_brand, this, _pending).call(this, opencode, options.session));
+	}
+	/**
+	* The opened OpenCode host, for anything the interface does not cover.
+	* The harness closes an idle host, so call this again each time rather
+	* than keeping the result; work done through it does not keep it open.
+	*/
+	opencode() {
+		return this.use(async (opencode) => opencode);
+	}
+	/**
+	* @internal Run `call` with OpenCode open. The host is not closed while
+	* any call holds it.
+	*/
+	async use(call) {
+		const release = this.lease();
+		try {
+			return await call(await _assertClassBrand(_OpenCodeHarness_brand, this, _open).call(this));
+		} finally {
+			await release();
+		}
+	}
+	/**
+	* @internal Hold OpenCode open until the returned release is called, for
+	* work that outlives one call, such as an event stream.
+	*/
+	lease() {
+		_classPrivateFieldSet2(_leases, this, _classPrivateFieldGet2(_leases, this) + 1);
+		let released = false;
+		return async () => {
+			if (released) return;
+			released = true;
+			_classPrivateFieldSet2(_leases, this, _classPrivateFieldGet2(_leases, this) - 1);
+			if (_classPrivateFieldGet2(_leases, this) === 0) await _assertClassBrand(_OpenCodeHarness_brand, this, _scheduleClose).call(this);
+		};
+	}
+	/** @internal Admit an input to OpenCode once, behind the session's wake. */
+	async enqueue(session, input, options) {
+		const operationId = options.operationId ?? crypto.randomUUID();
+		const messageId = messageIdOf(operationId);
+		return this.use(async (opencode) => {
+			const content = typeof input === "string" ? { text: input } : input;
+			_classPrivateFieldGet2(_admitting, this).set(session, (_classPrivateFieldGet2(_admitting, this).get(session) ?? 0) + 1);
+			let accepted;
+			try {
+				await _assertClassBrand(_OpenCodeHarness_brand, this, _wake).call(this, session);
+				accepted = !await _assertClassBrand(_OpenCodeHarness_brand, this, _known).call(this, opencode, session, messageId);
+				await _assertClassBrand(_OpenCodeHarness_brand, this, _call).call(this, () => opencode.sessions.prompt({
+					...content,
+					sessionID: session,
+					id: messageId,
+					delivery: options.whenBusy === "steer" ? "steer" : "queue",
+					resume: true
+				}));
+			} finally {
+				const left = (_classPrivateFieldGet2(_admitting, this).get(session) ?? 1) - 1;
+				if (left === 0) _classPrivateFieldGet2(_admitting, this).delete(session);
+				else _classPrivateFieldGet2(_admitting, this).set(session, left);
+			}
+			await _assertClassBrand(_OpenCodeHarness_brand, this, _wake).call(this, session);
+			return {
+				operationId,
+				session,
+				accepted
+			};
+		});
+	}
+	/** @internal Withdraw a queued input, or interrupt the run it joined. */
+	async withdraw(session, operationId) {
+		const messageId = messageIdOf(operationId);
+		return this.use(async (opencode) => {
+			switch ((await _assertClassBrand(_OpenCodeHarness_brand, this, _state).call(this, opencode, session, messageId))._tag) {
+				case "queued":
+					await _assertClassBrand(_OpenCodeHarness_brand, this, _call).call(this, () => opencode.sessions.inbox.cancel({
+						sessionID: session,
+						inboxID: messageId
+					}));
+					return true;
+				case "running": return (await _assertClassBrand(_OpenCodeHarness_brand, this, _call).call(this, () => opencode.sessions.interrupt({ sessionID: session }))).interrupted;
+				case "missing":
+				case "settled": return false;
+			}
+		});
+	}
+	/** @internal Withdraw every queued input and interrupt the running work. */
+	interrupt(session) {
+		return this.use(async (opencode) => {
+			for (const item of await _assertClassBrand(_OpenCodeHarness_brand, this, _call).call(this, () => opencode.sessions.inbox.list({ sessionID: session }))) await _assertClassBrand(_OpenCodeHarness_brand, this, _call).call(this, () => opencode.sessions.inbox.cancel({
+				sessionID: session,
+				inboxID: item.id
+			}));
+			await _assertClassBrand(_OpenCodeHarness_brand, this, _call).call(this, () => opencode.sessions.interrupt({ sessionID: session }));
+		});
+	}
+	/** @internal Wait for OpenCode to settle an operation, by its id. */
+	async settled(session, operationId, signal) {
+		const messageId = messageIdOf(operationId);
+		return this.use(async (opencode) => {
+			for (;;) {
+				signal?.throwIfAborted();
+				const state = await _assertClassBrand(_OpenCodeHarness_brand, this, _state).call(this, opencode, session, messageId);
+				switch (state._tag) {
+					case "missing": return {
+						operationId,
+						session,
+						status: "unanswered",
+						reason: "not_found"
+					};
+					case "settled": return state.outcome === "succeeded" ? {
+						operationId,
+						session,
+						status: "done",
+						text: state.text
+					} : {
+						operationId,
+						session,
+						status: "unanswered",
+						reason: state.outcome === "failed" ? state.error ?? "failed" : "interrupted"
+					};
+					case "queued":
+					case "running":
+						await _assertClassBrand(_OpenCodeHarness_brand, this, _call).call(this, () => opencode.sessions.wait({ sessionID: session }, signal ? { signal } : void 0));
+						if ((await opencode.sessions.active())[session] === void 0) {
+							await _assertClassBrand(_OpenCodeHarness_brand, this, _wake).call(this, session);
+							await delay(_classPrivateFieldGet2(_heartbeatMs, this) / 30, signal);
+						}
+				}
+			}
+		});
+	}
+	/** @internal Create a session with the harness defaults. */
+	async create(options = {}) {
+		return this.use((opencode) => _assertClassBrand(_OpenCodeHarness_brand, this, _createSession).call(this, opencode, options.id));
+	}
+};
+async function _pending(opencode, only) {
+	const sessions = only === void 0 ? (await listSessions(opencode)).map((info) => info.id) : [only];
+	const active = await opencode.sessions.active();
+	const pending = [];
+	for (const session of sessions) {
+		if (active[session] !== void 0 || await unsettled(opencode, session)) for (const operationId of await _assertClassBrand(_OpenCodeHarness_brand, this, _running).call(this, opencode, session)) pending.push({
+			operationId,
+			session,
+			status: "running"
+		});
+		for (const item of await opencode.sessions.inbox.list({ sessionID: session })) pending.push({
+			operationId: operationIdOf(item.id),
+			session,
+			status: "queued"
+		});
+	}
+	return pending;
+}
+/** Call OpenCode, turning its tagged errors into `Error`s. */
+async function _call(call) {
+	try {
+		return await call();
+	} catch (error) {
+		if (error instanceof Error) throw error;
+		throw new Error(`OpenCode: ${describe(error)}`, { cause: error });
+	}
+}
+/** The session's info, or undefined when it does not exist. */
+async function _info(opencode, session) {
+	try {
+		return await opencode.sessions.get({ sessionID: session });
+	} catch (error) {
+		if (isTagged(error, "SessionNotFoundError")) return void 0;
+		throw new Error(`OpenCode: ${describe(error)}`, { cause: error });
+	}
+}
+async function _createSession(opencode, id) {
+	const defaults = _classPrivateFieldGet2(_options, this).defaults;
+	return (await _assertClassBrand(_OpenCodeHarness_brand, this, _call).call(this, () => opencode.sessions.create({
+		...id === void 0 ? {} : { id },
+		...defaults?.model === void 0 ? {} : { model: {
+			providerID: defaults.model.providerID,
+			id: defaults.model.id
+		} },
+		...defaults?.agent === void 0 ? {} : { agent: defaults.agent }
+	}))).id;
+}
+/** Schedule the session's wake job now, or pull it forward. */
+function _wake(session, time = Date.now()) {
+	return this.lifecycle.jobs.push({
+		id: wakeJobId(session),
+		fn: WAKE_FN,
+		time,
+		payload: { session },
+		singleflight: true,
+		recoveryLoop: true
+	});
+}
+/**
+* One run of a session's wake job. It never admits anything new: it waits
+* while the session runs and completes when it is idle with nothing left
+* to do. OpenCode does all the work in between.
+*/
+async function _wakeStep(session) {
+	const heartbeat = { rescheduleAt: Date.now() + _classPrivateFieldGet2(_heartbeatMs, this) };
+	if (_classPrivateFieldGet2(_waits, this).has(session)) return heartbeat;
+	const opencode = await _assertClassBrand(_OpenCodeHarness_brand, this, _open).call(this);
+	if (await _assertClassBrand(_OpenCodeHarness_brand, this, _info).call(this, opencode, session) === void 0) return void 0;
+	const inbox = await opencode.sessions.inbox.list({ sessionID: session });
+	const open = await unsettled(opencode, session);
+	if (!((await opencode.sessions.active())[session] !== void 0)) {
+		const first = inbox.find((item) => item.type !== "move");
+		if (first !== void 0) await _assertClassBrand(_OpenCodeHarness_brand, this, _ring).call(this, opencode, session, first);
+		else if (open) return heartbeat;
+		else return _classPrivateFieldGet2(_admitting, this).has(session) ? heartbeat : void 0;
+	}
+	const wait = _assertClassBrand(_OpenCodeHarness_brand, this, _waitForIdle).call(this, opencode, session).finally(() => {
+		_classPrivateFieldGet2(_waits, this).delete(session);
+		_assertClassBrand(_OpenCodeHarness_brand, this, _wake).call(this, session);
+	});
+	_classPrivateFieldGet2(_waits, this).set(session, wait);
+	this.lifecycle.trackAlarmWork(wait);
+	return heartbeat;
+}
+async function _waitForIdle(opencode, session) {
+	const budget = new AbortController();
+	const timer = setTimeout(() => budget.abort(), _classPrivateFieldGet2(_waitBudgetMs, this));
+	try {
+		await opencode.sessions.wait({ sessionID: session }, { signal: budget.signal });
+	} catch (error) {
+		if (!budget.signal.aborted) this.lifecycle.events.emit("opencode:wake_error", {
+			session,
+			error: describe(error)
+		});
+	} finally {
+		clearTimeout(timer);
+	}
+}
+/** Re-admit an inbox item by its id, which starts the session again. */
+async function _ring(opencode, session, item) {
+	switch (item.type) {
+		case "user":
+			await opencode.sessions.prompt({
+				text: item.payload.text,
+				sessionID: session,
+				id: item.id,
+				delivery: item.delivery,
+				resume: true
+			});
+			return;
+		case "synthetic":
+			await opencode.sessions.synthetic({
+				text: item.payload.text,
+				sessionID: session,
+				id: item.id,
+				delivery: item.delivery,
+				resume: true
+			});
+			return;
+		case "compaction":
+			await opencode.sessions.compact({
+				sessionID: session,
+				id: item.id,
+				delivery: item.delivery
+			});
+			return;
+		case "move": return;
+	}
+}
+/** Schedule the idle close, unless one is already due late enough. */
+async function _scheduleClose() {
+	const time = Date.now() + _classPrivateFieldGet2(_idleCloseMs, this);
+	const pending = this.lifecycle.jobs.get(CLOSE_JOB_ID);
+	if (pending !== void 0 && pending.time >= time - _classPrivateFieldGet2(_idleCloseMs, this) / 2) return;
+	await this.lifecycle.jobs.push({
+		id: CLOSE_JOB_ID,
+		fn: CLOSE_FN,
+		time,
+		payload: {},
+		singleflight: true
+	});
+}
+/** Close OpenCode if nothing is using it or running in it. */
+async function _closeStep() {
+	const opening = _classPrivateFieldGet2(_opening, this);
+	if (opening === void 0) return void 0;
+	const later = { rescheduleAt: Date.now() + _classPrivateFieldGet2(_idleCloseMs, this) };
+	const busy = () => _classPrivateFieldGet2(_leases, this) > 0 || _classPrivateFieldGet2(_waits, this).size > 0 || _classPrivateFieldGet2(_admitting, this).size > 0 || this.lifecycle.jobs.list().some((job) => job.fn === WAKE_FN);
+	if (busy()) return later;
+	const opencode = await opening.catch(() => void 0);
+	if (opencode === void 0) return void 0;
+	if (Object.keys(await opencode.sessions.active()).length > 0) return later;
+	if (busy() || _classPrivateFieldGet2(_opening, this) !== opening) return later;
+	_classPrivateFieldSet2(_opening, this, void 0);
+	await opencode.close();
+}
+/**
+* OpenCode, opened. Waits for Lifecycle startup first, so it is only ever
+* opened inside it: startup holds the input gate (`blockConcurrencyWhile`)
+* and awaits the open in `onStart`, so an open begun before startup would
+* be awaited behind a closed gate and never finish.
+*/
+async function _open() {
+	await this.lifecycle.ready();
+	_classPrivateFieldGet2(_opening, this) ?? _classPrivateFieldSet2(_opening, this, _assertClassBrand(_OpenCodeHarness_brand, this, _doOpen).call(this).catch((error) => {
+		_classPrivateFieldSet2(_opening, this, void 0);
+		throw error;
+	}));
+	return _classPrivateFieldGet2(_opening, this);
+}
+async function _doOpen() {
+	const storage = prefixTables(this.lifecycle.storage, TABLE_PREFIX);
+	const opencode = await _classPrivateFieldGet2(_options, this).opencode({ storage });
+	try {
+		await opencode.sessions.get({ sessionID: ROOT_SESSION });
+	} catch (error) {
+		if (!isTagged(error, "SessionNotFoundError")) {
+			await opencode.close();
+			throw new Error(`OpenCode: ${describe(error)}`, { cause: error });
+		}
+		await _assertClassBrand(_OpenCodeHarness_brand, this, _createSession).call(this, opencode, ROOT_SESSION);
+	}
+	return opencode;
+}
+/** Whether OpenCode has the message, as an inbox item or in the transcript. */
+async function _known(opencode, session, messageId) {
+	return (await _assertClassBrand(_OpenCodeHarness_brand, this, _state).call(this, opencode, session, messageId))._tag !== "missing";
+}
+/**
+* Where an operation is. Reads the transcript newest first, back to the
+* operation's message, then finds the first idle marker after it: the end
+* of the run that answered it.
+*/
+async function _state(opencode, session, messageId) {
+	if ((await _assertClassBrand(_OpenCodeHarness_brand, this, _call).call(this, () => opencode.sessions.inbox.list({ sessionID: session }))).some((item) => item.id === messageId)) return { _tag: "queued" };
+	const after = await _assertClassBrand(_OpenCodeHarness_brand, this, _messagesAfter).call(this, opencode, session, messageId);
+	if (after === void 0) return { _tag: "missing" };
+	let last;
+	for (const message of after) {
+		if (message.type === "idle") return settledState(message.outcome, last);
+		if (message.type === "user" && last !== void 0) return settledState("succeeded", last);
+		if (message.type === "assistant") last = message;
+	}
+	return { _tag: "running" };
+}
+/**
+* The messages after `messageId`, oldest first, or undefined when the
+* transcript has no such message.
+*/
+async function _messagesAfter(opencode, session, messageId) {
+	const newer = [];
+	let cursor;
+	for (;;) {
+		const page = await _assertClassBrand(_OpenCodeHarness_brand, this, _call).call(this, () => opencode.message.list(cursor === void 0 ? {
+			sessionID: session,
+			order: "desc",
+			limit: MESSAGE_PAGE
+		} : {
+			sessionID: session,
+			cursor
+		}));
+		for (const message of page.data) {
+			if (message.id === messageId) return newer.reverse();
+			newer.push(message);
+		}
+		const next = page.cursor.next;
+		if (next === void 0 || next === null) return void 0;
+		cursor = next;
+	}
+}
+/**
+* Operations the running turn is answering: the newest user messages, back
+* to the assistant message or idle marker before them. Earlier inputs of
+* the same run already have their answer.
+*/
+async function _running(opencode, session) {
+	const running = [];
+	let cursor;
+	for (;;) {
+		const page = await _assertClassBrand(_OpenCodeHarness_brand, this, _call).call(this, () => opencode.message.list(cursor === void 0 ? {
+			sessionID: session,
+			order: "desc",
+			limit: MESSAGE_PAGE
+		} : {
+			sessionID: session,
+			cursor
+		}));
+		for (const message of page.data) if (message.type === "user") running.push(operationIdOf(message.id));
+		else if (message.type === "idle" || message.type === "assistant" && running.length > 0) return running.reverse();
+		const next = page.cursor.next;
+		if (next === void 0 || next === null) return running.reverse();
+		cursor = next;
+	}
+}
+/**
+* Whether the transcript ends in a turn with no idle marker after it: a run
+* in progress, or one a restart cut off that OpenCode resumes on boot.
+*/
+async function unsettled(opencode, session) {
+	let cursor;
+	for (;;) {
+		const page = await opencode.message.list(cursor === void 0 ? {
+			sessionID: session,
+			order: "desc",
+			limit: MESSAGE_PAGE
+		} : {
+			sessionID: session,
+			cursor
+		});
+		for (const message of page.data) {
+			if (message.type === "idle") return false;
+			if (message.type === "user" || message.type === "synthetic") return true;
+		}
+		const next = page.cursor.next;
+		if (next === void 0 || next === null) return false;
+		cursor = next;
+	}
+}
+/**
+* Whether the session has work: running, input waiting in its inbox, or a
+* turn a restart cut off, which OpenCode resumes in the background on boot
+* and so is not running yet.
+*/
+async function sessionBusy(opencode, session, active) {
+	if (active[session] !== void 0) return true;
+	return (await opencode.sessions.inbox.list({ sessionID: session })).length > 0 || await unsettled(opencode, session);
+}
+/** Every session, with whether it has work. */
+async function listSessions(opencode) {
+	const active = await opencode.sessions.active();
+	const sessions = [];
+	let cursor;
+	for (;;) {
+		const page = await opencode.sessions.list(cursor === void 0 ? {} : { cursor });
+		for (const info of page.data) {
+			const parent = info.fork?.sessionID ?? info.parentID;
+			sessions.push({
+				id: info.id,
+				...parent === void 0 ? {} : { parent },
+				...info.title === void 0 ? {} : { title: info.title },
+				busy: await sessionBusy(opencode, info.id, active)
+			});
+		}
+		const next = page.cursor.next;
+		if (next === void 0 || next === null) return sessions;
+		cursor = next;
+	}
+}
+/** An operation's end, from the last assistant message of its run. */
+function settledState(outcome, last) {
+	const error = last?.type === "assistant" ? last.error?.message : void 0;
+	return {
+		_tag: "settled",
+		outcome: error !== void 0 && outcome === "succeeded" ? "failed" : outcome,
+		text: textOf(last),
+		error
+	};
+}
+/** Resolve after `ms`, or reject when `signal` aborts. */
+function delay(ms, signal) {
+	return new Promise((resolve, reject) => {
+		const timer = setTimeout(resolve, ms);
+		signal?.addEventListener("abort", () => {
+			clearTimeout(timer);
+			reject(signal.reason);
+		}, { once: true });
+	});
+}
+var _harness = /* @__PURE__ */ new WeakMap();
+/** One OpenCode session, addressed through the harness. */
+var OpenCodeSession = class {
+	/**
+	* @param harness - The harness that hosts the session.
+	* @param id - The session's id.
+	*/
+	constructor(harness, id) {
+		_classPrivateFieldInitSpec(this, _harness, void 0);
+		_classPrivateFieldSet2(_harness, this, harness);
+		this.id = id;
+	}
+	/** Durably submit a prompt. Resolves before the model runs. */
+	submit(input, options = {}) {
+		return _classPrivateFieldGet2(_harness, this).enqueue(this.id, input, options);
+	}
+	/** Submit and wait for the answer and the updated transcript. */
+	async prompt(input, options = {}) {
+		const receipt = await this.submit(input, options);
+		return {
+			...await this.wait(receipt.operationId),
+			messages: await this.messages()
+		};
+	}
+	/** Join the running work at its next step. */
+	steer(input, options = {}) {
+		return this.submit(input, {
+			...options,
+			whenBusy: "steer"
+		});
+	}
+	/** Wait for an operation to settle. Aborting `signal` stops only the wait. */
+	wait(operationId, signal) {
+		return _classPrivateFieldGet2(_harness, this).settled(this.id, operationId, signal);
+	}
+	/**
+	* Withdraw one queued operation (or interrupt the run it joined), or, with
+	* no id, abort the session: OpenCode's queued inputs are withdrawn and the
+	* running work is interrupted.
+	*/
+	async abort(operationId) {
+		if (operationId !== void 0) return _classPrivateFieldGet2(_harness, this).withdraw(this.id, operationId);
+		await _classPrivateFieldGet2(_harness, this).interrupt(this.id);
+		return true;
+	}
+	/** Change this session's model; `agents/models/opencode` makes them. */
+	async setModel(model) {
+		await _classPrivateFieldGet2(_harness, this).use((opencode) => opencode.sessions.switchModel({
+			sessionID: this.id,
+			model: {
+				providerID: model.providerID,
+				id: model.id
+			}
+		}));
+	}
+	/** Change this session's OpenCode agent, such as `build` or `plan`. */
+	async setAgent(agent) {
+		await _classPrivateFieldGet2(_harness, this).use((opencode) => opencode.sessions.switchAgent({
+			sessionID: this.id,
+			agent
+		}));
+	}
+	/** The active transcript: OpenCode's messages since the newest compaction. */
+	async messages() {
+		return _classPrivateFieldGet2(_harness, this).use((opencode) => opencode.sessions.context({ sessionID: this.id }));
+	}
+	/**
+	* The whole transcript, oldest first, compacted messages included.
+	* OpenCode compacts a long session on its own; `messages()` is what the
+	* model sees after that, this is everything the session has said.
+	*/
+	history() {
+		return _classPrivateFieldGet2(_harness, this).use(async (opencode) => {
+			const messages = [];
+			let cursor;
+			for (;;) {
+				const page = await opencode.message.list(cursor === void 0 ? {
+					sessionID: this.id,
+					order: "asc",
+					limit: 100
+				} : {
+					sessionID: this.id,
+					cursor
+				});
+				messages.push(...page.data);
+				const next = page.cursor.next;
+				if (next === void 0 || next === null) return messages;
+				cursor = next;
+			}
+		});
+	}
+	/**
+	* 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.
+	*/
+	async *events(signal) {
+		const release = _classPrivateFieldGet2(_harness, this).lease();
+		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 {
+			await release();
+		}
+	}
+	/**
+	* The session's durable events after sequence number `after` (from the
+	* start by default), then, with `follow`, new ones as they are committed,
+	* until `signal` aborts.
+	*/
+	async *log(options = {}) {
+		const release = _classPrivateFieldGet2(_harness, this).lease();
+		try {
+			yield* (await _classPrivateFieldGet2(_harness, this).opencode()).sessions.log({
+				sessionID: this.id,
+				...options.after === void 0 ? {} : { after: options.after },
+				...options.follow === void 0 ? {} : { follow: options.follow }
+			}, options.signal ? { signal: options.signal } : void 0);
+		} finally {
+			await release();
+		}
+	}
+	/**
+	* Whether the session has work: running, input waiting, or a turn a
+	* restart cut off that OpenCode is about to resume.
+	*/
+	async busy() {
+		return _classPrivateFieldGet2(_harness, this).use(async (opencode) => sessionBusy(opencode, this.id, await opencode.sessions.active()));
+	}
+};
+var _harness2 = /* @__PURE__ */ new WeakMap();
+/** Every OpenCode session in this object. */
+var OpenCodeSessions = class {
+	/** @param harness - The harness that hosts the sessions. */
+	constructor(harness) {
+		_classPrivateFieldInitSpec(this, _harness2, void 0);
+		_classPrivateFieldSet2(_harness2, this, harness);
+	}
+	/** A handle on one session. No I/O until you call it. */
+	get(id) {
+		return _classPrivateFieldGet2(_harness2, this).session(id);
+	}
+	/** A new top-level session, configured like the root. */
+	async create() {
+		return _classPrivateFieldGet2(_harness2, this).session(await _classPrivateFieldGet2(_harness2, this).create());
+	}
+	/** A new session that sees `from`'s history up to now. */
+	async fork(from) {
+		const fork = await _classPrivateFieldGet2(_harness2, this).use((opencode) => opencode.sessions.fork({ sessionID: from }));
+		return _classPrivateFieldGet2(_harness2, this).session(fork.id);
+	}
+	/** Every session, including subagent sessions OpenCode spawned. */
+	list() {
+		return _classPrivateFieldGet2(_harness2, this).use(listSessions);
+	}
+};
+//#endregion
+export { OpenCodeHarness, OpenCodeSession, OpenCodeSessions, ROOT_SESSION };
+
+//# sourceMappingURL=index.js.map