@fevex/core 0.1.0-alpha.0 → 0.1.0-alpha.10

package/dist/runtime/index.d.mts

@@ -1,17 +1,2 @@
-import { a as ExecutionContext, t as AgentEvent } from "../index-D_RBJmVt.mjs";
-import { ModelUsage } from "../models/index.mjs";
-import { StandardSchemaV1 } from "@standard-schema/spec";
-//#region src/runtime/index.d.ts
-interface RunRequest<TInput = unknown, TOutput = unknown> {
-  input: TInput;
-  context?: ExecutionContext;
-  outputSchema?: StandardSchemaV1<unknown, TOutput>;
-  signal?: AbortSignal;
-}
-interface RunResult<TOutput = unknown> {
-  output: TOutput;
-  events?: AgentEvent[];
-  usage?: ModelUsage;
-}
-//#endregion
-export { RunRequest, RunResult };
+import { $ as SessionCompaction, A as ElicitationMode, B as ResumeRunResolution, C as ApprovalMode, D as CoordinatorRun, E as CoordinatorCheckpoint, F as ExecutionCreate, G as RunLease, H as RetainableRunStore, I as ListEventsOptions, J as RunRequest, K as RunPause, L as PendingToolExecution, M as ElicitationResolution, N as EventResolution, O as CredentialStore, P as ExecutionCommit, Q as Session, R as PurgeRunsOptions, S as AgentRunPause, T as ApprovalResolution, U as RunCheckpoint, V as RetainableRunStatus, W as RunCorrelation, X as RunStatus, Y as RunResult, Z as RunStore, _ as createDigestContextCompactor, _t as validatePurgeRunsOptions, at as ToolExecutionRecord, b as resolveContextBudget, c as InMemoryRunStore, ct as WorkflowBudgetUsage, d as ContextCompactionStats, dt as WorkflowRun, et as SessionId, f as ContextCompactor, ft as WorkflowStepRecord, g as ResolvedContextBudget, gt as validateListEventsOptions, h as ModelContextCompactorOptions, ht as isRetainableRunStore, it as TimerResolution, j as ElicitationRequest, k as DurableRunStore, l as ContextCompactionInput, lt as WorkflowCheckpoint, m as DigestContextCompactorOptions, mt as isDurableRunStore, nt as TeamCheckpoint, ot as ToolExecutionResolution, p as ContextTokenEstimator, pt as WorkflowWaitRecord, q as RunRecord, rt as TeamRun, st as ToolExecutionStatus, tt as StoredRunCheckpoint, u as ContextCompactionOptions, ut as WorkflowCompensationRecord, v as createModelContextCompactor, w as ApprovalRequest, x as AgentRun, y as estimateContextTokens, z as PurgeRunsResult } from "../index-lCCFokc6.mjs";
+export { AgentRun, AgentRunPause, ApprovalMode, ApprovalRequest, ApprovalResolution, ContextCompactionInput, ContextCompactionOptions, ContextCompactionStats, ContextCompactor, ContextTokenEstimator, CoordinatorCheckpoint, CoordinatorRun, CredentialStore, DigestContextCompactorOptions, DurableRunStore, ElicitationMode, ElicitationRequest, ElicitationResolution, EventResolution, ExecutionCommit, ExecutionCreate, InMemoryRunStore, ListEventsOptions, ModelContextCompactorOptions, PendingToolExecution, PurgeRunsOptions, PurgeRunsResult, ResolvedContextBudget, ResumeRunResolution, RetainableRunStatus, RetainableRunStore, RunCheckpoint, RunCorrelation, RunLease, RunPause, RunRecord, RunRequest, RunResult, RunStatus, RunStore, Session, SessionCompaction, SessionId, StoredRunCheckpoint, TeamCheckpoint, TeamRun, TimerResolution, ToolExecutionRecord, ToolExecutionResolution, ToolExecutionStatus, WorkflowBudgetUsage, WorkflowCheckpoint, WorkflowCompensationRecord, WorkflowRun, WorkflowStepRecord, WorkflowWaitRecord, createDigestContextCompactor, createModelContextCompactor, estimateContextTokens, isDurableRunStore, isRetainableRunStore, resolveContextBudget, validateListEventsOptions, validatePurgeRunsOptions };

package/dist/runtime/index.mjs

@@ -1 +1,354 @@
-export {};
+import { t as FevexRunError } from "../run-error-Cr17wPGH.mjs";
+//#region src/runtime/compaction.ts
+/** Validates a context budget and fills in defaults. */
+function resolveContextBudget(budget, label) {
+	if (budget === void 0) return void 0;
+	if (!isRecord(budget)) throw new TypeError(`${label} must be an object`);
+	const contextWindow = budget.contextWindow;
+	if (!Number.isSafeInteger(contextWindow) || contextWindow <= 0) throw new TypeError(`${label}.contextWindow must be a positive safe integer`);
+	const reserveOutputTokens = budget.reserveOutputTokens ?? 0;
+	if (!Number.isSafeInteger(reserveOutputTokens) || reserveOutputTokens < 0 || reserveOutputTokens >= contextWindow) throw new TypeError(`${label}.reserveOutputTokens must be a non-negative safe integer below contextWindow`);
+	const usable = contextWindow - reserveOutputTokens;
+	const compactAt = budget.compactAt ?? .8;
+	if (typeof compactAt !== "number" || !Number.isFinite(compactAt) || compactAt <= 0 || compactAt > 1) throw new TypeError(`${label}.compactAt must be greater than 0 and at most 1`);
+	const targetTokens = budget.targetTokens ?? Math.max(1, Math.floor(usable * Math.min(.5, compactAt * .9)));
+	if (!Number.isSafeInteger(targetTokens) || targetTokens <= 0 || targetTokens >= usable) throw new TypeError(`${label}.targetTokens must be a positive safe integer below the usable window`);
+	if (targetTokens > Math.floor(usable * compactAt)) throw new TypeError(`${label}.targetTokens must not exceed the compaction threshold`);
+	const safetyFactor = budget.safetyFactor ?? 1.1;
+	if (typeof safetyFactor !== "number" || !Number.isFinite(safetyFactor) || safetyFactor < 1 || safetyFactor > 2) throw new TypeError(`${label}.safetyFactor must be between 1 and 2`);
+	return {
+		contextWindow,
+		reserveOutputTokens,
+		compactAt,
+		targetTokens,
+		safetyFactor
+	};
+}
+/**
+* Rough provider-neutral estimate: about four characters per token plus
+* message and tool framing. Hosts can inject a real tokenizer instead.
+*/
+function estimateContextTokens(input) {
+	let characters = 0;
+	for (const message of input.messages) {
+		characters += message.role.length + message.content.length + 16;
+		if (message.name !== void 0) characters += message.name.length;
+		if (message.toolCallId !== void 0) characters += message.toolCallId.length;
+		if (message.toolCalls !== void 0) characters += JSON.stringify(message.toolCalls).length;
+	}
+	if (input.tools?.length) characters += JSON.stringify(input.tools).length;
+	return Math.max(1, Math.ceil(characters / 4));
+}
+const DEFAULT_COMPACTOR_PROMPT = "You compact conversation history for another agent. Preserve decisions, approvals, constraints, identifiers, tool results and open tasks. Return only the summary.";
+/**
+* Creates a semantic compactor backed by a model. Use a cheap, fast model and
+* keep it separate from the agent model when possible. Large transcripts are
+* summarized in chunks and then merged.
+*/
+function createModelContextCompactor(options) {
+	const maxOutputTokens = options.maxOutputTokens ?? 1024;
+	if (!Number.isSafeInteger(maxOutputTokens) || maxOutputTokens <= 0) throw new TypeError("Model compactor maxOutputTokens must be a positive safe integer");
+	const maxInputChars = options.maxInputChars ?? 12e4;
+	if (!Number.isSafeInteger(maxInputChars) || maxInputChars < 1e3) throw new TypeError("Model compactor maxInputChars must be a safe integer of at least 1,000");
+	const systemPrompt = options.systemPrompt ?? DEFAULT_COMPACTOR_PROMPT;
+	const summarize = async (text, instruction, signal) => {
+		const stream = options.model.stream({
+			messages: [{
+				role: "system",
+				content: systemPrompt
+			}, {
+				role: "user",
+				content: `${instruction}\n\n${text || "(empty)"}`
+			}],
+			maxOutputTokens,
+			...signal === void 0 ? {} : { signal }
+		});
+		let deltas = "";
+		let output;
+		for await (const event of stream) if (event.type === "output.delta") deltas += event.delta;
+		else output = event.result.output;
+		const summary = typeof output === "string" ? output : deltas;
+		if (!summary.trim()) throw new Error("Model context compactor returned an empty summary");
+		return summary.trim();
+	};
+	return { async compact(input) {
+		let current = formatTranscript(input.messages);
+		let depth = 0;
+		while (current.length > maxInputChars && depth < 4) {
+			const summaries = [];
+			for (const chunk of splitText(current, maxInputChars)) summaries.push(await summarize(chunk, "Summarize this part of a longer conversation. Preserve decisions, constraints, identifiers, tool results and open tasks.", input.signal));
+			current = summaries.join("\n\n");
+			depth += 1;
+		}
+		if (current.length > maxInputChars) current = `${current.slice(0, maxInputChars - 1)}…`;
+		return [{
+			role: "system",
+			content: await summarize(current, `Merge the following into one summary in at most ${input.targetTokens} tokens.`, input.signal)
+		}];
+	} };
+}
+function formatTranscript(messages) {
+	return messages.map((message) => {
+		const toolCalls = message.toolCalls?.length ? `\nTool calls: ${message.toolCalls.map((call) => `${call.name}(${JSON.stringify(call.input)})`).join(", ")}` : "";
+		const name = message.name === void 0 ? "" : ` (${message.name})`;
+		return `${message.role}${name}: ${message.content}${toolCalls}`;
+	}).join("\n\n");
+}
+function splitText(text, maxChars) {
+	const chunks = [];
+	let rest = text;
+	while (rest.length > maxChars) {
+		let cut = rest.lastIndexOf("\n", maxChars);
+		if (cut < Math.floor(maxChars / 2)) cut = maxChars;
+		chunks.push(rest.slice(0, cut));
+		rest = rest.slice(cut).trimStart();
+	}
+	if (rest) chunks.push(rest);
+	return chunks;
+}
+/**
+* Deterministic compactor used when the host does not inject one. It keeps
+* role-aware excerpts of older messages and drops the oldest excerpts first.
+* It never calls a model.
+*/
+function createDigestContextCompactor(options = {}) {
+	const maxChars = options.maxCharsPerMessage ?? 400;
+	if (!Number.isSafeInteger(maxChars) || maxChars < 40) throw new TypeError("Digest compactor maxCharsPerMessage must be a safe integer of at least 40");
+	return { compact(input) {
+		if (input.messages.length === 0) return [{
+			role: "system",
+			content: "[Compacted earlier conversation]"
+		}];
+		let perMessage = maxChars;
+		let lines = input.messages.flatMap((message) => digestMessage(message, perMessage));
+		while (input.estimateTokens([{
+			role: "system",
+			content: digestContent(lines, input.messages.length)
+		}]) > input.targetTokens && perMessage > 40) {
+			perMessage = Math.max(40, Math.floor(perMessage * .7));
+			lines = input.messages.flatMap((message) => digestMessage(message, perMessage));
+		}
+		let selected = lines;
+		let content = digestContent(selected, input.messages.length);
+		while (input.estimateTokens([{
+			role: "system",
+			content
+		}]) > input.targetTokens && selected.length > 1) {
+			selected = selected.slice(1);
+			content = digestContent(selected, input.messages.length);
+		}
+		const limit = Math.max(80, input.targetTokens * 4);
+		if (content.length > limit) content = `${content.slice(0, Math.max(0, limit - 1))}…`;
+		return [{
+			role: "system",
+			content
+		}];
+	} };
+}
+function digestContent(lines, totalMessages) {
+	const omitted = Math.max(0, totalMessages - lines.length);
+	return [`[Compacted conversation: ${totalMessages} earlier messages${omitted ? `, ${omitted} omitted` : ""}]`, ...lines].join("\n");
+}
+function digestMessage(message, maxChars) {
+	const content = truncate(message.content, maxChars);
+	if (message.role === "user") return content ? [`User: ${content}`] : [];
+	if (message.role === "assistant") {
+		const lines = [];
+		if (content) lines.push(`Assistant: ${content}`);
+		for (const call of message.toolCalls ?? []) lines.push(`Tool call ${call.name}: ${truncate(JSON.stringify(call.input), Math.min(maxChars, 200))}`);
+		return lines;
+	}
+	if (message.role === "tool") return content ? [`Tool result${message.name === void 0 ? "" : ` (${message.name})`}: ${content}`] : [];
+	return content ? [`System: ${content}`] : [];
+}
+function truncate(value, maxChars) {
+	const normalized = value.replace(/\s+/g, " ").trim();
+	if (normalized.length <= maxChars) return normalized;
+	return `${normalized.slice(0, Math.max(0, maxChars - 1))}…`;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/runtime/run-store.ts
+function validateListEventsOptions(options) {
+	if (options.limit !== void 0 && (!Number.isSafeInteger(options.limit) || options.limit < 1)) throw new TypeError("Event limit must be a positive safe integer");
+	if (options.order !== void 0 && options.order !== "asc" && options.order !== "desc") throw new TypeError("Event order must be asc or desc");
+}
+function isRetainableRunStore(store) {
+	return typeof store.purgeRuns === "function";
+}
+function validatePurgeRunsOptions(options = {}) {
+	const statuses = options.statuses ?? [
+		"completed",
+		"failed",
+		"cancelled"
+	];
+	if (statuses.length === 0 || statuses.some((status) => status !== "completed" && status !== "failed" && status !== "cancelled")) throw new TypeError("Purge statuses must contain only completed, failed or cancelled");
+	if (options.before !== void 0 && Number.isNaN(Date.parse(options.before))) throw new TypeError("Purge before must be an ISO timestamp");
+	if (options.limit !== void 0 && (!Number.isSafeInteger(options.limit) || options.limit < 1)) throw new TypeError("Purge limit must be a positive safe integer");
+	return {
+		statuses,
+		...options.before === void 0 ? {} : { before: new Date(options.before).toISOString() },
+		...options.limit === void 0 ? {} : { limit: options.limit }
+	};
+}
+function isDurableRunStore(store) {
+	const value = store;
+	return [
+		value.getCheckpoint,
+		value.getToolExecution,
+		value.createExecution,
+		value.commitExecution,
+		value.acquireLease,
+		value.renewLease,
+		value.releaseLease
+	].every((method) => typeof method === "function");
+}
+//#endregion
+//#region src/runtime/in-memory-run-store.ts
+/**
+* In-process durable store intended for development and tests.
+*
+* Values are cloned at the boundary so callers cannot mutate persisted state.
+* Data is lost when the process exits.
+*/
+var InMemoryRunStore = class {
+	#runs = /* @__PURE__ */ new Map();
+	#sessions = /* @__PURE__ */ new Map();
+	#events = /* @__PURE__ */ new Map();
+	#checkpoints = /* @__PURE__ */ new Map();
+	#toolExecutions = /* @__PURE__ */ new Map();
+	#leases = /* @__PURE__ */ new Map();
+	async getRun(runId) {
+		const run = this.#runs.get(runId);
+		return run === void 0 ? void 0 : structuredClone(run);
+	}
+	async saveRun(run) {
+		this.#runs.set(run.id, structuredClone(run));
+		if (!this.#events.has(run.id)) this.#events.set(run.id, []);
+	}
+	async getSession(sessionId) {
+		const session = this.#sessions.get(sessionId);
+		return session === void 0 ? void 0 : structuredClone(session);
+	}
+	async saveSession(session) {
+		const current = this.#sessions.get(session.id);
+		if (this.#sessionBusy(session.id) || (current?.revision ?? 0) !== (session.revision ?? 0)) throw new FevexRunError("RUN_CONFLICT", `Session "${session.id}" is active or was modified`);
+		session.revision = (session.revision ?? 0) + 1;
+		this.#sessions.set(session.id, structuredClone(session));
+	}
+	async appendEvent(event) {
+		const events = this.#events.get(event.runId);
+		if (!events) throw new Error(`Run "${event.runId}" does not exist`);
+		events.push(structuredClone(event));
+	}
+	async listEvents(runId, options = {}) {
+		validateListEventsOptions(options);
+		const events = this.#events.get(runId);
+		if (!events) throw new Error(`Run "${runId}" does not exist`);
+		let start = 0;
+		if (options.after !== void 0) {
+			const cursor = events.findIndex(({ id }) => id === options.after);
+			if (cursor < 0) throw new FevexRunError("INVALID_CURSOR", `Event cursor "${options.after}" does not exist in run "${runId}"`, runId);
+			start = cursor + 1;
+		}
+		const sequence = start ? events[start - 1].sequence : -1;
+		const ordered = events.filter((event) => event.sequence > sequence).sort((a, b) => options.order === "desc" ? b.sequence - a.sequence : a.sequence - b.sequence);
+		return structuredClone(ordered.slice(0, options.limit));
+	}
+	async getCheckpoint(runId) {
+		const checkpoint = this.#checkpoints.get(runId);
+		return checkpoint === void 0 ? void 0 : structuredClone(checkpoint);
+	}
+	async getToolExecution(runId, toolCallId) {
+		const execution = this.#toolExecutions.get(`${runId}:${toolCallId}`);
+		return execution === void 0 ? void 0 : structuredClone(execution);
+	}
+	async createExecution(create) {
+		if (this.#runs.has(create.run.id)) return false;
+		const session = create.session;
+		const currentSession = this.#sessions.get(create.run.sessionId);
+		if (!session || session.id !== create.run.sessionId || this.#sessionBusy(session.id) || (currentSession?.revision ?? 0) !== (session.revision ?? 0)) return false;
+		const run = structuredClone(create.run);
+		run.revision = 1;
+		this.#runs.set(run.id, run);
+		create.run.revision = 1;
+		session.revision = (session.revision ?? 0) + 1;
+		this.#sessions.set(session.id, structuredClone(session));
+		this.#events.set(run.id, structuredClone(create.events));
+		this.#checkpoints.set(run.id, structuredClone(create.checkpoint));
+		create.lease.generation = 1;
+		this.#leases.set(run.id, structuredClone(create.lease));
+		return true;
+	}
+	async commitExecution(commit) {
+		const current = this.#runs.get(commit.run.id);
+		if (!current || current.revision !== commit.expectedRevision) return false;
+		const lease = this.#leases.get(commit.run.id);
+		if (!lease || !commit.lease || !(commit.lease.generation > 0) || lease.ownerId !== commit.lease.ownerId || lease.generation !== commit.lease.generation || !(Date.parse(lease.expiresAt) > Date.now())) return false;
+		if (commit.session && (commit.session.id !== current.sessionId || (this.#sessions.get(current.sessionId)?.revision ?? 0) !== (commit.session.revision ?? 0) || this.#sessionBusy(current.sessionId, current.id))) return false;
+		const run = structuredClone(commit.run);
+		run.revision = commit.expectedRevision + 1;
+		this.#runs.set(run.id, run);
+		commit.run.revision = run.revision;
+		if (commit.session) {
+			commit.session.revision = (commit.session.revision ?? 0) + 1;
+			this.#sessions.set(commit.session.id, structuredClone(commit.session));
+		}
+		if (commit.checkpoint === null) this.#checkpoints.delete(run.id);
+		else if (commit.checkpoint) this.#checkpoints.set(run.id, structuredClone(commit.checkpoint));
+		if (commit.toolExecution) this.#toolExecutions.set(`${run.id}:${commit.toolExecution.toolCallId}`, structuredClone(commit.toolExecution));
+		const events = this.#events.get(run.id);
+		if (!events) throw new Error(`Run "${run.id}" does not exist`);
+		for (const event of commit.events ?? []) events.push(structuredClone(event));
+		return true;
+	}
+	#sessionBusy(sessionId, exceptRunId) {
+		return [...this.#runs.values()].some((run) => run.sessionId === sessionId && run.id !== exceptRunId && (run.status === "running" || run.status === "paused"));
+	}
+	async purgeRuns(options = {}) {
+		const { statuses, before, limit } = validatePurgeRunsOptions(options);
+		const allowed = new Set(statuses);
+		const beforeTime = before === void 0 ? void 0 : Date.parse(before);
+		const candidates = [...this.#runs.entries()].filter(([, run]) => allowed.has(run.status) && (beforeTime === void 0 || Date.parse(run.createdAt) < beforeTime)).sort(([, first], [, second]) => Date.parse(first.createdAt) - Date.parse(second.createdAt)).slice(0, limit);
+		for (const [runId] of candidates) {
+			this.#runs.delete(runId);
+			this.#events.delete(runId);
+			this.#checkpoints.delete(runId);
+			this.#leases.delete(runId);
+			for (const key of this.#toolExecutions.keys()) if (key.startsWith(`${runId}:`)) this.#toolExecutions.delete(key);
+		}
+		const affectedSessions = new Set(candidates.map(([, run]) => run.sessionId));
+		const usedSessions = new Set([...this.#runs.values()].map(({ sessionId }) => sessionId));
+		let sessions = 0;
+		for (const sessionId of affectedSessions) {
+			if (usedSessions.has(sessionId)) continue;
+			if (this.#sessions.delete(sessionId)) sessions += 1;
+		}
+		return {
+			runs: candidates.length,
+			sessions
+		};
+	}
+	async acquireLease(lease) {
+		const current = this.#leases.get(lease.runId);
+		if (current && Date.parse(current.expiresAt) > Date.now()) return false;
+		lease.generation = (current?.generation ?? 0) + 1;
+		this.#leases.set(lease.runId, structuredClone(lease));
+		return true;
+	}
+	async renewLease(lease) {
+		const current = this.#leases.get(lease.runId);
+		if (!current || current.ownerId !== lease.ownerId || current.generation !== lease.generation || !(Date.parse(current.expiresAt) > Date.now())) return false;
+		this.#leases.set(lease.runId, structuredClone(lease));
+		return true;
+	}
+	async releaseLease(runId, ownerId, generation) {
+		if (!(generation > 0)) return;
+		const current = this.#leases.get(runId);
+		if (current?.ownerId === ownerId && current.generation === generation) current.expiresAt = (/* @__PURE__ */ new Date(0)).toISOString();
+	}
+};
+//#endregion
+export { InMemoryRunStore, createDigestContextCompactor, createModelContextCompactor, estimateContextTokens, isDurableRunStore, isRetainableRunStore, resolveContextBudget, validateListEventsOptions, validatePurgeRunsOptions };

package/dist/sandbox/index.d.mts

@@ -0,0 +1,2 @@
+import { a as SandboxError, c as sandboxResultToJson, i as SandboxCapabilities, n as createLocalSandbox, o as SandboxRunRequest, r as Sandbox, s as SandboxRunResult, t as LocalSandboxOptions } from "../index-DUhNa7IR.mjs";
+export { LocalSandboxOptions, Sandbox, SandboxCapabilities, SandboxError, SandboxRunRequest, SandboxRunResult, createLocalSandbox, sandboxResultToJson };

package/dist/sandbox/index.mjs

@@ -0,0 +1,147 @@
+import { relative, resolve } from "node:path";
+import { spawn } from "node:child_process";
+import { realpathSync } from "node:fs";
+//#region src/sandbox/sandbox.ts
+var SandboxError = class extends Error {
+	code;
+	safeMessage;
+	name = "SandboxError";
+	constructor(code, safeMessage, options) {
+		super(safeMessage, options);
+		this.code = code;
+		this.safeMessage = safeMessage;
+	}
+};
+function sandboxResultToJson(result) {
+	return {
+		exitCode: result.exitCode,
+		stdout: result.stdout,
+		stderr: result.stderr,
+		durationMs: result.durationMs,
+		timedOut: result.timedOut
+	};
+}
+//#endregion
+//#region src/sandbox/local-sandbox.ts
+/** Creates a subprocess sandbox restricted to a root directory and command allowlist. */
+function createLocalSandbox(options) {
+	if (!options.rootDir.trim()) throw new SandboxError("SANDBOX_INVALID_CONFIG", "Sandbox rootDir must be non-empty");
+	if (!options.commands.length || options.commands.some((command) => !command.trim())) throw new SandboxError("SANDBOX_INVALID_CONFIG", "Sandbox commands allowlist must contain non-empty commands");
+	const rootDir = realpathSync(resolve(options.rootDir));
+	const allowed = new Set(options.commands);
+	const defaultTimeoutMs = options.defaultTimeoutMs ?? 1e4;
+	const maxOutputBytes = options.maxOutputBytes ?? 64e3;
+	return { async run(request) {
+		if (request.capabilities?.network) throw new SandboxError("SANDBOX_NETWORK_UNSUPPORTED", "Local sandbox does not support network access");
+		const command = request.command;
+		if (!allowed.has(command) || !request.capabilities?.process?.commands?.includes(command)) throw new SandboxError("SANDBOX_COMMAND_DENIED", `Command "${command}" is not allowed`);
+		const cwd = resolve(rootDir, request.cwd ?? request.capabilities.filesystem?.cwd ?? ".");
+		if (!isInside(rootDir, cwd)) throw new SandboxError("SANDBOX_CWD_DENIED", "Sandbox cwd must stay inside rootDir");
+		const timeoutMs = request.timeoutMs ?? request.capabilities.resources?.timeoutMs ?? request.capabilities.process.timeoutMs ?? defaultTimeoutMs;
+		const outputLimit = request.maxOutputBytes ?? request.capabilities.resources?.maxOutputBytes ?? maxOutputBytes;
+		if (!Number.isInteger(timeoutMs) || timeoutMs < 1) throw new SandboxError("SANDBOX_INVALID_REQUEST", "Sandbox timeoutMs must be positive");
+		if (!Number.isInteger(outputLimit) || outputLimit < 1) throw new SandboxError("SANDBOX_INVALID_REQUEST", "Sandbox maxOutputBytes must be positive");
+		return runProcess({
+			command,
+			args: request.args ?? [],
+			cwd,
+			env: {
+				...options.env ?? {},
+				...request.env ?? {}
+			},
+			input: request.input,
+			timeoutMs,
+			maxOutputBytes: outputLimit,
+			signal: request.signal
+		});
+	} };
+}
+async function runProcess(options) {
+	const started = Date.now();
+	let timedOut = false;
+	const stdout = {
+		text: "",
+		bytes: 0
+	};
+	const stderr = {
+		text: "",
+		bytes: 0
+	};
+	return await new Promise((resolvePromise, reject) => {
+		options.signal?.throwIfAborted();
+		const child = spawn(options.command, [...options.args], {
+			cwd: options.cwd,
+			env: options.env,
+			shell: false,
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		});
+		let aborted = false;
+		let killTimer;
+		const terminate = () => {
+			if (killTimer !== void 0) return;
+			child.kill("SIGTERM");
+			killTimer = setTimeout(() => child.kill("SIGKILL"), 100);
+		};
+		const abort = () => {
+			aborted = true;
+			clearTimeout(timer);
+			terminate();
+		};
+		const timer = setTimeout(() => {
+			timedOut = true;
+			terminate();
+		}, options.timeoutMs);
+		const cleanup = () => {
+			clearTimeout(timer);
+			clearTimeout(killTimer);
+			options.signal?.removeEventListener("abort", abort);
+		};
+		options.signal?.addEventListener("abort", abort, { once: true });
+		if (options.signal?.aborted) abort();
+		child.stdout.setEncoding("utf8");
+		child.stderr.setEncoding("utf8");
+		child.stdout.on("data", (chunk) => {
+			appendLimited(stdout, String(chunk), options.maxOutputBytes);
+		});
+		child.stderr.on("data", (chunk) => {
+			appendLimited(stderr, String(chunk), options.maxOutputBytes);
+		});
+		child.on("error", (error) => {
+			cleanup();
+			reject(new SandboxError("SANDBOX_PROCESS_ERROR", "Sandbox process failed", { cause: error }));
+		});
+		child.on("close", (exitCode) => {
+			cleanup();
+			if (aborted) {
+				reject(options.signal?.reason ?? new DOMException("Sandbox aborted", "AbortError"));
+				return;
+			}
+			resolvePromise({
+				exitCode,
+				stdout: stdout.text,
+				stderr: stderr.text,
+				durationMs: Date.now() - started,
+				timedOut
+			});
+		});
+		if (options.input !== void 0) child.stdin.end(options.input);
+		else child.stdin.end();
+	});
+}
+function appendLimited(output, chunk, maxBytes) {
+	const remaining = maxBytes - output.bytes;
+	if (remaining <= 0) return;
+	const bytes = Buffer.from(chunk).subarray(0, remaining);
+	output.bytes += bytes.length;
+	output.text += new TextDecoder("utf-8", { ignoreBOM: true }).decode(bytes, { stream: true });
+}
+function isInside(rootDir, value) {
+	const path = relative(rootDir, value);
+	return path === "" || !path.startsWith("..") && !resolve(path).startsWith("..");
+}
+//#endregion
+export { SandboxError, createLocalSandbox, sandboxResultToJson };

package/dist/teams/index.d.mts

@@ -0,0 +1,2 @@
+import { a as TeamMember, c as defineTeam, i as TeamLimits, n as TeamDelegation, o as TeamStep, r as TeamHandoff, s as TeamTaskResult, t as TeamDefinition } from "../index-26ilbzAs.mjs";
+export { type TeamDefinition, type TeamDelegation, type TeamHandoff, type TeamLimits, type TeamMember, type TeamStep, type TeamTaskResult, defineTeam };

package/dist/teams/index.mjs

@@ -0,0 +1,2 @@
+import { t as defineTeam } from "../teams-Ctz676G4.mjs";
+export { defineTeam };

package/dist/teams-Ctz676G4.mjs

@@ -0,0 +1,82 @@
+//#region src/teams/team.ts
+function defineTeam(team) {
+	return team;
+}
+/** @internal Compiles teams onto the existing durable workflow engine. */
+function teamAsWorkflow(team) {
+	const allowed = /* @__PURE__ */ new Set([team.supervisor, ...team.members.map(({ agent }) => agent)]);
+	const limits = team.limits && {
+		...team.limits.maxSteps === void 0 ? {} : { maxSteps: team.limits.maxSteps },
+		...team.limits.maxToolCalls === void 0 ? {} : { maxToolCalls: team.limits.maxToolCalls },
+		...team.limits.maxInputTokens === void 0 ? {} : { maxInputTokens: team.limits.maxInputTokens },
+		...team.limits.maxOutputTokens === void 0 ? {} : { maxOutputTokens: team.limits.maxOutputTokens }
+	};
+	return {
+		name: team.name,
+		version: team.version ?? "1",
+		inputSchema: team.inputSchema,
+		outputSchema: team.outputSchema,
+		limits,
+		async run(step, input) {
+			let delegations = 0;
+			const countDelegation = () => {
+				delegations += 1;
+				if (team.limits?.maxDelegations !== void 0 && delegations > team.limits.maxDelegations) throw new Error(`Team "${team.name}" exceeded maxDelegations limit of ${team.limits.maxDelegations}`);
+			};
+			const runAgent = async (delegationId, delegation, metadata) => {
+				if (!delegationId.trim()) throw new Error("Team delegation id cannot be empty");
+				if (!allowed.has(delegation.agent)) throw new Error(`Agent "${delegation.agent}" is not a member of team "${team.name}"`);
+				if (delegation.expectedOutput !== void 0 && !delegation.expectedOutput.trim()) throw new Error("Team delegation expectedOutput cannot be empty");
+				if (delegation.constraints !== void 0 && (!Array.isArray(delegation.constraints) || delegation.constraints.some((constraint) => typeof constraint !== "string" || !constraint.trim()))) throw new Error("Team delegation constraints must be non-empty strings");
+				countDelegation();
+				const request = {
+					input: delegation.task,
+					...delegation.context === void 0 ? {} : { context: delegation.context },
+					...delegation.limits === void 0 ? {} : { limits: delegation.limits }
+				};
+				return {
+					...await step.agent(delegationId, delegation.agent, request, { metadata }),
+					delegationId,
+					agentName: delegation.agent
+				};
+			};
+			return team.run({
+				delegate(delegationId, delegation) {
+					return runAgent(delegationId, delegation, {
+						teamAction: "delegate",
+						...delegation.expectedOutput === void 0 ? {} : { expectedOutput: delegation.expectedOutput },
+						...delegation.constraints === void 0 ? {} : { constraints: delegation.constraints }
+					});
+				},
+				handoff(delegationId, handoff) {
+					if (!allowed.has(handoff.from)) throw new Error(`Agent "${handoff.from}" is not a member of team "${team.name}"`);
+					if (!handoff.reason.trim()) throw new Error("Team handoff reason cannot be empty");
+					return runAgent(delegationId, {
+						agent: handoff.to,
+						task: handoff.task,
+						context: handoff.context,
+						limits: handoff.limits,
+						expectedOutput: handoff.expectedOutput,
+						constraints: handoff.constraints
+					}, {
+						teamAction: "handoff",
+						from: handoff.from,
+						reason: handoff.reason,
+						...handoff.expectedOutput === void 0 ? {} : { expectedOutput: handoff.expectedOutput },
+						...handoff.constraints === void 0 ? {} : { constraints: handoff.constraints }
+					});
+				},
+				parallel(stepId, tasks) {
+					const width = Object.keys(tasks).length;
+					if (team.limits?.maxParallel !== void 0 && width > team.limits.maxParallel) throw new Error(`Team "${team.name}" exceeded maxParallel limit of ${team.limits.maxParallel}`);
+					return step.parallel(stepId, tasks, { metadata: {
+						teamAction: "merge",
+						width
+					} });
+				}
+			}, input);
+		}
+	};
+}
+//#endregion
+export { teamAsWorkflow as n, defineTeam as t };