agents 0.24.0 → 0.26.0

package/dist/harness/pi/index.js

@@ -0,0 +1,873 @@
+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 { LiveDoc, ROOT_CONVERSATION_ID, watchEvents } from "@earendil-works/pi-durable";
+import { SQLITE_MIGRATIONS, SqliteStorage } from "@earendil-works/pi-durable/storage/sqlite";
+import { Type } from "@earendil-works/pi-ai";
+//#region src/harness/pi/context.ts
+/** chord's `BACKGROUND_CONTEXT`: no values, never cancelled. */
+const BACKGROUND_CONTEXT = Object.freeze({
+	abortSignal: void 0,
+	value: () => void 0,
+	toString: () => "[Context pi-harness background]"
+});
+/**
+* chord's `withAbortSignal`: a context cancelled by either the parent's
+* signal or `signal`, carrying the parent's values.
+*/
+function withAbortSignal(signal, parent) {
+	const abortSignal = parent.abortSignal === void 0 ? signal : AbortSignal.any([parent.abortSignal, signal]);
+	return Object.freeze({
+		abortSignal,
+		value: parent.value.bind(parent),
+		toString: () => `${parent}.WithAbortSignal`
+	});
+}
+//#endregion
+//#region src/harness/pi/session-store.ts
+const DEFAULT_PREFIX = "pi_";
+/** Open pi-durable's storage over this object's SQLite database. */
+function openPiSessionStore(storage, options = {}) {
+	return SqliteStorage.open(new DurableObjectSqliteDatabase(storage, options));
+}
+/** Names pi's migrations create: every table and index, in any version. */
+function schemaNames() {
+	const names = /* @__PURE__ */ new Set(["durable_schema"]);
+	const pattern = /\bCREATE\s+(?:UNIQUE\s+)?(?:TABLE|INDEX)\s+(?:IF\s+NOT\s+EXISTS\s+)?([A-Za-z_][A-Za-z0-9_]*)/gi;
+	for (const migration of SQLITE_MIGRATIONS) for (const statement of migration.statements) for (const match of statement.matchAll(pattern)) names.add(match[1]);
+	return [...names];
+}
+var _pattern = /* @__PURE__ */ new WeakMap();
+var _prefix = /* @__PURE__ */ new WeakMap();
+var _cache = /* @__PURE__ */ new WeakMap();
+/**
+* Rewrites pi's schema identifiers outside string literals. Identifiers are
+* matched on word boundaries, so column names such as `record_type` or
+* `document_id` are left alone.
+*/
+var Prefixer = class {
+	constructor(prefix) {
+		_classPrivateFieldInitSpec(this, _pattern, void 0);
+		_classPrivateFieldInitSpec(this, _prefix, void 0);
+		_classPrivateFieldInitSpec(this, _cache, /* @__PURE__ */ new Map());
+		if (!/^[A-Za-z][A-Za-z0-9_]*$/.test(prefix)) throw new Error(`Invalid pi session store prefix ${JSON.stringify(prefix)}`);
+		if (prefix.startsWith("_cf_")) throw new Error("The pi session store prefix must not start with _cf_");
+		_classPrivateFieldSet2(_prefix, this, prefix);
+		_classPrivateFieldSet2(_pattern, this, new RegExp(`\\b(${schemaNames().join("|")})\\b`, "g"));
+	}
+	rewrite(sql) {
+		const cached = _classPrivateFieldGet2(_cache, this).get(sql);
+		if (cached !== void 0) return cached;
+		const rewritten = sql.split(/('(?:[^']|'')*')/).map((part, index) => index % 2 === 1 ? part : part.replace(_classPrivateFieldGet2(_pattern, this), (name) => `${_classPrivateFieldGet2(_prefix, this)}${name}`)).join("");
+		_classPrivateFieldGet2(_cache, this).set(sql, rewritten);
+		return rewritten;
+	}
+};
+/** Durable Objects bind strings, numbers, null, and ArrayBuffers. */
+function binding(value) {
+	if (typeof value === "bigint") {
+		if (value > BigInt(Number.MAX_SAFE_INTEGER) || value < BigInt(Number.MIN_SAFE_INTEGER)) throw new RangeError(`SQLite integer ${value} is outside the safe range`);
+		return Number(value);
+	}
+	if (value instanceof Uint8Array) return value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength);
+	return value;
+}
+/** Blobs come back as ArrayBuffers; pi's contract reads Uint8Arrays. */
+function row(raw) {
+	for (const key of Object.keys(raw)) {
+		const value = raw[key];
+		if (value instanceof ArrayBuffer) raw[key] = new Uint8Array(value);
+	}
+	return raw;
+}
+var _tail = /* @__PURE__ */ new WeakMap();
+var _pending = /* @__PURE__ */ new WeakMap();
+var _OperationQueue_brand = /* @__PURE__ */ new WeakSet();
+/**
+* Orders calls on the one SQLite connection. A statement runs at once,
+* directly, when nothing is waiting; while a transaction is open, it and
+* every call after it wait, in call order, for the transaction to settle,
+* so none runs inside it. A failure does not stop the calls behind it.
+*
+* The queue holds calls, not data: a caller has no result until its call
+* runs, so an isolate that dies loses only calls nobody has seen succeed,
+* as it would without the queue. pi's transactions await only their own
+* synchronous statements, so a transaction holds the queue for microtasks,
+* never for I/O.
+*/
+var OperationQueue = class {
+	constructor() {
+		_classPrivateMethodInitSpec(this, _OperationQueue_brand);
+		_classPrivateFieldInitSpec(this, _tail, Promise.resolve());
+		_classPrivateFieldInitSpec(this, _pending, 0);
+	}
+	/** A synchronous statement: runs now unless something is ahead of it. */
+	run(statement) {
+		if (_classPrivateFieldGet2(_pending, this) > 0) return _assertClassBrand(_OperationQueue_brand, this, _enqueue).call(this, statement);
+		try {
+			return Promise.resolve(statement());
+		} catch (error) {
+			return Promise.reject(error);
+		}
+	}
+	/** An asynchronous call that holds the queue until it settles. */
+	hold(call) {
+		return _assertClassBrand(_OperationQueue_brand, this, _enqueue).call(this, call);
+	}
+};
+function _enqueue(call) {
+	_classPrivateFieldSet2(_pending, this, _classPrivateFieldGet2(_pending, this) + 1);
+	const settled = _classPrivateFieldGet2(_tail, this).then(call).finally(() => {
+		_classPrivateFieldSet2(_pending, this, _classPrivateFieldGet2(_pending, this) - 1);
+	});
+	_classPrivateFieldSet2(_tail, this, settled.then(() => void 0, () => void 0));
+	return settled;
+}
+var _sql = /* @__PURE__ */ new WeakMap();
+var _prefixer = /* @__PURE__ */ new WeakMap();
+/** One statement on a Durable Object's synchronous SQL API. */
+var Statements = class {
+	constructor(sql, prefixer) {
+		_classPrivateFieldInitSpec(this, _sql, void 0);
+		_classPrivateFieldInitSpec(this, _prefixer, void 0);
+		_classPrivateFieldSet2(_sql, this, sql);
+		_classPrivateFieldSet2(_prefixer, this, prefixer);
+	}
+	exec(sql) {
+		_classPrivateFieldGet2(_sql, this).exec(_classPrivateFieldGet2(_prefixer, this).rewrite(sql));
+	}
+	run(sql, params) {
+		_classPrivateFieldGet2(_sql, this).exec(_classPrivateFieldGet2(_prefixer, this).rewrite(sql), ...params.map(binding));
+	}
+	get(sql, params) {
+		const first = _classPrivateFieldGet2(_sql, this).exec(_classPrivateFieldGet2(_prefixer, this).rewrite(sql), ...params.map(binding)).next();
+		return first.done ? void 0 : row(first.value);
+	}
+	all(sql, params) {
+		return _classPrivateFieldGet2(_sql, this).exec(_classPrivateFieldGet2(_prefixer, this).rewrite(sql), ...params.map(binding)).toArray().map((raw) => row(raw));
+	}
+};
+var _statements = /* @__PURE__ */ new WeakMap();
+var _active = /* @__PURE__ */ new WeakMap();
+var _DurableObjectSqliteTransaction_brand = /* @__PURE__ */ new WeakSet();
+/**
+* The handle pi's transaction callback gets. It runs statements directly:
+* the transaction holds the database's queue for as long as it is open.
+*/
+var DurableObjectSqliteTransaction = class {
+	constructor(statements) {
+		_classPrivateMethodInitSpec(this, _DurableObjectSqliteTransaction_brand);
+		_classPrivateFieldInitSpec(this, _statements, void 0);
+		_classPrivateFieldInitSpec(this, _active, true);
+		_classPrivateFieldSet2(_statements, this, statements);
+	}
+	/** Called once the transaction settles; the handle is unusable after. */
+	end() {
+		_classPrivateFieldSet2(_active, this, false);
+	}
+	async exec(sql) {
+		_assertClassBrand(_DurableObjectSqliteTransaction_brand, this, _assertActive).call(this);
+		_classPrivateFieldGet2(_statements, this).exec(sql);
+	}
+	async run(sql, ...params) {
+		_assertClassBrand(_DurableObjectSqliteTransaction_brand, this, _assertActive).call(this);
+		_classPrivateFieldGet2(_statements, this).run(sql, params);
+	}
+	async get(sql, ...params) {
+		_assertClassBrand(_DurableObjectSqliteTransaction_brand, this, _assertActive).call(this);
+		return _classPrivateFieldGet2(_statements, this).get(sql, params);
+	}
+	async all(sql, ...params) {
+		_assertClassBrand(_DurableObjectSqliteTransaction_brand, this, _assertActive).call(this);
+		return _classPrivateFieldGet2(_statements, this).all(sql, params);
+	}
+};
+function _assertActive() {
+	if (!_classPrivateFieldGet2(_active, this)) throw new Error("The pi SQLite transaction is no longer active");
+}
+var _storage = /* @__PURE__ */ new WeakMap();
+var _statements2 = /* @__PURE__ */ new WeakMap();
+var _queue = /* @__PURE__ */ new WeakMap();
+/**
+* pi's `SqliteDatabase` facade over `DurableObjectStorage`.
+*
+* Durable Object SQL is synchronous, but pi's facade is asynchronous and a
+* transaction's callback awaits between statements. A statement issued
+* outside the transaction while it waits would run inside it: it would see
+* uncommitted rows, and roll back with it. pi's contract therefore has the
+* adapter queue every other call until the transaction settles: every
+* call goes through one `OperationQueue`, which runs a statement at once
+* when no transaction is open. As the contract says, a call on the database from inside a
+* transaction's callback waits for that transaction and never settles; the
+* callback must use its handle.
+*
+* Transactions run in `storage.transaction()`, which rolls back when the
+* callback rejects and rejects with the same error.
+*/
+var DurableObjectSqliteDatabase = class {
+	constructor(storage, options = {}) {
+		_classPrivateFieldInitSpec(this, _storage, void 0);
+		_classPrivateFieldInitSpec(this, _statements2, void 0);
+		_classPrivateFieldInitSpec(this, _queue, new OperationQueue());
+		_classPrivateFieldSet2(_storage, this, storage);
+		_classPrivateFieldSet2(_statements2, this, new Statements(storage.sql, new Prefixer(options.prefix ?? DEFAULT_PREFIX)));
+	}
+	exec(sql) {
+		return _classPrivateFieldGet2(_queue, this).run(() => _classPrivateFieldGet2(_statements2, this).exec(sql));
+	}
+	run(sql, ...params) {
+		return _classPrivateFieldGet2(_queue, this).run(() => _classPrivateFieldGet2(_statements2, this).run(sql, params));
+	}
+	get(sql, ...params) {
+		return _classPrivateFieldGet2(_queue, this).run(() => _classPrivateFieldGet2(_statements2, this).get(sql, params));
+	}
+	all(sql, ...params) {
+		return _classPrivateFieldGet2(_queue, this).run(() => _classPrivateFieldGet2(_statements2, this).all(sql, params));
+	}
+	transaction(callback) {
+		return _classPrivateFieldGet2(_queue, this).hold(() => _classPrivateFieldGet2(_storage, this).transaction(async () => {
+			const transaction = new DurableObjectSqliteTransaction(_classPrivateFieldGet2(_statements2, this));
+			try {
+				return await callback(transaction);
+			} finally {
+				transaction.end();
+			}
+		}));
+	}
+	/** The object owns the database; there is nothing to close. */
+	close() {
+		return _classPrivateFieldGet2(_queue, this).run(() => void 0);
+	}
+};
+//#endregion
+//#region src/harness/pi/harness.ts
+const BG = BACKGROUND_CONTEXT;
+/** The root session's id. */
+const ROOT_SESSION = String(ROOT_CONVERSATION_ID);
+/**
+* The three wake timings. They suit a real deployment; only tests change
+* them, with `setWakeTimingForTests`, so a suite does not sit on the real
+* heartbeat.
+*
+* A pi long wait further away than this is handed to the alarm, so the
+* alarm, not pi's in-memory timer, is what wakes the object.
+*/
+const SLEEP_THRESHOLD_MS = 6e4;
+/**
+* Longest one wake waits on pi. 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, and how often it re-checks work
+* it cannot wait on, such as background tasks. If the object is evicted, the
+* job is still due and its alarm restarts the object.
+*/
+const HEARTBEAT_MS = 3e4;
+const WAKE_FN = "wake";
+function wakeJobId(session) {
+	return `pi-wake:${session}`;
+}
+function sessionOfJob(payload) {
+	return typeof payload === "object" && payload !== null && "session" in payload && typeof payload.session === "string" ? payload.session : void 0;
+}
+/** pi-durable's stored reference to a pi-ai model. */
+function modelRef(model) {
+	return {
+		provider: model.provider,
+		modelId: model.id
+	};
+}
+function conversationId(session) {
+	const id = Number(session);
+	if (!Number.isSafeInteger(id) || id < 1) throw new Error(`Invalid pi session ${JSON.stringify(session)}`);
+	return id;
+}
+/** The text of an assistant entry, for an operation's result. */
+function assistantText(entry) {
+	const message = entry?.model?.[0];
+	if (message?.role !== "assistant") return "";
+	return message.content.map((part) => part.type === "text" ? part.text : "").join("");
+}
+function signalContext(signal) {
+	return signal ? withAbortSignal(signal, BG) : BG;
+}
+var _options = /* @__PURE__ */ new WeakMap();
+var _waits = /* @__PURE__ */ new WeakMap();
+var _admitting = /* @__PURE__ */ new WeakMap();
+var _sleepThresholdMs = /* @__PURE__ */ new WeakMap();
+var _waitBudgetMs = /* @__PURE__ */ new WeakMap();
+var _heartbeatMs = /* @__PURE__ */ new WeakMap();
+var _opening = /* @__PURE__ */ new WeakMap();
+var _PiHarness_brand = /* @__PURE__ */ new WeakSet();
+/**
+* pi-durable hosted in a Durable Object, behind a small harness interface:
+* `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()`.
+*
+* pi owns everything about a run: the transcript, the inbox of steers and
+* follow-ups, generation and tool tasks, retries, crash recovery, and the
+* live view. It keeps all of it in its own tables in this object's SQLite
+* database (see `session-store.ts`).
+*
+* What pi cannot do on a Durable Object is wake itself: its scheduler runs
+* in memory, and an evicted object has no memory. The harness is that wake,
+* with one Lifecycle job per session. Input goes to pi once, in `submit()`,
+* after the session's job is scheduled. The job waits while pi has live
+* tasks in the session, rescheduling itself as a heartbeat, and completes
+* when there are none. An eviction mid-run leaves the job due, so its alarm
+* restarts the object, pi reopens and resumes its own tasks, and the job
+* waits again.
+*
+* @beta The API may change between releases.
+*/
+var PiHarness = class extends LifecycleCapability {
+	constructor(options) {
+		super("pi-harness");
+		_classPrivateMethodInitSpec(this, _PiHarness_brand);
+		_classPrivateFieldInitSpec(this, _options, void 0);
+		_classPrivateFieldInitSpec(this, _waits, /* @__PURE__ */ new Map());
+		_classPrivateFieldInitSpec(this, _admitting, /* @__PURE__ */ new Map());
+		_classPrivateFieldInitSpec(this, _sleepThresholdMs, SLEEP_THRESHOLD_MS);
+		_classPrivateFieldInitSpec(this, _waitBudgetMs, WAIT_BUDGET_MS);
+		_classPrivateFieldInitSpec(this, _heartbeatMs, HEARTBEAT_MS);
+		_classPrivateFieldInitSpec(this, _opening, void 0);
+		_classPrivateFieldSet2(_options, this, options);
+		this.sessions = new PiSessions(this);
+	}
+	async onStart(_context) {
+		const { pi } = await _assertClassBrand(_PiHarness_brand, this, _open).call(this);
+		const inspection = await pi.inspect(BG);
+		const sessions = new Set(inspection.tasks.map((task) => String(task.record.conversationId)));
+		for (const session of sessions) await _assertClassBrand(_PiHarness_brand, this, _wake).call(this, session);
+	}
+	async onJob(context) {
+		if (context.job.fn !== WAKE_FN) return;
+		const session = sessionOfJob(context.job.payload);
+		if (session !== void 0) return _assertClassBrand(_PiHarness_brand, this, _wakeStep).call(this, session);
+	}
+	/** Close pi'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))?.pi.close(BG);
+	}
+	/** A handle on one session. No I/O until you call it. */
+	session(id = ROOT_SESSION) {
+		return new PiSession(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(operationId, options = {}) {
+		return this.session(options.session).wait(operationId, options.signal);
+	}
+	/** The session's active transcript, as pi's entries. */
+	messages(options = {}) {
+		return this.session(options.session).messages();
+	}
+	/** Submissions pi has not settled yet, oldest first. */
+	async pending(options = {}) {
+		const { pi } = await _assertClassBrand(_PiHarness_brand, this, _open).call(this);
+		const id = options.session === void 0 ? void 0 : conversationId(options.session);
+		return (await pi.inspect(BG)).submissions.filter((record) => record.requestId !== void 0 && (id === void 0 || record.conversationId === id)).map((record) => ({
+			operationId: record.requestId,
+			session: String(record.conversationId),
+			status: record.status === "queued" ? "queued" : "running"
+		}));
+	}
+	/** The opened pi Harness, for anything the interface does not cover. */
+	async pi() {
+		return (await _assertClassBrand(_PiHarness_brand, this, _open).call(this)).pi;
+	}
+	/** @internal */
+	async conversation(session) {
+		const { pi } = await _assertClassBrand(_PiHarness_brand, this, _open).call(this);
+		const conversation = await pi.conversation(conversationId(session), BG);
+		if (!conversation) throw new Error(`Unknown pi session ${session}`);
+		return conversation;
+	}
+	/** @internal */
+	async storage() {
+		return (await _assertClassBrand(_PiHarness_brand, this, _open).call(this)).storage;
+	}
+	/** @internal */
+	async enqueue(session, input, options) {
+		const operationId = options.operationId ?? crypto.randomUUID();
+		const { storage } = await _assertClassBrand(_PiHarness_brand, this, _open).call(this);
+		const conversation = await this.conversation(session);
+		_classPrivateFieldGet2(_admitting, this).set(session, (_classPrivateFieldGet2(_admitting, this).get(session) ?? 0) + 1);
+		let accepted;
+		try {
+			await _assertClassBrand(_PiHarness_brand, this, _wake).call(this, session);
+			accepted = await storage.submissionByRequest(conversation.id, operationId, BG) === void 0;
+			await conversation.submit({
+				type: "input",
+				content: input,
+				whenBusy: options.whenBusy ?? "followUp",
+				requestId: operationId
+			}, BG);
+		} 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(_PiHarness_brand, this, _wake).call(this, session);
+		return {
+			operationId,
+			session,
+			accepted
+		};
+	}
+	/** @internal Withdraw a queued input, or abort the run it joined. */
+	async withdraw(session, operationId) {
+		const { pi, storage } = await _assertClassBrand(_PiHarness_brand, this, _open).call(this);
+		const id = conversationId(session);
+		const record = await storage.submissionByRequest(id, operationId, BG);
+		if (!record || record.status === "done" || record.status === "unanswered") return false;
+		const withdrawn = await pi.abortSubmission(record.id, BG, id);
+		if (withdrawn === "already_placed") await (await pi.conversation(id, BG))?.abort(BG);
+		return withdrawn !== "settled" && withdrawn !== "not_found";
+	}
+	/** @internal Wait for pi to settle an operation, by its request id. */
+	async settled(session, operationId, signal) {
+		const conversation = await this.conversation(session);
+		const context = signalContext(signal);
+		const submission = await _assertClassBrand(_PiHarness_brand, this, _findSubmission).call(this, conversation.id, operationId, context);
+		if (!submission) return {
+			operationId,
+			session,
+			status: "unanswered",
+			reason: "not_found"
+		};
+		return _assertClassBrand(_PiHarness_brand, this, _result).call(this, session, operationId, await submission.wait(context), context);
+	}
+	/** @internal The per-conversation defaults supported by pi-durable. */
+	agentDefaults() {
+		const defaults = _classPrivateFieldGet2(_options, this).defaults;
+		return {
+			...defaults?.model === void 0 ? {} : { model: modelRef(defaults.model) },
+			...defaults?.thinkingLevel === void 0 ? {} : { thinkingLevel: defaults.thinkingLevel }
+		};
+	}
+};
+/** 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 or replays anything:
+* it waits while pi has live tasks in the session and completes when it
+* has none. pi 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 { pi } = await _assertClassBrand(_PiHarness_brand, this, _open).call(this);
+	const conversation = await pi.conversation(conversationId(session), BG);
+	if (!conversation) return void 0;
+	const tasks = (await pi.inspect(BG)).tasks.filter((task) => task.record.conversationId === conversation.id);
+	if (tasks.length === 0) return _classPrivateFieldGet2(_admitting, this).has(session) ? heartbeat : void 0;
+	const wakeAt = await _assertClassBrand(_PiHarness_brand, this, _longWait).call(this, pi, conversation.id, BG);
+	if (wakeAt !== void 0) return { rescheduleAt: wakeAt };
+	if (tasks.every((task) => task.record.background)) return heartbeat;
+	const wait = _assertClassBrand(_PiHarness_brand, this, _waitForIdle).call(this, conversation).finally(() => {
+		_classPrivateFieldGet2(_waits, this).delete(session);
+		_assertClassBrand(_PiHarness_brand, this, _wake).call(this, session);
+	});
+	_classPrivateFieldGet2(_waits, this).set(session, wait);
+	this.lifecycle.trackAlarmWork(wait);
+	return heartbeat;
+}
+async function _waitForIdle(conversation) {
+	const budget = new AbortController();
+	const timer = setTimeout(() => budget.abort(), _classPrivateFieldGet2(_waitBudgetMs, this));
+	try {
+		await conversation.waitForIdle(withAbortSignal(budget.signal, BG));
+	} catch (error) {
+		if (!budget.signal.aborted) this.lifecycle.events.emit("pi:wake_error", {
+			session: String(conversation.id),
+			error: error instanceof Error ? error.message : String(error)
+		});
+	} finally {
+		clearTimeout(timer);
+	}
+}
+/**
+* pi, opened. Waits for Lifecycle startup first, so pi 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, with its timers and I/O held back, and
+* never finish.
+*/
+async function _open() {
+	await this.lifecycle.ready();
+	_classPrivateFieldGet2(_opening, this) ?? _classPrivateFieldSet2(_opening, this, _assertClassBrand(_PiHarness_brand, this, _doOpen).call(this).catch((error) => {
+		_classPrivateFieldSet2(_opening, this, void 0);
+		throw error;
+	}));
+	return _classPrivateFieldGet2(_opening, this);
+}
+async function _doOpen() {
+	const storage = await openPiSessionStore(this.lifecycle.storage);
+	const pi = await _classPrivateFieldGet2(_options, this).harness({
+		storage,
+		context: BG
+	});
+	await pi.root(BG, { agent: this.agentDefaults() });
+	pi.resume();
+	return {
+		pi,
+		storage
+	};
+}
+async function _findSubmission(id, operationId, context) {
+	const { pi, storage } = await _assertClassBrand(_PiHarness_brand, this, _open).call(this);
+	const record = await storage.submissionByRequest(id, operationId, context);
+	return record ? pi.submission(record.id, context) : void 0;
+}
+/** When pi's current wait is far enough away to hand to the alarm. */
+async function _longWait(pi, id, context) {
+	const live = await pi.snapshot(LiveDoc, id, context);
+	const at = live?.generation?.deferred?.pollAt ?? live?.generation?.retry?.at;
+	return at !== void 0 && at - Date.now() > _classPrivateFieldGet2(_sleepThresholdMs, this) ? at : void 0;
+}
+async function _result(session, operationId, settled, context) {
+	if (settled.status === "unanswered") return {
+		operationId,
+		session,
+		status: "unanswered",
+		reason: settled.reason
+	};
+	if (settled.type !== "input") return {
+		operationId,
+		session,
+		status: "done"
+	};
+	return {
+		operationId,
+		session,
+		status: "done",
+		text: assistantText((await (await this.conversation(session)).entries({
+			minEntryId: settled.answer,
+			maxEntryId: settled.answer
+		}, 1, void 0, context)).items[0])
+	};
+}
+var _harness = /* @__PURE__ */ new WeakMap();
+/** One pi conversation, addressed through the harness. */
+var PiSession = class {
+	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 after its current tool round. */
+	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 abort the run it joined), or, with no
+	* id, abort the session: pi withdraws queued inputs and aborts the
+	* running work.
+	*/
+	async abort(operationId) {
+		if (operationId !== void 0) return _classPrivateFieldGet2(_harness, this).withdraw(this.id, operationId);
+		await (await _classPrivateFieldGet2(_harness, this).conversation(this.id)).abort(BG);
+		return true;
+	}
+	/** Start a new context, optionally from a handoff note. */
+	async reset(handoff) {
+		await (await _classPrivateFieldGet2(_harness, this).conversation(this.id)).reset(handoff, BG);
+	}
+	/**
+	* Change this session's model, by its `provider` and `id`; it must be on
+	* the `Models` the factory opened pi with (see `PiModel`).
+	*/
+	async setModel(model) {
+		await (await _classPrivateFieldGet2(_harness, this).conversation(this.id)).configure({ model: modelRef(model) }, BG);
+	}
+	/** The active transcript, as pi's entries since the newest reset. */
+	async messages() {
+		return [...(await (await _classPrivateFieldGet2(_harness, this).conversation(this.id)).context(BG)).entries];
+	}
+	/** pi's agent events for this session: a snapshot, then one batch per commit. */
+	async events(context = BG) {
+		return watchEvents(await _classPrivateFieldGet2(_harness, this).pi(), conversationId(this.id), context);
+	}
+	async busy() {
+		return (await (await _classPrivateFieldGet2(_harness, this).pi()).snapshot(LiveDoc, conversationId(this.id), BG))?.run !== void 0;
+	}
+};
+var _harness2 = /* @__PURE__ */ new WeakMap();
+/** Every pi conversation in this object. */
+var PiSessions = class {
+	constructor(harness) {
+		_classPrivateFieldInitSpec(this, _harness2, void 0);
+		_classPrivateFieldSet2(_harness2, this, harness);
+	}
+	get(id) {
+		return _classPrivateFieldGet2(_harness2, this).session(id);
+	}
+	/** A new top-level session, configured like the root. */
+	async create() {
+		const conversation = await (await _classPrivateFieldGet2(_harness2, this).pi()).createConversation({
+			ownership: { kind: "ownerless" },
+			agent: _classPrivateFieldGet2(_harness2, this).agentDefaults()
+		}, BG);
+		return _classPrivateFieldGet2(_harness2, this).session(String(conversation.id));
+	}
+	/** A new session that sees `from`'s history up to its newest entry. */
+	async fork(from) {
+		const conversation = await _classPrivateFieldGet2(_harness2, this).conversation(from);
+		const at = (await conversation.entries({}, 1, void 0, BG)).items[0];
+		if (!at) throw new Error(`Session ${from} has no entries to fork from`);
+		const fork = await conversation.fork(at.id, { ownership: { kind: "ownerless" } }, BG);
+		return _classPrivateFieldGet2(_harness2, this).session(String(fork.id));
+	}
+	/**
+	* Every conversation, including ones subagent tools own. Read from pi's
+	* storage directly: the Harness has no conversation listing.
+	*/
+	async list() {
+		const storage = await _classPrivateFieldGet2(_harness2, this).storage();
+		const pi = await _classPrivateFieldGet2(_harness2, this).pi();
+		const sessions = [];
+		let cursor;
+		for (;;) {
+			const page = await storage.scanConversations({}, 100, cursor, BG);
+			for (const record of page.items) {
+				const live = await pi.snapshot(LiveDoc, record.id, BG);
+				sessions.push({
+					id: String(record.id),
+					...record.parent ? { parent: String(record.parent.conversationId) } : {},
+					busy: live?.run !== void 0
+				});
+			}
+			if (page.next === void 0) return sessions;
+			cursor = page.next;
+		}
+	}
+};
+//#endregion
+//#region src/harness/pi/skills.ts
+function skillsFingerprint(sources) {
+	return sources.map((source) => `${source.id}:${source.fingerprint}`).join("|");
+}
+function textResult(text) {
+	return { content: [{
+		type: "text",
+		text
+	}] };
+}
+function attributes(pairs) {
+	return pairs.filter((pair) => pair[1] !== void 0).map(([key, value]) => ` ${key}="${value.replace(/"/g, "&quot;")}"`).join("");
+}
+function describeResource(resource) {
+	const details = [
+		resource.kind,
+		resource.encoding ?? "text",
+		resource.mimeType,
+		resource.size === void 0 ? void 0 : `${resource.size} bytes`
+	].filter((value) => value !== void 0);
+	return `- ${resource.path} (${details.join(", ")})`;
+}
+function renderSkillContent(skill) {
+	const resources = skill.content.resources ?? [];
+	const lines = [`<skill_content${attributes([["name", skill.descriptor.name], ["version", skill.descriptor.version]])}>`, skill.content.body.trim()];
+	if (resources.length > 0) {
+		lines.push("<skill_resources>");
+		for (const resource of resources) lines.push(`  <file${attributes([
+			["kind", resource.kind],
+			["encoding", resource.encoding ?? "text"],
+			["size", resource.size === void 0 ? void 0 : String(resource.size)]
+		])}>${resource.path}</file>`);
+		lines.push("</skill_resources>");
+	}
+	lines.push("</skill_content>", "");
+	lines.push(resources.length === 0 ? "No bundled resources." : ["Bundled resources:", ...resources.map(describeResource)].join("\n"));
+	return lines.join("\n");
+}
+/**
+* Resolve `agents/skills` sources into a system-prompt catalog and two
+* tools.
+*
+* The first source to list a name wins, as in `SkillRegistry`. pi-durable
+* has no skill concept of its own, so the model activates skills through
+* `activate_skill` and reads bundled files through `read_skill_resource` —
+* the same tools `@cloudflare/think` offers, so skills authored for one
+* framework work in the other.
+*/
+async function resolveSkillSources(sources) {
+	const fingerprint = skillsFingerprint(sources);
+	const warnings = [];
+	const resolved = /* @__PURE__ */ new Map();
+	for (const source of sources) {
+		let descriptors;
+		try {
+			descriptors = await source.list();
+		} catch (error) {
+			warnings.push(`Skill source "${source.id}" failed to list skills: ${error instanceof Error ? error.message : String(error)}`);
+			continue;
+		}
+		for (const descriptor of descriptors) {
+			if (resolved.has(descriptor.name)) {
+				warnings.push(`Skill "${descriptor.name}" from source "${source.id}" is shadowed by an earlier source`);
+				continue;
+			}
+			let content;
+			try {
+				content = await source.load(descriptor.name);
+			} catch (error) {
+				warnings.push(`Skill "${descriptor.name}" from source "${source.id}" failed to load: ${error instanceof Error ? error.message : String(error)}`);
+				continue;
+			}
+			if (!content) continue;
+			resolved.set(descriptor.name, {
+				descriptor,
+				content,
+				source
+			});
+		}
+	}
+	const visible = [...resolved.values()].filter((skill) => skill.descriptor.metadata?.["disable-model-invocation"] !== true);
+	if (visible.length === 0) return {
+		fingerprint,
+		tools: [],
+		catalog: null,
+		warnings
+	};
+	const names = visible.map((skill) => skill.descriptor.name);
+	const nameSchema = Type.Union(names.map((name) => Type.Literal(name)));
+	const byName = new Map(visible.map((skill) => [skill.descriptor.name, skill]));
+	const activateSkill = {
+		name: "activate_skill",
+		description: "Activate a skill by name. Use this when the user's task matches one of the available skills; the response contains the skill's full instructions.",
+		parameters: Type.Object({ name: nameSchema }),
+		replay: "safe",
+		async execute(input) {
+			const skill = byName.get(input.name);
+			return textResult(skill ? renderSkillContent(skill) : `Skill not found: ${input.name}`);
+		}
+	};
+	const readResource = {
+		name: "read_skill_resource",
+		description: "Read a file bundled with a skill, such as a reference document or template. Provide the skill name and the file's path from the skill's resource list.",
+		parameters: Type.Object({
+			name: Type.Optional(nameSchema),
+			path: Type.String({ minLength: 1 })
+		}),
+		replay: "safe",
+		async execute(input) {
+			const target = resolveResourceTarget(byName, input.name, input.path);
+			if (!target) return textResult(`Skill resource not found: ${input.name ? `${input.name}/` : ""}${input.path}`);
+			const resource = await target.skill.source.readResource?.(target.skill.descriptor.name, target.path).catch(() => null);
+			if (!resource) return textResult(`Skill resource not found: ${target.skill.descriptor.name}/${target.path}`);
+			return textResult([
+				`<skill_resource${attributes([
+					["name", target.skill.descriptor.name],
+					["path", resource.path],
+					["kind", resource.kind],
+					["encoding", resource.encoding ?? "text"],
+					["mimeType", resource.mimeType]
+				])}>`,
+				resource.content,
+				"</skill_resource>"
+			].join("\n"));
+		}
+	};
+	const catalog = [
+		"Available skills. When a task matches a skill, use activate_skill with its name before proceeding.",
+		"",
+		...visible.map((skill) => `- ${skill.descriptor.name}: ${skill.descriptor.description}`)
+	].join("\n");
+	return {
+		fingerprint,
+		tools: [activateSkill, readResource],
+		catalog,
+		warnings
+	};
+}
+function resolveResourceTarget(byName, name, path) {
+	if (path.split("/").some((segment) => segment === "..")) return void 0;
+	if (name !== void 0) {
+		const skill = byName.get(name);
+		return skill && hasResource(skill, path) ? {
+			skill,
+			path
+		} : void 0;
+	}
+	const [head, ...rest] = path.split("/");
+	const skill = head === void 0 ? void 0 : byName.get(head);
+	const relative = rest.join("/");
+	return skill && relative && hasResource(skill, relative) ? {
+		skill,
+		path: relative
+	} : void 0;
+}
+function hasResource(skill, path) {
+	return (skill.content.resources ?? []).some((resource) => resource.path === path);
+}
+/**
+* `agents/skills` sources as a pi extension, named `agents.skills`: the
+* activation tools and a `skills` system prompt section. Install it on
+* pi's registry in the harness factory.
+*
+* ```ts
+* registry.install(await skills(sources));
+* ```
+*/
+async function skills(sources) {
+	const resolved = await resolveSkillSources(sources);
+	for (const warning of resolved.warnings) console.warn(`pi skills: ${warning}`);
+	const catalog = resolved.catalog;
+	return {
+		name: "agents.skills",
+		tools: resolved.tools,
+		sections: catalog === null ? [] : [{
+			key: "skills",
+			render: () => catalog
+		}]
+	};
+}
+//#endregion
+export { PiHarness, PiSession, PiSessions, ROOT_SESSION, openPiSessionStore, skills };
+
+//# sourceMappingURL=index.js.map