@pumped-fn/agent-sdk 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1281 @@
+import { atom, flow, resource, tag, tags, typed } from "@pumped-fn/lite";
+import { SuspendSignal, SuspenseSignal, extension as extension$1, formatSuspenseStepKey, stepCounter } from "@pumped-fn/lite-extension-suspense";
+//#region src/index.ts
+const step = tag({
+	label: "agent.step",
+	default: {}
+});
+const materialKind = tag({ label: "agent.materialKind" });
+const workers = tag({ label: "agent.workerRegistry" });
+var WorkerRegistry = class {
+	flows = /* @__PURE__ */ new Map();
+	register(flow, name = flow.name) {
+		if (!name) throw new Error("Worker flow must have a name");
+		this.flows.set(name, flow);
+		return this;
+	}
+	get(name) {
+		const found = this.flows.get(name);
+		if (!found) throw new Error(`Worker "${name}" not registered`);
+		return found;
+	}
+	list() {
+		return [...this.flows.keys()];
+	}
+};
+function workerRegistry(flows = []) {
+	const registry = new WorkerRegistry();
+	for (const workerFlow of flows) registry.register(workerFlow);
+	return registry;
+}
+function formatStepKey(key) {
+	return formatSuspenseStepKey(key);
+}
+const workflowRun = tag({ label: "workflow.run" });
+const workflow = tag({ label: "workflow.runtime" });
+const runtime = tag({ label: "agent.runtime" });
+const abortSignal = tag({ label: "workflow.abortSignal" });
+const activeWorkflowEvent = tag({ label: "workflow.event" });
+async function delegateWorker(ctx, name, input) {
+	const registry = registryOf(ctx);
+	if (!registry) throw new Error("Worker registry not found");
+	const target = registry.get(name);
+	return ctx.exec({
+		flow: target,
+		input
+	});
+}
+function workflowExtension(options) {
+	const base = createWorkflowExtension({
+		name: "workflow",
+		options,
+		shouldHandle: shouldHandleWorkflowTarget,
+		run: (event, next) => runTimer(event.target, event.ctx, next)
+	});
+	return {
+		...base,
+		async wrapExec(next, target, ctx) {
+			const wrapExec = base.wrapExec;
+			if (!wrapExec) return withRuntimeTag(ctx, workflow, workflowRuntimeOf(ctx, options), next);
+			return withRuntimeTag(ctx, workflow, workflowRuntimeOf(ctx, options), () => wrapExec(next, target, ctx));
+		}
+	};
+}
+function extension(options = {}) {
+	return {
+		name: "agent-sdk",
+		async wrapExec(next, target, ctx) {
+			return withRuntimeTag(ctx, runtime, runtimeOf(ctx), async () => {
+				if (stepOf(target, ctx).remote !== true) return next();
+				if (!options.remoteRunner) throw new Error("Remote step requires remoteRunner");
+				return options.remoteRunner.run(execEvent(target, ctx), next);
+			});
+		}
+	};
+}
+function createWorkflowExtension(options) {
+	return extension$1({
+		name: options.name,
+		log: options.options.log,
+		defaultTaskId: options.options.defaultTaskId,
+		defaultRunId: options.options.defaultRunId,
+		getKey: (ctx) => nextWorkflowKey(ctx, options.options),
+		shouldHandle: options.shouldHandle,
+		shouldSuspend: (event) => {
+			const config = stepOf(event.target, event.ctx);
+			return config.durable === true && config.remote !== true;
+		},
+		createPendingEntry: (event) => ({
+			status: "pending",
+			key: event.key,
+			targetName: event.targetName,
+			input: event.input,
+			kind: "durable"
+		}),
+		run: (event, next) => {
+			const previous = event.ctx.data.getTag(activeWorkflowEvent);
+			event.ctx.data.setTag(activeWorkflowEvent, event);
+			return options.run(event, next).finally(() => {
+				if (previous) event.ctx.data.setTag(activeWorkflowEvent, previous);
+				else event.ctx.data.deleteTag(activeWorkflowEvent);
+			});
+		}
+	});
+}
+function registryOf(ctx) {
+	return ctx.data.seekTag(workers);
+}
+function execEvent(target, ctx) {
+	return ctx.data.seekTag(activeWorkflowEvent) ?? {
+		target,
+		ctx,
+		targetName: targetNameOf(target, ctx),
+		input: ctx.input
+	};
+}
+function nextWorkflowKey(ctx, options) {
+	const config = ctx.data.seekTag(workflowRun);
+	const foundTaskId = config?.taskId ?? options.defaultTaskId ?? "default-task";
+	const foundRunId = config?.runId ?? options.defaultRunId ?? "default-run";
+	let counter = ctx.data.seekTag(stepCounter);
+	if (!counter) {
+		counter = { next: 0 };
+		rootContext(ctx).data.setTag(stepCounter, counter);
+	}
+	return {
+		taskId: foundTaskId,
+		runId: foundRunId,
+		step: counter.next++
+	};
+}
+function workflowRuntimeOf(ctx, options) {
+	const config = ctx.data.seekTag(workflowRun);
+	return {
+		taskId: config?.taskId ?? options.defaultTaskId ?? "default-task",
+		runId: config?.runId ?? options.defaultRunId ?? "default-run"
+	};
+}
+function runtimeOf(ctx) {
+	const config = ctx.data.seekTag(workflow);
+	if (!config) throw new Error("agent extension requires workflow extension");
+	return {
+		taskId: config.taskId,
+		runId: config.runId,
+		delegate: (name, input) => delegateWorker(ctx, name, input)
+	};
+}
+function withRuntimeTag(ctx, runtimeTag, value, next) {
+	const hadPrevious = ctx.data.hasTag(runtimeTag);
+	const previous = ctx.data.getTag(runtimeTag);
+	ctx.data.setTag(runtimeTag, value);
+	return next().finally(() => {
+		if (hadPrevious) ctx.data.setTag(runtimeTag, previous);
+		else ctx.data.deleteTag(runtimeTag);
+	});
+}
+function shouldHandleWorkflowTarget(target, ctx) {
+	const config = stepOf(target, ctx);
+	return config.workflow === true || config.durable === true || config.timeoutMs !== void 0;
+}
+function rootContext(ctx) {
+	let current = ctx;
+	while (current.parent) current = current.parent;
+	return current;
+}
+function targetNameOf(target, ctx) {
+	const name = ctx.name || target.name;
+	if (!name) throw new Error("Agent target must have a name");
+	return name;
+}
+function runTimer(target, ctx, next) {
+	const timeoutMs = stepOf(target, ctx).timeoutMs;
+	if (timeoutMs === void 0) return next();
+	const controller = new AbortController();
+	let timer;
+	return withRuntimeTag(ctx, abortSignal, controller.signal, () => Promise.race([next(), new Promise((_, reject) => {
+		timer = setTimeout(() => {
+			const error = /* @__PURE__ */ new Error(`Workflow step timed out after ${timeoutMs}ms`);
+			controller.abort(error);
+			reject(error);
+		}, timeoutMs);
+	})])).finally(() => {
+		if (timer) clearTimeout(timer);
+	});
+}
+function stepOf(target, ctx) {
+	return {
+		...typeof target === "function" ? {} : step.find(target),
+		...ctx.data.seekTag(step) ?? {}
+	};
+}
+const materialPatches = /* @__PURE__ */ new WeakMap();
+var MaterialConflictError = class extends Error {
+	expectedRevision;
+	currentRevision;
+	name = "MaterialConflictError";
+	constructor(expectedRevision, currentRevision) {
+		super(`Material revision conflict: expected ${expectedRevision}, current ${currentRevision}`);
+		this.expectedRevision = expectedRevision;
+		this.currentRevision = currentRevision;
+	}
+};
+function material(name, options) {
+	return atom({
+		keepAlive: options.keepAlive ?? true,
+		tags: [materialKind(options.kind), ...options.tags ?? []],
+		factory: () => ({
+			name,
+			kind: options.kind,
+			revision: 0,
+			state: clone(options.initialState)
+		})
+	});
+}
+async function patchMaterial(ctx, target, ops, options = {}) {
+	return queueMaterialPatch(ctx, target, async () => {
+		const ctrl = ctx.scope.controller(target);
+		if (ctrl.state === "idle") await ctrl.resolve();
+		const current = ctrl.get();
+		if (current.kind !== "json") throw new Error(`Material "${current.name}" does not accept JSON Patch`);
+		if (options.expectedRevision !== void 0 && options.expectedRevision !== current.revision) throw new MaterialConflictError(options.expectedRevision, current.revision);
+		ctrl.set({
+			...current,
+			revision: current.revision + 1,
+			state: applyJsonPatch(current.state, ops)
+		});
+		return ctrl.get();
+	});
+}
+function derivedMaterial(name, source, derive, options) {
+	return atom({
+		keepAlive: options.keepAlive ?? true,
+		deps: { source },
+		tags: [materialKind(options.kind), ...options.tags ?? []],
+		factory: (_ctx, deps) => ({
+			name,
+			kind: options.kind,
+			revision: deps.source.revision,
+			state: derive(deps.source.state)
+		})
+	});
+}
+function queueMaterialPatch(ctx, target, run) {
+	let scopePatches = materialPatches.get(ctx.scope);
+	if (!scopePatches) {
+		scopePatches = /* @__PURE__ */ new WeakMap();
+		materialPatches.set(ctx.scope, scopePatches);
+	}
+	const current = (scopePatches.get(target) ?? Promise.resolve()).catch(() => void 0).then(run);
+	const lock = current.then(() => void 0, () => void 0);
+	scopePatches.set(target, lock);
+	lock.then(() => {
+		if (scopePatches.get(target) === lock) scopePatches.delete(target);
+	});
+	return current;
+}
+function applyJsonPatch(source, ops) {
+	let document = clone(source);
+	for (const op of ops) {
+		if (op.path === "") {
+			if (op.op === "remove") document = null;
+			else document = clone(op.value);
+			continue;
+		}
+		const parts = splitPointer(op.path);
+		const key = parts.at(-1);
+		if (key === void 0) throw new Error("JSON Patch path cannot be empty");
+		const parent = findPatchParent(document, parts.slice(0, -1));
+		if (op.op === "remove") removeValue(parent, key);
+		else setValue(parent, key, clone(op.value), op.op);
+	}
+	return document;
+}
+function splitPointer(path) {
+	if (!path.startsWith("/")) throw new Error(`Invalid JSON Pointer "${path}"`);
+	return path.slice(1).split("/").map((part) => part.replace(/~1/g, "/").replace(/~0/g, "~"));
+}
+function findPatchParent(document, parts) {
+	let current = document;
+	for (const part of parts) {
+		if (Array.isArray(current)) {
+			current = current[Number(part)];
+			continue;
+		}
+		if (isRecord(current)) {
+			current = current[part];
+			continue;
+		}
+		throw new Error(`Cannot traverse JSON Patch path at "${part}"`);
+	}
+	return current;
+}
+function setValue(parent, key, value, op) {
+	if (Array.isArray(parent)) {
+		if (key === "-") {
+			parent.push(value);
+			return;
+		}
+		const index = Number(key);
+		if (op === "add") parent.splice(index, 0, value);
+		else parent[index] = value;
+		return;
+	}
+	if (!isRecord(parent)) throw new Error(`Cannot set JSON Patch path "${key}"`);
+	parent[key] = value;
+}
+function removeValue(parent, key) {
+	if (Array.isArray(parent)) {
+		parent.splice(Number(key), 1);
+		return;
+	}
+	if (!isRecord(parent)) throw new Error(`Cannot remove JSON Patch path "${key}"`);
+	delete parent[key];
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function clone(value) {
+	return structuredClone(value);
+}
+var CliWorkerError = class extends Error {
+	result;
+	name = "CliWorkerError";
+	constructor(message, result) {
+		super(message);
+		this.result = result;
+	}
+};
+function cliWorker(options) {
+	const config = { kind: options.kind ?? "cli" };
+	if (options.timeoutMs !== void 0) config.timeoutMs = options.timeoutMs;
+	const tags = [step(config), ...options.tags ?? []];
+	const factory = async (ctx) => {
+		const input = ctx.input;
+		const result = await runCli({
+			command: resolveRequiredValue(options.command, input, ctx),
+			args: resolveValue(options.args ?? [], input, ctx),
+			stdin: resolveValue(options.stdin, input, ctx),
+			cwd: resolveValue(options.cwd, input, ctx),
+			env: resolveValue(options.env, input, ctx),
+			isolate: resolveValue(options.isolate, input, ctx),
+			timeoutMs: options.timeoutMs,
+			signal: ctx.data.seekTag(abortSignal)
+		});
+		return options.parseOutput ? options.parseOutput(result, input) : result.stdout.trim();
+	};
+	const flowOptions = {
+		name: options.name,
+		tags,
+		factory
+	};
+	return typeof options.parse === "function" ? flow({
+		...flowOptions,
+		parse: options.parse
+	}) : flow({
+		...flowOptions,
+		parse: options.parse ?? typed()
+	});
+}
+async function runCli(options) {
+	const { execFile } = await import("node:child_process");
+	const prepared = await prepareCli(options);
+	return new Promise((resolve, reject) => {
+		execFile(prepared.command, [...prepared.args], {
+			cwd: prepared.cwd,
+			env: prepared.env,
+			timeout: options.timeoutMs,
+			signal: options.signal
+		}, async (error, stdout, stderr) => {
+			await prepared.cleanup();
+			const execError = error;
+			const exitCode = typeof execError?.code === "number" ? execError.code : error ? null : 0;
+			const signal = execError?.signal ?? null;
+			const result = {
+				stdout: String(stdout),
+				stderr: String(stderr),
+				exitCode,
+				signal
+			};
+			if (execError?.killed && options.timeoutMs !== void 0) {
+				reject(new CliWorkerError(`CLI command timed out after ${options.timeoutMs}ms`, result));
+				return;
+			}
+			if (execError?.name === "AbortError") {
+				reject(new CliWorkerError("CLI command aborted", result));
+				return;
+			}
+			if (error) {
+				reject(new CliWorkerError(exitCode === null ? error.message : `CLI command failed with exit code ${exitCode}`, result));
+				return;
+			}
+			resolve(result);
+		}).stdin?.end(options.stdin);
+	});
+}
+async function prepareCli(options) {
+	if (!options.isolate) return {
+		command: options.command,
+		args: options.args ?? [],
+		cwd: options.cwd,
+		env: {
+			...process.env,
+			...options.env
+		},
+		cleanup: async () => void 0
+	};
+	return prepareIsolatedCli(options, typeof options.isolate === "boolean" ? {} : options.isolate);
+}
+async function prepareIsolatedCli(options, isolate) {
+	const { mkdtemp, rm, realpath } = await import("node:fs/promises");
+	const { existsSync } = await import("node:fs");
+	const { dirname, join, resolve } = await import("node:path");
+	const { tmpdir } = await import("node:os");
+	const hostCwd = resolve(options.cwd ?? process.cwd());
+	const workdir = isolate.workdir ?? "/workspace";
+	const tempDirs = [];
+	const home = isolate.home ?? await mkdtemp(join(tmpdir(), "pumped-fn-home-"));
+	if (!isolate.home) tempDirs.push(home);
+	const binds = /* @__PURE__ */ new Map();
+	addBind(binds, hostCwd, workdir, isolate.writable === true ? "rw" : "ro");
+	addBind(binds, home, "/home/agent", "rw");
+	if (isolate.codexHome) addBind(binds, isolate.codexHome, "/codex-home", "rw");
+	const commandPath = await commandPathOf(options.command, process.env["PATH"] ?? "", existsSync, realpath);
+	const nodePath = await realpath(process.execPath);
+	for (const dir of defaultCliDirs(existsSync)) addBind(binds, dir, dir, "ro");
+	for (const dir of defaultCliCertDirs(existsSync)) addBind(binds, dir, dir, "ro");
+	for (const file of defaultCliFiles(existsSync)) addBind(binds, file, file, "ro");
+	if (commandPath) {
+		addBind(binds, dirname(commandPath), dirname(commandPath), "ro");
+		addBind(binds, dirname(dirname(commandPath)), dirname(dirname(commandPath)), "ro");
+	}
+	addBind(binds, dirname(nodePath), dirname(nodePath), "ro");
+	addBind(binds, dirname(dirname(nodePath)), dirname(dirname(nodePath)), "ro");
+	for (const bind of isolate.bind ?? []) addBind(binds, bind.source, bind.target ?? bind.source, bind.mode ?? "ro");
+	const env = {
+		PATH: isolatedPathEnv(commandPath, nodePath, dirname),
+		HOME: "/home/agent",
+		TMPDIR: "/tmp",
+		...isolate.codexHome ? { CODEX_HOME: "/codex-home" } : {},
+		...options.env,
+		...isolate.env
+	};
+	return {
+		command: isolate.bwrap ?? "bwrap",
+		args: [
+			"--die-with-parent",
+			"--unshare-all",
+			...isolate.network === true ? ["--share-net"] : [],
+			"--proc",
+			"/proc",
+			"--dev",
+			"/dev",
+			"--tmpfs",
+			"/tmp",
+			"--dir",
+			"/etc",
+			"--dir",
+			"/home",
+			...Object.entries(env).flatMap(([key, value]) => value === void 0 ? [] : [
+				"--setenv",
+				key,
+				value
+			]),
+			...[...binds.values()].flatMap((bind) => [
+				bind.mode === "rw" ? "--bind" : "--ro-bind",
+				bind.source,
+				bind.target
+			]),
+			"--chdir",
+			workdir,
+			"--",
+			commandPath ?? options.command,
+			...options.args ?? []
+		],
+		env: { PATH: process.env["PATH"] },
+		cleanup: async () => {
+			await Promise.all(tempDirs.map((dir) => rm(dir, {
+				recursive: true,
+				force: true
+			})));
+		}
+	};
+}
+function addBind(binds, source, target, mode) {
+	binds.set(`${source}\u0000${target}`, {
+		source,
+		target,
+		mode
+	});
+}
+function defaultCliDirs(exists) {
+	return [
+		"/usr/bin",
+		"/bin",
+		"/usr/lib",
+		"/usr/lib64",
+		"/lib",
+		"/lib64"
+	].filter((path, index, items) => items.indexOf(path) === index && exists(path));
+}
+function defaultCliCertDirs(exists) {
+	return [
+		"/etc/ssl",
+		"/etc/pki",
+		"/etc/ca-certificates",
+		"/usr/share/ca-certificates",
+		"/usr/local/share/ca-certificates"
+	].filter((path, index, items) => items.indexOf(path) === index && exists(path));
+}
+function defaultCliFiles(exists) {
+	return ["/etc/hosts", "/etc/resolv.conf"].filter((path, index, items) => items.indexOf(path) === index && exists(path));
+}
+function isolatedPathEnv(commandPath, nodePath, dirname) {
+	return [
+		commandPath ? dirname(commandPath) : void 0,
+		dirname(nodePath),
+		"/usr/bin",
+		"/bin"
+	].filter((path, index, items) => path !== void 0 && items.indexOf(path) === index).join(":");
+}
+async function commandPathOf(command, pathEnv, exists, realpath) {
+	if (command.includes("/")) return realpath(command);
+	const found = pathEnv.split(":").filter(Boolean).map((dir) => `${dir}/${command}`).find((path) => exists(path));
+	return found ? realpath(found) : void 0;
+}
+function resolveValue(value, input, ctx) {
+	if (typeof value === "function") return value(input, ctx);
+	return value;
+}
+function resolveRequiredValue(value, input, ctx) {
+	if (typeof value === "function") return value(input, ctx);
+	return value;
+}
+function guard(name, text = "") {
+	return material(name, {
+		kind: "json",
+		initialState: { text }
+	});
+}
+function claudeCliWorker(options = {}) {
+	assertNoClaudeBare(options.extraArgs ?? []);
+	return cliWorker({
+		name: options.name ?? "claude",
+		command: options.command ?? "claude",
+		args: (input) => cliPromptArgs(["-p", ...options.extraArgs ?? []], input.prompt),
+		isolate: options.isolate,
+		timeoutMs: options.timeoutMs,
+		kind: "llm",
+		tags: options.tags
+	});
+}
+function codexCliWorker(options = {}) {
+	return cliWorker({
+		name: options.name ?? "codex",
+		command: options.command ?? "codex",
+		args: (input) => cliPromptArgs([
+			"exec",
+			"-s",
+			options.sandbox ?? "read-only",
+			...options.extraArgs ?? []
+		], input.prompt),
+		isolate: options.isolate,
+		timeoutMs: options.timeoutMs,
+		kind: "llm",
+		tags: options.tags
+	});
+}
+function claudeHarness(options = {}) {
+	return cliHarnessModel(claudeCliWorker({
+		name: options.name ?? "claude-harness",
+		command: options.command,
+		extraArgs: ["--no-session-persistence", ...options.extraArgs ?? []],
+		isolate: options.isolate ?? { network: true },
+		timeoutMs: options.timeoutMs,
+		tags: options.tags
+	}), {
+		guard: options.guard === void 0 ? guard(`${options.name ?? "claude-harness"}-guard`) : options.guard,
+		prompt: options.prompt,
+		parse: options.parse
+	});
+}
+function codexHarness(options = {}) {
+	return cliHarnessModel(codexCliWorker({
+		name: options.name ?? "codex-harness",
+		command: options.command,
+		sandbox: options.sandbox,
+		extraArgs: [
+			"--ephemeral",
+			"--ignore-user-config",
+			...options.extraArgs ?? []
+		],
+		isolate: options.isolate ?? { network: true },
+		timeoutMs: options.timeoutMs,
+		tags: options.tags
+	}), {
+		guard: options.guard === void 0 ? guard(`${options.name ?? "codex-harness"}-guard`) : options.guard,
+		prompt: options.prompt,
+		parse: options.parse
+	});
+}
+function cliHarnessModel(worker, config) {
+	return { complete: async (ctx, request) => {
+		const current = config.guard ? await ctx.resolve(config.guard) : void 0;
+		const state = current?.state ?? { text: "" };
+		const output = await ctx.exec({
+			flow: worker,
+			input: { prompt: config.prompt ? config.prompt(request, state) : modelPrompt(request, state) }
+		});
+		const response = config.parse ? config.parse(output) : parseModelOutput(output);
+		if (config.guard && current) await collectGuard(ctx, config.guard, current, response);
+		return response;
+	} };
+}
+async function collectGuard(ctx, store, current, response) {
+	const text = guardTextOf(response.guard);
+	if (!text || current.state.text) return;
+	await patchMaterial(ctx, store, [{
+		op: "replace",
+		path: "/text",
+		value: text
+	}], { expectedRevision: current.revision });
+}
+function modelPrompt(request, guard) {
+	return [
+		"Return JSON only.",
+		"Schema: {\"content\":string,\"stop\"?:boolean,\"guard\"?:string,\"skillCalls\"?:array,\"toolCalls\"?:array,\"subagentCalls\"?:array}.",
+		guard.text ? `Guard:\n${guard.text}` : "First run only: set guard to the anti-goal that should prevent this agent from drifting.",
+		`Agent: ${request.agentName}`,
+		request.instructions ? `Instructions:\n${request.instructions}` : void 0,
+		request.skills.length ? `Available skills:\n${request.skills.map(formatCapability).join("\n")}` : void 0,
+		request.loadedSkills.length ? `Loaded skills:\n${request.loadedSkills.map(formatLoadedSkill).join("\n\n")}` : void 0,
+		request.tools.length ? `Available tools:\n${request.tools.map(formatCapability).join("\n")}` : void 0,
+		request.subagents.length ? `Available subagents:\n${request.subagents.map(formatCapability).join("\n")}` : void 0,
+		`Round: ${request.round}`,
+		`Messages:\n${request.messages.map(formatMessage).join("\n")}`
+	].filter((item) => item !== void 0).join("\n\n");
+}
+function parseModelOutput(output) {
+	const value = readJson(output);
+	if (!isRecord(value)) return {
+		content: output,
+		stop: true
+	};
+	const response = {
+		content: typeof value["content"] === "string" ? value["content"] : output,
+		stop: typeof value["stop"] === "boolean" ? value["stop"] : true
+	};
+	const guard = guardTextOf(value["guard"] ?? value["antiGoal"]);
+	const skillCalls = skillCallsOf(value["skillCalls"]);
+	const toolCalls = toolCallsOf(value["toolCalls"]);
+	const subagentCalls = subagentCallsOf(value["subagentCalls"]);
+	if (guard) response.guard = guard;
+	if (skillCalls) response.skillCalls = skillCalls;
+	if (toolCalls) response.toolCalls = toolCalls;
+	if (subagentCalls) response.subagentCalls = subagentCalls;
+	return response;
+}
+function readJson(output) {
+	const trimmed = output.trim();
+	if (!trimmed) return void 0;
+	try {
+		return JSON.parse(trimmed);
+	} catch {
+		const start = trimmed.indexOf("{");
+		const end = trimmed.lastIndexOf("}");
+		if (start === -1 || end <= start) return void 0;
+		try {
+			return JSON.parse(trimmed.slice(start, end + 1));
+		} catch {
+			return;
+		}
+	}
+}
+function skillCallsOf(value) {
+	if (!Array.isArray(value)) return void 0;
+	const calls = value.flatMap((item) => {
+		if (!isRecord(item) || typeof item["name"] !== "string") return [];
+		return [{
+			name: item["name"],
+			...typeof item["id"] === "string" ? { id: item["id"] } : {}
+		}];
+	});
+	return calls.length ? calls : void 0;
+}
+function toolCallsOf(value) {
+	if (!Array.isArray(value)) return void 0;
+	const calls = value.flatMap((item) => {
+		if (!isRecord(item) || typeof item["name"] !== "string") return [];
+		return [{
+			name: item["name"],
+			input: item["input"],
+			...typeof item["id"] === "string" ? { id: item["id"] } : {}
+		}];
+	});
+	return calls.length ? calls : void 0;
+}
+function subagentCallsOf(value) {
+	if (!Array.isArray(value)) return void 0;
+	const calls = value.flatMap((item) => {
+		if (!isRecord(item) || typeof item["name"] !== "string") return [];
+		return [{
+			name: item["name"],
+			input: turnInputOf(item["input"]),
+			...typeof item["id"] === "string" ? { id: item["id"] } : {}
+		}];
+	});
+	return calls.length ? calls : void 0;
+}
+function turnInputOf(value) {
+	if (isRecord(value)) return value;
+	return { prompt: stringifyAgentValue(value) };
+}
+function guardTextOf(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function formatCapability(capability) {
+	return `- ${capability.name}: ${capability.description}`;
+}
+function formatLoadedSkill(skill) {
+	return `## ${skill.name}\n${skill.content}`;
+}
+function formatMessage(message) {
+	return message.name ? `${message.role}(${message.name}): ${message.content}` : `${message.role}: ${message.content}`;
+}
+function assertNoClaudeBare(args) {
+	if (args.some((arg) => arg === "--bare" || arg.startsWith("--bare="))) throw new Error("Claude harness must not use --bare");
+}
+function cliPromptArgs(args, prompt) {
+	if (args.includes("--")) throw new Error("CLI helper extraArgs cannot include --");
+	return [
+		...args,
+		"--",
+		prompt
+	];
+}
+const events = resource({
+	name: "agent.events",
+	ownership: "boundary",
+	factory: () => {
+		let next = 0;
+		const events = [];
+		return {
+			get events() {
+				return events;
+			},
+			record(event) {
+				const stored = {
+					...event,
+					index: next++
+				};
+				events.push(stored);
+				return stored;
+			}
+		};
+	}
+});
+const model = tag({ label: "agent.model" });
+const sandbox = tag({ label: "agent.sandbox" });
+function session(name, options = {}) {
+	return material(name, {
+		kind: "json",
+		initialState: { messages: options.messages ?? [] },
+		tags: options.tags,
+		keepAlive: options.keepAlive
+	});
+}
+function tool(options) {
+	const name = options.name ?? options.flow.name;
+	if (!name) throw new Error("Agent tool requires a name");
+	return {
+		name,
+		description: options.description,
+		flow: options.flow
+	};
+}
+function skill(options) {
+	if (options.load) return {
+		name: options.name,
+		description: options.description,
+		load: options.load
+	};
+	const content = options.content ?? "";
+	return {
+		name: options.name,
+		description: options.description,
+		load: () => content
+	};
+}
+function sub(options) {
+	return {
+		name: options.name ?? options.agent.name,
+		description: options.description,
+		agent: options.agent
+	};
+}
+function agent(options) {
+	const tools = options.tools ?? [];
+	const skills = options.skills ?? [];
+	const subagents = options.subagents ?? [];
+	const maxRounds = options.maxRounds ?? 4;
+	let agent;
+	const turn = flow({
+		name: options.name,
+		parse: typed(),
+		deps: { model: tags.required(model) },
+		tags: agentStepTags({
+			workflow: true,
+			kind: "agent"
+		}, options.tags),
+		factory: (ctx, deps) => executeAgentTurn(ctx, agent, deps.model)
+	});
+	agent = {
+		name: options.name,
+		description: options.description,
+		instructions: options.instructions ?? "",
+		tools,
+		skills,
+		subagents,
+		turn,
+		maxRounds
+	};
+	return agent;
+}
+function execTurn(ctx, agent, input, tags = []) {
+	return ctx.exec({
+		flow: agent.turn,
+		input,
+		name: agent.name,
+		tags: [...tags]
+	});
+}
+async function send(ctx, session, agent, input) {
+	const current = await ctx.resolve(session);
+	const result = await execTurn(ctx, agent, {
+		...input,
+		messages: [...current.state.messages, ...input.messages ?? []]
+	});
+	await patchMaterial(ctx, session, [{
+		op: "replace",
+		path: "/messages",
+		value: serializeMessages(result.messages)
+	}], { expectedRevision: current.revision });
+	return result;
+}
+function channel(options) {
+	const flowOptions = {
+		name: options.name,
+		tags: agentStepTags({
+			workflow: true,
+			kind: "channel"
+		}, options.tags),
+		factory: async (ctx) => execTurn(ctx, options.agent, await options.input(ctx))
+	};
+	return typeof options.parse === "function" ? flow({
+		...flowOptions,
+		parse: options.parse
+	}) : flow({
+		...flowOptions,
+		parse: options.parse
+	});
+}
+function schedule(options) {
+	return flow({
+		name: options.name,
+		tags: agentStepTags({
+			workflow: true,
+			kind: "schedule"
+		}, options.tags),
+		factory: async (ctx) => execTurn(ctx, options.agent, await options.input(ctx))
+	});
+}
+function judge(options) {
+	return options;
+}
+function suite(options) {
+	const judges = options.judges ?? [];
+	assertJudgeQuorum(judges);
+	return {
+		name: options.name,
+		agent: options.agent,
+		cases: options.cases,
+		judges
+	};
+}
+function includes(text) {
+	return (result) => ({
+		name: `output includes "${text}"`,
+		passed: result.content.includes(text)
+	});
+}
+function used(name) {
+	return (result) => ({
+		name: `tool used "${name}"`,
+		passed: result.toolResults.some((call) => call.name === name)
+	});
+}
+function loaded(name) {
+	return (result) => ({
+		name: `skill loaded "${name}"`,
+		passed: result.skillResults.some((call) => call.name === name)
+	});
+}
+function delegated(name) {
+	return (result) => ({
+		name: `subagent used "${name}"`,
+		passed: result.subagentResults.some((call) => call.name === name)
+	});
+}
+async function runEval(ctx, target) {
+	assertJudgeQuorum(target.judges);
+	const cases = [];
+	for (const item of target.cases) {
+		const result = await execTurn(ctx, target.agent, item.input);
+		const checks = await runEvalChecks(result, item.checks ?? []);
+		const judges = await runEvalJudges(ctx, result, target.judges);
+		cases.push({
+			name: item.name,
+			result,
+			checks,
+			judges,
+			passed: checks.every((check) => check.passed) && judges.every((judge) => judge.passed)
+		});
+	}
+	return {
+		name: target.name,
+		cases,
+		passed: cases.every((item) => item.passed)
+	};
+}
+async function inspect(log, query) {
+	const entries = (await log.entries(query)).filter((entry) => entry.key.taskId === query.taskId && entry.key.runId === query.runId);
+	if (!entries[0]) throw new Error("Run not found");
+	const steps = entries.map(runStep);
+	return {
+		taskId: query.taskId,
+		runId: query.runId,
+		status: steps.some((item) => item.status === "pending") ? "pending" : "completed",
+		steps
+	};
+}
+function summary(report) {
+	return jsonValue({
+		name: report.name,
+		passed: report.passed,
+		cases: report.cases.map((item) => ({
+			name: item.name,
+			passed: item.passed,
+			output: item.result.content,
+			checks: item.checks,
+			judges: item.judges,
+			tools: item.result.toolResults.map((call) => ({
+				name: call.name,
+				output: call.output
+			})),
+			skills: item.result.skillResults.map((call) => ({ name: call.name })),
+			subagents: item.result.subagentResults.map((call) => ({
+				name: call.name,
+				output: call.output.content
+			})),
+			events: item.result.events.map((event) => ({
+				type: event.type,
+				agentName: event.agentName,
+				targetName: event.targetName,
+				round: event.round
+			}))
+		}))
+	});
+}
+function http(options) {
+	return flow({
+		name: options.name ?? `${options.agent.name}-http`,
+		parse: typed(),
+		tags: agentStepTags({
+			workflow: true,
+			kind: "channel"
+		}),
+		factory: async (ctx) => {
+			const request = ctx.input;
+			const input = options.input ? await options.input(request) : await request.json();
+			const tags = options.tags ? await options.tags(request) : [];
+			return Response.json(jsonValue(await execTurn(ctx, options.agent, input, tags)));
+		}
+	});
+}
+async function executeAgentTurn(ctx, agent, model) {
+	const messages = initialMessages(ctx.input);
+	const loadedSkills = [];
+	const skillResults = [];
+	const toolResults = [];
+	const subagentResults = [];
+	const maxRounds = ctx.input.maxRounds ?? agent.maxRounds;
+	let content = "";
+	let rounds = 0;
+	const startIndex = (await ctx.resolve(events)).events.length;
+	await recordAgentEvent(ctx, {
+		type: "agent_start",
+		agentName: agent.name,
+		input: ctx.input
+	});
+	for (let round = 0; round < maxRounds; round++) {
+		rounds = round + 1;
+		await recordAgentEvent(ctx, {
+			type: "agent_model_start",
+			agentName: agent.name,
+			round,
+			input: messages
+		});
+		const response = await model.complete(ctx, {
+			agentName: agent.name,
+			instructions: agent.instructions,
+			messages,
+			tools: agent.tools.map(agentToolCapability),
+			skills: agent.skills.map(agentSkillCapability),
+			loadedSkills,
+			subagents: agent.subagents.map(agentSubagentCapability),
+			round
+		});
+		content = response.content;
+		await recordAgentEvent(ctx, {
+			type: "agent_model_end",
+			agentName: agent.name,
+			round,
+			output: response
+		});
+		const skillCalls = response.skillCalls ?? [];
+		const toolCalls = response.toolCalls ?? [];
+		const subagentCalls = response.subagentCalls ?? [];
+		if (response.content) messages.push({
+			role: "assistant",
+			content: response.content
+		});
+		if (response.stop === true || skillCalls.length === 0 && toolCalls.length === 0 && subagentCalls.length === 0) break;
+		for (const call of skillCalls) {
+			const result = await executeAgentSkill(ctx, agent, call);
+			loadedSkills.push({
+				name: result.name,
+				content: result.content,
+				description: findByName(agent.skills, result.name, "skill").description
+			});
+			skillResults.push(result);
+			messages.push({
+				role: "skill",
+				name: result.name,
+				content: result.content
+			});
+		}
+		for (const call of toolCalls) {
+			const result = await executeAgentTool(ctx, agent, call);
+			toolResults.push(result);
+			messages.push({
+				role: "tool",
+				name: result.name,
+				content: stringifyAgentValue(result.output)
+			});
+		}
+		for (const call of subagentCalls) {
+			const result = await executeAgentSubagent(ctx, agent, call);
+			subagentResults.push(result);
+			messages.push({
+				role: "subagent",
+				name: result.name,
+				content: result.output.content
+			});
+		}
+	}
+	await recordAgentEvent(ctx, {
+		type: "agent_end",
+		agentName: agent.name,
+		output: content
+	});
+	const buffer = await ctx.resolve(events);
+	return {
+		agentName: agent.name,
+		content,
+		messages,
+		skillResults,
+		toolResults,
+		subagentResults,
+		rounds,
+		events: buffer.events.slice(startIndex)
+	};
+}
+async function executeAgentSkill(ctx, agent, call) {
+	const target = findByName(agent.skills, call.name, "skill");
+	await recordAgentEvent(ctx, {
+		type: "agent_skill_start",
+		agentName: agent.name,
+		targetName: target.name
+	});
+	const content = await ctx.exec({
+		fn: (skillCtx) => target.load(skillCtx),
+		params: [],
+		name: target.name,
+		tags: [agentStepTag({
+			workflow: true,
+			kind: "skill"
+		})]
+	});
+	await recordAgentEvent(ctx, {
+		type: "agent_skill_end",
+		agentName: agent.name,
+		targetName: target.name,
+		output: content
+	});
+	return {
+		name: target.name,
+		id: call.id,
+		content
+	};
+}
+async function executeAgentTool(ctx, agent, call) {
+	const target = findByName(agent.tools, call.name, "tool");
+	await recordAgentEvent(ctx, {
+		type: "agent_tool_start",
+		agentName: agent.name,
+		targetName: target.name,
+		input: call.input
+	});
+	const output = await ctx.exec({
+		flow: target.flow,
+		rawInput: call.input,
+		name: target.name,
+		tags: [agentStepTag({
+			workflow: true,
+			kind: "tool"
+		}, target.flow.tags)]
+	});
+	await recordAgentEvent(ctx, {
+		type: "agent_tool_end",
+		agentName: agent.name,
+		targetName: target.name,
+		output
+	});
+	return {
+		name: target.name,
+		id: call.id,
+		input: call.input,
+		output
+	};
+}
+async function executeAgentSubagent(ctx, agent, call) {
+	const target = findByName(agent.subagents, call.name, "subagent");
+	await recordAgentEvent(ctx, {
+		type: "agent_subagent_start",
+		agentName: agent.name,
+		targetName: target.name,
+		input: call.input
+	});
+	const output = await ctx.exec({
+		flow: target.agent.turn,
+		input: call.input,
+		name: target.name,
+		tags: [agentStepTag({
+			workflow: true,
+			kind: "subagent"
+		}, target.agent.turn.tags)]
+	});
+	await recordAgentEvent(ctx, {
+		type: "agent_subagent_end",
+		agentName: agent.name,
+		targetName: target.name,
+		output
+	});
+	return {
+		name: target.name,
+		id: call.id,
+		input: call.input,
+		output
+	};
+}
+async function recordAgentEvent(ctx, event) {
+	return (await ctx.resolve(events)).record(event);
+}
+function initialMessages(input) {
+	return [...input.messages ?? [], ...input.prompt ? [{
+		role: "user",
+		content: input.prompt
+	}] : []];
+}
+function agentStepTags(defaults, source = []) {
+	return [agentStepTag(defaults, source), ...source.filter((tagged) => tagged.key !== step.key)];
+}
+function agentStepTag(defaults, source = []) {
+	return step(Object.assign({}, defaults, ...step.collect(source)));
+}
+function agentToolCapability(tool) {
+	return {
+		name: tool.name,
+		description: tool.description
+	};
+}
+function agentSkillCapability(skill) {
+	return {
+		name: skill.name,
+		description: skill.description ?? ""
+	};
+}
+function agentSubagentCapability(subagent) {
+	return {
+		name: subagent.name,
+		description: subagent.description
+	};
+}
+function findByName(items, name, kind) {
+	const found = items.find((item) => item.name === name);
+	if (!found) throw new Error(`Agent ${kind} "${name}" not found`);
+	return found;
+}
+function runStep(entry) {
+	if (entry.status === "pending") return {
+		key: entry.key,
+		status: entry.status,
+		targetName: entry.targetName,
+		input: entry.input,
+		kind: entry.kind
+	};
+	if (entry.status === "resolved") return {
+		key: entry.key,
+		status: entry.status,
+		targetName: entry.targetName,
+		output: entry.value
+	};
+	return {
+		key: entry.key,
+		status: entry.status,
+		targetName: entry.targetName,
+		output: entry.result
+	};
+}
+function stringifyAgentValue(value) {
+	if (typeof value === "string") return value;
+	if (value === void 0) return String(value);
+	if (typeof value === "bigint" || typeof value === "symbol" || typeof value === "function") return String(value);
+	const seen = /* @__PURE__ */ new WeakSet();
+	return JSON.stringify(value, (_key, item) => {
+		if (typeof item === "bigint" || typeof item === "symbol" || typeof item === "function") return String(item);
+		if (typeof item === "object" && item !== null) {
+			if (seen.has(item)) return "[Circular]";
+			seen.add(item);
+		}
+		return item;
+	}) ?? String(value);
+}
+function jsonValue(value, seen = /* @__PURE__ */ new WeakSet()) {
+	if (value === null) return null;
+	if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+	if (value === void 0 || typeof value === "bigint" || typeof value === "symbol" || typeof value === "function") return String(value);
+	if (Array.isArray(value)) return value.map((item) => jsonValue(item, seen));
+	if (typeof value === "object") {
+		if (seen.has(value)) return "[Circular]";
+		seen.add(value);
+		return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, jsonValue(item, seen)]));
+	}
+	return String(value);
+}
+function serializeMessages(messages) {
+	return messages.map((message) => {
+		const serialized = {
+			role: message.role,
+			content: message.content
+		};
+		if (message.name !== void 0) serialized["name"] = message.name;
+		return serialized;
+	});
+}
+async function runEvalChecks(result, checks) {
+	const results = [];
+	for (const check of checks) results.push(await check(result));
+	return results;
+}
+function assertJudgeQuorum(judges) {
+	if (judges.length === 1) throw new Error("Agent evals require zero judges or at least two judges");
+}
+async function runEvalJudges(ctx, result, judges) {
+	const results = [];
+	for (const judge of judges) results.push(await judge.evaluate(ctx, result));
+	return results;
+}
+//#endregion
+export { CliWorkerError, MaterialConflictError, SuspendSignal, SuspenseSignal, WorkerRegistry, abortSignal, agent, channel, claudeCliWorker, claudeHarness, cliWorker, codexCliWorker, codexHarness, delegated, derivedMaterial, events, extension, formatStepKey, guard, http, includes, inspect, judge, loaded, material, materialKind, model, patchMaterial, runCli, runEval, runtime, sandbox, schedule, send, session, skill, step, sub, suite, summary, tool, used, workerRegistry, workers, workflow, workflowExtension, workflowRun };
+
+//# sourceMappingURL=index.mjs.map