@fevex/core 0.1.0-alpha.1 → 0.1.0-alpha.3

package/dist/knowledge/index.d.mts

@@ -0,0 +1,2 @@
+import { a as MemoryQuery, c as MemoryWrite, d as defineContextProvider, f as defineSkill, i as KnowledgeContext, l as SkillDefinition, n as ContextBlock, o as MemoryRecord, r as ContextProvider, s as MemoryStore, t as InMemoryMemoryStore, u as createMemoryContextProvider } from "../index-DeXUtyd9.mjs";
+export { ContextBlock, ContextProvider, InMemoryMemoryStore, KnowledgeContext, MemoryQuery, MemoryRecord, MemoryStore, MemoryWrite, SkillDefinition, createMemoryContextProvider, defineContextProvider, defineSkill };

package/dist/knowledge/index.mjs

@@ -0,0 +1,89 @@
+//#region src/knowledge/in-memory-memory-store.ts
+/** Volatile keyword-search memory store for tests and local development. */
+var InMemoryMemoryStore = class {
+	#records = /* @__PURE__ */ new Map();
+	async search(query, context) {
+		context.signal?.throwIfAborted();
+		const terms = query.query.toLowerCase().split(/\s+/).filter(Boolean);
+		const scored = [...this.#records.values()].filter((record) => matchesScope(record, query)).map((record) => ({
+			record,
+			score: score(record.content, terms)
+		})).filter(({ score }) => !terms.length || score > 0).sort((left, right) => right.score - left.score || right.record.createdAt.localeCompare(left.record.createdAt));
+		return scored.slice(0, query.limit ?? scored.length).map(({ record }) => structuredClone(record));
+	}
+	async write(record, context) {
+		context.signal?.throwIfAborted();
+		const saved = {
+			id: crypto.randomUUID(),
+			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+			...structuredClone(record)
+		};
+		this.#records.set(saved.id, saved);
+		return structuredClone(saved);
+	}
+};
+function matchesScope(record, query) {
+	return matches(record.agentName, query.agentName) && matches(record.sessionId, query.sessionId) && matches(record.namespace, query.namespace) && matches(record.actor?.id, query.actor?.id);
+}
+function matches(left, right) {
+	return right === void 0 || left === void 0 || left === right;
+}
+function score(content, terms) {
+	const text = content.toLowerCase();
+	return terms.reduce((total, term) => total + (text.includes(term) ? 1 : 0), 0);
+}
+//#endregion
+//#region src/knowledge/knowledge.ts
+function defineContextProvider(provider) {
+	return provider;
+}
+function defineSkill(skill) {
+	return defineContextProvider({
+		name: skill.name,
+		async read() {
+			return [{
+				id: `${skill.name}:instructions`,
+				content: skill.instructions
+			}, ...(skill.resources ?? []).map((resource, index) => {
+				const normalized = isSkillResource(resource) ? resource : { content: resource };
+				return {
+					id: normalized.id ?? `${skill.name}:resource:${index + 1}`,
+					content: stringifyKnowledge(normalized.content),
+					...normalized.metadata === void 0 ? {} : { metadata: normalized.metadata }
+				};
+			})];
+		}
+	});
+}
+function isSkillResource(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && "content" in value && (value.id === void 0 || typeof value.id === "string");
+}
+function createMemoryContextProvider(options) {
+	return defineContextProvider({
+		name: options.name ?? "memory",
+		async read(context) {
+			return (await options.store.search({
+				query: context.input,
+				limit: options.limit,
+				agentName: context.agentName,
+				sessionId: context.sessionId,
+				namespace: context.context?.namespace,
+				actor: context.context?.actor
+			}, context)).map((record) => ({
+				id: record.id,
+				content: record.content,
+				metadata: {
+					...record.metadata ?? {},
+					createdAt: record.createdAt,
+					...record.agentName === void 0 ? {} : { agentName: record.agentName },
+					...record.sessionId === void 0 ? {} : { sessionId: record.sessionId }
+				}
+			}));
+		}
+	});
+}
+function stringifyKnowledge(value) {
+	return typeof value === "string" ? value : JSON.stringify(value);
+}
+//#endregion
+export { InMemoryMemoryStore, createMemoryContextProvider, defineContextProvider, defineSkill };

package/dist/models/index.d.mts

@@ -1,46 +1,2 @@
-import { h as ToolSpec, i as AgentMessage, l as JsonValue, m as ToolCall, s as JsonObject } from "../index-C_Zpr13f.mjs";
-//#region src/models/index.d.ts
-type ReasoningEffort = 'provider-default' | 'none' | 'minimal' | 'low' | 'medium' | 'high';
-interface ModelUsage {
-  inputTokens?: number;
-  outputTokens?: number;
-  totalTokens?: number;
-}
-interface ModelInput {
-  messages: AgentMessage[];
-  tools?: ToolSpec[];
-  reasoning?: ReasoningEffort;
-  modelOptions?: Record<string, unknown>;
-  outputSchema?: JsonObject;
-  maxOutputTokens?: number;
-  providerState?: unknown;
-  signal?: AbortSignal;
-}
-interface ModelResult<TOutput = unknown> {
-  output?: TOutput;
-  toolCalls?: ToolCall[];
-  usage?: ModelUsage;
-  providerState?: unknown;
-}
-interface ModelMetadata {
-  provider?: string;
-  model?: string;
-}
-interface ModelGateway {
-  stream(input: ModelInput): AsyncIterable<ModelStreamEvent>;
-  metadata?: ModelMetadata;
-  stateCodec?: {
-    serialize(state: unknown): JsonValue;
-    restore(state: JsonValue): unknown;
-  };
-}
-type ModelStreamEvent<TOutput = unknown> = {
-  type: 'output.delta';
-  delta: string;
-} | {
-  type: 'completed';
-  result: ModelResult<TOutput>;
-};
-type ModelRef = string | ModelGateway;
-//#endregion
-export { ModelGateway, ModelInput, ModelMetadata, ModelRef, ModelResult, ModelStreamEvent, ModelUsage, ReasoningEffort };
+import { a as ModelResult, c as ReasoningEffort, i as ModelRef, l as ToolChoice, n as ModelInput, o as ModelStreamEvent, r as ModelMetadata, s as ModelUsage, t as ModelGateway } from "../index-CTIwrVf9.mjs";
+export { ModelGateway, ModelInput, ModelMetadata, ModelRef, ModelResult, ModelStreamEvent, ModelUsage, ReasoningEffort, ToolChoice };

package/dist/observability/index.d.mts

@@ -1,2 +1,2 @@
-import { a as TraceAnnotation, c as TraceContentPolicy, d as TraceRedactor, f as TraceRedactorInput, h as TraceStatus, i as RunTrace, l as TraceCost, m as TraceSpanKind, n as CostCalculatorInput, o as TraceContent, p as TraceSpan, r as ObservabilityOptions, s as TraceContentKind, t as CostCalculator, u as TraceExporter } from "../index-ojCY3lwm.mjs";
+import { a as TraceAnnotation, c as TraceContentPolicy, d as TraceRedactor, f as TraceRedactorInput, h as TraceStatus, i as RunTrace, l as TraceCost, m as TraceSpanKind, n as CostCalculatorInput, o as TraceContent, p as TraceSpan, r as ObservabilityOptions, s as TraceContentKind, t as CostCalculator, u as TraceExporter } from "../index-B4PIkqOU.mjs";
 export { CostCalculator, CostCalculatorInput, ObservabilityOptions, RunTrace, TraceAnnotation, TraceContent, TraceContentKind, TraceContentPolicy, TraceCost, TraceExporter, TraceRedactor, TraceRedactorInput, TraceSpan, TraceSpanKind, TraceStatus };

package/dist/policies/index.d.mts

@@ -1,2 +1,2 @@
-import { i as definePolicy, n as PolicyDecision, r as PolicyDefinition, t as PolicyAuthorization } from "../index-QTkd6a7C.mjs";
+import { i as definePolicy, n as PolicyDecision, r as PolicyDefinition, t as PolicyAuthorization } from "../index-dkFyTNh4.mjs";
 export { PolicyAuthorization, PolicyDecision, PolicyDefinition, definePolicy };

package/dist/policies/index.mjs

@@ -1,4 +1,4 @@
-//#region src/policies/index.ts
+//#region src/policies/policy.ts
 function definePolicy(policy) {
 	return policy;
 }

package/dist/run-error-Cr17wPGH.mjs

@@ -0,0 +1,23 @@
+//#region src/run-error.ts
+var FevexRunError = class extends Error {
+	code;
+	runId;
+	name = "FevexRunError";
+	constructor(code, message, runId, options) {
+		super(message, options);
+		this.code = code;
+		this.runId = runId;
+	}
+};
+var RunPausedError = class extends FevexRunError {
+	runId;
+	pause;
+	name = "RunPausedError";
+	constructor(runId, pause) {
+		super("RUN_PAUSED", `Run "${runId}" is paused`, runId);
+		this.runId = runId;
+		this.pause = pause;
+	}
+};
+//#endregion
+export { RunPausedError as n, FevexRunError as t };

package/dist/runtime/index.d.mts

@@ -1,2 +1,2 @@
-import { C as isDurableRunStore, S as ToolExecutionStatus, _ as RunStore, a as DurableRunStore, b as ToolExecutionRecord, c as ListEventsOptions, d as RunCheckpoint, f as RunLease, g as RunStatus, h as RunResult, i as CredentialStore, l as PendingToolExecution, m as RunRequest, n as ApprovalRequest, o as ExecutionCommit, p as RunPause, r as ApprovalResolution, s as InMemoryRunStore, t as AgentRun, u as ResumeRunResolution, v as Session, x as ToolExecutionResolution, y as SessionId } from "../index-DGWOGXzc.mjs";
-export { AgentRun, ApprovalRequest, ApprovalResolution, CredentialStore, DurableRunStore, ExecutionCommit, InMemoryRunStore, ListEventsOptions, PendingToolExecution, ResumeRunResolution, RunCheckpoint, RunLease, RunPause, RunRequest, RunResult, RunStatus, RunStore, Session, SessionId, ToolExecutionRecord, ToolExecutionResolution, ToolExecutionStatus, isDurableRunStore };
+import { A as RunStore, B as WorkflowBudgetUsage, C as RunCheckpoint, D as RunRequest, E as RunRecord, F as TeamRun, G as WorkflowWaitRecord, H as WorkflowCompensationRecord, I as TimerResolution, K as isDurableRunStore, L as ToolExecutionRecord, M as SessionId, N as StoredRunCheckpoint, O as RunResult, P as TeamCheckpoint, R as ToolExecutionResolution, S as ResumeRunResolution, T as RunPause, U as WorkflowRun, V as WorkflowCheckpoint, W as WorkflowStepRecord, _ as EventResolution, a as AgentRun, b as ListEventsOptions, c as ApprovalRequest, d as CoordinatorRun, f as CredentialStore, g as ElicitationResolution, h as ElicitationRequest, i as InMemoryRunStore, j as Session, k as RunStatus, l as ApprovalResolution, m as ElicitationMode, o as AgentRunPause, p as DurableRunStore, q as validateListEventsOptions, s as ApprovalMode, u as CoordinatorCheckpoint, v as ExecutionCommit, w as RunLease, x as PendingToolExecution, y as ExecutionCreate, z as ToolExecutionStatus } from "../index-Dx_LotWZ.mjs";
+export { AgentRun, AgentRunPause, ApprovalMode, ApprovalRequest, ApprovalResolution, CoordinatorCheckpoint, CoordinatorRun, CredentialStore, DurableRunStore, ElicitationMode, ElicitationRequest, ElicitationResolution, EventResolution, ExecutionCommit, ExecutionCreate, InMemoryRunStore, ListEventsOptions, PendingToolExecution, ResumeRunResolution, RunCheckpoint, RunLease, RunPause, RunRecord, RunRequest, RunResult, RunStatus, RunStore, Session, SessionId, StoredRunCheckpoint, TeamCheckpoint, TeamRun, TimerResolution, ToolExecutionRecord, ToolExecutionResolution, ToolExecutionStatus, WorkflowBudgetUsage, WorkflowCheckpoint, WorkflowCompensationRecord, WorkflowRun, WorkflowStepRecord, WorkflowWaitRecord, isDurableRunStore, validateListEventsOptions };

package/dist/runtime/index.mjs

@@ -1,15 +1,29 @@
-//#region src/runtime/index.ts
+import { t as FevexRunError } from "../run-error-Cr17wPGH.mjs";
+//#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 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();
@@ -30,6 +44,9 @@ var InMemoryRunStore = class {
 		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) {
@@ -38,15 +55,18 @@ var InMemoryRunStore = class {
 		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 Error(`Event cursor "${options.after}" does not exist in run "${runId}"`);
+			if (cursor < 0) throw new FevexRunError("INVALID_CURSOR", `Event cursor "${options.after}" does not exist in run "${runId}"`, runId);
 			start = cursor + 1;
 		}
-		return structuredClone(events.slice(start).sort((a, b) => a.sequence - b.sequence));
+		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);
@@ -56,14 +76,37 @@ var InMemoryRunStore = class {
 		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) this.#sessions.set(commit.session.id, structuredClone(commit.session));
+		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));
@@ -72,21 +115,27 @@ var InMemoryRunStore = class {
 		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 acquireLease(lease) {
 		const current = this.#leases.get(lease.runId);
-		if (current && current.ownerId !== lease.ownerId && Date.parse(current.expiresAt) > Date.now()) return false;
+		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) return false;
+		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) {
-		if (this.#leases.get(runId)?.ownerId === ownerId) this.#leases.delete(runId);
+	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, isDurableRunStore };
+export { InMemoryRunStore, isDurableRunStore, validateListEventsOptions };

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-CrOId2px.mjs";
+export { LocalSandboxOptions, Sandbox, SandboxCapabilities, SandboxError, SandboxRunRequest, SandboxRunResult, createLocalSandbox, sandboxResultToJson };

package/dist/sandbox/index.mjs

@@ -0,0 +1,122 @@
+import { spawn } from "node:child_process";
+import { realpathSync } from "node:fs";
+import { relative, resolve } from "node:path";
+//#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;
+	let stdout = "";
+	let stderr = "";
+	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"
+			]
+		});
+		const abort = () => {
+			child.kill("SIGTERM");
+			reject(options.signal?.reason ?? new DOMException("Sandbox aborted", "AbortError"));
+		};
+		const timer = setTimeout(() => {
+			timedOut = true;
+			child.kill("SIGTERM");
+		}, options.timeoutMs);
+		options.signal?.addEventListener("abort", abort, { once: true });
+		child.stdout.setEncoding("utf8");
+		child.stderr.setEncoding("utf8");
+		child.stdout.on("data", (chunk) => {
+			stdout = appendLimited(stdout, String(chunk), options.maxOutputBytes);
+		});
+		child.stderr.on("data", (chunk) => {
+			stderr = appendLimited(stderr, String(chunk), options.maxOutputBytes);
+		});
+		child.on("error", (error) => {
+			clearTimeout(timer);
+			options.signal?.removeEventListener("abort", abort);
+			reject(new SandboxError("SANDBOX_PROCESS_ERROR", "Sandbox process failed", { cause: error }));
+		});
+		child.on("close", (exitCode) => {
+			clearTimeout(timer);
+			options.signal?.removeEventListener("abort", abort);
+			resolvePromise({
+				exitCode,
+				stdout,
+				stderr,
+				durationMs: Date.now() - started,
+				timedOut
+			});
+		});
+		if (options.input !== void 0) child.stdin.end(options.input);
+		else child.stdin.end();
+	});
+}
+function appendLimited(current, chunk, maxBytes) {
+	const next = current + chunk;
+	return Buffer.byteLength(next) <= maxBytes ? next : next.slice(0, maxBytes);
+}
+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-Bg9rr8Qe.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 };

package/dist/testing/index.d.mts

@@ -1,18 +1,42 @@
-import { m as ToolCall } from "../index-C_Zpr13f.mjs";
-import { ModelGateway, ModelInput, ModelResult } from "../models/index.mjs";
-import { a as DurableRunStore } from "../index-DGWOGXzc.mjs";
-//#region src/testing/index.d.ts
-interface FakeModel extends ModelGateway {
-  readonly calls: readonly ModelInput[];
-}
-declare function fakeModel(...responses: ModelResult[]): FakeModel;
+import { m as ToolCall } from "../types-CuoRx12Q.mjs";
+import { a as ModelResult, n as ModelInput, t as ModelGateway } from "../index-CTIwrVf9.mjs";
+import { p as DurableRunStore } from "../index-Dx_LotWZ.mjs";
+import { s as MemoryStore } from "../index-DeXUtyd9.mjs";
+import { d as ToolProvider } from "../index-CqOjvtQ9.mjs";
+import { c as ChannelMessage, l as ChannelOutput, n as ChannelAdapter } from "../index-Bgcxgy66.mjs";
+//#region src/testing/contracts.d.ts
 interface ModelGatewayContract {
   output?: unknown;
   toolCall?: ToolCall;
   usage?: boolean;
   error?: Error;
 }
+interface ChannelAdapterContract<TInput, TOutput> {
+  input: TInput;
+  message: ChannelMessage;
+  output: ChannelOutput;
+  delivered: TOutput;
+  ignoredInput?: TInput;
+}
+interface ToolProviderContract {
+  allowedTool: string;
+  input?: unknown;
+  output?: unknown;
+  disallowedTool?: string;
+  safeError?: boolean;
+  timeout?: boolean;
+}
+declare function testMemoryStore(store: MemoryStore): Promise<void>;
+declare function testToolProvider(provider: ToolProvider, contract: ToolProviderContract): Promise<void>;
+declare function testChannelAdapter<TInput, TOutput>(adapter: ChannelAdapter<TInput, TOutput>, contract: ChannelAdapterContract<TInput, TOutput>): Promise<void>;
 declare function testModelGateway(model: ModelGateway, contract?: ModelGatewayContract): Promise<void>;
 declare function testRunStore(store: DurableRunStore): Promise<void>;
 //#endregion
-export { FakeModel, ModelGatewayContract, fakeModel, testModelGateway, testRunStore };
+//#region src/testing/fake-model.d.ts
+interface FakeModel extends ModelGateway {
+  readonly calls: readonly ModelInput[];
+}
+/** Creates a deterministic model gateway for unit tests. */
+declare function fakeModel(...responses: ModelResult[]): FakeModel;
+//#endregion
+export { ChannelAdapterContract, FakeModel, ModelGatewayContract, ToolProviderContract, fakeModel, testChannelAdapter, testMemoryStore, testModelGateway, testRunStore, testToolProvider };