experimental-a2 0.17.0 → 0.18.1

package/dist/ai-pi.js

@@ -0,0 +1,950 @@
+import { u as ambientToolScopeStorage } from "./internal-CscSY7K_.js";
+import { t as boundedCache } from "./bounded-cache-CPHWF-8h.js";
+import { c as pending, d as saveHarness, i as gatewayCredential, l as readHarness, n as deferred, r as defineHarness, t as Divergence } from "./ai-harness-BuLh_EYi.js";
+import { t as schemaInput } from "./ai-tool-input-DmSqMUQi.js";
+import { createHash } from "node:crypto";
+import { asSchema, jsonSchema } from "ai";
+import { readFile, unlink } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, dirname, join } from "node:path";
+//#region src/ai-pi.ts
+/**
+* experimental-a2/ai/pi — `pi()`: the Pi harness for `agent({ harness })`.
+* Server-only; Pi comes from the optional `@earendil-works/pi-coding-agent`
+* and `@earendil-works/pi-ai` peer dependencies.
+*/
+/**
+* The Pi harness. Every model call Pi makes is one durable step; A2 rebuilds
+* Pi's session for each step from its latest snapshot and the log since.
+*/
+function pi(options) {
+	if (typeof options?.sandbox !== "function") throw new TypeError("pi() requires sandbox");
+	return defineHarness("pi", {
+		sandbox: options.sandbox,
+		tools: builtinTools,
+		step: (step) => runStep(step, async () => options.sandbox({
+			session: { id: step.sessionId },
+			signal: step.signal
+		}))
+	});
+}
+const SNAPSHOT_VERSION = 1;
+const GATEWAY = "vercel-ai-gateway";
+const MAX_TRANSFER_BYTES = 4194304;
+const MAX_TRANSFER = "4 MiB";
+const BUILTINS = [
+	"read",
+	"write",
+	"edit",
+	"bash"
+];
+function endStep(state) {
+	state.over = true;
+	state.stepOver.resolve();
+}
+const diverged = (message) => new Divergence("Pi", message);
+async function runStep(step, sandbox) {
+	const modules = await loadPi();
+	const credential = gatewayCredential("pi");
+	const name = `${step.agentName}.a2.harness.pi`;
+	const { replayAll, ...first } = await readHarness({
+		step,
+		name,
+		parse: savedSession
+	});
+	let read = first;
+	let results = read.results;
+	const cwd = read.saved?.cwd ?? await sessionCwd({
+		key: cwdKey(step.agentName, step.sessionId),
+		sandbox
+	});
+	let completion = {};
+	let session;
+	let compacting = false;
+	let turn;
+	const fail = (state, error) => {
+		state.failure ??= error;
+		endStep(state);
+		session?.abort();
+		throw state.failure;
+	};
+	let controller;
+	let closed = false;
+	const emit = (chunk) => {
+		if (!closed) controller.enqueue(chunk);
+	};
+	const record = (data) => emit({
+		type: "data-a2-pi",
+		data,
+		transient: true
+	});
+	const answer = async (out, model, context, options) => {
+		const state = turn;
+		if (state.failure) throw state.failure;
+		if (state.over) {
+			replay(out, interrupted(model));
+			return;
+		}
+		const kind = compacting ? "compaction" : "step";
+		const recorded = state.calls[state.next];
+		if (recorded !== void 0) {
+			if (recorded.kind !== kind) fail(state, diverged(`call ${state.next} is not a ${kind}`));
+			state.next++;
+			for (const text of recorded.steers) await session.steer(text);
+			replay(out, recorded.response);
+			return;
+		}
+		if (state.plan.end === "stop") fail(state, diverged("Pi continued a turn the log ended"));
+		if (state.plan.end === "interrupted") {
+			replay(out, interrupted(model));
+			return;
+		}
+		if (kind === "step" && state.liveStep) {
+			endStep(state);
+			replay(out, interrupted(model));
+			return;
+		}
+		if (kind === "step") state.liveStep = true;
+		const upstream = realStream(model, context, {
+			...options,
+			headers: {
+				...options?.headers,
+				...gatewayHeaders(credential)
+			}
+		});
+		const live = kind === "step" ? liveStep() : void 0;
+		for await (const event of upstream) {
+			await live?.(event);
+			if (event.type === "done" || event.type === "error") {
+				const response = event.type === "done" ? event.message : event.error;
+				if (kind === "compaction") state.compactions.push(response);
+				if (event.type === "error" && event.reason === "error") {
+					state.failure ??= new Error(response.errorMessage ?? "the Pi model call failed");
+					endStep(state);
+				}
+			}
+			out.push(event);
+		}
+	};
+	/**
+	* A live call's input as Pi's loop, then the AI SDK step, read it. Pi
+	* answers a call to no tool, or whose arguments it cannot prepare or
+	* validate, itself. The agent's tool reads the arguments Pi accepts through
+	* its own schema; A2 runs Pi's own tools from the model's arguments, as
+	* Pi's loop does.
+	*/
+	const callInput = async (block) => {
+		const definition = tools.find((tool) => tool.name === block.name);
+		if (definition === void 0) return {
+			success: false,
+			errorText: `Tool ${block.name} not found`
+		};
+		let args;
+		try {
+			const prepared = definition.prepareArguments?.(block.arguments);
+			args = modules.ai.validateToolArguments(definition, prepared === void 0 ? block : {
+				...block,
+				arguments: prepared
+			});
+		} catch (error) {
+			return {
+				success: false,
+				errorText: asError(error).message
+			};
+		}
+		if (builtinOf(step.tools, block.name) !== void 0) return {
+			success: true,
+			value: block.arguments
+		};
+		return schemaInput({
+			tools: step.tools,
+			toolName: block.name,
+			value: args
+		});
+	};
+	/** Streams one live step response as UI chunks and records it. */
+	const liveStep = () => {
+		const ref = (index) => `pi:${step.requestIndex}:${index}`;
+		const started = /* @__PURE__ */ new Set();
+		return async (event) => {
+			switch (event.type) {
+				case "start":
+					emit({ type: "start-step" });
+					break;
+				case "text_start":
+					emit({
+						type: "text-start",
+						id: ref(event.contentIndex)
+					});
+					break;
+				case "text_delta":
+					emit({
+						type: "text-delta",
+						id: ref(event.contentIndex),
+						delta: event.delta
+					});
+					break;
+				case "text_end":
+					emit({
+						type: "text-end",
+						id: ref(event.contentIndex)
+					});
+					break;
+				case "thinking_start":
+					emit({
+						type: "reasoning-start",
+						id: ref(event.contentIndex)
+					});
+					break;
+				case "thinking_delta":
+					emit({
+						type: "reasoning-delta",
+						id: ref(event.contentIndex),
+						delta: event.delta
+					});
+					break;
+				case "thinking_end":
+					emit({
+						type: "reasoning-end",
+						id: ref(event.contentIndex)
+					});
+					break;
+				case "toolcall_start":
+				case "toolcall_delta": {
+					const call = event.partial.content[event.contentIndex];
+					if (!call.id) break;
+					if (!started.has(call.id)) {
+						started.add(call.id);
+						emit({
+							type: "tool-input-start",
+							toolCallId: call.id,
+							toolName: call.name
+						});
+					}
+					if (event.type === "toolcall_delta") emit({
+						type: "tool-input-delta",
+						toolCallId: call.id,
+						inputTextDelta: event.delta
+					});
+					break;
+				}
+				case "done":
+				case "error": {
+					const response = event.type === "done" ? event.message : event.error;
+					const changed = /* @__PURE__ */ new Set();
+					if (event.type === "done") for (const block of response.content) {
+						if (block.type !== "toolCall") continue;
+						if (!started.has(block.id)) emit({
+							type: "tool-input-start",
+							toolCallId: block.id,
+							toolName: block.name
+						});
+						const input = response.stopReason === "length" ? {
+							success: false,
+							errorText: "The response hit the output token limit before this call was complete."
+						} : await callInput(block);
+						if (input.success && JSON.stringify(input.value) !== JSON.stringify(block.arguments)) changed.add(block.id);
+						emit(input.success ? {
+							type: "tool-input-available",
+							toolCallId: block.id,
+							toolName: block.name,
+							input: input.value
+						} : {
+							type: "tool-input-error",
+							toolCallId: block.id,
+							toolName: block.name,
+							input: block.arguments,
+							errorText: input.errorText
+						});
+					}
+					record({
+						call: "step",
+						response: storedResponse(response, ref, changed)
+					});
+					completion = {
+						finishReason: finishReason(response.stopReason),
+						usage: modelUsage(response.usage)
+					};
+					break;
+				}
+			}
+		};
+	};
+	const toolResult = async (toolCallId, signal, shape) => {
+		const state = turn;
+		if (state.failure) throw state.failure;
+		const result = results.get(toolCallId);
+		if (result !== void 0) return answeredTool(result, shape);
+		if (state.plan.end === "live" && state.liveStep) {
+			endStep(state);
+			return pending(signal);
+		}
+		if (state.plan.end === "interrupted") {
+			session.abort();
+			return pending(signal);
+		}
+		return fail(state, diverged(`no recorded result for ${toolCallId}`));
+	};
+	const runtime = await modules.agent.ModelRuntime.create({
+		credentials: new modules.ai.InMemoryCredentialStore(),
+		modelsPath: null,
+		allowModelNetwork: false,
+		refreshOnCreate: false
+	});
+	await runtime.setRuntimeApiKey(GATEWAY, credential.token);
+	const model = runtime.getModel(GATEWAY, step.model);
+	if (model === void 0) throw new Error(`Pi does not know the Gateway model ${step.model}`);
+	const realStream = runtime.streamSimple.bind(runtime);
+	runtime.streamSimple = (requested, context, options) => {
+		const out = modules.ai.createAssistantMessageEventStream();
+		answer(out, requested, context, options).catch((error) => {
+			const state = turn;
+			if (state) state.failure ??= asError(error);
+			replay(out, {
+				...interrupted(requested),
+				stopReason: "error"
+			});
+		});
+		return out;
+	};
+	const tools = await sessionTools(modules, step.tools, cwd, toolResult);
+	const createSession = async (from) => {
+		const sessionManager = from === void 0 ? modules.agent.SessionManager.inMemory(cwd, { id: sessionUuid(step.agentName, step.sessionId) }) : modules.agent.SessionManager.inMemory(cwd, { id: from.header.id }, [from.header, ...from.entries]);
+		const created = await modules.agent.createAgentSession({
+			cwd,
+			agentDir: join(tmpdir(), "a2-pi"),
+			model,
+			...thinkingLevel(step),
+			modelRuntime: runtime,
+			resourceLoader: resources(modules, step.instructions),
+			sessionManager,
+			settingsManager: modules.agent.SettingsManager.inMemory({
+				retry: {
+					enabled: false,
+					maxRetries: 0,
+					baseDelayMs: 0
+				},
+				cacheWarming: "off"
+			}),
+			customTools: tools,
+			tools: tools.map((definition) => definition.name)
+		});
+		created.session.subscribe((event) => {
+			if (event.type === "compaction_start") compacting = true;
+			if (event.type !== "compaction_end") return;
+			compacting = false;
+			const state = turn;
+			if (state === void 0 || state.over || state.compactions.length === 0) return;
+			for (const response of state.compactions.splice(0)) record({
+				call: "compaction",
+				response
+			});
+			emit({
+				type: "data-a2-compaction",
+				id: `pi-compaction:${step.requestIndex}:${compactions++}`,
+				data: compactionData(event)
+			});
+		});
+		return created.session;
+	};
+	let compactions = 0;
+	const saveSnapshot = async () => {
+		const manager = session.sessionManager;
+		const header = manager.getHeader();
+		const entries = manager.getEntries();
+		const last = entries.findLast((entry) => entry.type === "message" && entry.message.role === "assistant");
+		const stop = last?.type === "message" && last.message.role === "assistant" ? last.message.stopReason : void 0;
+		if (header === null || step.signal.aborted || stop === "aborted" || stop === "error") return;
+		await saveHarness({
+			step,
+			name,
+			state: {
+				version: SNAPSHOT_VERSION,
+				cwd,
+				header,
+				entries
+			}
+		});
+	};
+	const run = async () => {
+		emit({
+			type: "start",
+			messageId: step.responseMessageId
+		});
+		try {
+			session = await createSession(read.saved);
+		} catch (error) {
+			if (read.saved === void 0) throw error;
+			read = await replayAll();
+			results = read.results;
+			session = await createSession(void 0);
+		}
+		for (const plan of read.turns) {
+			if (step.signal.aborted) return;
+			const state = {
+				plan,
+				calls: recordedTurn(plan),
+				next: 0,
+				liveStep: false,
+				over: false,
+				stepOver: deferred(),
+				compactions: []
+			};
+			turn = state;
+			const running = session.prompt(plan.prompt, { expandPromptTemplates: false });
+			if (plan.end !== "live") {
+				await running.catch((error) => {
+					throw state.failure ?? error;
+				});
+				if (state.failure) throw state.failure;
+				continue;
+			}
+			const ended = await Promise.race([running.then(() => true), state.stepOver.promise.then(() => false)]).catch((error) => {
+				throw state.failure ?? error;
+			});
+			if (!ended) {
+				await session.abort();
+				await running.catch(() => {});
+			}
+			if (state.failure) throw state.failure;
+			if (ended) await saveSnapshot();
+			emit({ type: "finish-step" });
+			emit({
+				type: "finish",
+				...completion.finishReason === void 0 ? {} : { finishReason: completion.finishReason }
+			});
+		}
+	};
+	return {
+		stream: new ReadableStream({
+			start(streamController) {
+				controller = streamController;
+				const abort = () => void session?.abort();
+				step.signal.addEventListener("abort", abort, { once: true });
+				(async () => {
+					try {
+						await run();
+						closed = true;
+						streamController.close();
+					} catch (error) {
+						closed = true;
+						streamController.error(step.signal.aborted ? step.signal.reason : error);
+					} finally {
+						step.signal.removeEventListener("abort", abort);
+						session?.dispose();
+					}
+				})();
+			},
+			cancel() {
+				closed = true;
+				session?.abort();
+			}
+		}),
+		completion: () => completion
+	};
+}
+/** A turn's recorded model calls, in the order Pi made them. */
+function recordedTurn(turn) {
+	const calls = [];
+	turn.generations.forEach((generation, index) => {
+		calls.push(...recordedCalls(generation));
+		const steers = turn.steers.get(index);
+		const last = calls.findLast((call) => call.kind === "step");
+		if (steers !== void 0 && last !== void 0) last.steers.push(...steers);
+	});
+	return calls;
+}
+function recordedCalls(generation) {
+	const texts = /* @__PURE__ */ new Map();
+	const inputs = /* @__PURE__ */ new Map();
+	const calls = [];
+	for (const chunk of generation.chunks) switch (chunk.type) {
+		case "text-delta":
+		case "reasoning-delta":
+			texts.set(chunk.id, (texts.get(chunk.id) ?? "") + chunk.delta);
+			break;
+		case "tool-input-available":
+		case "tool-input-error":
+			inputs.set(chunk.toolCallId, chunk.input);
+			break;
+		case "data-a2-pi": {
+			const record = chunk.data;
+			calls.push({
+				kind: record.call,
+				response: record.call === "step" ? restoredResponse(record.response, texts, inputs) : record.response,
+				steers: []
+			});
+			break;
+		}
+	}
+	if (!calls.some((call) => call.kind === "step")) throw diverged("a completed generation has no recorded response");
+	return calls;
+}
+function storedResponse(response, ref, changed) {
+	return {
+		...response,
+		content: response.content.map((block, index) => {
+			switch (block.type) {
+				case "text": {
+					const { text: _, ...rest } = block;
+					return {
+						...rest,
+						ref: ref(index)
+					};
+				}
+				case "thinking": {
+					const { thinking: _, ...rest } = block;
+					return {
+						...rest,
+						ref: ref(index)
+					};
+				}
+				case "toolCall": {
+					if (changed.has(block.id)) return block;
+					const { arguments: _, ...rest } = block;
+					return rest;
+				}
+			}
+		})
+	};
+}
+function restoredResponse(stored, texts, inputs) {
+	return {
+		...stored,
+		content: stored.content.map((block) => {
+			if (block.type === "toolCall") return {
+				...block,
+				arguments: block.arguments ?? inputs.get(block.id) ?? {}
+			};
+			const { ref, ...rest } = block;
+			const text = texts.get(ref) ?? "";
+			return rest.type === "text" ? {
+				...rest,
+				text
+			} : {
+				...rest,
+				thinking: text
+			};
+		})
+	};
+}
+/** Hands a recorded response to Pi's loop. */
+function replay(out, response) {
+	out.push({
+		type: "start",
+		partial: response
+	});
+	const reason = response.stopReason;
+	if (reason === "error" || reason === "aborted") out.push({
+		type: "error",
+		reason,
+		error: response
+	});
+	else if (reason === "pending") out.push({
+		type: "done",
+		reason: "stop",
+		message: response
+	});
+	else out.push({
+		type: "done",
+		reason,
+		message: response
+	});
+}
+/** The response of a model call that A2 interrupted. */
+function interrupted(model) {
+	return {
+		role: "assistant",
+		content: [],
+		api: model.api,
+		provider: model.provider,
+		model: model.id,
+		usage: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			totalTokens: 0,
+			cost: {
+				input: 0,
+				output: 0,
+				cacheRead: 0,
+				cacheWrite: 0,
+				total: 0
+			}
+		},
+		stopReason: "aborted",
+		timestamp: Date.now()
+	};
+}
+const builtinTools = Object.fromEntries(BUILTINS.map((name) => [name, {
+	inputSchema: jsonSchema(async () => builtinDefinition(await loadPi(), name, "/").parameters),
+	execute: (input, options) => runBuiltin(name, input, options)
+}]));
+/** Runs one of Pi's tools in the session's sandbox, as Pi's loop would. */
+async function runBuiltin(name, input, options) {
+	const sandbox = options.experimental_sandbox;
+	if (sandbox === void 0) throw new Error(`pi() runs ${name} in the agent's sandbox`);
+	const modules = await loadPi();
+	const scope = ambientToolScopeStorage()?.getStore();
+	const event = (scope?.context)?.event;
+	const definition = builtinDefinition(modules, name, await sessionCwd({
+		key: scope?.contract !== void 0 && typeof event?.sessionId === "string" ? cwdKey(scope.contract.name, event.sessionId) : void 0,
+		sandbox: async () => sandbox
+	}), {
+		sandbox,
+		signal: options.abortSignal
+	});
+	const args = modules.ai.validateToolArguments(definition, {
+		type: "toolCall",
+		id: options.toolCallId,
+		name,
+		arguments: definition.prepareArguments?.(input) ?? input
+	});
+	let outputFile;
+	try {
+		const result = await definition.execute(options.toolCallId, args, options.abortSignal, (update) => {
+			outputFile ??= fullOutputPath(update);
+		}, void 0);
+		outputFile ??= fullOutputPath(result);
+		return await recordedResult(result, sandbox);
+	} catch (error) {
+		outputFile ??= namedOutputFile(error);
+		throw error;
+	} finally {
+		if (outputFile !== void 0) await unlink(outputFile).catch(() => {});
+	}
+}
+const fullOutputPath = (result) => {
+	const path = result.details?.fullOutputPath;
+	return typeof path === "string" ? path : void 0;
+};
+/** The full-output file an aborted or timed-out bash call's error names. */
+function namedOutputFile(error) {
+	if (!(error instanceof Error)) return void 0;
+	const path = /Full output: ([^\n]+)\]\n\nCommand [^\n]+$/.exec(error.message)?.[1];
+	return path !== void 0 && dirname(path) === tmpdir() && /^pi-bash-[0-9a-f]{16}\.log$/.test(basename(path)) ? path : void 0;
+}
+/**
+* What the log keeps of a result: what Pi's tool-result message holds. A
+* long output's full text moves to the path its result names in the sandbox,
+* where the model's `read` finds it.
+*/
+async function recordedResult(result, sandbox) {
+	const { structuredContent: _, ...kept } = result;
+	const details = kept.details;
+	const path = fullOutputPath(kept);
+	if (path !== void 0) try {
+		await sandbox.writeBinaryFile({
+			path,
+			content: await readFile(path)
+		});
+	} catch {}
+	if (details?.truncation === void 0) return kept;
+	const { content: __, ...truncation } = details.truncation;
+	return {
+		...kept,
+		details: {
+			...details,
+			truncation
+		}
+	};
+}
+/** The Pi tool a name in the agent's tool set runs, unless the agent replaced it. */
+const builtinOf = (tools, name) => BUILTINS.find((candidate) => candidate === name && Object.hasOwn(tools, name) && tools[name] === builtinTools[name]);
+const untyped = (definition) => definition;
+function builtinDefinition(modules, name, cwd, call) {
+	const sandbox = call?.sandbox;
+	const files = call === void 0 ? void 0 : { operations: sandboxFiles(call) };
+	switch (name) {
+		case "read": return untyped(modules.agent.createReadToolDefinition(cwd, files));
+		case "write": return untyped(modules.agent.createWriteToolDefinition(cwd, files));
+		case "edit": return untyped(modules.agent.createEditToolDefinition(cwd, files));
+		case "bash": return untyped(modules.agent.createBashToolDefinition(cwd, {
+			exposeSessionEnvironment: false,
+			...sandbox === void 0 ? {} : { operations: sandboxBash(sandbox) }
+		}));
+	}
+}
+/**
+* The tools Pi's session declares: Pi's own, and the agent's. Their results
+* come from A2's log; A2's tool handlers ran them.
+*/
+async function sessionTools(modules, tools, cwd, result) {
+	return Promise.all(Object.entries(tools).filter(([, tool]) => tool.type !== "provider").map(async ([name, tool]) => {
+		const builtin = builtinOf(tools, name);
+		if (builtin !== void 0) return Object.assign(builtinDefinition(modules, builtin, cwd), { execute: (toolCallId, _params, signal) => result(toolCallId, signal, "pi") });
+		return {
+			name,
+			label: name,
+			description: typeof tool.description === "string" ? tool.description : "",
+			parameters: await asSchema(tool.inputSchema).jsonSchema,
+			execute: (toolCallId, _params, signal) => result(toolCallId, signal, "tool")
+		};
+	}));
+}
+function answeredTool(result, shape) {
+	if (result.error !== void 0) throw new Error(result.error);
+	if (result.denied === true) throw new Error("The tool call was denied.");
+	if (shape === "pi") return result.output;
+	const output = result.output;
+	return {
+		content: [{
+			type: "text",
+			text: typeof output === "string" ? output : JSON.stringify(output) ?? ""
+		}],
+		details: void 0
+	};
+}
+/** Pi's file operations, against the sandbox. */
+function sandboxFiles({ sandbox, signal }) {
+	const abortSignal = signal === void 0 ? {} : { abortSignal: signal };
+	let checked;
+	const readFile = async (path) => {
+		if (checked?.path === path) {
+			const { bytes } = checked;
+			checked = void 0;
+			return bytes;
+		}
+		const stream = await sandbox.readFile({
+			path,
+			...abortSignal
+		});
+		if (stream === null) throw Object.assign(/* @__PURE__ */ new Error(`ENOENT: no such file or directory, open '${path}'`), { code: "ENOENT" });
+		const chunks = [];
+		let size = 0;
+		for await (const chunk of stream) {
+			size += chunk.byteLength;
+			if (size > MAX_TRANSFER_BYTES) throw new Error(`${path} is larger than ${MAX_TRANSFER}. Read or change parts of it with bash, using sed, head, or grep.`);
+			chunks.push(chunk);
+		}
+		return Buffer.concat(chunks);
+	};
+	return {
+		readFile,
+		access: async (path) => {
+			checked = {
+				path,
+				bytes: await readFile(path)
+			};
+		},
+		writeFile: async (path, content) => {
+			checked = void 0;
+			await sandbox.writeTextFile({
+				path,
+				content,
+				...abortSignal
+			});
+		},
+		mkdir: async () => {}
+	};
+}
+/** Pi's shell operations, against the sandbox. */
+const sandboxBash = (sandbox) => ({ exec: (command, cwd, { onData, signal, timeout }) => sandboxExec({
+	sandbox,
+	command,
+	workingDirectory: cwd,
+	onData,
+	signal,
+	timeout
+}) });
+/**
+* Runs a command in the sandbox with Pi's error contract. At most
+* `MAX_TRANSFER_BYTES` of its output reach the server; past that, the
+* command is stopped.
+*/
+async function sandboxExec({ sandbox, command, workingDirectory, onData, signal, timeout }) {
+	if (signal?.aborted) throw new Error("aborted");
+	const stop = new AbortController();
+	const abort = () => stop.abort();
+	signal?.addEventListener("abort", abort, { once: true });
+	let timedOut = false;
+	const timer = timeout === void 0 || timeout <= 0 ? void 0 : setTimeout(() => {
+		timedOut = true;
+		stop.abort();
+	}, timeout * 1e3);
+	let size = 0;
+	let overflowed = false;
+	const overflow = (options) => new Error(`The command's output passed ${MAX_TRANSFER}, so it was stopped. Write long output to a file and read parts of it with head, tail, or grep.`, options);
+	let exitCode;
+	try {
+		const process = await sandbox.spawn({
+			command,
+			...workingDirectory === void 0 ? {} : { workingDirectory },
+			abortSignal: stop.signal
+		});
+		const pipe = async (stream) => {
+			for await (const chunk of process[stream]) {
+				size += chunk.byteLength;
+				if (size > MAX_TRANSFER_BYTES) {
+					overflowed = true;
+					stop.abort();
+					return;
+				}
+				onData(Buffer.from(chunk), stream);
+			}
+		};
+		const [exited] = await Promise.all([
+			process.wait(),
+			pipe("stdout"),
+			pipe("stderr")
+		]);
+		exitCode = exited.exitCode;
+	} catch (error) {
+		if (signal?.aborted) throw new Error("aborted", { cause: error });
+		if (timedOut) throw new Error(`timeout:${timeout}`, { cause: error });
+		if (overflowed) throw overflow({ cause: error });
+		throw error;
+	} finally {
+		clearTimeout(timer);
+		signal?.removeEventListener("abort", abort);
+	}
+	if (signal?.aborted) throw new Error("aborted");
+	if (timedOut) throw new Error(`timeout:${timeout}`);
+	if (overflowed) throw overflow();
+	return { exitCode };
+}
+const cwds = boundedCache({
+	maxEntries: 1e3,
+	maxBytes: 1e3
+});
+const cwdKey = (agentName, sessionId) => `${agentName}\u001f${sessionId}`;
+/** A session's working directory in its sandbox: Pi's cwd. */
+function sessionCwd({ key, sandbox }) {
+	const cached = key === void 0 ? void 0 : cwds.get(key);
+	if (cached !== void 0) return cached;
+	const cwd = sandbox().then(async (resolved) => {
+		const output = {
+			stdout: "",
+			stderr: ""
+		};
+		const decoder = {
+			stdout: new TextDecoder(),
+			stderr: new TextDecoder()
+		};
+		const { exitCode } = await sandboxExec({
+			sandbox: resolved,
+			command: "pwd",
+			onData: (data, stream) => {
+				output[stream] += decoder[stream].decode(data, { stream: true });
+			}
+		}).catch((error) => {
+			throw new Error("pi() could not read the sandbox's working directory", { cause: error });
+		});
+		const path = output.stdout.trim();
+		if (exitCode !== 0 || !path.startsWith("/")) throw new Error(`pi() could not read the sandbox's working directory: ${(output.stderr || output.stdout).slice(0, 1e3)}`);
+		return path;
+	});
+	if (key !== void 0) {
+		cwds.set(key, cwd, 1);
+		cwd.catch(() => cwds.delete(key));
+	}
+	return cwd;
+}
+let loading;
+function loadPi() {
+	loading ??= Promise.all([import("@earendil-works/pi-coding-agent"), import("@earendil-works/pi-ai")]).then(([agent, ai]) => ({
+		agent,
+		ai
+	}), (error) => {
+		loading = void 0;
+		throw new Error("pi() needs @earendil-works/pi-coding-agent and @earendil-works/pi-ai: install them", { cause: error });
+	});
+	return loading;
+}
+/** Pi's resources: nothing discovered from disk, the agent's instructions appended. */
+function resources(modules, instructions) {
+	const runtime = modules.agent.createExtensionRuntime();
+	return {
+		getExtensions: () => ({
+			extensions: [],
+			errors: [],
+			runtime
+		}),
+		getSkills: () => ({
+			skills: [],
+			diagnostics: []
+		}),
+		getPrompts: () => ({
+			prompts: [],
+			diagnostics: []
+		}),
+		getThemes: () => ({
+			themes: [],
+			diagnostics: []
+		}),
+		getAgentsFiles: () => ({ agentsFiles: [] }),
+		getSystemPrompt: () => void 0,
+		getSystemPromptSource: () => void 0,
+		getAppendSystemPrompt: () => instructions,
+		getAppendSystemPromptSources: () => [],
+		extendResources: () => {},
+		reload: async () => {}
+	};
+}
+function thinkingLevel(step) {
+	if (step.reasoning === void 0 || step.reasoning === "provider-default") return {};
+	return { thinkingLevel: step.reasoning === "none" ? "off" : step.reasoning };
+}
+function gatewayHeaders(credential) {
+	return {
+		authorization: `Bearer ${credential.token}`,
+		"ai-gateway-auth-method": credential.method
+	};
+}
+/** A stable Pi session ID for an A2 session, so Pi's cache affinity holds. */
+function sessionUuid(agentName, sessionId) {
+	const hex = createHash("sha256").update(`${agentName}\u001f${sessionId}`).digest("hex");
+	return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-8${hex.slice(13, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+}
+function savedSession(state) {
+	if (typeof state !== "object" || state === null) return void 0;
+	const { version, cwd, header, entries } = state;
+	if (version !== SNAPSHOT_VERSION || typeof cwd !== "string" || typeof header !== "object" || header === null || !Array.isArray(entries)) return void 0;
+	return {
+		cwd,
+		header,
+		entries
+	};
+}
+function compactionData(event) {
+	if (event.result === void 0) return { status: event.aborted ? "interrupted" : "failed" };
+	return {
+		status: "completed",
+		inputTokens: event.result.tokensBefore,
+		summary: event.result.summary,
+		...event.result.usage === void 0 ? {} : { usage: modelUsage(event.result.usage) }
+	};
+}
+function finishReason(reason) {
+	switch (reason) {
+		case "stop": return "stop";
+		case "length": return "length";
+		case "toolUse": return "tool-calls";
+		case "error": return "error";
+		default: return "other";
+	}
+}
+function modelUsage(usage) {
+	return {
+		inputTokens: usage.input + usage.cacheRead + usage.cacheWrite,
+		inputTokenDetails: {
+			noCacheTokens: usage.input,
+			cacheReadTokens: usage.cacheRead,
+			cacheWriteTokens: usage.cacheWrite
+		},
+		outputTokens: usage.output,
+		outputTokenDetails: {
+			textTokens: usage.reasoning === void 0 ? void 0 : usage.output - usage.reasoning,
+			reasoningTokens: usage.reasoning
+		},
+		totalTokens: usage.totalTokens
+	};
+}
+function asError(error) {
+	return error instanceof Error ? error : new Error(String(error));
+}
+//#endregion
+export { pi };
+
+//# sourceMappingURL=ai-pi.js.map