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

package/dist/index.mjs

@@ -1,9 +1,15 @@
 import { defineAgent } from "./agents/index.mjs";
-import { InMemoryRunStore, isDurableRunStore } from "./runtime/index.mjs";
+import { ChannelError, handleChannelInput } from "./channels/index.mjs";
+import { InMemoryMemoryStore, createMemoryContextProvider, defineContextProvider, defineSkill } from "./knowledge/index.mjs";
+import { n as teamAsWorkflow, t as defineTeam } from "./teams-Ctz676G4.mjs";
+import { n as RunPausedError, t as FevexRunError } from "./run-error-Cr17wPGH.mjs";
+import { InMemoryRunStore, isDurableRunStore, validateListEventsOptions } from "./runtime/index.mjs";
+import { FEVEX_JSON_SCHEMA_PROFILE_VERSION, IntegrationError, compileFevexJsonSchema, defineConnection, defineTool, toToolSpec, validateFevexJsonSchemaProfile } from "./tools/index.mjs";
 import { a as assertTokenBudget, c as remainingOutputTokens, d as serializeValue, f as toJsonValue, i as assertContinuationBudget, l as toErrorMessage, n as abortable, o as cancellationReason, r as addUsage, s as eventUsage, t as readModelStream, u as serializeJsonValue } from "./model-stream-u2xMsEaf.mjs";
-import { defineTool, toToolSpec } from "./tools/index.mjs";
 import "./models/index.mjs";
 import { definePolicy } from "./policies/index.mjs";
+import { SandboxError, createLocalSandbox, sandboxResultToJson } from "./sandbox/index.mjs";
+import { defineWorkflow } from "./workflows/index.mjs";
 //#region src/configuration-error.ts
 var FevexConfigurationError = class extends Error {
 	code;
@@ -14,7 +20,7 @@ var FevexConfigurationError = class extends Error {
 	}
 };
 //#endregion
-//#region src/core/index.ts
+//#region src/core/types.ts
 const SCHEMA_NOT_TRANSPORTABLE = "SCHEMA_NOT_TRANSPORTABLE";
 const PROVIDER_SCHEMA_UNSUPPORTED = "PROVIDER_SCHEMA_UNSUPPORTED";
 const PROVIDER_REASONING_UNSUPPORTED = "PROVIDER_REASONING_UNSUPPORTED";
@@ -25,9 +31,6 @@ function isStandardSchema(value) {
 	const standard = value["~standard"];
 	return typeof standard === "object" && standard !== null && standard.version === 1 && typeof standard.validate === "function";
 }
-function assertStandardSchema(value, errorMessage) {
-	if (!isStandardSchema(value)) throw new TypeError(errorMessage);
-}
 function isStandardJsonSchema(value) {
 	if (!isStandardSchema(value)) return false;
 	const jsonSchema = value["~standard"].jsonSchema;
@@ -69,8 +72,12 @@ const REASONING_EFFORTS = /* @__PURE__ */ new Set([
 	"minimal",
 	"low",
 	"medium",
-	"high"
+	"high",
+	"xhigh",
+	"max"
 ]);
+const DEFAULT_CONNECTION_TIMEOUT_MS = 3e4;
+const INTERNAL_TOOL_PREFIX = "fevex__";
 function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -93,18 +100,206 @@ function isRunStore(value) {
 		"listEvents"
 	].every((method) => typeof value[method] === "function");
 }
-function assertLimit(value, name, minimum, agentName, allowFalse = false) {
+function isSandbox(value) {
+	return isRecord(value) && typeof value.run === "function";
+}
+function isJsonObject(value) {
+	return isRecord(value);
+}
+function isToolProvider(value) {
+	return (typeof value === "object" && value !== null || typeof value === "function") && typeof value.listTools === "function" && typeof value.callTool === "function";
+}
+function isContextProvider(value) {
+	return (typeof value === "object" && value !== null || typeof value === "function") && typeof value.name === "string" && typeof value.read === "function";
+}
+function isMemoryStore(value) {
+	return (typeof value === "object" && value !== null || typeof value === "function") && typeof value.search === "function" && typeof value.write === "function";
+}
+function connectionAllowlist(connection) {
+	if (connection.allowlist) return connection.allowlist;
+	if (connection.tools && Array.isArray(connection.tools.allow)) return connection.tools.allow;
+}
+function connectionMetadata(connection, remoteName) {
+	if (!connection.tools || "allow" in connection.tools) return void 0;
+	return connection.tools[remoteName];
+}
+function namespacedToolName(connectionName, toolName) {
+	return `${connectionName}__${toolName}`;
+}
+function timeoutSignal(parent, timeoutMs) {
+	const controller = new AbortController();
+	const onAbort = () => controller.abort(parent?.reason);
+	const timer = setTimeout(() => {
+		controller.abort(new IntegrationError("CONNECTION_TIMEOUT", "timeout", true, "Connection tool call timed out"));
+	}, timeoutMs);
+	parent?.addEventListener("abort", onAbort, { once: true });
+	return {
+		signal: controller.signal,
+		dispose() {
+			clearTimeout(timer);
+			parent?.removeEventListener("abort", onAbort);
+		}
+	};
+}
+function connectionError(error, source) {
+	if (error instanceof IntegrationError) {
+		if (!source || error.source) return error;
+		return new IntegrationError(error.code, error.category, error.retryable, error.safeMessage, {
+			cause: error,
+			source
+		});
+	}
+	if (error instanceof DOMException && error.name === "AbortError") return new IntegrationError("CONNECTION_TIMEOUT", "timeout", true, "Connection tool call timed out", {
+		cause: error,
+		source
+	});
+	return new IntegrationError("CONNECTION_REMOTE_ERROR", "remote", false, "Connection tool call failed", {
+		cause: error,
+		source
+	});
+}
+function expandConnection(connection) {
+	assertConfiguration(isRecord(connection), "INVALID_CONNECTION", "Connection must be an object");
+	const allowlist = connectionAllowlist(connection);
+	assertConfiguration(typeof connection.name === "string" && Boolean(connection.name.trim()), "INVALID_CONNECTION", "Connection name must be a non-empty string");
+	assertConfiguration(!connection.name.includes("__"), "INVALID_CONNECTION", `Connection "${connection.name}" name cannot contain "__"`);
+	assertConfiguration(isToolProvider(connection.provider), "INVALID_CONNECTION", `Connection "${connection.name}" provider must implement listTools and callTool`);
+	assertConfiguration(Array.isArray(allowlist) && allowlist.length > 0, "INVALID_CONNECTION", `Connection "${connection.name}" allowlist must be a non-empty array`);
+	assertConfiguration(connection.timeoutMs === void 0 || Number.isInteger(connection.timeoutMs) && connection.timeoutMs > 0, "INVALID_CONNECTION", `Connection "${connection.name}" timeoutMs must be a positive integer`);
+	const seen = /* @__PURE__ */ new Set();
+	const listRemoteTools = async (context) => {
+		const tools = await connection.provider.listTools(context);
+		return new Map(tools.map((tool) => [tool.name, tool]));
+	};
+	return allowlist.map((remoteName) => {
+		assertConfiguration(typeof remoteName === "string" && Boolean(remoteName.trim()), "INVALID_TOOL", `Connection "${connection.name}" tool names must be non-empty strings`);
+		assertConfiguration(!remoteName.includes("__"), "INVALID_TOOL", `Connection "${connection.name}" tool "${remoteName}" cannot contain "__"`);
+		assertConfiguration(!seen.has(remoteName), "DUPLICATE_TOOL", `Connection "${connection.name}" tool "${remoteName}" is duplicated`);
+		seen.add(remoteName);
+		const policy = connectionMetadata(connection, remoteName);
+		const source = {
+			kind: "connection",
+			provider: typeof connection.provider.kind === "string" && connection.provider.kind.trim() ? connection.provider.kind : "custom",
+			connectionName: connection.name,
+			remoteToolName: remoteName
+		};
+		assertConfiguration(policy?.inputSchema === void 0 || isJsonObject(policy.inputSchema), "INVALID_TOOL", `Input schema for connection tool "${remoteName}" must be a JSON object`);
+		assertConfiguration(policy?.outputSchema === void 0 || isJsonObject(policy.outputSchema), "INVALID_TOOL", `Output schema for connection tool "${remoteName}" must be a JSON object`);
+		return {
+			name: namespacedToolName(connection.name, remoteName),
+			...policy?.label === void 0 ? {} : { label: policy.label },
+			...policy?.description === void 0 ? {} : { description: policy.description },
+			...policy?.inputSchema === void 0 ? {} : { inputJsonSchema: policy.inputSchema },
+			...policy?.outputSchema === void 0 ? {} : { outputJsonSchema: policy.outputSchema },
+			...policy?.risk === void 0 ? {} : { risk: policy.risk },
+			...policy?.approval === void 0 ? {} : { approval: policy.approval },
+			...policy?.idempotency === void 0 ? {} : { idempotency: policy.idempotency },
+			...policy?.retry === void 0 ? {} : { retry: policy.retry },
+			...policy?.credentials === void 0 ? {} : { credentials: policy.credentials },
+			source,
+			async resolve(context) {
+				try {
+					return (await listRemoteTools(context)).get(remoteName);
+				} catch (error) {
+					throw connectionError(error, source);
+				}
+			},
+			async execute(input, context) {
+				const timeout = timeoutSignal(context.signal, connection.timeoutMs ?? DEFAULT_CONNECTION_TIMEOUT_MS);
+				try {
+					return await Promise.race([connection.provider.callTool(remoteName, input, {
+						runId: context.runId,
+						toolCallId: context.toolCallId,
+						attempt: context.attempt,
+						idempotencyKey: context.idempotencyKey,
+						context: context.context,
+						signal: timeout.signal
+					}), new Promise((_, reject) => {
+						timeout.signal.addEventListener("abort", () => {
+							reject(timeout.signal.reason ?? new DOMException("Aborted", "AbortError"));
+						}, { once: true });
+					})]);
+				} catch (error) {
+					throw connectionError(error, source);
+				} finally {
+					timeout.dispose();
+				}
+			}
+		};
+	});
+}
+function assertLimit(value, name, minimum, ownerName, allowFalse = false, owner = "Agent", code = "INVALID_AGENT") {
 	if (value === void 0 || allowFalse && value === false) return;
-	if (typeof value !== "number" || !Number.isInteger(value) || value < minimum) throw configurationError("INVALID_AGENT", `Agent "${agentName}" limit "${name}" must be ${minimum === 0 ? "a non-negative" : "a positive"} integer${allowFalse ? " or false" : ""}`);
+	if (typeof value !== "number" || !Number.isInteger(value) || value < minimum) throw configurationError(code, `${owner} "${ownerName}" limit "${name}" must be ${minimum === 0 ? "a non-negative" : "a positive"} integer${allowFalse ? " or false" : ""}`);
+}
+function assertStringArray(value, code, message) {
+	assertConfiguration(value === void 0 || Array.isArray(value) && value.every((item) => typeof item === "string" && item.trim()), code, message);
+}
+function assertPositiveInteger(value, code, message) {
+	assertConfiguration(value === void 0 || Number.isInteger(value) && value > 0, code, message);
+}
+function assertSandboxCapabilities(value, ownerName) {
+	if (value === void 0) return;
+	assertConfiguration(isRecord(value), "INVALID_TOOL", `Tool "${ownerName}" sandbox must be an object`);
+	const capabilities = value;
+	const process = capabilities.process;
+	if (process !== void 0) {
+		assertConfiguration(isRecord(process), "INVALID_TOOL", `Tool "${ownerName}" sandbox.process must be an object`);
+		assertStringArray(process.commands, "INVALID_TOOL", `Tool "${ownerName}" sandbox.process.commands must contain non-empty strings`);
+		assertPositiveInteger(process.timeoutMs, "INVALID_TOOL", `Tool "${ownerName}" sandbox.process.timeoutMs must be a positive integer`);
+	}
+	const filesystem = capabilities.filesystem;
+	if (filesystem !== void 0) {
+		assertConfiguration(isRecord(filesystem), "INVALID_TOOL", `Tool "${ownerName}" sandbox.filesystem must be an object`);
+		assertConfiguration(filesystem.cwd === void 0 || typeof filesystem.cwd === "string", "INVALID_TOOL", `Tool "${ownerName}" sandbox.filesystem.cwd must be a string`);
+		assertStringArray(filesystem.read, "INVALID_TOOL", `Tool "${ownerName}" sandbox.filesystem.read must contain non-empty strings`);
+		assertStringArray(filesystem.write, "INVALID_TOOL", `Tool "${ownerName}" sandbox.filesystem.write must contain non-empty strings`);
+	}
+	const network = capabilities.network;
+	if (network !== void 0 && network !== false) {
+		assertConfiguration(isRecord(network), "INVALID_TOOL", `Tool "${ownerName}" sandbox.network must be false or an object`);
+		assertStringArray(network.allow, "INVALID_TOOL", `Tool "${ownerName}" sandbox.network.allow must contain non-empty strings`);
+	}
+	const resources = capabilities.resources;
+	if (resources !== void 0) {
+		assertConfiguration(isRecord(resources), "INVALID_TOOL", `Tool "${ownerName}" sandbox.resources must be an object`);
+		assertPositiveInteger(resources.timeoutMs, "INVALID_TOOL", `Tool "${ownerName}" sandbox.resources.timeoutMs must be a positive integer`);
+		assertPositiveInteger(resources.maxOutputBytes, "INVALID_TOOL", `Tool "${ownerName}" sandbox.resources.maxOutputBytes must be a positive integer`);
+	}
+}
+function copySandboxCapabilities(value) {
+	if (!value) return void 0;
+	return {
+		...value.process === void 0 ? {} : { process: {
+			...value.process.commands === void 0 ? {} : { commands: [...value.process.commands] },
+			...value.process.timeoutMs === void 0 ? {} : { timeoutMs: value.process.timeoutMs }
+		} },
+		...value.filesystem === void 0 ? {} : { filesystem: {
+			...value.filesystem.cwd === void 0 ? {} : { cwd: value.filesystem.cwd },
+			...value.filesystem.read === void 0 ? {} : { read: [...value.filesystem.read] },
+			...value.filesystem.write === void 0 ? {} : { write: [...value.filesystem.write] }
+		} },
+		...value.network === void 0 ? {} : { network: value.network === false ? false : { allow: [...value.network.allow ?? []] } },
+		...value.resources === void 0 ? {} : { resources: {
+			...value.resources.timeoutMs === void 0 ? {} : { timeoutMs: value.resources.timeoutMs },
+			...value.resources.maxOutputBytes === void 0 ? {} : { maxOutputBytes: value.resources.maxOutputBytes }
+		} }
+	};
 }
 function createComposition(config) {
 	assertConfiguration(isRecord(config), "INVALID_CONFIG", "Fevex config must be an object");
 	assertConfiguration(isRecord(config.models), "INVALID_CONFIG", "Fevex config \"models\" must be an object");
 	assertConfiguration(Array.isArray(config.agents), "INVALID_CONFIG", "Fevex config \"agents\" must be an array");
+	assertConfiguration(config.workflows === void 0 || Array.isArray(config.workflows), "INVALID_CONFIG", "Fevex config \"workflows\" must be an array");
+	assertConfiguration(config.teams === void 0 || Array.isArray(config.teams), "INVALID_CONFIG", "Fevex config \"teams\" must be an array");
 	assertConfiguration(config.tools === void 0 || Array.isArray(config.tools), "INVALID_CONFIG", "Fevex config \"tools\" must be an array");
+	assertConfiguration(config.connections === void 0 || Array.isArray(config.connections), "INVALID_CONFIG", "Fevex config \"connections\" must be an array");
+	assertConfiguration(config.contextProviders === void 0 || Array.isArray(config.contextProviders), "INVALID_CONFIG", "Fevex config \"contextProviders\" must be an array");
+	assertConfiguration(config.memoryStore === void 0 || isMemoryStore(config.memoryStore), "INVALID_CONFIG", "Fevex config \"memoryStore\" must implement MemoryStore");
 	assertConfiguration(config.onEvent === void 0 || typeof config.onEvent === "function", "INVALID_CONFIG", "Fevex config \"onEvent\" must be a function");
 	assertConfiguration(config.runStore === void 0 || isRunStore(config.runStore), "INVALID_CONFIG", "Fevex config \"runStore\" must implement RunStore");
 	assertConfiguration(config.credentialStore === void 0 || typeof config.credentialStore?.resolve === "function", "INVALID_CONFIG", "Fevex config \"credentialStore\" must implement resolve");
+	assertConfiguration(config.sandbox === void 0 || isSandbox(config.sandbox), "INVALID_CONFIG", "Fevex config \"sandbox\" must implement Sandbox");
 	assertConfiguration(config.policies === void 0 || Array.isArray(config.policies), "INVALID_CONFIG", "Fevex config \"policies\" must be an array");
 	if (config.observability !== void 0) {
 		assertConfiguration(isRecord(config.observability), "INVALID_CONFIG", "Fevex config \"observability\" must be an object");
@@ -121,18 +316,30 @@ function createComposition(config) {
 	}
 	const models = /* @__PURE__ */ new Map();
 	const agents = /* @__PURE__ */ new Map();
+	const workflows = /* @__PURE__ */ new Map();
+	const teams = /* @__PURE__ */ new Map();
 	const tools = /* @__PURE__ */ new Map();
+	const contextProviders = /* @__PURE__ */ new Map();
 	for (const [name, model] of Object.entries(config.models)) {
 		assertConfiguration(name.trim(), "INVALID_MODEL", "Model name cannot be empty");
 		assertConfiguration(isModelGateway(model), "INVALID_MODEL", `Model "${name}" must implement stream`);
 		assertConfiguration(model.stateCodec === void 0 || isRecord(model.stateCodec) && typeof model.stateCodec.serialize === "function" && typeof model.stateCodec.restore === "function", "INVALID_MODEL", `Model "${name}" stateCodec must implement serialize and restore`);
 		models.set(name, model);
 	}
-	for (const [index, definition] of (config.tools ?? []).entries()) {
+	for (const [index, provider] of (config.contextProviders ?? []).entries()) {
+		assertConfiguration(isContextProvider(provider), "INVALID_CONTEXT_PROVIDER", `Context provider at index ${index} must have a name and read`);
+		const name = provider.name;
+		assertConfiguration(name.trim(), "INVALID_CONTEXT_PROVIDER", "Context provider name cannot be empty");
+		assertConfiguration(!contextProviders.has(name), "DUPLICATE_CONTEXT_PROVIDER", `Context provider "${name}" is duplicated`);
+		contextProviders.set(name, provider);
+	}
+	const expandedTools = [...config.tools ?? [], ...(config.connections ?? []).flatMap((connection) => expandConnection(connection))];
+	for (const [index, definition] of expandedTools.entries()) {
 		assertConfiguration(isRecord(definition), "INVALID_TOOL", `Tool at index ${index} must be an object`);
 		assertConfiguration(typeof definition.name === "string", "INVALID_TOOL", "Tool name must be a string");
 		const name = definition.name;
 		assertConfiguration(name.trim(), "INVALID_TOOL", "Tool name cannot be empty");
+		assertConfiguration(!name.startsWith(INTERNAL_TOOL_PREFIX), "INVALID_TOOL", `Tool "${name}" uses reserved prefix "${INTERNAL_TOOL_PREFIX}"`);
 		assertConfiguration(!tools.has(name), "DUPLICATE_TOOL", `Tool "${name}" is duplicated`);
 		assertConfiguration(definition.description === void 0 || typeof definition.description === "string", "INVALID_TOOL", `Tool "${name}" description must be a string`);
 		assertConfiguration(typeof definition.execute === "function", "INVALID_TOOL", `Tool "${name}" must implement execute`);
@@ -145,25 +352,36 @@ function createComposition(config) {
 		assertConfiguration(definition.approval === void 0 || definition.approval === "never" || definition.approval === "required", "INVALID_TOOL", `Tool "${name}" approval is invalid`);
 		assertConfiguration(definition.idempotency === void 0 || definition.idempotency === "none" || definition.idempotency === "keyed", "INVALID_TOOL", `Tool "${name}" idempotency is invalid`);
 		assertConfiguration(definition.credentials === void 0 || Array.isArray(definition.credentials) && definition.credentials.every((value) => typeof value === "string" && value.trim()), "INVALID_TOOL", `Tool "${name}" credentials must be non-empty strings`);
+		assertSandboxCapabilities(definition.sandbox, name);
+		assertConfiguration(definition.sandbox === void 0 || config.sandbox !== void 0, "INVALID_TOOL", `Tool "${name}" requires Fevex config "sandbox"`);
 		if (definition.retry !== void 0) assertConfiguration(isRecord(definition.retry) && Number.isInteger(definition.retry.maxAttempts) && definition.retry.maxAttempts >= 1 && Number.isInteger(definition.retry.backoffMs) && definition.retry.backoffMs >= 0 && (definition.retry.maxBackoffMs === void 0 || Number.isInteger(definition.retry.maxBackoffMs) && definition.retry.maxBackoffMs >= 0), "INVALID_TOOL", `Tool "${name}" retry is invalid`);
 		if (definition.inputSchema !== void 0) assertConfiguration(isStandardSchema(definition.inputSchema), "INVALID_TOOL", `Input schema for tool "${name}" must implement Standard Schema`);
+		if (definition.inputSchema !== void 0) assertConfiguration(isStandardSchema(definition.inputSchema), "INVALID_AGENT", `Input schema for agent "${name}" must implement Standard Schema`);
 		if (definition.outputSchema !== void 0) assertConfiguration(isStandardSchema(definition.outputSchema), "INVALID_TOOL", `Output schema for tool "${name}" must implement Standard Schema`);
+		if (definition.inputJsonSchema !== void 0) assertConfiguration(isJsonObject(definition.inputJsonSchema), "INVALID_TOOL", `Input JSON schema for tool "${name}" must be an object`);
+		if (definition.outputJsonSchema !== void 0) assertConfiguration(isJsonObject(definition.outputJsonSchema), "INVALID_TOOL", `Output JSON schema for tool "${name}" must be an object`);
 		tools.set(name, {
 			name,
+			...definition.label === void 0 ? {} : { label: definition.label },
 			...definition.description === void 0 ? {} : { description: definition.description },
 			...definition.inputSchema === void 0 ? {} : { inputSchema: definition.inputSchema },
 			...definition.outputSchema === void 0 ? {} : { outputSchema: definition.outputSchema },
+			...definition.inputJsonSchema === void 0 ? {} : { inputJsonSchema: definition.inputJsonSchema },
+			...definition.outputJsonSchema === void 0 ? {} : { outputJsonSchema: definition.outputJsonSchema },
 			...definition.risk === void 0 ? {} : { risk: definition.risk },
 			...definition.approval === void 0 ? {} : { approval: definition.approval },
 			...definition.idempotency === void 0 ? {} : { idempotency: definition.idempotency },
 			...definition.retry === void 0 ? {} : { retry: { ...definition.retry } },
 			...definition.credentials === void 0 ? {} : { credentials: [...definition.credentials] },
+			...definition.sandbox === void 0 ? {} : { sandbox: copySandboxCapabilities(definition.sandbox) },
+			...definition.source === void 0 ? {} : { source: { ...definition.source } },
+			...definition.resolve === void 0 ? {} : { resolve: definition.resolve },
 			execute: definition.execute
 		});
 	}
 	const policies = [];
 	for (const [index, policy] of (config.policies ?? []).entries()) {
-		assertConfiguration(isRecord(policy) && typeof policy.name === "string" && Boolean(policy.name.trim()) && typeof policy.authorize === "function", "INVALID_CONFIG", `Policy at index ${index} must have a name and authorize`);
+		assertConfiguration(isRecord(policy) && typeof policy.name === "string" && Boolean(policy.name.trim()) && typeof policy.authorize === "function", "INVALID_POLICY", `Policy at index ${index} must have a name and authorize`);
 		policies.push({
 			name: policy.name,
 			authorize: policy.authorize
@@ -192,8 +410,39 @@ function createComposition(config) {
 				agentTools.push(toolName);
 			}
 		}
+		let agentContext;
+		if (definition.context !== void 0) {
+			assertConfiguration(Array.isArray(definition.context), "INVALID_AGENT", `Agent "${name}" context must be an array`);
+			agentContext = [];
+			const seenContext = /* @__PURE__ */ new Set();
+			for (const [contextIndex, providerName] of definition.context.entries()) {
+				assertConfiguration(typeof providerName === "string" && Boolean(providerName.trim()), "INVALID_AGENT", `Context provider name at index ${contextIndex} for agent "${name}" must be a non-empty string`);
+				assertConfiguration(!seenContext.has(providerName), "INVALID_AGENT", `Context provider "${providerName}" is duplicated in agent "${name}"`);
+				seenContext.add(providerName);
+				agentContext.push(providerName);
+			}
+		}
+		let agentSkills;
+		if (definition.skills !== void 0) {
+			assertConfiguration(Array.isArray(definition.skills), "INVALID_AGENT", `Agent "${name}" skills must be an array`);
+			agentSkills = [];
+			const seenSkills = /* @__PURE__ */ new Set();
+			for (const [skillIndex, skillName] of definition.skills.entries()) {
+				assertConfiguration(typeof skillName === "string" && Boolean(skillName.trim()), "INVALID_AGENT", `Skill name at index ${skillIndex} for agent "${name}" must be a non-empty string`);
+				assertConfiguration(!seenSkills.has(skillName), "INVALID_AGENT", `Skill "${skillName}" is duplicated in agent "${name}"`);
+				seenSkills.add(skillName);
+				agentSkills.push(skillName);
+			}
+		}
+		assertConfiguration(definition.memory === void 0 || isRecord(definition.memory), "INVALID_AGENT", `Agent "${name}" memory must be an object`);
+		assertConfiguration(definition.memory?.read === void 0 || typeof definition.memory.read === "boolean", "INVALID_AGENT", `Agent "${name}" memory.read must be a boolean`);
+		assertConfiguration(definition.memory?.write === void 0 || typeof definition.memory.write === "boolean", "INVALID_AGENT", `Agent "${name}" memory.write must be a boolean`);
+		assertConfiguration(definition.memory?.limit === void 0 || Number.isInteger(definition.memory.limit) && definition.memory.limit > 0, "INVALID_AGENT", `Agent "${name}" memory.limit must be a positive integer`);
 		assertConfiguration(definition.reasoning === void 0 || typeof definition.reasoning === "string" && REASONING_EFFORTS.has(definition.reasoning), "INVALID_AGENT", `Agent "${name}" reasoning is invalid`);
 		assertConfiguration(definition.modelOptions === void 0 || isRecord(definition.modelOptions), "INVALID_AGENT", `Agent "${name}" modelOptions must be an object`);
+		assertConfiguration(definition.elicitation === void 0 || definition.elicitation === "pause" || definition.elicitation === "forbid", "INVALID_AGENT", `Agent "${name}" elicitation is invalid`);
+		assertConfiguration(definition.approvalMode === void 0 || definition.approvalMode === "pause" || definition.approvalMode === "deny", "INVALID_AGENT", `Agent "${name}" approvalMode is invalid`);
+		assertConfiguration(definition.toolChoice === void 0 || definition.toolChoice === "auto" || definition.toolChoice === "required" || definition.toolChoice === "none" || isRecord(definition.toolChoice) && typeof definition.toolChoice.name === "string" && Boolean(definition.toolChoice.name.trim()), "INVALID_AGENT", `Agent "${name}" toolChoice is invalid`);
 		assertConfiguration(definition.limits === void 0 || isRecord(definition.limits), "INVALID_AGENT", `Agent "${name}" limits must be an object`);
 		if (definition.outputSchema !== void 0) assertConfiguration(isStandardSchema(definition.outputSchema), "INVALID_AGENT", `Output schema for agent "${name}" must implement Standard Schema`);
 		const rawLimits = definition.limits;
@@ -206,8 +455,19 @@ function createComposition(config) {
 			instructions: definition.instructions,
 			...model === void 0 ? {} : { model },
 			...agentTools === void 0 ? {} : { tools: agentTools },
+			...agentContext === void 0 ? {} : { context: agentContext },
+			...agentSkills === void 0 ? {} : { skills: agentSkills },
+			...definition.memory === void 0 ? {} : { memory: {
+				...definition.memory.read === void 0 ? {} : { read: definition.memory.read },
+				...definition.memory.write === void 0 ? {} : { write: definition.memory.write },
+				...definition.memory.limit === void 0 ? {} : { limit: definition.memory.limit }
+			} },
 			...definition.reasoning === void 0 ? {} : { reasoning: definition.reasoning },
 			...definition.modelOptions === void 0 ? {} : { modelOptions: { ...definition.modelOptions } },
+			...definition.toolChoice === void 0 ? {} : { toolChoice: typeof definition.toolChoice === "string" ? definition.toolChoice : { name: definition.toolChoice.name } },
+			...definition.elicitation === void 0 ? {} : { elicitation: definition.elicitation },
+			...definition.approvalMode === void 0 ? {} : { approvalMode: definition.approvalMode },
+			...definition.inputSchema === void 0 ? {} : { inputSchema: definition.inputSchema },
 			...definition.outputSchema === void 0 ? {} : { outputSchema: definition.outputSchema },
 			...rawLimits === void 0 ? {} : { limits: {
 				...rawLimits.maxSteps === void 0 ? {} : { maxSteps: rawLimits.maxSteps },
@@ -221,13 +481,119 @@ function createComposition(config) {
 		if (typeof agent.model === "string" && !models.has(agent.model)) throw configurationError("MISSING_MODEL", `Model "${agent.model}" required by agent "${agent.name}" is not registered`);
 		if (agent.model === void 0 && !models.has("default")) throw configurationError("MISSING_MODEL", `Default model "default" required by agent "${agent.name}" is not registered`);
 		for (const toolName of agent.tools ?? []) if (!tools.has(toolName)) throw configurationError("MISSING_TOOL", `Tool "${toolName}" required by agent "${agent.name}" is not registered`);
+		if (typeof agent.toolChoice === "object" && !agent.tools?.includes(agent.toolChoice.name)) throw configurationError("MISSING_TOOL", `Tool "${agent.toolChoice.name}" required by agent "${agent.name}" toolChoice is not registered`);
+		for (const providerName of [...agent.context ?? [], ...agent.skills ?? []]) if (!contextProviders.has(providerName)) throw configurationError("INVALID_AGENT", `Context provider "${providerName}" required by agent "${agent.name}" is not registered`);
+	}
+	for (const [index, definition] of (config.workflows ?? []).entries()) {
+		assertConfiguration(isRecord(definition), "INVALID_WORKFLOW", `Workflow at index ${index} must be an object`);
+		assertConfiguration(typeof definition.name === "string", "INVALID_WORKFLOW", "Workflow name must be a string");
+		const name = definition.name;
+		assertConfiguration(name.trim(), "INVALID_WORKFLOW", "Workflow name cannot be empty");
+		assertConfiguration(typeof definition.run === "function", "INVALID_WORKFLOW", `Workflow "${name}" must implement run`);
+		assertConfiguration(definition.version === void 0 || typeof definition.version === "string" && Boolean(definition.version.trim()), "INVALID_WORKFLOW", `Workflow "${name}" version must be a non-empty string`);
+		assertConfiguration(definition.limits === void 0 || isRecord(definition.limits), "INVALID_WORKFLOW", `Workflow "${name}" limits must be an object`);
+		if (definition.inputSchema !== void 0) assertConfiguration(isStandardSchema(definition.inputSchema), "INVALID_WORKFLOW", `Input schema for workflow "${name}" must implement Standard Schema`);
+		if (definition.outputSchema !== void 0) assertConfiguration(isStandardSchema(definition.outputSchema), "INVALID_WORKFLOW", `Output schema for workflow "${name}" must implement Standard Schema`);
+		assertConfiguration(definition.events === void 0 || isRecord(definition.events), "INVALID_WORKFLOW", `Workflow "${name}" events must be an object`);
+		const workflowEvents = {};
+		for (const [eventName, rawEvent] of Object.entries(definition.events ?? {})) {
+			assertConfiguration(Boolean(eventName.trim()) && isRecord(rawEvent), "INVALID_WORKFLOW", `Workflow "${name}" event definitions must be named objects`);
+			assertConfiguration(rawEvent.requireActor === void 0 || typeof rawEvent.requireActor === "boolean", "INVALID_WORKFLOW", `Workflow "${name}" event "${eventName}" requireActor must be a boolean`);
+			assertConfiguration(rawEvent.payloadSchema === void 0 || isStandardSchema(rawEvent.payloadSchema), "INVALID_WORKFLOW", `Payload schema for workflow "${name}" event "${eventName}" must implement Standard Schema`);
+			workflowEvents[eventName] = {
+				...rawEvent.payloadSchema === void 0 ? {} : { payloadSchema: rawEvent.payloadSchema },
+				...rawEvent.requireActor === void 0 ? {} : { requireActor: rawEvent.requireActor }
+			};
+		}
+		const rawLimits = definition.limits;
+		assertLimit(rawLimits?.maxSteps, "maxSteps", 1, name, false, "Workflow", "INVALID_WORKFLOW");
+		assertLimit(rawLimits?.maxToolCalls, "maxToolCalls", 0, name, false, "Workflow", "INVALID_WORKFLOW");
+		assertLimit(rawLimits?.maxInputTokens, "maxInputTokens", 1, name, true, "Workflow", "INVALID_WORKFLOW");
+		assertLimit(rawLimits?.maxOutputTokens, "maxOutputTokens", 1, name, true, "Workflow", "INVALID_WORKFLOW");
+		assertConfiguration(!workflows.has(name), "DUPLICATE_WORKFLOW", `Workflow "${name}" is duplicated`);
+		workflows.set(name, {
+			name,
+			version: definition.version ?? "1",
+			...definition.inputSchema === void 0 ? {} : { inputSchema: definition.inputSchema },
+			...definition.outputSchema === void 0 ? {} : { outputSchema: definition.outputSchema },
+			...definition.events === void 0 ? {} : { events: workflowEvents },
+			...rawLimits === void 0 ? {} : { limits: {
+				...rawLimits.maxSteps === void 0 ? {} : { maxSteps: rawLimits.maxSteps },
+				...rawLimits.maxToolCalls === void 0 ? {} : { maxToolCalls: rawLimits.maxToolCalls },
+				...rawLimits.maxInputTokens === void 0 ? {} : { maxInputTokens: rawLimits.maxInputTokens },
+				...rawLimits.maxOutputTokens === void 0 ? {} : { maxOutputTokens: rawLimits.maxOutputTokens }
+			} },
+			run: definition.run
+		});
+	}
+	for (const [index, definition] of (config.teams ?? []).entries()) {
+		assertConfiguration(isRecord(definition), "INVALID_TEAM", `Team at index ${index} must be an object`);
+		assertConfiguration(typeof definition.name === "string", "INVALID_TEAM", "Team name must be a string");
+		const name = definition.name;
+		assertConfiguration(name.trim(), "INVALID_TEAM", "Team name cannot be empty");
+		assertConfiguration(typeof definition.supervisor === "string" && Boolean(definition.supervisor.trim()), "INVALID_TEAM", `Team "${name}" supervisor must be a non-empty string`);
+		assertConfiguration(typeof definition.run === "function", "INVALID_TEAM", `Team "${name}" must implement run`);
+		assertConfiguration(definition.version === void 0 || typeof definition.version === "string" && Boolean(definition.version.trim()), "INVALID_TEAM", `Team "${name}" version must be a non-empty string`);
+		assertConfiguration(Array.isArray(definition.members), "INVALID_TEAM", `Team "${name}" members must be an array`);
+		const members = [];
+		const memberNames = /* @__PURE__ */ new Set();
+		for (const [memberIndex, rawMember] of definition.members.entries()) {
+			assertConfiguration(isRecord(rawMember) && typeof rawMember.agent === "string" && Boolean(rawMember.agent.trim()) && typeof rawMember.role === "string" && Boolean(rawMember.role.trim()) && (rawMember.description === void 0 || typeof rawMember.description === "string"), "INVALID_TEAM", `Team "${name}" member at index ${memberIndex} is invalid`);
+			assertConfiguration(!memberNames.has(rawMember.agent), "INVALID_TEAM", `Team "${name}" member "${rawMember.agent}" is duplicated`);
+			memberNames.add(rawMember.agent);
+			members.push({
+				agent: rawMember.agent,
+				role: rawMember.role,
+				...rawMember.description === void 0 ? {} : { description: rawMember.description }
+			});
+		}
+		const supervisor = definition.supervisor;
+		assertConfiguration(agents.has(supervisor), "INVALID_TEAM", `Supervisor "${supervisor}" required by team "${name}" is not registered`);
+		for (const member of members) assertConfiguration(agents.has(member.agent), "INVALID_TEAM", `Agent "${member.agent}" required by team "${name}" is not registered`);
+		if (definition.inputSchema !== void 0) assertConfiguration(isStandardSchema(definition.inputSchema), "INVALID_TEAM", `Input schema for team "${name}" must implement Standard Schema`);
+		if (definition.outputSchema !== void 0) assertConfiguration(isStandardSchema(definition.outputSchema), "INVALID_TEAM", `Output schema for team "${name}" must implement Standard Schema`);
+		assertConfiguration(definition.limits === void 0 || isRecord(definition.limits), "INVALID_TEAM", `Team "${name}" limits must be an object`);
+		const rawLimits = definition.limits;
+		assertLimit(rawLimits?.maxDelegations, "maxDelegations", 1, name, false, "Team", "INVALID_TEAM");
+		assertLimit(rawLimits?.maxParallel, "maxParallel", 1, name, false, "Team", "INVALID_TEAM");
+		assertLimit(rawLimits?.maxSteps, "maxSteps", 1, name, false, "Team", "INVALID_TEAM");
+		assertLimit(rawLimits?.maxToolCalls, "maxToolCalls", 0, name, false, "Team", "INVALID_TEAM");
+		assertLimit(rawLimits?.maxInputTokens, "maxInputTokens", 1, name, true, "Team", "INVALID_TEAM");
+		assertLimit(rawLimits?.maxOutputTokens, "maxOutputTokens", 1, name, true, "Team", "INVALID_TEAM");
+		assertConfiguration(!teams.has(name), "DUPLICATE_TEAM", `Team "${name}" is duplicated`);
+		assertConfiguration(!workflows.has(name), "INVALID_TEAM", `Team "${name}" conflicts with a workflow of the same name`);
+		const team = {
+			name,
+			version: definition.version ?? "1",
+			supervisor,
+			members,
+			...definition.inputSchema === void 0 ? {} : { inputSchema: definition.inputSchema },
+			...definition.outputSchema === void 0 ? {} : { outputSchema: definition.outputSchema },
+			...rawLimits === void 0 ? {} : { limits: {
+				...rawLimits.maxDelegations === void 0 ? {} : { maxDelegations: rawLimits.maxDelegations },
+				...rawLimits.maxParallel === void 0 ? {} : { maxParallel: rawLimits.maxParallel },
+				...rawLimits.maxSteps === void 0 ? {} : { maxSteps: rawLimits.maxSteps },
+				...rawLimits.maxToolCalls === void 0 ? {} : { maxToolCalls: rawLimits.maxToolCalls },
+				...rawLimits.maxInputTokens === void 0 ? {} : { maxInputTokens: rawLimits.maxInputTokens },
+				...rawLimits.maxOutputTokens === void 0 ? {} : { maxOutputTokens: rawLimits.maxOutputTokens }
+			} },
+			run: definition.run
+		};
+		teams.set(name, team);
+		workflows.set(name, teamAsWorkflow(team));
 	}
+	const usesMemory = [...agents.values()].some((agent) => agent.memory && (agent.memory.read !== false || agent.memory.write === true));
 	return {
 		models,
 		agents,
+		workflows,
+		teams,
 		tools,
+		contextProviders,
+		memoryStore: config.memoryStore ?? (usesMemory ? new InMemoryMemoryStore() : void 0),
 		runStore: config.runStore ?? new InMemoryRunStore(),
 		credentialStore: config.credentialStore,
+		sandbox: config.sandbox,
 		policies,
 		onEvent: config.onEvent,
 		observability: config.observability === void 0 ? void 0 : {
@@ -241,552 +607,454 @@ function createComposition(config) {
 	};
 }
 //#endregion
-//#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;
+//#region src/internal/runtime-constants.ts
+/** How long a run lease stays valid before it must be renewed. */
+const LEASE_MS = 3e4;
+/** How often a running execution renews its lease. */
+const LEASE_RENEW_MS = 1e4;
+/** Reserved name of the internal elicitation tool exposed to the model. */
+const ELICIT_TOOL_NAME = "fevex__elicit";
+//#endregion
+//#region src/internal/run-helpers.ts
+function redact(message, secrets) {
+	return secrets.reduce((safe, secret) => secret ? safe.split(secret).join("[REDACTED]") : safe, message);
+}
+function containsSecret(value, secrets) {
+	if (typeof value === "string") return secrets.some((secret) => secret && value.includes(secret));
+	if (Array.isArray(value)) return value.some((item) => containsSecret(item, secrets));
+	if (value && typeof value === "object") return Object.values(value).some((item) => containsSecret(item, secrets));
+	return false;
+}
+function effectiveElicitationMode(agent, request) {
+	return request.elicitation ?? agent.elicitation ?? "forbid";
+}
+function effectiveApprovalMode(agent, request) {
+	return request.approvalMode ?? agent.approvalMode ?? "pause";
+}
+function effectiveToolChoice(agent, request) {
+	return request.toolChoice ?? agent.toolChoice ?? "auto";
+}
+function isElicitationToolCall(call) {
+	return call.name === ELICIT_TOOL_NAME;
+}
+function readElicitationInput(input) {
+	if (typeof input !== "object" || input === null || Array.isArray(input)) throw new TypeError("Elicitation input must be an object");
+	const prompt = input.prompt;
+	const responseSchema = input.responseSchema;
+	const expiresAt = input.expiresAt;
+	if (typeof prompt !== "string" || !prompt.trim()) throw new TypeError("Elicitation prompt must be a non-empty string");
+	if (typeof responseSchema !== "object" || responseSchema === null || Array.isArray(responseSchema)) throw new TypeError("Elicitation responseSchema must be an object");
+	validateFevexJsonSchemaProfile(responseSchema);
+	if (expiresAt !== void 0) {
+		if (typeof expiresAt !== "string" || !Number.isFinite(Date.parse(expiresAt))) throw new TypeError("Elicitation expiresAt must be a valid ISO date string");
+	}
+	return {
+		prompt,
+		responseSchema,
+		...expiresAt === void 0 ? {} : { expiresAt }
+	};
+}
+function isCoordinatorRun(run) {
+	return run.kind === "workflow" || run.kind === "team";
+}
+function isTeamRun(run) {
+	return run.kind === "team";
+}
+function coordinatorName(run) {
+	return run.kind === "team" ? run.teamName : run.workflowName;
+}
+var WorkflowChildPausedError = class extends Error {
+	stepId;
+	paused;
+	constructor(stepId, paused) {
+		super(paused.message, { cause: paused });
+		this.stepId = stepId;
+		this.paused = paused;
 	}
 };
-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;
+function pauseMatchesResolution(pause, resolution) {
+	if (pause.type === "elicitation" && resolution.type === "elicitation") return pause.request.id === resolution.requestId;
+	if (pause.type === "approval" && resolution.type === "approval") return pause.approval.id === resolution.approvalId;
+	if (pause.type === "tool_execution_unknown" && resolution.type === "tool_execution") return pause.toolCallId === resolution.toolCallId;
+	return false;
+}
+function mergeExecutionContext(parent, child) {
+	if (!parent) return child;
+	if (!child) return parent;
+	return {
+		...parent,
+		...child,
+		actor: parent.actor ?? child.actor,
+		...parent.attributes || child.attributes ? { attributes: {
+			...parent.attributes,
+			...child.attributes
+		} } : {},
+		...parent.prompt || child.prompt ? { prompt: {
+			...parent.prompt,
+			...child.prompt
+		} } : {}
+	};
+}
+function systemBlock(label, provider, block) {
+	return {
+		role: "system",
+		content: `[${label}: ${provider}/${block.id}]\n${block.content}`
+	};
+}
+async function readMemoryMessages(agent, context, memoryStore) {
+	if (!agent.memory || agent.memory.read === false || !memoryStore) return [];
+	try {
+		return (await abortable(() => memoryStore.search({
+			query: context.input,
+			limit: agent.memory?.limit ?? 5,
+			agentName: context.agentName,
+			sessionId: context.sessionId,
+			namespace: context.context?.namespace,
+			actor: context.context?.actor
+		}, context), context.signal)).filter((record) => record.content.trim()).map((record) => ({
+			role: "system",
+			content: `[Memory: ${record.id}]\n${record.content}`
+		}));
+	} catch (cause) {
+		throw new Error("Memory search failed", { cause });
 	}
+}
+const toolSourcePayload = (tool, error) => {
+	const source = error instanceof IntegrationError ? error.source ?? tool.source : tool.source;
+	return source === void 0 ? {} : { source };
+};
+const toolLabelPayload = (tool) => tool.label === void 0 ? {} : { toolLabel: tool.label };
+const toolErrorPayload = (tool, error) => ({
+	...toolSourcePayload(tool, error),
+	...error instanceof IntegrationError ? {
+		errorCode: error.code,
+		retryable: error.retryable
+	} : {}
+});
+const runErrorPayload = (error) => {
+	if (!(error instanceof IntegrationError)) return {};
+	return {
+		errorCode: error.code,
+		retryable: error.retryable,
+		...error.source === void 0 ? {} : { source: error.source }
+	};
 };
 //#endregion
-//#region src/internal/observability.ts
-const TERMINAL_TYPES = /* @__PURE__ */ new Set([
-	"run.completed",
-	"run.failed",
-	"run.cancelled"
-]);
-const SENSITIVE_KEY = /api[-_]?key|authorization|cookie|credential|password|secret|token/i;
-function durationMs(startedAt, endedAt) {
-	return Math.max(0, Date.parse(endedAt) - Date.parse(startedAt));
+//#region src/internal/definition-hash.ts
+function canonicalize(value) {
+	if (Array.isArray(value)) return value.map(canonicalize);
+	if (typeof value !== "object" || value === null) return value;
+	return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, canonicalize(item)]));
 }
-function traceStatus(event) {
-	if (event.type === "run.completed") return "completed";
-	if (event.type === "run.cancelled") return "cancelled";
-	return "failed";
+async function transportableTool(tool) {
+	return {
+		name: tool.name,
+		description: tool.description,
+		inputSchema: tool.inputJsonSchema ?? (tool.inputSchema === void 0 ? void 0 : toTransportableSchema(tool.inputSchema, "input", `Input schema for tool "${tool.name}" is not transportable`)),
+		outputSchema: tool.outputJsonSchema ?? (tool.outputSchema === void 0 ? void 0 : toTransportableSchema(tool.outputSchema, "output", `Output schema for tool "${tool.name}" is not transportable`)),
+		risk: tool.risk ?? "read",
+		approval: tool.approval ?? "never",
+		idempotency: tool.idempotency ?? "none",
+		retry: tool.retry,
+		credentials: tool.credentials ?? [],
+		sandbox: tool.sandbox,
+		source: tool.source
+	};
 }
-function redactKeys(value) {
-	if (Array.isArray(value)) return value.map(redactKeys);
-	if (value === null || typeof value !== "object") return value;
-	const result = {};
-	for (const [key, item] of Object.entries(value)) result[key] = SENSITIVE_KEY.test(key) ? "[REDACTED]" : redactKeys(item);
-	return result;
+async function sha256(value) {
+	const encoded = new TextEncoder().encode(JSON.stringify(canonicalize(value)));
+	const digest = await crypto.subtle.digest("SHA-256", encoded);
+	return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
 }
-function content(options, kind, value) {
-	if (!options.content?.include.includes(kind)) return void 0;
-	let parsed = value;
-	if (typeof value === "string") try {
-		parsed = JSON.parse(value);
-	} catch {}
-	const redacted = redactKeys(parsed);
-	const safe = options.content.redact ? options.content.redact({
-		kind,
-		value: redacted
-	}) : redacted;
-	return safe === void 0 ? void 0 : {
-		kind,
-		value: toJsonValue(safe, `TraceRedactor output for "${kind}" must be JSON-serializable`)
+async function definitionHash(name, modelName, agent, tools) {
+	const toolDefinitions = await Promise.all((agent.tools ?? []).map((toolName) => transportableTool(tools.get(toolName))));
+	return sha256({
+		name,
+		modelName,
+		instructions: agent.instructions,
+		context: agent.context,
+		memory: agent.memory,
+		skills: agent.skills,
+		tools: toolDefinitions,
+		reasoning: agent.reasoning,
+		modelOptions: agent.modelOptions,
+		toolChoice: agent.toolChoice,
+		elicitation: agent.elicitation,
+		approvalMode: agent.approvalMode,
+		limits: agent.limits,
+		inputSchema: agent.inputSchema === void 0 ? void 0 : toTransportableSchema(agent.inputSchema, "input", `Input schema for agent "${name}" is not transportable`),
+		outputSchema: agent.outputSchema === void 0 ? void 0 : toTransportableSchema(agent.outputSchema, "output", `Output schema for agent "${name}" is not transportable`)
+	});
+}
+function workflowDefinitionHash(name, workflow) {
+	return sha256({
+		name,
+		version: workflow.version ?? "1",
+		limits: workflow.limits,
+		inputSchema: workflow.inputSchema === void 0 ? void 0 : toTransportableSchema(workflow.inputSchema, "input", `Input schema for workflow "${name}" is not transportable`),
+		outputSchema: workflow.outputSchema === void 0 ? void 0 : toTransportableSchema(workflow.outputSchema, "output", `Output schema for workflow "${name}" is not transportable`),
+		events: Object.fromEntries(Object.entries(workflow.events ?? {}).map(([eventName, event]) => [eventName, {
+			requireActor: event.requireActor ?? false,
+			payloadSchema: event.payloadSchema === void 0 ? void 0 : toTransportableSchema(event.payloadSchema, "input", `Payload schema for workflow "${name}" event "${eventName}" is not transportable`)
+		}]))
+	});
+}
+function teamDefinitionHash(name, team) {
+	return sha256({
+		name,
+		version: team.version ?? "1",
+		supervisor: team.supervisor,
+		members: team.members,
+		limits: team.limits,
+		inputSchema: team.inputSchema === void 0 ? void 0 : toTransportableSchema(team.inputSchema, "input", `Input schema for team "${name}" is not transportable`),
+		outputSchema: team.outputSchema === void 0 ? void 0 : toTransportableSchema(team.outputSchema, "output", `Output schema for team "${name}" is not transportable`)
+	});
+}
+//#endregion
+//#region src/internal/workflow-budget.ts
+function minLimit(first, second) {
+	if (first === void 0) return second;
+	if (second === void 0) return first;
+	if (first === false) return second;
+	if (second === false) return first;
+	return Math.min(first, second);
+}
+function combineLimits(first, second) {
+	if (!first) return second;
+	if (!second) return first;
+	return {
+		...minLimit(first.maxSteps, second.maxSteps) === void 0 ? {} : { maxSteps: minLimit(first.maxSteps, second.maxSteps) },
+		...minLimit(first.maxToolCalls, second.maxToolCalls) === void 0 ? {} : { maxToolCalls: minLimit(first.maxToolCalls, second.maxToolCalls) },
+		...minLimit(first.maxInputTokens, second.maxInputTokens) === void 0 ? {} : { maxInputTokens: minLimit(first.maxInputTokens, second.maxInputTokens) },
+		...minLimit(first.maxOutputTokens, second.maxOutputTokens) === void 0 ? {} : { maxOutputTokens: minLimit(first.maxOutputTokens, second.maxOutputTokens) }
 	};
 }
-function usageFrom(value) {
-	if (!value) return void 0;
-	const usage = {};
-	if (typeof value.inputTokens === "number") usage.inputTokens = value.inputTokens;
-	if (typeof value.outputTokens === "number") usage.outputTokens = value.outputTokens;
-	if (typeof value.totalTokens === "number") usage.totalTokens = value.totalTokens;
-	return Object.keys(usage).length ? usage : void 0;
+function subtractLimit(limit, used) {
+	if (limit === void 0 || limit === false) return limit;
+	return Math.max(0, limit - (used ?? 0));
 }
-function subtractUsage(current, previous) {
-	if (!current) return void 0;
-	const usage = {};
-	for (const key of [
-		"inputTokens",
-		"outputTokens",
-		"totalTokens"
-	]) if (current[key] !== void 0) usage[key] = Math.max(0, current[key] - (previous[key] ?? 0));
-	return Object.keys(usage).length ? usage : void 0;
+function remainingWorkflowLimits(limits, budget) {
+	if (!limits) return void 0;
+	return {
+		...limits.maxSteps === void 0 ? {} : { maxSteps: subtractLimit(limits.maxSteps, budget?.steps) },
+		...limits.maxToolCalls === void 0 ? {} : { maxToolCalls: subtractLimit(limits.maxToolCalls, budget?.toolCalls) },
+		...limits.maxInputTokens === void 0 ? {} : { maxInputTokens: subtractLimit(limits.maxInputTokens, budget?.usage?.inputTokens) },
+		...limits.maxOutputTokens === void 0 ? {} : { maxOutputTokens: subtractLimit(limits.maxOutputTokens, budget?.usage?.outputTokens) }
+	};
 }
-function costFor(options, modelRegistryName, model, usage) {
-	if (!options.calculateCost || !usage) return void 0;
-	const cost = options.calculateCost({
-		modelRegistryName,
-		model,
-		usage
-	});
-	if (!cost) return void 0;
-	if (!Number.isFinite(cost.amount) || cost.amount < 0 || !cost.currency.trim()) throw new TypeError("CostCalculator must return a non-negative amount and currency");
+function assertWorkflowBudget(workflowName, limits, budget) {
+	if (!limits || !budget) return;
+	if (limits.maxSteps !== void 0 && budget.steps > limits.maxSteps) throw new Error(`Workflow "${workflowName}" exceeded maxSteps limit of ${limits.maxSteps}`);
+	if (limits.maxToolCalls !== void 0 && budget.toolCalls > limits.maxToolCalls) throw new Error(`Workflow "${workflowName}" exceeded maxToolCalls limit of ${limits.maxToolCalls}`);
+	assertTokenBudget(`workflow:${workflowName}`, "maxInputTokens", "inputTokens", limits.maxInputTokens, budget.usage, budget.usage);
+	assertTokenBudget(`workflow:${workflowName}`, "maxOutputTokens", "outputTokens", limits.maxOutputTokens, budget.usage, budget.usage);
+}
+function addWorkflowBudget(first, second) {
 	return {
-		amount: cost.amount,
-		currency: cost.currency
+		usage: addUsage(first?.usage, second.usage),
+		steps: (first?.steps ?? 0) + second.steps,
+		toolCalls: (first?.toolCalls ?? 0) + second.toolCalls
 	};
 }
-function annotation(event) {
-	switch (event.type) {
-		case "run.paused": return {
-			name: event.type,
-			timestamp: event.timestamp,
-			attributes: {
-				reason: event.payload.reason,
-				toolCallId: event.payload.toolCallId
-			}
-		};
-		case "run.resumed": return {
-			name: event.type,
-			timestamp: event.timestamp
-		};
-		case "approval.requested": return {
-			name: event.type,
-			timestamp: event.timestamp,
-			attributes: {
-				approvalId: event.payload.approvalId,
-				toolCallId: event.payload.toolCallId,
-				toolName: event.payload.toolName
-			}
+//#endregion
+//#region src/internal/agent-engine.ts
+/**
+* Everything that runs a single agent: preparation, the model/tool loop,
+* checkpointing, knowledge and memory, resume and out-of-band cancellation.
+*
+* Depends only on {@link RunCore}. It must never reach into the workflow
+* engine — that direction is what keeps the two separable.
+*/
+function createAgentEngine(composition, core) {
+	const { models, agents, tools, contextProviders, memoryStore, runStore, credentialStore, sandbox, policies } = composition;
+	const { activeRuns, activeSessions, runtimeOwner, resolveModel, resolveCheckpointModel, notifyObserver, createEvent, emitEvent, releaseExecution, commit, startLease, cancelExecution, authorize } = core;
+	const prepareExecution = async (name, request) => {
+		const agent = agents.get(name);
+		if (!agent) throw new FevexRunError("AGENT_NOT_FOUND", `Agent "${name}" is not registered`);
+		const { modelName } = resolveModel(agent, request.model);
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		let session;
+		const newSession = request.sessionId === void 0;
+		if (newSession) session = {
+			id: crypto.randomUUID(),
+			history: [],
+			createdAt: now,
+			updatedAt: now
 		};
-		case "approval.resolved": return {
-			name: event.type,
-			timestamp: event.timestamp,
-			attributes: {
-				approvalId: event.payload.approvalId,
-				toolCallId: event.payload.toolCallId,
-				decision: event.payload.decision
-			}
+		else {
+			const stored = await runStore.getSession(request.sessionId);
+			if (!stored) throw new FevexRunError("SESSION_NOT_FOUND", `Session "${request.sessionId}" does not exist`);
+			session = stored;
+		}
+		if (activeSessions.has(session.id)) throw new FevexRunError("RUN_CONFLICT", `Session "${session.id}" already has an active run`);
+		activeSessions.add(session.id);
+		const controller = new AbortController();
+		const signal = request.signal ? AbortSignal.any([controller.signal, request.signal]) : controller.signal;
+		const run = {
+			id: crypto.randomUUID(),
+			sessionId: session.id,
+			agentName: name,
+			status: "running",
+			revision: 0,
+			createdAt: now,
+			updatedAt: now
 		};
-		case "tool.retrying": return {
-			name: event.type,
-			timestamp: event.timestamp,
-			attributes: {
-				toolCallId: event.payload.toolCallId,
-				toolName: event.payload.toolName,
-				attempt: event.payload.attempt,
-				delayMs: event.payload.delayMs
-			}
+		const state = {
+			run,
+			session,
+			request: {
+				...request,
+				sessionId: session.id,
+				signal
+			},
+			controller,
+			eventSequence: 0,
+			advancing: false
 		};
-		case "tool.execution_unknown": return {
-			name: event.type,
-			timestamp: event.timestamp,
-			attributes: {
-				toolCallId: event.payload.toolCallId,
-				toolName: event.payload.toolName
+		try {
+			if (isDurableRunStore(runStore)) {
+				const inputContent = serializeValue(agent.inputSchema === void 0 ? request.input : await abortable(() => validateSchema(agent.inputSchema, request.input, `Input for agent "${name}" does not match inputSchema`), signal), "Run input must be a string or JSON-serializable value");
+				const knowledge = await readKnowledgeMessages(state, agent, inputContent);
+				const messages = [
+					{
+						role: "system",
+						content: agent.instructions
+					},
+					...knowledge.skills,
+					...session.history,
+					...knowledge.context,
+					...knowledge.memory,
+					{
+						role: "user",
+						content: inputContent
+					}
+				];
+				const checkpoint = {
+					version: 2,
+					runId: run.id,
+					...request.model !== void 0 || typeof agent.model === "string" ? { modelName } : {},
+					...request.reasoning === void 0 ? {} : { reasoning: request.reasoning },
+					definitionHash: await definitionHash(name, modelName, agent, tools),
+					limits: combineLimits(agent.limits, request.limits),
+					messages,
+					inputContent,
+					context: request.context,
+					step: 1,
+					toolCallCount: 0,
+					seenToolCallIds: [],
+					pendingTools: [],
+					pendingIndex: 0,
+					effectiveElicitationMode: effectiveElicitationMode(agent, request),
+					effectiveApprovalMode: effectiveApprovalMode(agent, request),
+					effectiveToolChoice: effectiveToolChoice(agent, request)
+				};
+				const ownerId = `${runtimeOwner}:${crypto.randomUUID()}`;
+				const lease = {
+					generation: 0,
+					runId: run.id,
+					ownerId,
+					expiresAt: new Date(Date.now() + LEASE_MS).toISOString()
+				};
+				const started = createEvent(state, "run.started", void 0);
+				if (!await runStore.createExecution({
+					run,
+					checkpoint,
+					session,
+					lease,
+					events: [started]
+				})) throw new FevexRunError("RUN_CONFLICT", `Run or session "${session.id}" is active or was modified`, run.id);
+				state.checkpoint = checkpoint;
+				state.lease = lease;
+				state.initialEvents = [started];
+				notifyObserver(started);
+				startLease(state, runStore);
+			} else {
+				if (newSession) await runStore.saveSession(session);
+				await runStore.saveRun(run);
 			}
+		} catch (error) {
+			activeSessions.delete(session.id);
+			throw error;
+		}
+		activeRuns.set(run.id, state);
+		return state;
+	};
+	const durableCheckpoint = async (state, model, modelName, messages, inputContent, usage, providerState, step, toolCallCount, seenToolCallIds, pendingTools, pendingIndex) => {
+		const agent = agents.get(state.run.agentName);
+		if (agent.model !== void 0 && typeof agent.model !== "string") throw new FevexRunError("RUN_NOT_RESUMABLE", "Durable continuation requires a named model", state.run.id);
+		let serializedState;
+		if (providerState !== void 0) {
+			if (!model.stateCodec) throw new FevexRunError("RUN_NOT_RESUMABLE", "ModelGateway must provide stateCodec for durable continuation", state.run.id);
+			serializedState = toJsonValue(model.stateCodec.serialize(providerState), "Model provider state must be JSON-serializable");
+		}
+		return {
+			version: 2,
+			runId: state.run.id,
+			modelName,
+			...state.request.reasoning === void 0 ? {} : { reasoning: state.request.reasoning },
+			definitionHash: await definitionHash(state.run.agentName, modelName, agent, tools),
+			limits: state.checkpoint?.limits ?? combineLimits(agent.limits, state.request.limits),
+			messages: structuredClone(messages),
+			inputContent,
+			context: state.request.context,
+			usage,
+			providerState: serializedState,
+			step,
+			toolCallCount,
+			seenToolCallIds: [...seenToolCallIds],
+			pendingTools: structuredClone(pendingTools),
+			pendingIndex,
+			effectiveElicitationMode: state.checkpoint?.effectiveElicitationMode ?? effectiveElicitationMode(agent, state.request),
+			effectiveApprovalMode: state.checkpoint?.effectiveApprovalMode ?? effectiveApprovalMode(agent, state.request),
+			effectiveToolChoice: state.checkpoint?.effectiveToolChoice ?? effectiveToolChoice(agent, state.request)
 		};
-		default: return;
-	}
-}
-function buildRunTrace(run, rawEvents, modelRegistryName, model, options) {
-	const events = [...rawEvents].sort((left, right) => left.sequence - right.sequence);
-	const terminal = [...events].reverse().find((event) => TERMINAL_TYPES.has(event.type));
-	if (!terminal) throw new TypeError(`Run "${run.id}" has no terminal event`);
-	const started = events.find((event) => event.type === "run.started") ?? events[0];
-	if (!started) throw new TypeError(`Run "${run.id}" has no events`);
-	const status = traceStatus(terminal);
-	const annotations = [];
-	const spans = [];
-	const openModels = /* @__PURE__ */ new Map();
-	const openTools = /* @__PURE__ */ new Map();
-	const previousUsage = {};
-	const closeModel = (step, endedAt, spanStatus) => {
-		const open = openModels.get(step);
-		if (!open) return;
-		openModels.delete(step);
-		const completed = events.find((event) => event.type === "model.completed" && event.payload.step === step && event.sequence >= open.event.sequence);
-		const cumulative = completed?.type === "model.completed" ? usageFrom(completed.payload.usage) : void 0;
-		const usage = subtractUsage(cumulative, previousUsage);
-		if (cumulative) Object.assign(previousUsage, cumulative);
-		const spanContent = open.output.length ? content(options, "model.output", open.output.join("")) : void 0;
-		const span = {
-			id: open.event.id,
-			parentId: run.id,
-			kind: "model",
-			name: `model step ${step}`,
-			startedAt: open.event.timestamp,
-			endedAt,
-			durationMs: durationMs(open.event.timestamp, endedAt),
-			status: spanStatus,
-			attributes: {
-				step,
-				modelRegistryName
-			},
-			annotations: open.annotations,
-			...usage ? { usage } : {},
-			...spanContent ? { content: [spanContent] } : {}
-		};
-		const spanCost = costFor(options, modelRegistryName, model, usage);
-		if (spanCost) span.cost = spanCost;
-		spans.push(span);
 	};
-	const findOpenTool = (toolCallId) => {
-		const entries = [...openTools.entries()];
-		for (let index = entries.length - 1; index >= 0; index -= 1) {
-			const entry = entries[index];
-			const event = entry[1].event;
-			if (event.type === "tool.started" && event.payload.toolCallId === toolCallId) return entry;
+	const knowledgeContext = (state, input) => ({
+		agentName: state.run.agentName,
+		input,
+		sessionId: state.session.id,
+		...state.request.context === void 0 ? {} : { context: state.request.context },
+		signal: state.request.signal
+	});
+	const readProvider = async (providerName, label, context) => {
+		try {
+			const provider = contextProviders.get(providerName);
+			return (await abortable(() => provider.read(context), context.signal)).filter((block) => block.content.trim()).map((block) => systemBlock(label, providerName, block));
+		} catch (cause) {
+			throw new Error(`${label} provider "${providerName}" failed`, { cause });
 		}
 	};
-	const closeTool = (toolCallId, endedAt, spanStatus, error) => {
-		const entry = findOpenTool(toolCallId);
-		if (!entry) return;
-		const [key, open] = entry;
-		openTools.delete(key);
-		const event = open.event;
-		if (event.type !== "tool.started") return;
-		const errorContent = error ? content(options, "error.message", error) : void 0;
-		spans.push({
-			id: event.id,
-			parentId: run.id,
-			kind: "tool",
-			name: event.payload.toolName,
-			startedAt: event.timestamp,
-			endedAt,
-			durationMs: durationMs(event.timestamp, endedAt),
-			status: spanStatus,
-			attributes: {
-				step: event.payload.step,
-				toolCallId,
-				toolName: event.payload.toolName,
-				attempt: event.payload.attempt ?? 1
-			},
-			annotations: open.annotations,
-			...errorContent ? { content: [errorContent] } : {}
-		});
+	const readKnowledgeMessages = async (state, agent, input) => {
+		const context = knowledgeContext(state, input);
+		return {
+			skills: (await Promise.all((agent.skills ?? []).map((name) => readProvider(name, "Skill", context)))).flat(),
+			context: (await Promise.all((agent.context ?? []).map((name) => readProvider(name, "Context", context)))).flat(),
+			memory: await readMemoryMessages(agent, context, memoryStore)
+		};
 	};
-	for (const event of events) {
-		const item = annotation(event);
-		if (item) annotations.push(item);
-		switch (event.type) {
-			case "model.started":
-				openModels.set(event.payload.step, {
-					event,
-					annotations: [],
-					output: []
-				});
-				break;
-			case "model.output.delta":
-				openModels.get(event.payload.step)?.output.push(event.payload.delta);
-				break;
-			case "model.completed":
-				closeModel(event.payload.step, event.timestamp, "completed");
-				break;
-			case "tool.started": {
-				const attempt = event.payload.attempt ?? 1;
-				openTools.set(`${event.payload.toolCallId}:${attempt}`, {
-					event,
-					annotations: [],
-					output: []
-				});
-				break;
-			}
-			case "tool.retrying": {
-				const open = findOpenTool(event.payload.toolCallId)?.[1];
-				const retry = annotation(event);
-				if (open && retry) open.annotations.push(retry);
-				closeTool(event.payload.toolCallId, event.timestamp, "failed", event.payload.error);
-				break;
-			}
-			case "tool.completed":
-				closeTool(event.payload.toolCallId, event.timestamp, "completed");
-				break;
-			case "tool.failed":
-				closeTool(event.payload.toolCallId, event.timestamp, "failed", event.payload.error);
-				break;
-			case "tool.execution_unknown":
-				closeTool(event.payload.toolCallId, event.timestamp, "failed");
-				break;
+	const writeMemory = async (state, agent, input, output) => {
+		if (!agent.memory?.write || !memoryStore) return;
+		const context = knowledgeContext(state, input);
+		try {
+			await abortable(() => memoryStore.write({
+				content: `User: ${input}\nAssistant: ${serializeJsonValue(output)}`,
+				agentName: state.run.agentName,
+				sessionId: state.session.id,
+				namespace: state.request.context?.namespace,
+				actor: state.request.context?.actor,
+				metadata: { runId: state.run.id }
+			}, context), state.request.signal);
+		} catch (cause) {
+			throw new Error("Memory write failed", { cause });
 		}
-	}
-	for (const step of [...openModels.keys()]) closeModel(step, terminal.timestamp, status);
-	for (const open of [...openTools.values()]) if (open.event.type === "tool.started") closeTool(open.event.payload.toolCallId, terminal.timestamp, status);
-	const finalUsage = run.usage ?? previousUsage;
-	const totalCost = costFor(options, modelRegistryName, model, finalUsage);
-	const traceContent = [];
-	if (terminal.type === "run.completed") {
-		const output = content(options, "run.output", terminal.payload.output);
-		if (output) traceContent.push(output);
-	} else if (terminal.type === "run.failed") {
-		const error = content(options, "error.message", terminal.payload.error);
-		if (error) traceContent.push(error);
-	}
-	return {
-		schemaVersion: "1",
-		traceId: run.id,
-		runId: run.id,
-		sessionId: run.sessionId,
-		agentName: run.agentName,
-		modelRegistryName,
-		...model ? { model: { ...model } } : {},
-		startedAt: started.timestamp,
-		endedAt: terminal.timestamp,
-		durationMs: durationMs(started.timestamp, terminal.timestamp),
-		status,
-		attributes: {
-			eventCount: events.length,
-			modelCallCount: spans.filter(({ kind }) => kind === "model").length,
-			toolCallCount: spans.filter(({ kind }) => kind === "tool").length
-		},
-		annotations,
-		spans,
-		...Object.keys(finalUsage).length ? { usage: { ...finalUsage } } : {},
-		...totalCost ? { cost: totalCost } : {},
-		...traceContent.length ? { content: traceContent } : {}
-	};
-}
-//#endregion
-//#region src/internal/runtime.ts
-const LEASE_MS = 3e4;
-const LEASE_RENEW_MS = 1e4;
-function redact(message, secrets) {
-	return secrets.reduce((safe, secret) => secret ? safe.split(secret).join("[REDACTED]") : safe, message);
-}
-function containsSecret(value, secrets) {
-	if (typeof value === "string") return secrets.some((secret) => secret && value.includes(secret));
-	if (Array.isArray(value)) return value.some((item) => containsSecret(item, secrets));
-	if (value && typeof value === "object") return Object.values(value).some((item) => containsSecret(item, secrets));
-	return false;
-}
-function canonicalize(value) {
-	if (Array.isArray(value)) return value.map(canonicalize);
-	if (typeof value !== "object" || value === null) return value;
-	return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, canonicalize(item)]));
-}
-async function definitionHash(name, modelName, agent, tools) {
-	const portable = JSON.stringify(canonicalize({
-		name,
-		modelName,
-		instructions: agent.instructions,
-		tools: (agent.tools ?? []).map((toolName) => {
-			const tool = tools.get(toolName);
-			return {
-				name: tool.name,
-				description: tool.description,
-				inputSchema: tool.inputSchema === void 0 ? void 0 : toTransportableSchema(tool.inputSchema, "input", `Input schema for tool "${tool.name}" is not transportable`),
-				outputSchema: tool.outputSchema === void 0 ? void 0 : toTransportableSchema(tool.outputSchema, "output", `Output schema for tool "${tool.name}" is not transportable`),
-				risk: tool.risk ?? "read",
-				approval: tool.approval ?? "never",
-				idempotency: tool.idempotency ?? "none",
-				retry: tool.retry,
-				credentials: tool.credentials ?? []
-			};
-		}),
-		reasoning: agent.reasoning,
-		modelOptions: agent.modelOptions,
-		limits: agent.limits,
-		outputSchema: agent.outputSchema === void 0 ? void 0 : toTransportableSchema(agent.outputSchema, "output", `Output schema for agent "${name}" is not transportable`)
-	}));
-	const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(portable));
-	return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
-}
-function createRuntime({ models, agents, tools, runStore, credentialStore, policies, onEvent, observability }) {
-	const activeRuns = /* @__PURE__ */ new Map();
-	const activeSessions = /* @__PURE__ */ new Set();
-	const pendingExports = /* @__PURE__ */ new Set();
-	const exportFailures = [];
-	const exportedRuns = /* @__PURE__ */ new Set();
-	const runtimeOwner = crypto.randomUUID();
-	const scheduleTraceExport = (event) => {
-		if (!observability || ![
-			"run.completed",
-			"run.failed",
-			"run.cancelled"
-		].includes(event.type) || exportedRuns.has(event.runId)) return;
-		exportedRuns.add(event.runId);
-		let task;
-		task = (async () => {
-			const run = await runStore.getRun(event.runId);
-			if (!run) throw new Error(`Run "${event.runId}" does not exist`);
-			const agent = agents.get(run.agentName);
-			if (!agent) throw new Error(`Agent "${run.agentName}" is not registered`);
-			const modelRegistryName = typeof agent.model === "string" ? agent.model : "default";
-			const gateway = typeof agent.model === "string" ? models.get(agent.model) : agent.model ?? models.get("default");
-			const trace = buildRunTrace(run, await runStore.listEvents(run.id), modelRegistryName, gateway?.metadata, observability);
-			const failures = (await Promise.allSettled(observability.exporters.map((exporter) => Promise.resolve().then(() => exporter.export(trace))))).filter((result) => result.status === "rejected").map(({ reason }) => reason);
-			if (failures.length) throw new AggregateError(failures, "Trace export failed");
-		})().catch((error) => {
-			exportFailures.push(error);
-		}).finally(() => pendingExports.delete(task));
-		pendingExports.add(task);
-	};
-	const notifyObserver = (event) => {
-		scheduleTraceExport(event);
-		if (!onEvent) return;
-		try {
-			Promise.resolve(onEvent(event)).catch(() => {});
-		} catch {}
-	};
-	const createEvent = (state, type, payload) => ({
-		id: crypto.randomUUID(),
-		sequence: state.eventSequence += 1,
-		type,
-		runId: state.run.id,
-		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-		...payload === void 0 ? {} : { payload }
-	});
-	const emitEvent = async (state, type, payload) => {
-		const event = createEvent(state, type, payload);
-		await runStore.appendEvent(event);
-		notifyObserver(event);
-		return event;
-	};
-	const releaseExecution = async (state) => {
-		activeRuns.delete(state.run.id);
-		activeSessions.delete(state.session.id);
-		if (state.leaseTimer) clearInterval(state.leaseTimer);
-		if (state.leaseOwner && isDurableRunStore(runStore)) await runStore.releaseLease(state.run.id, state.leaseOwner).catch(() => {});
-	};
-	const commit = async (state, options = {}) => {
-		if (!isDurableRunStore(runStore)) throw new FevexRunError("DURABLE_STORE_REQUIRED", "This run requires a DurableRunStore", state.run.id);
-		state.run.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-		if (!await runStore.commitExecution({
-			expectedRevision: state.run.revision,
-			run: state.run,
-			...options
-		})) throw new FevexRunError("RUN_CONFLICT", `Run "${state.run.id}" was modified`, state.run.id);
-		for (const event of options.events ?? []) notifyObserver(event);
-	};
-	const startLease = (state, store) => {
-		state.leaseTimer = setInterval(() => {
-			if (!state.leaseOwner || state.request.signal.aborted) return;
-			const expiresAt = new Date(Date.now() + LEASE_MS).toISOString();
-			store.renewLease({
-				runId: state.run.id,
-				ownerId: state.leaseOwner,
-				expiresAt
-			}).then((renewed) => {
-				if (!renewed) state.controller.abort(/* @__PURE__ */ new Error("Run lease was lost"));
-			});
-		}, LEASE_RENEW_MS);
-	};
-	const cancelExecution = async (state, reason = cancellationReason(state.request.signal)) => {
-		if (state.run.status === "completed" || state.run.status === "failed" || state.run.status === "cancelled") return;
-		Object.assign(state.run, {
-			status: "cancelled",
-			pause: void 0,
-			error: reason,
-			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-		});
-		const event = createEvent(state, "run.cancelled", { reason });
-		if (isDurableRunStore(runStore)) await commit(state, {
-			checkpoint: null,
-			events: [event]
-		});
-		else {
-			await runStore.saveRun(state.run);
-			await runStore.appendEvent(event);
-			notifyObserver(event);
-		}
-		await releaseExecution(state);
-		return event;
-	};
-	const prepareExecution = async (name, request) => {
-		if (!agents.has(name)) throw new Error(`Agent "${name}" is not registered`);
-		const now = (/* @__PURE__ */ new Date()).toISOString();
-		let session;
-		if (request.sessionId === void 0) {
-			session = {
-				id: crypto.randomUUID(),
-				history: [],
-				createdAt: now,
-				updatedAt: now
-			};
-			await runStore.saveSession(session);
-		} else {
-			const stored = await runStore.getSession(request.sessionId);
-			if (!stored) throw new Error(`Session "${request.sessionId}" does not exist`);
-			session = stored;
-		}
-		if (activeSessions.has(session.id)) throw new Error(`Session "${session.id}" already has an active run`);
-		activeSessions.add(session.id);
-		const controller = new AbortController();
-		const signal = request.signal ? AbortSignal.any([controller.signal, request.signal]) : controller.signal;
-		const run = {
-			id: crypto.randomUUID(),
-			sessionId: session.id,
-			agentName: name,
-			status: "running",
-			revision: 0,
-			createdAt: now,
-			updatedAt: now
-		};
-		const state = {
-			run,
-			session,
-			request: {
-				...request,
-				sessionId: session.id,
-				signal
-			},
-			controller,
-			eventSequence: 0,
-			advancing: false
-		};
-		try {
-			await runStore.saveRun(run);
-		} catch (error) {
-			activeSessions.delete(session.id);
-			throw error;
-		}
-		activeRuns.set(run.id, state);
-		return state;
-	};
-	const authorize = async (state, tool, input, action, context = state.request.context) => {
-		let approval = false;
-		for (const policy of policies) {
-			const decision = await policy.authorize({
-				runId: state.run.id,
-				agentName: state.run.agentName,
-				toolName: tool.name,
-				risk: tool.risk ?? "read",
-				input,
-				action,
-				context
-			});
-			if (decision === "deny") throw new FevexRunError("POLICY_DENIED", `Policy "${policy.name}" denied tool "${tool.name}"`, state.run.id);
-			if (decision === "require_approval") approval = true;
-		}
-		return approval ? "require_approval" : "allow";
-	};
-	const durableCheckpoint = async (state, model, modelName, messages, inputContent, usage, providerState, step, toolCallCount, seenToolCallIds, pendingTools, pendingIndex) => {
-		const agent = agents.get(state.run.agentName);
-		if (agent.model !== void 0 && typeof agent.model !== "string") throw new FevexRunError("RUN_NOT_RESUMABLE", "Durable continuation requires a named model", state.run.id);
-		if (state.request.outputSchema !== void 0) throw new FevexRunError("RUN_NOT_RESUMABLE", "Durable runs must declare outputSchema on the agent", state.run.id);
-		let serializedState;
-		if (providerState !== void 0) {
-			if (!model.stateCodec) throw new FevexRunError("RUN_NOT_RESUMABLE", "ModelGateway must provide stateCodec for durable continuation", state.run.id);
-			serializedState = toJsonValue(model.stateCodec.serialize(providerState), "Model provider state must be JSON-serializable");
-		}
-		return {
-			runId: state.run.id,
-			definitionHash: await definitionHash(state.run.agentName, modelName, agent, tools),
-			messages: structuredClone(messages),
-			inputContent,
-			context: state.request.context,
-			usage,
-			providerState: serializedState,
-			step,
-			toolCallCount,
-			seenToolCallIds: [...seenToolCallIds],
-			pendingTools: structuredClone(pendingTools),
-			pendingIndex
-		};
 	};
 	async function* executeAgent(name, state) {
 		const { request } = state;
 		const agent = agents.get(name);
-		const modelName = typeof agent.model === "string" ? agent.model : "default";
-		const model = typeof agent.model === "string" ? models.get(agent.model) : agent.model ?? models.get("default");
-		const events = [];
+		const { modelName, model } = resolveModel(agent, state.checkpoint?.modelName ?? request.model);
+		const events = [...state.initialEvents ?? []];
+		const firstEvents = state.initialEvents ?? [];
+		state.initialEvents = void 0;
 		const emit = async (type, payload) => {
 			const event = await emitEvent(state, type, payload);
 			events.push(event);
@@ -802,8 +1070,10 @@ function createRuntime({ models, agents, tools, runStore, credentialStore, polic
 		let pendingTools;
 		let pendingIndex;
 		try {
+			for (const event of firstEvents) yield event;
 			if (state.checkpoint) {
 				const checkpoint = state.checkpoint;
+				if (checkpoint.version !== 2) throw new FevexRunError("CHECKPOINT_UNSUPPORTED", `Checkpoint for run "${state.run.id}" is unsupported`, state.run.id);
 				const hash = await definitionHash(name, modelName, agent, tools);
 				if (checkpoint.definitionHash !== hash) throw new FevexRunError("RUN_DEFINITION_CHANGED", `Definition for agent "${name}" changed`, state.run.id);
 				inputContent = checkpoint.inputContent;
@@ -818,14 +1088,17 @@ function createRuntime({ models, agents, tools, runStore, credentialStore, polic
 			} else {
 				yield await emit("run.started", void 0);
 				request.signal.throwIfAborted();
-				if (request.outputSchema !== void 0) assertStandardSchema(request.outputSchema, `Output schema for request to agent "${name}" must implement Standard Schema`);
-				inputContent = serializeValue(request.input, "Run input must be a string or JSON-serializable value");
+				inputContent = serializeValue(agent.inputSchema === void 0 ? request.input : await abortable(() => validateSchema(agent.inputSchema, request.input, `Input for agent "${name}" does not match inputSchema`), request.signal), "Run input must be a string or JSON-serializable value");
+				const knowledge = await readKnowledgeMessages(state, agent, inputContent);
 				messages = [
 					{
 						role: "system",
 						content: agent.instructions
 					},
+					...knowledge.skills,
 					...state.session.history,
+					...knowledge.context,
+					...knowledge.memory,
 					{
 						role: "user",
 						content: inputContent
@@ -837,26 +1110,58 @@ function createRuntime({ models, agents, tools, runStore, credentialStore, polic
 				pendingTools = [];
 				pendingIndex = 0;
 			}
-			const activeOutputSchema = request.outputSchema ?? agent.outputSchema;
+			const activeOutputSchema = agent.outputSchema;
 			const outputSchema = activeOutputSchema === void 0 ? void 0 : toTransportableSchema(activeOutputSchema, "output", `Output schema for agent "${name}" is not transportable`);
-			const agentTools = (agent.tools ?? []).map((toolName) => {
+			const currentElicitationMode = state.checkpoint?.effectiveElicitationMode ?? effectiveElicitationMode(agent, request);
+			const currentApprovalMode = state.checkpoint?.effectiveApprovalMode ?? effectiveApprovalMode(agent, request);
+			const currentToolChoice = state.checkpoint?.effectiveToolChoice ?? effectiveToolChoice(agent, request);
+			const agentTools = await Promise.all((agent.tools ?? []).map(async (toolName) => {
 				const tool = tools.get(toolName);
-				return toToolSpec(tool, tool.inputSchema === void 0 ? void 0 : toTransportableSchema(tool.inputSchema, "input", `Input schema for tool "${tool.name}" is not transportable`));
-			});
-			const maxSteps = agent.limits?.maxSteps ?? 8;
-			const maxToolCalls = agent.limits?.maxToolCalls ?? 16;
+				const remote = await tool.resolve?.({ context: request.context });
+				const inputSchema = tool.inputJsonSchema ?? remote?.inputSchema ?? (tool.inputSchema === void 0 ? void 0 : toTransportableSchema(tool.inputSchema, "input", `Input schema for tool "${tool.name}" is not transportable`));
+				return toToolSpec(tool.description === void 0 && remote?.description !== void 0 ? {
+					...tool,
+					description: remote.description
+				} : tool, inputSchema);
+			}));
+			const allTools = currentElicitationMode === "pause" ? [...agentTools, {
+				name: ELICIT_TOOL_NAME,
+				description: "Request external information required to continue this run. Use prompt for explanatory text shown outside the form. Put short field labels in responseSchema property titles and optional field help in property descriptions.",
+				inputSchema: {
+					type: "object",
+					properties: {
+						prompt: {
+							type: "string",
+							description: "Explanatory text for the user; do not duplicate field labels here."
+						},
+						responseSchema: {
+							type: "object",
+							description: "JSON Schema for the expected response. Each property should include a short title for the form label and may include a description for field help."
+						},
+						expiresAt: { type: "string" }
+					},
+					required: ["prompt", "responseSchema"],
+					additionalProperties: false
+				}
+			}] : agentTools;
+			const effectiveLimits = state.checkpoint?.limits ?? combineLimits(agent.limits, request.limits);
+			const maxSteps = effectiveLimits?.maxSteps ?? 8;
+			const maxToolCalls = effectiveLimits?.maxToolCalls ?? 16;
+			if (typeof currentToolChoice === "object" && !allTools.some((tool) => tool.name === currentToolChoice.name)) throw new Error(`Tool "${currentToolChoice.name}" is not available to agent "${name}"`);
 			while (step <= maxSteps) {
 				request.signal.throwIfAborted();
 				if (pendingTools.length === 0) {
 					const hasToolBudget = step < maxSteps && toolCallCount < maxToolCalls;
+					const modelToolChoice = hasToolBudget && allTools.length ? currentToolChoice === "auto" ? void 0 : currentToolChoice : void 0;
 					yield await emit("model.started", { step });
 					const modelStream = readModelStream(model, {
 						messages: [...messages],
-						tools: hasToolBudget && agentTools.length ? agentTools : void 0,
-						reasoning: agent.reasoning,
+						tools: hasToolBudget && allTools.length ? allTools : void 0,
+						...modelToolChoice === void 0 ? {} : { toolChoice: modelToolChoice },
+						reasoning: state.request.reasoning ?? agent.reasoning,
 						modelOptions: agent.modelOptions,
 						outputSchema,
-						...remainingOutputTokens(agent.limits?.maxOutputTokens, usage) === void 0 ? {} : { maxOutputTokens: remainingOutputTokens(agent.limits?.maxOutputTokens, usage) },
+						...remainingOutputTokens(effectiveLimits?.maxOutputTokens, usage) === void 0 ? {} : { maxOutputTokens: remainingOutputTokens(effectiveLimits?.maxOutputTokens, usage) },
 						...providerState === void 0 ? {} : { providerState },
 						signal: request.signal
 					});
@@ -876,11 +1181,12 @@ function createRuntime({ models, agents, tools, runStore, credentialStore, polic
 						step,
 						...usagePayload === void 0 ? {} : { usage: usagePayload }
 					});
-					assertTokenBudget(name, "maxInputTokens", "inputTokens", agent.limits?.maxInputTokens, result.usage, usage);
-					assertTokenBudget(name, "maxOutputTokens", "outputTokens", agent.limits?.maxOutputTokens, result.usage, usage);
+					assertTokenBudget(name, "maxInputTokens", "inputTokens", effectiveLimits?.maxInputTokens, result.usage, usage);
+					assertTokenBudget(name, "maxOutputTokens", "outputTokens", effectiveLimits?.maxOutputTokens, result.usage, usage);
 					if (!result.toolCalls?.length) {
 						if (result.output === void 0) throw new Error(`Model for agent "${name}" returned no output`);
 						const output = toJsonValue(activeOutputSchema === void 0 ? result.output : await abortable(() => validateSchema(activeOutputSchema, result.output, `Output from agent "${name}" does not match outputSchema`), request.signal), `Output from agent "${name}" must be JSON-serializable`);
+						await writeMemory(state, agent, inputContent, output);
 						state.session.history.push({
 							role: "user",
 							content: inputContent
@@ -923,9 +1229,56 @@ function createRuntime({ models, agents, tools, runStore, credentialStore, polic
 						};
 					}
 					if (!hasToolBudget) throw new Error(step >= maxSteps ? `Agent "${name}" reached maxSteps limit of ${maxSteps}` : `Agent "${name}" reached maxToolCalls limit of ${maxToolCalls}`);
-					assertContinuationBudget(name, "maxInputTokens", "inputTokens", agent.limits?.maxInputTokens, usage);
-					assertContinuationBudget(name, "maxOutputTokens", "outputTokens", agent.limits?.maxOutputTokens, usage);
+					assertContinuationBudget(name, "maxInputTokens", "inputTokens", effectiveLimits?.maxInputTokens, usage);
+					assertContinuationBudget(name, "maxOutputTokens", "outputTokens", effectiveLimits?.maxOutputTokens, usage);
 					if (result.toolCalls.length > maxToolCalls - toolCallCount) throw new Error(`Agent "${name}" exceeded maxToolCalls limit of ${maxToolCalls}`);
+					const elicitationCall = result.toolCalls.find(isElicitationToolCall);
+					if (elicitationCall) {
+						if (!isDurableRunStore(runStore)) throw new FevexRunError("DURABLE_STORE_REQUIRED", "Elicitation requires a DurableRunStore", state.run.id);
+						if (currentElicitationMode !== "pause") throw new Error(`Tool "${ELICIT_TOOL_NAME}" is not available to agent "${name}"`);
+						if (result.toolCalls.length !== 1) throw new Error(`${ELICIT_TOOL_NAME} must be the only tool call in a model turn`);
+						if (!elicitationCall.id?.trim()) throw new Error("Tool call id cannot be empty");
+						if (seenToolCallIds.has(elicitationCall.id)) throw new Error(`Tool call id "${elicitationCall.id}" is duplicated in run "${state.run.id}"`);
+						const rawInput = toJsonValue(elicitationCall.input, `Input for tool "${ELICIT_TOOL_NAME}" must be JSON-serializable`);
+						const input = readElicitationInput(rawInput);
+						seenToolCallIds.add(elicitationCall.id);
+						messages.push({
+							role: "assistant",
+							content: result.output === void 0 ? "" : serializeValue(result.output, `Model output for agent "${name}" must be serializable`),
+							toolCalls: [{
+								...elicitationCall,
+								input: rawInput
+							}]
+						});
+						const checkpoint = await durableCheckpoint(state, model, modelName, messages, inputContent, usage, providerState, step + 1, toolCallCount, seenToolCallIds, [], 0);
+						const request = {
+							id: crypto.randomUUID(),
+							toolCallId: elicitationCall.id,
+							prompt: input.prompt,
+							responseSchema: input.responseSchema,
+							requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
+							...input.expiresAt === void 0 ? {} : { expiresAt: input.expiresAt }
+						};
+						state.run.status = "paused";
+						state.run.pause = {
+							type: "elicitation",
+							request
+						};
+						const requested = createEvent(state, "elicitation.requested", { request });
+						const paused = createEvent(state, "run.paused", {
+							reason: "elicitation",
+							toolCallId: elicitationCall.id
+						});
+						await commit(state, {
+							checkpoint,
+							events: [requested, paused]
+						});
+						events.push(requested, paused);
+						await releaseExecution(state);
+						yield requested;
+						yield paused;
+						return void 0;
+					}
 					const batch = /* @__PURE__ */ new Set();
 					pendingTools = [];
 					for (const call of result.toolCalls) {
@@ -944,7 +1297,8 @@ function createRuntime({ models, agents, tools, runStore, credentialStore, polic
 								step,
 								toolCallId: call.id,
 								toolName: call.name,
-								error: toErrorMessage(error)
+								error: toErrorMessage(error),
+								...toolErrorPayload(tool, error)
 							});
 							throw error;
 						}
@@ -972,13 +1326,16 @@ function createRuntime({ models, agents, tools, runStore, credentialStore, polic
 					const tool = tools.get(pending.call.name);
 					const durable = isDurableRunStore(runStore) ? runStore : void 0;
 					if (!durable && (tool.approval === "required" || tool.idempotency === "keyed")) throw new FevexRunError("DURABLE_STORE_REQUIRED", `Tool "${tool.name}" requires a DurableRunStore`, state.run.id);
+					let record = durable ? await durable.getToolExecution(state.run.id, pending.call.id) : void 0;
 					const policy = await authorize(state, tool, pending.input, "tool.execute");
-					if ((tool.approval === "required" || policy === "require_approval") && state.approvedToolCallId !== pending.call.id) {
+					if ((tool.approval === "required" || policy === "require_approval") && state.approvedToolCallId !== pending.call.id && record?.status !== "started" && record?.status !== "completed") {
+						if (currentApprovalMode === "deny") throw new FevexRunError("POLICY_DENIED", `Tool "${tool.name}" requires approval but approvalMode is "deny"`, state.run.id);
 						const checkpoint = await durableCheckpoint(state, model, modelName, messages, inputContent, usage, providerState, step, toolCallCount, seenToolCallIds, pendingTools, pendingIndex);
 						const approval = {
 							id: crypto.randomUUID(),
 							toolCallId: pending.call.id,
 							toolName: pending.call.name,
+							...tool.label === void 0 ? {} : { toolLabel: tool.label },
 							input: pending.input,
 							risk: tool.risk ?? "read",
 							requestedAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -991,7 +1348,9 @@ function createRuntime({ models, agents, tools, runStore, credentialStore, polic
 						const requested = createEvent(state, "approval.requested", {
 							approvalId: approval.id,
 							toolCallId: approval.toolCallId,
-							toolName: approval.toolName
+							toolName: approval.toolName,
+							...toolLabelPayload(tool),
+							...toolSourcePayload(tool)
 						});
 						const paused = createEvent(state, "run.paused", {
 							reason: "approval",
@@ -1013,7 +1372,6 @@ function createRuntime({ models, agents, tools, runStore, credentialStore, polic
 						await commit(state, { checkpoint });
 						state.checkpoint = checkpoint;
 					}
-					let record = durable ? await durable.getToolExecution(state.run.id, pending.call.id) : void 0;
 					if (record?.status === "completed") {
 						messages.push({
 							role: "tool",
@@ -1037,7 +1395,8 @@ function createRuntime({ models, agents, tools, runStore, credentialStore, polic
 						const unknown = createEvent(state, "tool.execution_unknown", {
 							step,
 							toolCallId: pending.call.id,
-							toolName: pending.call.name
+							toolName: pending.call.name,
+							...toolSourcePayload(tool)
 						});
 						const paused = createEvent(state, "run.paused", {
 							reason: "tool_execution_unknown",
@@ -1053,18 +1412,22 @@ function createRuntime({ models, agents, tools, runStore, credentialStore, polic
 						yield paused;
 						return void 0;
 					}
+					const forcedRetry = state.forcedRetryToolCallId === pending.call.id;
 					state.forcedRetryToolCallId = void 0;
-					const maxAttempts = tool.retry?.maxAttempts ?? 1;
+					const configuredMaxAttempts = tool.retry?.maxAttempts ?? 1;
+					const maxAttempts = forcedRetry ? Math.max(configuredMaxAttempts, (record?.attempt ?? 0) + 1) : configuredMaxAttempts;
 					let output;
-					let attempt = record?.attempt ?? 0;
+					let attempt = record?.status === "started" && tool.idempotency === "keyed" ? Math.max(0, record.attempt - 1) : record?.attempt ?? 0;
 					while (attempt < maxAttempts) {
 						if (attempt > 0) {
 							if (await authorize(state, tool, pending.input, "tool.execute") === "require_approval") {
+								if (currentApprovalMode === "deny") throw new FevexRunError("POLICY_DENIED", `Tool "${tool.name}" requires approval but approvalMode is "deny"`, state.run.id);
 								const checkpoint = await durableCheckpoint(state, model, modelName, messages, inputContent, usage, providerState, step, toolCallCount, seenToolCallIds, pendingTools, pendingIndex);
 								const approval = {
 									id: crypto.randomUUID(),
 									toolCallId: pending.call.id,
 									toolName: pending.call.name,
+									...tool.label === void 0 ? {} : { toolLabel: tool.label },
 									input: pending.input,
 									risk: tool.risk ?? "read",
 									requestedAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -1077,7 +1440,9 @@ function createRuntime({ models, agents, tools, runStore, credentialStore, polic
 								const requested = createEvent(state, "approval.requested", {
 									approvalId: approval.id,
 									toolCallId: approval.toolCallId,
-									toolName: approval.toolName
+									toolName: approval.toolName,
+									...toolLabelPayload(tool),
+									...toolSourcePayload(tool)
 								});
 								const paused = createEvent(state, "run.paused", {
 									reason: "approval",
@@ -1111,6 +1476,20 @@ function createRuntime({ models, agents, tools, runStore, credentialStore, polic
 							if (!tool.credentials?.includes(credentialName)) throw new FevexRunError("CREDENTIAL_NOT_FOUND", `Credential "${credentialName}" is not declared for tool "${tool.name}"`, state.run.id);
 							return resolvedCredentials.get(credentialName);
 						};
+						const scopedSandbox = tool.sandbox === void 0 ? void 0 : { run: (sandboxRequest) => {
+							if (!sandbox) throw new FevexRunError("SANDBOX_REQUIRED", `Tool "${tool.name}" requires a sandbox`, state.run.id);
+							const signal = sandboxRequest.signal ? AbortSignal.any([request.signal, sandboxRequest.signal]) : request.signal;
+							return sandbox.run({
+								...sandboxRequest,
+								capabilities: tool.sandbox,
+								runId: state.run.id,
+								toolCallId: pending.call.id,
+								attempt,
+								idempotencyKey: pending.idempotencyKey,
+								context: request.context,
+								signal
+							});
+						} };
 						record = {
 							runId: state.run.id,
 							toolCallId: pending.call.id,
@@ -1125,6 +1504,7 @@ function createRuntime({ models, agents, tools, runStore, credentialStore, polic
 							step,
 							toolCallId: pending.call.id,
 							toolName: pending.call.name,
+							...toolSourcePayload(tool),
 							...attempt > 1 ? { attempt } : {}
 						});
 						if (durable) await commit(state, {
@@ -1144,6 +1524,7 @@ function createRuntime({ models, agents, tools, runStore, credentialStore, polic
 								attempt,
 								idempotencyKey: pending.idempotencyKey,
 								getCredential,
+								...scopedSandbox === void 0 ? {} : { sandbox: scopedSandbox },
 								context: request.context,
 								signal: request.signal
 							}), request.signal);
@@ -1159,6 +1540,7 @@ function createRuntime({ models, agents, tools, runStore, credentialStore, polic
 								step,
 								toolCallId: pending.call.id,
 								toolName: pending.call.name,
+								...toolSourcePayload(tool),
 								...attempt > 1 ? { attempt } : {}
 							});
 							if (durable) await commit(state, {
@@ -1187,69 +1569,1589 @@ function createRuntime({ models, agents, tools, runStore, credentialStore, polic
 									step,
 									toolCallId: pending.call.id,
 									toolName: pending.call.name,
-									error: safeError
+									error: safeError,
+									...toolErrorPayload(tool, error)
 								});
 								throw secrets.length ? new Error(safeError, { cause: error }) : error;
 							}
-							const delayMs = Math.min(tool.retry.backoffMs * 2 ** (attempt - 1), tool.retry.maxBackoffMs ?? Number.MAX_SAFE_INTEGER);
-							yield await emit("tool.retrying", {
-								step,
-								toolCallId: pending.call.id,
-								toolName: pending.call.name,
-								attempt: attempt + 1,
-								delayMs,
-								error: safeError
+							const delayMs = Math.min(tool.retry.backoffMs * 2 ** (attempt - 1), tool.retry.maxBackoffMs ?? Number.MAX_SAFE_INTEGER);
+							yield await emit("tool.retrying", {
+								step,
+								toolCallId: pending.call.id,
+								toolName: pending.call.name,
+								attempt: attempt + 1,
+								delayMs,
+								error: safeError,
+								...toolErrorPayload(tool, error)
+							});
+							if (delayMs) await abortable(() => new Promise((resolve) => setTimeout(resolve, delayMs)), request.signal);
+						}
+					}
+					if (output === void 0) throw new FevexRunError("TOOL_EXECUTION_UNKNOWN", `Tool "${tool.name}" exhausted its configured attempts`, state.run.id);
+					messages.push({
+						role: "tool",
+						name: pending.call.name,
+						toolCallId: pending.call.id,
+						content: serializeJsonValue(output)
+					});
+					toolCallCount += 1;
+					pendingIndex += 1;
+				}
+				pendingTools = [];
+				pendingIndex = 0;
+				step += 1;
+			}
+			throw new Error(`Agent "${name}" reached maxSteps limit of ${maxSteps}`);
+		} catch (error) {
+			if (request.signal.aborted) {
+				const event = await cancelExecution(state);
+				if (event) {
+					events.push(event);
+					yield event;
+				}
+			} else if (state.run.status === "running") {
+				Object.assign(state.run, {
+					status: "failed",
+					error: toErrorMessage(error),
+					...usage === void 0 ? {} : { usage },
+					updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+				});
+				const failed = createEvent(state, "run.failed", {
+					error: toErrorMessage(error),
+					...runErrorPayload(error)
+				});
+				if (isDurableRunStore(runStore)) try {
+					await commit(state, {
+						checkpoint: null,
+						events: [failed]
+					});
+				} catch (commitError) {
+					await releaseExecution(state);
+					throw commitError;
+				}
+				else {
+					await runStore.saveRun(state.run);
+					await runStore.appendEvent(failed);
+					notifyObserver(failed);
+				}
+				events.push(failed);
+				await releaseExecution(state);
+				yield failed;
+			} else await releaseExecution(state);
+			throw error;
+		}
+	}
+	const nextEvent = async (state, execution) => {
+		state.advancing = true;
+		try {
+			return await execution.next();
+		} finally {
+			state.advancing = false;
+		}
+	};
+	const drainExecution = async (name, state, throwOnPause) => {
+		const execution = executeAgent(name, state);
+		while (true) {
+			const next = await nextEvent(state, execution);
+			if (next.done) {
+				if (next.value === void 0 && throwOnPause) {
+					const run = await runStore.getRun(state.run.id);
+					if (run?.pause) throw new RunPausedError(run.id, run.pause);
+				}
+				return next.value;
+			}
+		}
+	};
+	const resumeAgent = async (runId, resolution, waitForCompletion = false, recoveryActor) => {
+		if (resolution?.type === "timer" || resolution?.type === "event") throw new FevexRunError("RUN_NOT_RESUMABLE", `Run "${runId}" cannot be resumed`, runId);
+		if (!isDurableRunStore(runStore)) throw new FevexRunError("DURABLE_STORE_REQUIRED", "resumeRun requires DurableRunStore", runId);
+		const run = await runStore.getRun(runId);
+		const checkpoint = await runStore.getCheckpoint(runId);
+		if (!run || !checkpoint) throw new FevexRunError(resolution ? "RUN_NOT_RESUMABLE" : "RUN_NOT_RECOVERABLE", `Run "${runId}" cannot be ${resolution ? "resumed" : "recovered"}`, runId);
+		if (checkpoint.version !== 2) throw new FevexRunError("CHECKPOINT_UNSUPPORTED", `Checkpoint for run "${runId}" is unsupported`, runId);
+		if (resolution && run.status !== "paused" && run.status !== "running" || !resolution && run.status !== "running") throw new FevexRunError(resolution ? "RUN_NOT_RESUMABLE" : "RUN_NOT_RECOVERABLE", `Run "${runId}" is not ${resolution ? "resumable" : "recoverable"}`, runId);
+		const agent = agents.get(run.agentName);
+		if (!agent) throw new FevexRunError("RUN_DEFINITION_CHANGED", `Agent "${run.agentName}" is unavailable`, runId);
+		const checkpointModel = await resolveCheckpointModel(run.agentName, agent, checkpoint);
+		if (!checkpointModel) throw new FevexRunError("RUN_DEFINITION_CHANGED", `Definition for agent "${run.agentName}" changed`, runId);
+		const { modelName, model } = checkpointModel;
+		if (checkpoint.providerState !== void 0 && !model.stateCodec) throw new FevexRunError("RUN_NOT_RESUMABLE", "ModelGateway no longer provides its stateCodec", runId);
+		const session = await runStore.getSession(run.sessionId);
+		if (!session) throw new Error(`Session "${run.sessionId}" does not exist`);
+		if (activeSessions.has(session.id)) throw new FevexRunError("RUN_CONFLICT", `Session "${session.id}" is active`, runId);
+		const ownerId = `${runtimeOwner}:${crypto.randomUUID()}`;
+		const lease = {
+			generation: 0,
+			runId,
+			ownerId,
+			expiresAt: new Date(Date.now() + LEASE_MS).toISOString()
+		};
+		if (!await runStore.acquireLease(lease)) throw new FevexRunError("RUN_CONFLICT", `Run "${runId}" is leased`, runId);
+		try {
+			const controller = new AbortController();
+			const state = {
+				run,
+				session,
+				request: {
+					input: "",
+					model: modelName,
+					...checkpoint.reasoning === void 0 ? {} : { reasoning: checkpoint.reasoning },
+					sessionId: session.id,
+					context: checkpoint.context,
+					limits: checkpoint.limits,
+					signal: controller.signal
+				},
+				controller,
+				eventSequence: (await runStore.listEvents(runId)).at(-1)?.sequence ?? 0,
+				advancing: false,
+				checkpoint,
+				lease,
+				...resolution?.type === "approval" ? { approvedToolCallId: run.pause?.type === "approval" ? run.pause.approval.toolCallId : void 0 } : resolution?.type === "tool_execution" ? {
+					approvedToolCallId: resolution.toolCallId,
+					...resolution.decision === "retry" ? { forcedRetryToolCallId: resolution.toolCallId } : {}
+				} : {}
+			};
+			if (!resolution) {
+				if (!recoveryActor?.id.trim()) throw new FevexRunError("RUN_NOT_RECOVERABLE", "Recovery actor is required", runId);
+				const recovered = createEvent(state, "run.recovered", { actorId: recoveryActor.id });
+				await commit(state, {
+					checkpoint,
+					events: [recovered]
+				});
+				state.initialEvents = [recovered];
+				activeRuns.set(runId, state);
+				activeSessions.add(session.id);
+				startLease(state, runStore);
+				if (waitForCompletion) await drainExecution(run.agentName, state, false);
+				else drainExecution(run.agentName, state, false).catch(() => {});
+				return structuredClone(run);
+			}
+			if (!resolution.actor?.id?.trim()) {
+				await runStore.releaseLease(runId, ownerId, lease.generation);
+				throw new FevexRunError(resolution.type === "elicitation" ? "ELICITATION_INVALID" : "APPROVAL_INVALID", "Resolution actor is required", runId);
+			}
+			if (resolution.type === "elicitation") {
+				const pause = run.pause;
+				if (pause?.type !== "elicitation" || pause.request.id !== resolution.requestId) {
+					await runStore.releaseLease(runId, ownerId, lease.generation);
+					throw new FevexRunError("ELICITATION_INVALID", "Elicitation does not match the run", runId);
+				}
+				if (pause.request.expiresAt && Date.now() > Date.parse(pause.request.expiresAt)) {
+					await runStore.releaseLease(runId, ownerId, lease.generation);
+					throw new FevexRunError("ELICITATION_INVALID", "Elicitation has expired", runId);
+				}
+				let value;
+				try {
+					value = compileFevexJsonSchema(pause.request.responseSchema).validate(resolution.value);
+				} catch (error) {
+					await runStore.releaseLease(runId, ownerId, lease.generation);
+					throw new FevexRunError("ELICITATION_INVALID", `Elicitation value does not match responseSchema: ${toErrorMessage(error)}`, runId, { cause: error });
+				}
+				checkpoint.messages.push({
+					role: "tool",
+					name: ELICIT_TOOL_NAME,
+					toolCallId: pause.request.toolCallId,
+					content: serializeJsonValue(value)
+				});
+				run.status = "running";
+				run.pause = void 0;
+				const resolved = createEvent(state, "elicitation.resolved", {
+					requestId: pause.request.id,
+					toolCallId: pause.request.toolCallId,
+					actorId: resolution.actor.id
+				});
+				const resumed = createEvent(state, "run.resumed", void 0);
+				await commit(state, {
+					checkpoint,
+					events: [resolved, resumed]
+				});
+				activeRuns.set(runId, state);
+				activeSessions.add(session.id);
+				startLease(state, runStore);
+				if (waitForCompletion) await drainExecution(run.agentName, state, false);
+				else drainExecution(run.agentName, state, false).catch(() => {});
+				return structuredClone(run);
+			}
+			if (resolution.type === "approval") {
+				if (run.pause?.type !== "approval" || run.pause.approval.id !== resolution.approvalId) {
+					await runStore.releaseLease(runId, ownerId, lease.generation);
+					throw new FevexRunError("APPROVAL_INVALID", "Approval does not match the run", runId);
+				}
+				const pending = checkpoint.pendingTools[checkpoint.pendingIndex];
+				const tool = pending && tools.get(pending.call.name);
+				if (!pending || !tool) {
+					await runStore.releaseLease(runId, ownerId, lease.generation);
+					throw new FevexRunError("APPROVAL_INVALID", "Approval tool is unavailable", runId);
+				}
+				if (resolution.decision === "approve") await authorize(state, tool, pending.input, "approval.resolve", {
+					...state.request.context,
+					actor: resolution.actor
+				});
+				if (resolution.decision === "reject") {
+					const approval = run.pause.approval;
+					const toolCallId = approval.toolCallId;
+					run.status = "cancelled";
+					run.pause = void 0;
+					run.error = "approval_rejected";
+					const resolved = createEvent(state, "approval.resolved", {
+						approvalId: resolution.approvalId,
+						toolCallId,
+						decision: "reject",
+						actorId: resolution.actor.id,
+						...approval.toolLabel === void 0 ? {} : { toolLabel: approval.toolLabel },
+						...toolSourcePayload(tool)
+					});
+					const cancelled = createEvent(state, "run.cancelled", { reason: "approval_rejected" });
+					await commit(state, {
+						checkpoint: null,
+						events: [resolved, cancelled]
+					});
+					await releaseExecution(state);
+					return structuredClone(run);
+				}
+			} else {
+				const pending = checkpoint.pendingTools[checkpoint.pendingIndex];
+				const record = await runStore.getToolExecution(runId, resolution.toolCallId);
+				const matchesUnknownPause = run.pause?.type === "tool_execution_unknown" && run.pause.toolCallId === resolution.toolCallId;
+				const matchesInterruptedAttempt = run.status === "running" && pending?.call.id === resolution.toolCallId && (record?.status === "started" || record?.status === "completed");
+				if (!matchesUnknownPause && !matchesInterruptedAttempt) {
+					await runStore.releaseLease(runId, ownerId, lease.generation);
+					throw new FevexRunError("RUN_NOT_RESUMABLE", "Tool execution resolution does not match a pending attempt", runId);
+				}
+			}
+			if (resolution.type === "tool_execution" && resolution.decision === "use_output") {
+				const pending = checkpoint.pendingTools[checkpoint.pendingIndex];
+				const tool = tools.get(pending.call.name);
+				if (!tool) {
+					await runStore.releaseLease(runId, ownerId, lease.generation);
+					throw new FevexRunError("RUN_DEFINITION_CHANGED", "Pending tool is unavailable", runId);
+				}
+				const output = toJsonValue(tool.outputSchema === void 0 ? resolution.output : await validateSchema(tool.outputSchema, resolution.output, `Manual output for tool "${tool.name}" does not match outputSchema`), "Manual tool output must be JSON-serializable");
+				const current = await runStore.getToolExecution(runId, resolution.toolCallId);
+				await commit(state, { toolExecution: {
+					runId,
+					toolCallId: resolution.toolCallId,
+					toolName: pending.call.name,
+					input: pending.input,
+					status: "completed",
+					attempt: current?.attempt ?? 1,
+					idempotencyKey: current?.idempotencyKey ?? pending.idempotencyKey,
+					output,
+					updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+				} });
+			}
+			const approval = run.pause?.type === "approval" ? run.pause.approval : void 0;
+			const approvalTool = approval ? tools.get(approval.toolName) : void 0;
+			run.status = "running";
+			run.pause = void 0;
+			const resumeEvents = [createEvent(state, "run.resumed", void 0)];
+			if (approval && resolution.type === "approval") resumeEvents.push(createEvent(state, "approval.resolved", {
+				approvalId: approval.id,
+				toolCallId: approval.toolCallId,
+				decision: "approve",
+				actorId: resolution.actor.id,
+				...approval.toolLabel === void 0 ? {} : { toolLabel: approval.toolLabel },
+				...approvalTool === void 0 ? {} : toolSourcePayload(approvalTool)
+			}));
+			await commit(state, {
+				checkpoint,
+				events: resumeEvents
+			});
+			activeRuns.set(runId, state);
+			activeSessions.add(session.id);
+			startLease(state, runStore);
+			if (waitForCompletion) await drainExecution(run.agentName, state, false);
+			else drainExecution(run.agentName, state, false).catch(() => {});
+			return structuredClone(run);
+		} catch (error) {
+			await runStore.releaseLease(runId, ownerId, lease.generation).catch(() => {});
+			throw error;
+		}
+	};
+	const cancelStoredAgent = async (runId) => {
+		const active = activeRuns.get(runId);
+		if (active && !active.request.signal.aborted) {
+			active.controller.abort(new DOMException("Run cancelled", "AbortError"));
+			if (!active.advancing) {
+				await cancelExecution(active);
+				return true;
+			}
+			for (let attempt = 0; attempt < 100; attempt += 1) {
+				const current = await runStore.getRun(runId);
+				if (current?.status === "cancelled" || current?.status === "completed" || current?.status === "failed") return true;
+				await new Promise((resolve) => setTimeout(resolve, 10));
+			}
+			return false;
+		}
+		if (!isDurableRunStore(runStore)) return false;
+		const run = await runStore.getRun(runId);
+		if (!run) return false;
+		if (run.status === "completed" || run.status === "failed" || run.status === "cancelled") return true;
+		const ownerId = `${runtimeOwner}:${crypto.randomUUID()}`;
+		const lease = {
+			generation: 0,
+			runId,
+			ownerId,
+			expiresAt: new Date(Date.now() + LEASE_MS).toISOString()
+		};
+		if (!await runStore.acquireLease(lease)) return false;
+		try {
+			const session = await runStore.getSession(run.sessionId);
+			if (!session) return false;
+			const controller = new AbortController();
+			const state = {
+				run,
+				session,
+				request: {
+					input: "",
+					sessionId: session.id,
+					signal: controller.signal
+				},
+				controller,
+				eventSequence: (await runStore.listEvents(runId)).at(-1)?.sequence ?? 0,
+				advancing: false,
+				lease
+			};
+			run.status = "cancelled";
+			run.pause = void 0;
+			run.error = "aborted";
+			const cancelled = createEvent(state, "run.cancelled", { reason: "aborted" });
+			await commit(state, {
+				checkpoint: null,
+				events: [cancelled]
+			});
+			return true;
+		} catch (error) {
+			if (error instanceof FevexRunError && error.code === "RUN_CONFLICT") return false;
+			throw error;
+		} finally {
+			await runStore.releaseLease(runId, ownerId, lease.generation).catch(() => {});
+		}
+	};
+	return {
+		prepareExecution,
+		executeAgent,
+		nextEvent,
+		drainExecution,
+		resumeAgent,
+		cancelStoredAgent
+	};
+}
+//#endregion
+//#region src/internal/observability.ts
+const TERMINAL_TYPES = /* @__PURE__ */ new Set([
+	"run.completed",
+	"run.failed",
+	"run.cancelled"
+]);
+const SENSITIVE_KEY = /api[-_]?key|authorization|cookie|credential|password|secret|token/i;
+function durationMs(startedAt, endedAt) {
+	return Math.max(0, Date.parse(endedAt) - Date.parse(startedAt));
+}
+function traceStatus(event) {
+	if (event.type === "run.completed") return "completed";
+	if (event.type === "run.cancelled") return "cancelled";
+	return "failed";
+}
+function redactKeys(value) {
+	if (Array.isArray(value)) return value.map(redactKeys);
+	if (value === null || typeof value !== "object") return value;
+	const result = {};
+	for (const [key, item] of Object.entries(value)) result[key] = SENSITIVE_KEY.test(key) ? "[REDACTED]" : redactKeys(item);
+	return result;
+}
+function content(options, kind, value) {
+	if (!options.content?.include.includes(kind)) return void 0;
+	let parsed = value;
+	if (typeof value === "string") try {
+		parsed = JSON.parse(value);
+	} catch {}
+	const redacted = redactKeys(parsed);
+	const safe = options.content.redact ? options.content.redact({
+		kind,
+		value: redacted
+	}) : redacted;
+	return safe === void 0 ? void 0 : {
+		kind,
+		value: toJsonValue(safe, `TraceRedactor output for "${kind}" must be JSON-serializable`)
+	};
+}
+function usageFrom(value) {
+	if (!value) return void 0;
+	const usage = {};
+	if (typeof value.inputTokens === "number") usage.inputTokens = value.inputTokens;
+	if (typeof value.outputTokens === "number") usage.outputTokens = value.outputTokens;
+	if (typeof value.totalTokens === "number") usage.totalTokens = value.totalTokens;
+	return Object.keys(usage).length ? usage : void 0;
+}
+function subtractUsage(current, previous) {
+	if (!current) return void 0;
+	const usage = {};
+	for (const key of [
+		"inputTokens",
+		"outputTokens",
+		"totalTokens"
+	]) if (current[key] !== void 0) usage[key] = Math.max(0, current[key] - (previous[key] ?? 0));
+	return Object.keys(usage).length ? usage : void 0;
+}
+function costFor(options, modelRegistryName, model, usage) {
+	if (!options.calculateCost || !usage) return void 0;
+	const cost = options.calculateCost({
+		modelRegistryName,
+		model,
+		usage
+	});
+	if (!cost) return void 0;
+	if (!Number.isFinite(cost.amount) || cost.amount < 0 || !cost.currency.trim()) throw new TypeError("CostCalculator must return a non-negative amount and currency");
+	return {
+		amount: cost.amount,
+		currency: cost.currency
+	};
+}
+function annotation(event) {
+	switch (event.type) {
+		case "run.paused": return {
+			name: event.type,
+			timestamp: event.timestamp,
+			attributes: {
+				reason: event.payload.reason,
+				toolCallId: event.payload.toolCallId
+			}
+		};
+		case "run.resumed": return {
+			name: event.type,
+			timestamp: event.timestamp
+		};
+		case "approval.requested": return {
+			name: event.type,
+			timestamp: event.timestamp,
+			attributes: {
+				approvalId: event.payload.approvalId,
+				toolCallId: event.payload.toolCallId,
+				toolName: event.payload.toolName
+			}
+		};
+		case "approval.resolved": return {
+			name: event.type,
+			timestamp: event.timestamp,
+			attributes: {
+				approvalId: event.payload.approvalId,
+				toolCallId: event.payload.toolCallId,
+				decision: event.payload.decision
+			}
+		};
+		case "tool.retrying": return {
+			name: event.type,
+			timestamp: event.timestamp,
+			attributes: {
+				toolCallId: event.payload.toolCallId,
+				toolName: event.payload.toolName,
+				attempt: event.payload.attempt,
+				delayMs: event.payload.delayMs
+			}
+		};
+		case "tool.execution_unknown": return {
+			name: event.type,
+			timestamp: event.timestamp,
+			attributes: {
+				toolCallId: event.payload.toolCallId,
+				toolName: event.payload.toolName
+			}
+		};
+		default: return;
+	}
+}
+function buildRunTrace(run, rawEvents, modelRegistryName, model, options) {
+	const events = [...rawEvents].sort((left, right) => left.sequence - right.sequence);
+	const terminal = [...events].reverse().find((event) => TERMINAL_TYPES.has(event.type));
+	if (!terminal) throw new TypeError(`Run "${run.id}" has no terminal event`);
+	const started = events.find((event) => event.type === "run.started") ?? events[0];
+	if (!started) throw new TypeError(`Run "${run.id}" has no events`);
+	const status = traceStatus(terminal);
+	const annotations = [];
+	const spans = [];
+	const openModels = /* @__PURE__ */ new Map();
+	const openTools = /* @__PURE__ */ new Map();
+	const previousUsage = {};
+	const closeModel = (step, endedAt, spanStatus) => {
+		const open = openModels.get(step);
+		if (!open) return;
+		openModels.delete(step);
+		const completed = events.find((event) => event.type === "model.completed" && event.payload.step === step && event.sequence >= open.event.sequence);
+		const cumulative = completed?.type === "model.completed" ? usageFrom(completed.payload.usage) : void 0;
+		const usage = subtractUsage(cumulative, previousUsage);
+		if (cumulative) Object.assign(previousUsage, cumulative);
+		const spanContent = open.output.length ? content(options, "model.output", open.output.join("")) : void 0;
+		const span = {
+			id: open.event.id,
+			parentId: run.id,
+			kind: "model",
+			name: `model step ${step}`,
+			startedAt: open.event.timestamp,
+			endedAt,
+			durationMs: durationMs(open.event.timestamp, endedAt),
+			status: spanStatus,
+			attributes: {
+				step,
+				modelRegistryName
+			},
+			annotations: open.annotations,
+			...usage ? { usage } : {},
+			...spanContent ? { content: [spanContent] } : {}
+		};
+		const spanCost = costFor(options, modelRegistryName, model, usage);
+		if (spanCost) span.cost = spanCost;
+		spans.push(span);
+	};
+	const findOpenTool = (toolCallId) => {
+		const entries = [...openTools.entries()];
+		for (let index = entries.length - 1; index >= 0; index -= 1) {
+			const entry = entries[index];
+			const event = entry[1].event;
+			if (event.type === "tool.started" && event.payload.toolCallId === toolCallId) return entry;
+		}
+	};
+	const closeTool = (toolCallId, endedAt, spanStatus, error) => {
+		const entry = findOpenTool(toolCallId);
+		if (!entry) return;
+		const [key, open] = entry;
+		openTools.delete(key);
+		const event = open.event;
+		if (event.type !== "tool.started") return;
+		const errorContent = error ? content(options, "error.message", error) : void 0;
+		spans.push({
+			id: event.id,
+			parentId: run.id,
+			kind: "tool",
+			name: event.payload.toolName,
+			startedAt: event.timestamp,
+			endedAt,
+			durationMs: durationMs(event.timestamp, endedAt),
+			status: spanStatus,
+			attributes: {
+				step: event.payload.step,
+				toolCallId,
+				toolName: event.payload.toolName,
+				attempt: event.payload.attempt ?? 1
+			},
+			annotations: open.annotations,
+			...errorContent ? { content: [errorContent] } : {}
+		});
+	};
+	for (const event of events) {
+		const item = annotation(event);
+		if (item) annotations.push(item);
+		switch (event.type) {
+			case "model.started":
+				openModels.set(event.payload.step, {
+					event,
+					annotations: [],
+					output: []
+				});
+				break;
+			case "model.output.delta":
+				openModels.get(event.payload.step)?.output.push(event.payload.delta);
+				break;
+			case "model.completed":
+				closeModel(event.payload.step, event.timestamp, "completed");
+				break;
+			case "tool.started": {
+				const attempt = event.payload.attempt ?? 1;
+				openTools.set(`${event.payload.toolCallId}:${attempt}`, {
+					event,
+					annotations: [],
+					output: []
+				});
+				break;
+			}
+			case "tool.retrying": {
+				const open = findOpenTool(event.payload.toolCallId)?.[1];
+				const retry = annotation(event);
+				if (open && retry) open.annotations.push(retry);
+				closeTool(event.payload.toolCallId, event.timestamp, "failed", event.payload.error);
+				break;
+			}
+			case "tool.completed":
+				closeTool(event.payload.toolCallId, event.timestamp, "completed");
+				break;
+			case "tool.failed":
+				closeTool(event.payload.toolCallId, event.timestamp, "failed", event.payload.error);
+				break;
+			case "tool.execution_unknown":
+				closeTool(event.payload.toolCallId, event.timestamp, "failed");
+				break;
+		}
+	}
+	for (const step of [...openModels.keys()]) closeModel(step, terminal.timestamp, status);
+	for (const open of [...openTools.values()]) if (open.event.type === "tool.started") closeTool(open.event.payload.toolCallId, terminal.timestamp, status);
+	const finalUsage = run.usage ?? previousUsage;
+	const totalCost = costFor(options, modelRegistryName, model, finalUsage);
+	const traceContent = [];
+	if (terminal.type === "run.completed") {
+		const output = content(options, "run.output", terminal.payload.output);
+		if (output) traceContent.push(output);
+	} else if (terminal.type === "run.failed") {
+		const error = content(options, "error.message", terminal.payload.error);
+		if (error) traceContent.push(error);
+	}
+	return {
+		schemaVersion: "1",
+		traceId: run.id,
+		runId: run.id,
+		sessionId: run.sessionId,
+		agentName: run.agentName,
+		modelRegistryName,
+		...model ? { model: { ...model } } : {},
+		startedAt: started.timestamp,
+		endedAt: terminal.timestamp,
+		durationMs: durationMs(started.timestamp, terminal.timestamp),
+		status,
+		attributes: {
+			eventCount: events.length,
+			modelCallCount: spans.filter(({ kind }) => kind === "model").length,
+			toolCallCount: spans.filter(({ kind }) => kind === "tool").length
+		},
+		annotations,
+		spans,
+		...Object.keys(finalUsage).length ? { usage: { ...finalUsage } } : {},
+		...totalCost ? { cost: totalCost } : {},
+		...traceContent.length ? { content: traceContent } : {}
+	};
+}
+//#endregion
+//#region src/internal/run-core.ts
+/**
+* Shared foundation both engines build on: the registries that enforce one
+* active run per session, the single event sequencer, the durable commit path,
+* leases and policy authorization.
+*
+* It must be instantiated exactly once per runtime. `createEvent` advances
+* `state.eventSequence` in place and `runtimeOwner` identifies this process to
+* the lease table, so a second instance would corrupt event ordering and lease
+* ownership without raising an error.
+*/
+function createRunCore({ models, agents, tools, runStore, policies, onEvent, observability }) {
+	const activeRuns = /* @__PURE__ */ new Map();
+	const activeWorkflowRuns = /* @__PURE__ */ new Map();
+	const activeSessions = /* @__PURE__ */ new Set();
+	const pendingExports = /* @__PURE__ */ new Set();
+	const exportFailures = [];
+	const exportedRuns = /* @__PURE__ */ new Set();
+	const runtimeOwner = crypto.randomUUID();
+	const resolveModel = (agent, requestedModel) => {
+		const modelName = requestedModel ?? (typeof agent.model === "string" ? agent.model : "default");
+		if (!modelName.trim()) throw new FevexRunError("MODEL_NOT_FOUND", "Model name cannot be empty");
+		const model = requestedModel !== void 0 || typeof agent.model === "string" ? models.get(modelName) : agent.model ?? models.get(modelName);
+		if (!model) throw new FevexRunError("MODEL_NOT_FOUND", `Model "${modelName}" is not registered`);
+		return {
+			modelName,
+			model
+		};
+	};
+	const resolveCheckpointModel = async (agentName, agent, checkpoint) => {
+		const preferred = resolveModel(agent, checkpoint.modelName);
+		if (checkpoint.definitionHash === await definitionHash(agentName, preferred.modelName, agent, tools)) return preferred;
+		if (checkpoint.modelName !== void 0) return void 0;
+		for (const candidateName of models.keys()) {
+			if (candidateName === preferred.modelName) continue;
+			const candidate = resolveModel(agent, candidateName);
+			if (checkpoint.definitionHash === await definitionHash(agentName, candidate.modelName, agent, tools)) return candidate;
+		}
+	};
+	const scheduleTraceExport = (event) => {
+		if (!observability || ![
+			"run.completed",
+			"run.failed",
+			"run.cancelled"
+		].includes(event.type) || exportedRuns.has(event.runId)) return;
+		exportedRuns.add(event.runId);
+		let task;
+		task = (async () => {
+			const run = await runStore.getRun(event.runId);
+			if (!run) throw new Error(`Run "${event.runId}" does not exist`);
+			if (isCoordinatorRun(run)) return;
+			const agentRun = run;
+			const agent = agents.get(agentRun.agentName);
+			if (!agent) throw new Error(`Agent "${agentRun.agentName}" is not registered`);
+			const checkpoint = isDurableRunStore(runStore) ? await runStore.getCheckpoint(agentRun.id) : void 0;
+			const { modelName: modelRegistryName, model: gateway } = resolveModel(agent, checkpoint?.modelName);
+			const trace = buildRunTrace(agentRun, await runStore.listEvents(agentRun.id), modelRegistryName, gateway?.metadata, observability);
+			const failures = (await Promise.allSettled(observability.exporters.map((exporter) => Promise.resolve().then(() => exporter.export(trace))))).filter((result) => result.status === "rejected").map(({ reason }) => reason);
+			if (failures.length) throw new AggregateError(failures, "Trace export failed");
+		})().catch((error) => {
+			exportFailures.push(error);
+		}).finally(() => pendingExports.delete(task));
+		pendingExports.add(task);
+	};
+	const notifyObserver = (event) => {
+		scheduleTraceExport(event);
+		if (!onEvent) return;
+		try {
+			Promise.resolve(onEvent(event)).catch(() => {});
+		} catch {}
+	};
+	const createEvent = (state, type, payload) => ({
+		id: crypto.randomUUID(),
+		sequence: state.eventSequence += 1,
+		type,
+		runId: state.run.id,
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		...payload === void 0 ? {} : { payload }
+	});
+	const createCoordinatorEvent = (state, workflowType, workflowPayload, teamType, teamPayload = workflowPayload) => createEvent(state, isTeamRun(state.run) ? teamType : workflowType, isTeamRun(state.run) ? teamPayload : workflowPayload);
+	const emitEvent = async (state, type, payload) => {
+		const event = createEvent(state, type, payload);
+		if (isDurableRunStore(runStore)) await commit(state, { events: [event] });
+		else {
+			await runStore.appendEvent(event);
+			notifyObserver(event);
+		}
+		return event;
+	};
+	const releaseExecution = async (state) => {
+		activeRuns.delete(state.run.id);
+		activeSessions.delete(state.session.id);
+		if (state.leaseTimer) clearInterval(state.leaseTimer);
+		if (state.leaseExpiryTimer) clearTimeout(state.leaseExpiryTimer);
+		state.leaseTimer = void 0;
+		state.leaseExpiryTimer = void 0;
+		if (state.lease && isDurableRunStore(runStore)) await runStore.releaseLease(state.run.id, state.lease.ownerId, state.lease.generation).catch(() => {});
+	};
+	const commit = async (state, options = {}) => {
+		if (!isDurableRunStore(runStore)) throw new FevexRunError("DURABLE_STORE_REQUIRED", "This run requires a DurableRunStore", state.run.id);
+		if (state.leaseLost && state.controller.signal.reason instanceof FevexRunError) throw state.controller.signal.reason;
+		if (!state.lease || state.leaseLost) throw new FevexRunError("RUN_CONFLICT", "Run lease is unavailable", state.run.id);
+		state.run.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+		if (!await runStore.commitExecution({
+			expectedRevision: state.run.revision,
+			lease: state.lease,
+			run: state.run,
+			...options
+		})) {
+			state.leaseLost = true;
+			const error = new FevexRunError("RUN_CONFLICT", `Run "${state.run.id}" ownership or revision was lost`, state.run.id);
+			state.controller.abort(error);
+			throw error;
+		}
+		for (const event of options.events ?? []) notifyObserver(event);
+	};
+	const startLease = (state, store) => {
+		let renewing = false;
+		const loseLease = (cause) => {
+			state.leaseLost = true;
+			if (state.leaseTimer) clearInterval(state.leaseTimer);
+			if (state.leaseExpiryTimer) clearTimeout(state.leaseExpiryTimer);
+			state.leaseTimer = void 0;
+			state.leaseExpiryTimer = void 0;
+			state.controller.abort(new FevexRunError("RUN_CONFLICT", `Run lease lost: ${cause instanceof Error ? cause.message : String(cause)}`, state.run.id, { cause }));
+		};
+		const watchExpiry = () => {
+			if (state.leaseExpiryTimer) clearTimeout(state.leaseExpiryTimer);
+			state.leaseExpiryTimer = setTimeout(() => loseLease(/* @__PURE__ */ new Error("Lease expired before renewal completed")), Math.max(0, Date.parse(state.lease.expiresAt) - Date.now()));
+		};
+		watchExpiry();
+		state.leaseTimer = setInterval(() => {
+			if (!state.lease || state.leaseLost || state.request.signal.aborted || renewing) return;
+			renewing = true;
+			const lease = {
+				...state.lease,
+				expiresAt: new Date(Date.now() + LEASE_MS).toISOString()
+			};
+			Promise.resolve().then(() => store.renewLease(lease)).then((renewed) => {
+				if (state.leaseLost || state.request.signal.aborted || !state.leaseTimer) return;
+				if (!renewed) loseLease(/* @__PURE__ */ new Error("Lease ownership changed"));
+				else {
+					state.lease.expiresAt = lease.expiresAt;
+					watchExpiry();
+				}
+			}).catch((error) => {
+				if (state.leaseTimer) loseLease(error);
+			}).finally(() => {
+				renewing = false;
+			});
+		}, LEASE_RENEW_MS);
+	};
+	const cancelExecution = async (state, reason = cancellationReason(state.request.signal)) => {
+		if (state.leaseLost) {
+			await releaseExecution(state);
+			throw state.controller.signal.reason;
+		}
+		if (state.run.status === "completed" || state.run.status === "failed" || state.run.status === "cancelled") return;
+		Object.assign(state.run, {
+			status: "cancelled",
+			pause: void 0,
+			error: reason,
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		const event = createEvent(state, "run.cancelled", { reason });
+		if (isDurableRunStore(runStore)) await commit(state, {
+			checkpoint: null,
+			events: [event]
+		});
+		else {
+			await runStore.saveRun(state.run);
+			await runStore.appendEvent(event);
+			notifyObserver(event);
+		}
+		await releaseExecution(state);
+		return event;
+	};
+	const releaseWorkflowExecution = async (state) => {
+		activeWorkflowRuns.delete(state.run.id);
+		activeSessions.delete(state.session.id);
+		if (state.leaseTimer) clearInterval(state.leaseTimer);
+		if (state.leaseExpiryTimer) clearTimeout(state.leaseExpiryTimer);
+		state.leaseTimer = void 0;
+		state.leaseExpiryTimer = void 0;
+		if (state.lease && isDurableRunStore(runStore)) await runStore.releaseLease(state.run.id, state.lease.ownerId, state.lease.generation).catch(() => {});
+	};
+	const commitWorkflow = async (state, update, events = []) => {
+		state.commitQueue = state.commitQueue.then(async () => {
+			if (state.run.status !== "running") throw new FevexRunError("RUN_CONFLICT", `Workflow run "${state.run.id}" is not running`, state.run.id);
+			update();
+			await commit(state, {
+				checkpoint: state.checkpoint,
+				events
+			});
+		});
+		await state.commitQueue;
+	};
+	const authorize = async (state, tool, input, action, context = state.request.context) => {
+		let approval = false;
+		for (const policy of policies) {
+			const decision = await policy.authorize({
+				runId: state.run.id,
+				agentName: state.run.agentName,
+				toolName: tool.name,
+				risk: tool.risk ?? "read",
+				input,
+				action,
+				context
+			});
+			if (decision === "deny") throw new FevexRunError("POLICY_DENIED", `Policy "${policy.name}" denied tool "${tool.name}"`, state.run.id);
+			if (decision === "require_approval") approval = true;
+		}
+		return approval ? "require_approval" : "allow";
+	};
+	return {
+		activeRuns,
+		activeWorkflowRuns,
+		activeSessions,
+		pendingExports,
+		exportFailures,
+		runtimeOwner,
+		resolveModel,
+		resolveCheckpointModel,
+		notifyObserver,
+		createEvent,
+		createCoordinatorEvent,
+		emitEvent,
+		releaseExecution,
+		commit,
+		startLease,
+		cancelExecution,
+		releaseWorkflowExecution,
+		commitWorkflow,
+		authorize
+	};
+}
+//#endregion
+//#region src/internal/workflow-engine.ts
+/**
+* Coordination on top of the agent engine: durable workflow and team runs,
+* the step API, compensation, waits, and resume.
+*
+* It receives {@link AgentEngine} explicitly. That is what makes the old
+* forward reference from workflow cancellation into agent cancellation a
+* declared dependency instead of a call resolved 2,900 lines later.
+*/
+function createWorkflowEngine(composition, core, agentEngine) {
+	const { models, agents, workflows, teams, runStore } = composition;
+	const { activeRuns, activeWorkflowRuns, activeSessions, runtimeOwner, createEvent, createCoordinatorEvent, notifyObserver, commit, startLease, releaseWorkflowExecution, commitWorkflow } = core;
+	const { prepareExecution, executeAgent, nextEvent, resumeAgent, cancelStoredAgent } = agentEngine;
+	const cancelWorkflowExecution = async (state, reason = cancellationReason(state.request.signal)) => {
+		if (state.leaseLost) {
+			await releaseWorkflowExecution(state);
+			throw state.controller.signal.reason;
+		}
+		if (state.run.status === "completed" || state.run.status === "failed" || state.run.status === "cancelled") return;
+		const childRunIds = Object.values(state.checkpoint.steps).filter((record) => record.type === "agent" && record.status === "running").map(({ childRunId }) => childRunId);
+		for (const childRunId of childRunIds) if (!await cancelStoredAgent(childRunId)) throw new FevexRunError("RUN_CONFLICT", `Workflow child "${childRunId}" could not be cancelled`, state.run.id);
+		state.run.status = "cancelled";
+		state.run.pause = void 0;
+		state.run.error = reason;
+		state.run.usage = state.checkpoint.budget?.usage;
+		const event = createCoordinatorEvent(state, "workflow.run.cancelled", { reason }, "team.run.cancelled");
+		await commit(state, {
+			checkpoint: null,
+			events: [event]
+		});
+		await releaseWorkflowExecution(state);
+		return event;
+	};
+	const prepareWorkflowExecution = async (name, request, kind = "workflow") => {
+		const workflow = workflows.get(name);
+		const team = kind === "team" ? teams.get(name) : void 0;
+		if (!workflow || kind === "team" && !team || kind === "workflow" && teams.has(name)) throw new FevexRunError(kind === "team" ? "TEAM_NOT_FOUND" : "WORKFLOW_NOT_FOUND", `${kind === "team" ? "Team" : "Workflow"} "${name}" is not registered`);
+		if (!isDurableRunStore(runStore)) throw new FevexRunError("DURABLE_STORE_REQUIRED", `${kind === "team" ? "Teams" : "Workflows"} require a DurableRunStore`);
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		let session;
+		if (request.sessionId === void 0) session = {
+			id: crypto.randomUUID(),
+			history: [],
+			createdAt: now,
+			updatedAt: now
+		};
+		else {
+			const stored = await runStore.getSession(request.sessionId);
+			if (!stored) throw new FevexRunError("SESSION_NOT_FOUND", `Session "${request.sessionId}" does not exist`);
+			session = stored;
+		}
+		if (activeSessions.has(session.id)) throw new FevexRunError("RUN_CONFLICT", `Session "${session.id}" already has an active run`);
+		activeSessions.add(session.id);
+		const controller = new AbortController();
+		const signal = request.signal ? AbortSignal.any([controller.signal, request.signal]) : controller.signal;
+		const input = toJsonValue(workflow.inputSchema === void 0 ? request.input : await abortable(() => validateSchema(workflow.inputSchema, request.input, `Input for ${kind} "${name}" does not match inputSchema`), signal), `${kind === "team" ? "Team" : "Workflow"} input must be a string or JSON-serializable value`);
+		const id = crypto.randomUUID();
+		const run = kind === "team" ? {
+			kind: "team",
+			id,
+			sessionId: session.id,
+			teamName: name,
+			status: "running",
+			revision: 0,
+			createdAt: now,
+			updatedAt: now
+		} : {
+			kind: "workflow",
+			id,
+			sessionId: session.id,
+			workflowName: name,
+			status: "running",
+			revision: 0,
+			createdAt: now,
+			updatedAt: now
+		};
+		const checkpoint = kind === "team" ? {
+			version: 2,
+			kind: "team",
+			runId: run.id,
+			teamName: name,
+			...request.model === void 0 ? {} : { model: request.model },
+			...request.reasoning === void 0 ? {} : { reasoning: request.reasoning },
+			definitionHash: await teamDefinitionHash(name, team),
+			input,
+			context: request.context,
+			steps: {},
+			limits: combineLimits(workflow.limits, request.limits)
+		} : {
+			version: 2,
+			kind: "workflow",
+			runId: run.id,
+			workflowName: name,
+			...request.model === void 0 ? {} : { model: request.model },
+			...request.reasoning === void 0 ? {} : { reasoning: request.reasoning },
+			definitionHash: await workflowDefinitionHash(name, workflow),
+			input,
+			context: request.context,
+			steps: {},
+			limits: combineLimits(workflow.limits, request.limits)
+		};
+		const state = {
+			run,
+			session,
+			request: {
+				...request,
+				sessionId: session.id,
+				signal
+			},
+			controller,
+			eventSequence: 0,
+			checkpoint,
+			advancing: false,
+			commitQueue: Promise.resolve()
+		};
+		try {
+			const ownerId = `${runtimeOwner}:${crypto.randomUUID()}`;
+			const lease = {
+				generation: 0,
+				runId: run.id,
+				ownerId,
+				expiresAt: new Date(Date.now() + LEASE_MS).toISOString()
+			};
+			const started = createCoordinatorEvent(state, "workflow.run.started", void 0, "team.run.started");
+			if (!await runStore.createExecution({
+				run,
+				checkpoint,
+				session,
+				lease,
+				events: [started]
+			})) throw new FevexRunError("RUN_CONFLICT", `Run or session "${session.id}" is active or was modified`, run.id);
+			state.lease = lease;
+			state.initialEvents = [started];
+			notifyObserver(started);
+			startLease(state, runStore);
+		} catch (error) {
+			activeSessions.delete(session.id);
+			throw error;
+		}
+		activeWorkflowRuns.set(run.id, state);
+		return state;
+	};
+	async function* executeWorkflow(name, state) {
+		const workflow = workflows.get(name);
+		const events = [];
+		let parallelDepth = 0;
+		const compensationHandlers = /* @__PURE__ */ new Map();
+		const pauseForChild = async (stepId, error) => {
+			if (parallelDepth > 0) throw new WorkflowChildPausedError(stepId, error);
+			const childPause = error.pause;
+			if (childPause.type === "workflow_child" || childPause.type === "workflow_children") throw error;
+			if (childPause.type === "workflow_timer" || childPause.type === "workflow_event") throw new FevexRunError("RUN_NOT_RESUMABLE", `Workflow child "${error.runId}" paused for a workflow wait`, state.run.id);
+			const event = createCoordinatorEvent(state, "workflow.run.paused", {
+				stepId,
+				reason: "child",
+				childRunId: error.runId
+			}, "team.run.paused", {
+				delegationId: stepId,
+				reason: "child",
+				childRunId: error.runId
+			});
+			await commitWorkflow(state, () => {
+				state.run.status = "paused";
+				state.run.pause = {
+					type: "workflow_child",
+					childRunId: error.runId,
+					childPause
+				};
+			}, [event]);
+			events.push(event);
+			await releaseWorkflowExecution(state);
+			throw new RunPausedError(state.run.id, state.run.pause);
+		};
+		const compensationContext = (stepId) => ({
+			runId: state.run.id,
+			sessionId: state.session.id,
+			stepId,
+			context: state.request.context,
+			signal: state.request.signal
+		});
+		const registerCompensation = (stepId, kind, result, options) => {
+			if (!options?.compensate) return;
+			compensationHandlers.set(stepId, {
+				kind,
+				async run() {
+					await options.compensate(structuredClone(result), compensationContext(stepId));
+				}
+			});
+		};
+		const childBudget = async (result) => {
+			const childEvents = await runStore.listEvents(result.runId);
+			return {
+				usage: result.usage,
+				steps: childEvents.filter(({ type }) => type === "model.completed").length,
+				toolCalls: childEvents.filter(({ type }) => type === "tool.completed").length
+			};
+		};
+		const addChildBudget = (budget) => {
+			state.checkpoint.budget = addWorkflowBudget(state.checkpoint.budget, budget);
+			state.run.usage = state.checkpoint.budget?.usage;
+		};
+		const relayChildEvent = async (event, stepId, agentName) => {
+			if (event.type !== "model.started" && event.type !== "model.output.delta" && event.type !== "model.completed" && event.type !== "tool.started" && event.type !== "tool.completed" && event.type !== "tool.failed" && event.type !== "tool.retrying" && event.type !== "tool.execution_unknown" && event.type !== "elicitation.requested" && event.type !== "elicitation.resolved" && event.type !== "approval.requested" && event.type !== "approval.resolved") return;
+			const relayed = createEvent(state, event.type, {
+				...event.payload,
+				...isTeamRun(state.run) ? {
+					teamDelegationId: stepId,
+					teamAgentName: agentName
+				} : {
+					workflowStepId: stepId,
+					workflowAgentName: agentName
+				}
+			});
+			await commitWorkflow(state, () => {}, [relayed]);
+			events.push(relayed);
+		};
+		const runCompensations = async () => {
+			const entries = Object.entries(state.checkpoint.steps).reverse();
+			for (const [stepId, record] of entries) {
+				if (record.type !== "agent" && record.type !== "parallel" || record.status !== "completed" || record.compensation?.status !== "pending") continue;
+				const handler = compensationHandlers.get(stepId);
+				if (!handler) throw new Error(`Workflow step "${stepId}" has no compensation handler`);
+				const started = createEvent(state, "workflow.compensation.started", {
+					stepId,
+					kind: handler.kind
+				});
+				await commitWorkflow(state, () => {}, [started]);
+				events.push(started);
+				try {
+					await abortable(() => handler.run(record.result), state.request.signal);
+					const completed = createEvent(state, "workflow.compensation.completed", {
+						stepId,
+						kind: handler.kind
+					});
+					await commitWorkflow(state, () => {
+						record.compensation = { status: "completed" };
+					}, [completed]);
+					events.push(completed);
+				} catch (error) {
+					const failed = createEvent(state, "workflow.compensation.failed", {
+						stepId,
+						kind: handler.kind,
+						error: toErrorMessage(error)
+					});
+					await commitWorkflow(state, () => {
+						record.compensation = {
+							status: "failed",
+							error: toErrorMessage(error)
+						};
+					}, [failed]);
+					events.push(failed);
+					throw error;
+				}
+			}
+		};
+		const completeAgentStep = async (stepId, agentName, childRunId, output, options) => {
+			const child = await runStore.getRun(childRunId);
+			const result = {
+				runId: childRunId,
+				sessionId: child.sessionId,
+				output,
+				...child.usage === void 0 ? {} : { usage: child.usage }
+			};
+			const budget = await childBudget(result);
+			const event = createCoordinatorEvent(state, "workflow.step.completed", {
+				stepId,
+				kind: "agent"
+			}, "team.task.completed", {
+				delegationId: stepId,
+				agentName,
+				...eventUsage(child.usage) === void 0 ? {} : { usage: eventUsage(child.usage) }
+			});
+			await commitWorkflow(state, () => {
+				addChildBudget(budget);
+				state.checkpoint.steps[stepId] = {
+					type: "agent",
+					status: "completed",
+					agentName,
+					childRunId,
+					result,
+					...options?.metadata === void 0 ? {} : { metadata: structuredClone(options.metadata) },
+					...options?.compensate === void 0 ? {} : { compensation: { status: "pending" } }
+				};
+			}, [event]);
+			if (options?.compensate) registerCompensation(stepId, "agent", result, options);
+			events.push(event);
+			assertWorkflowBudget(name, state.checkpoint.limits, state.checkpoint.budget);
+			return structuredClone(result);
+		};
+		const step = {
+			async agent(stepId, agentName, request, options) {
+				if (!stepId.trim()) throw new Error("Workflow step id cannot be empty");
+				const existing = state.checkpoint.steps[stepId];
+				if (existing?.type === "agent" && existing.status === "completed") {
+					const result = structuredClone(existing.result);
+					registerCompensation(stepId, "agent", result, options);
+					return result;
+				}
+				if (existing?.type === "agent" && existing.status === "running") {
+					let child = await runStore.getRun(existing.childRunId);
+					if (!child) throw new Error(`Child run "${existing.childRunId}" does not exist`);
+					if (child.status === "running") {
+						if (!state.recoveryActor) throw new FevexRunError("RUN_NOT_RECOVERABLE", `Child run "${child.id}" is still running`, state.run.id);
+						child = await resumeAgent(child.id, void 0, true, state.recoveryActor);
+					}
+					if (child.status === "completed") return completeAgentStep(stepId, existing.agentName, existing.childRunId, toJsonValue(child.output, "Child agent output must be JSON-serializable"), options);
+					if (child.status === "paused" && child.pause) return pauseForChild(stepId, new RunPausedError(child.id, child.pause));
+					if (child.status === "failed" || child.status === "cancelled") throw new Error(`Child run "${child.id}" ${child.status}`);
+				}
+				if (existing && existing.type !== "agent") throw new Error(`Workflow step "${stepId}" was already used as ${existing.type}`);
+				if (!agents.has(agentName)) throw new FevexRunError("AGENT_NOT_FOUND", `Agent "${agentName}" is not registered`);
+				const childSignal = request.signal ? AbortSignal.any([state.request.signal, request.signal]) : state.request.signal;
+				const childState = await prepareExecution(agentName, {
+					...request,
+					model: request.model ?? state.request.model,
+					reasoning: request.reasoning ?? state.request.reasoning,
+					context: mergeExecutionContext(state.request.context, request.context),
+					limits: combineLimits(request.limits, remainingWorkflowLimits(state.checkpoint.limits, state.checkpoint.budget)),
+					signal: childSignal
+				});
+				const action = options?.metadata?.teamAction === "handoff" ? "handoff" : "delegate";
+				const lifecycleEvents = [];
+				if (isTeamRun(state.run) && action === "handoff") lifecycleEvents.push(createEvent(state, "team.handoff.created", {
+					delegationId: stepId,
+					from: String(options?.metadata?.from ?? ""),
+					to: agentName,
+					reason: String(options?.metadata?.reason ?? "")
+				}));
+				const started = createCoordinatorEvent(state, "workflow.step.started", {
+					stepId,
+					kind: "agent",
+					agentName
+				}, "team.agent.assigned", {
+					delegationId: stepId,
+					agentName,
+					action,
+					...typeof options?.metadata?.expectedOutput === "string" ? { expectedOutput: options.metadata.expectedOutput } : {},
+					...Array.isArray(options?.metadata?.constraints) ? { constraints: options.metadata.constraints } : {}
+				});
+				lifecycleEvents.push(started);
+				await commitWorkflow(state, () => {
+					state.checkpoint.steps[stepId] = {
+						type: "agent",
+						status: "running",
+						agentName,
+						childRunId: childState.run.id,
+						...options?.metadata === void 0 ? {} : { metadata: structuredClone(options.metadata) }
+					};
+				}, lifecycleEvents);
+				events.push(...lifecycleEvents);
+				try {
+					const execution = executeAgent(agentName, childState);
+					let result;
+					while (true) {
+						const next = await nextEvent(childState, execution);
+						if (next.done) {
+							if (next.value === void 0) {
+								const run = await runStore.getRun(childState.run.id);
+								if (run?.pause) throw new RunPausedError(run.id, run.pause);
+							}
+							result = next.value;
+							break;
+						}
+						await relayChildEvent(next.value, stepId, agentName);
+					}
+					if (!result) throw new Error(`Agent "${agentName}" did not complete`);
+					const normalized = {
+						runId: result.runId,
+						sessionId: result.sessionId,
+						output: result.output,
+						...result.usage === void 0 ? {} : { usage: result.usage }
+					};
+					const budget = await childBudget(normalized);
+					const completed = createCoordinatorEvent(state, "workflow.step.completed", {
+						stepId,
+						kind: "agent"
+					}, "team.task.completed", {
+						delegationId: stepId,
+						agentName,
+						...eventUsage(normalized.usage) === void 0 ? {} : { usage: eventUsage(normalized.usage) }
+					});
+					await commitWorkflow(state, () => {
+						addChildBudget(budget);
+						state.checkpoint.steps[stepId] = {
+							type: "agent",
+							status: "completed",
+							agentName,
+							childRunId: normalized.runId,
+							result: structuredClone(normalized),
+							...options?.metadata === void 0 ? {} : { metadata: structuredClone(options.metadata) },
+							...options?.compensate === void 0 ? {} : { compensation: { status: "pending" } }
+						};
+					}, [completed]);
+					registerCompensation(stepId, "agent", normalized, options);
+					events.push(completed);
+					assertWorkflowBudget(name, state.checkpoint.limits, state.checkpoint.budget);
+					return normalized;
+				} catch (error) {
+					if (error instanceof RunPausedError) return pauseForChild(stepId, error);
+					const failed = createCoordinatorEvent(state, "workflow.step.failed", {
+						stepId,
+						kind: "agent",
+						error: toErrorMessage(error)
+					}, "team.task.failed", {
+						delegationId: stepId,
+						agentName,
+						error: toErrorMessage(error)
+					});
+					await commitWorkflow(state, () => {}, [failed]);
+					events.push(failed);
+					throw error;
+				}
+			},
+			async parallel(stepId, tasks, options) {
+				if (!stepId.trim()) throw new Error("Workflow step id cannot be empty");
+				const existing = state.checkpoint.steps[stepId];
+				if (existing?.type === "parallel" && existing.status === "completed") {
+					const result = structuredClone(existing.result);
+					registerCompensation(stepId, "parallel", result, options);
+					return result;
+				}
+				if (existing && existing.type !== "parallel") throw new Error(`Workflow step "${stepId}" was already used as ${existing.type}`);
+				const started = createCoordinatorEvent(state, "workflow.step.started", {
+					stepId,
+					kind: "parallel"
+				}, "team.merge.started", {
+					stepId,
+					width: typeof options?.metadata?.width === "number" ? options.metadata.width : Object.keys(tasks).length
+				});
+				await commitWorkflow(state, () => {
+					state.checkpoint.steps[stepId] = {
+						type: "parallel",
+						status: "running",
+						...options?.metadata === void 0 ? {} : { metadata: structuredClone(options.metadata) }
+					};
+				}, [started]);
+				events.push(started);
+				try {
+					parallelDepth += 1;
+					const taskEntries = Object.entries(tasks);
+					let settled;
+					try {
+						settled = await Promise.allSettled(taskEntries.map(async ([key, task]) => [key, await task()]));
+					} finally {
+						parallelDepth -= 1;
+					}
+					const failures = settled.filter((item) => item.status === "rejected").map(({ reason }) => reason);
+					const pauses = failures.filter((error) => error instanceof WorkflowChildPausedError);
+					const errors = failures.filter((error) => !(error instanceof WorkflowChildPausedError));
+					if (errors.length) {
+						for (const pause of pauses) if (!await cancelStoredAgent(pause.paused.runId)) throw new FevexRunError("RUN_CONFLICT", `Paused workflow child "${pause.paused.runId}" could not be cancelled`, state.run.id);
+						throw errors.length === 1 ? errors[0] : new AggregateError(errors, `Workflow parallel step "${stepId}" failed`);
+					}
+					if (pauses.length) {
+						if (pauses.length > 1) {
+							const event = createCoordinatorEvent(state, "workflow.run.paused", {
+								stepId,
+								reason: "child",
+								childRunId: pauses[0].paused.runId
+							}, "team.run.paused", {
+								delegationId: stepId,
+								reason: "child",
+								childRunId: pauses[0].paused.runId
 							});
-							if (delayMs) await abortable(() => new Promise((resolve) => setTimeout(resolve, delayMs)), request.signal);
+							await commitWorkflow(state, () => {
+								state.run.status = "paused";
+								state.run.pause = {
+									type: "workflow_children",
+									children: pauses.map((pause) => ({
+										stepId: pause.stepId,
+										childRunId: pause.paused.runId,
+										childPause: pause.paused.pause
+									}))
+								};
+							}, [event]);
+							events.push(event);
+							await releaseWorkflowExecution(state);
+							throw new RunPausedError(state.run.id, state.run.pause);
 						}
+						return pauseForChild(pauses[0].stepId, pauses[0].paused);
 					}
-					if (output === void 0) throw new FevexRunError("TOOL_EXECUTION_UNKNOWN", `Tool "${tool.name}" exhausted its configured attempts`, state.run.id);
-					messages.push({
-						role: "tool",
-						name: pending.call.name,
-						toolCallId: pending.call.id,
-						content: serializeJsonValue(output)
+					const entries = settled.map((item) => item.value);
+					const result = toJsonValue(Object.fromEntries(entries), `Workflow parallel step "${stepId}" result must be JSON-serializable`);
+					if (typeof result !== "object" || result === null || Array.isArray(result)) throw new Error(`Workflow parallel step "${stepId}" result must be an object`);
+					const completed = createCoordinatorEvent(state, "workflow.step.completed", {
+						stepId,
+						kind: "parallel"
+					}, "team.merge.completed", { stepId });
+					await commitWorkflow(state, () => {
+						state.checkpoint.steps[stepId] = {
+							type: "parallel",
+							status: "completed",
+							result,
+							...options?.metadata === void 0 ? {} : { metadata: structuredClone(options.metadata) },
+							...options?.compensate === void 0 ? {} : { compensation: { status: "pending" } }
+						};
+					}, [completed]);
+					registerCompensation(stepId, "parallel", structuredClone(result), options);
+					events.push(completed);
+					return structuredClone(result);
+				} catch (error) {
+					if (error instanceof RunPausedError) throw error;
+					const failed = createCoordinatorEvent(state, "workflow.step.failed", {
+						stepId,
+						kind: "parallel",
+						error: toErrorMessage(error)
+					}, "team.merge.failed", {
+						stepId,
+						error: toErrorMessage(error)
 					});
-					toolCallCount += 1;
-					pendingIndex += 1;
+					await commitWorkflow(state, () => {}, [failed]);
+					events.push(failed);
+					throw error;
 				}
-				pendingTools = [];
-				pendingIndex = 0;
-				step += 1;
+			},
+			async waitUntil(stepId, resumeAt) {
+				if (!stepId.trim()) throw new Error("Workflow step id cannot be empty");
+				const existing = state.checkpoint.steps[stepId];
+				if (existing?.type === "wait" && existing.status === "completed") return;
+				if (existing && existing.type !== "wait") throw new Error(`Workflow step "${stepId}" was already used as ${existing.type}`);
+				const at = resumeAt instanceof Date ? resumeAt : new Date(resumeAt);
+				if (!Number.isFinite(at.getTime())) throw new Error(`Workflow wait "${stepId}" resumeAt must be a valid date`);
+				const wait = {
+					type: "timer",
+					resumeAt: at.toISOString()
+				};
+				if (Date.now() >= at.getTime()) {
+					const started = createEvent(state, "workflow.wait.started", {
+						stepId,
+						kind: "timer",
+						resumeAt: wait.resumeAt
+					});
+					const completed = createEvent(state, "workflow.wait.completed", {
+						stepId,
+						kind: "timer"
+					});
+					await commitWorkflow(state, () => {
+						state.checkpoint.steps[stepId] = {
+							type: "wait",
+							status: "completed",
+							wait
+						};
+					}, [started, completed]);
+					events.push(started, completed);
+					return;
+				}
+				const started = createEvent(state, "workflow.wait.started", {
+					stepId,
+					kind: "timer",
+					resumeAt: wait.resumeAt
+				});
+				const paused = createEvent(state, "workflow.run.paused", {
+					stepId,
+					reason: "timer"
+				});
+				await commitWorkflow(state, () => {
+					state.checkpoint.steps[stepId] = {
+						type: "wait",
+						status: "running",
+						wait
+					};
+					state.run.status = "paused";
+					state.run.pause = {
+						type: "workflow_timer",
+						stepId,
+						resumeAt: wait.resumeAt
+					};
+				}, [started, paused]);
+				events.push(started, paused);
+				await releaseWorkflowExecution(state);
+				throw new RunPausedError(state.run.id, state.run.pause);
+			},
+			async waitForEvent(stepId, eventName) {
+				if (!stepId.trim()) throw new Error("Workflow step id cannot be empty");
+				if (!eventName.trim()) throw new Error("Workflow event name cannot be empty");
+				const definition = workflow.events?.[eventName];
+				if (!definition) throw new Error(`Workflow event "${eventName}" is not declared`);
+				const existing = state.checkpoint.steps[stepId];
+				if (existing?.type === "wait" && existing.status === "completed") return {
+					...existing.payload === void 0 ? {} : { payload: existing.payload },
+					...existing.actor === void 0 ? {} : { actor: existing.actor },
+					receivedAt: existing.receivedAt
+				};
+				if (existing && existing.type !== "wait") throw new Error(`Workflow step "${stepId}" was already used as ${existing.type}`);
+				const wait = {
+					type: "event",
+					eventName,
+					requireActor: definition.requireActor ?? false
+				};
+				const started = createEvent(state, "workflow.wait.started", {
+					stepId,
+					kind: "event",
+					eventName
+				});
+				const paused = createEvent(state, "workflow.run.paused", {
+					stepId,
+					reason: "event"
+				});
+				await commitWorkflow(state, () => {
+					state.checkpoint.steps[stepId] = {
+						type: "wait",
+						status: "running",
+						wait
+					};
+					state.run.status = "paused";
+					state.run.pause = {
+						type: "workflow_event",
+						stepId,
+						eventName
+					};
+				}, [started, paused]);
+				events.push(started, paused);
+				await releaseWorkflowExecution(state);
+				throw new RunPausedError(state.run.id, state.run.pause);
 			}
-			throw new Error(`Agent "${name}" reached maxSteps limit of ${maxSteps}`);
+		};
+		const firstEvents = state.initialEvents ?? [];
+		state.initialEvents = void 0;
+		events.push(...firstEvents);
+		try {
+			for (const event of firstEvents) yield event;
+			if (state.checkpoint.version !== 2) throw new FevexRunError("CHECKPOINT_UNSUPPORTED", `Checkpoint for run "${state.run.id}" is unsupported`, state.run.id);
+			const hash = isTeamRun(state.run) ? await teamDefinitionHash(name, teams.get(name)) : await workflowDefinitionHash(name, workflow);
+			if (state.checkpoint.definitionHash !== hash) throw new FevexRunError("RUN_DEFINITION_CHANGED", `Definition for ${(isTeamRun(state.run) ? "Team" : "Workflow").toLowerCase()} "${name}" changed`, state.run.id);
+			state.request.signal.throwIfAborted();
+			const rawOutput = await workflow.run(step, state.checkpoint.input);
+			const output = toJsonValue(workflow.outputSchema === void 0 ? rawOutput : await validateSchema(workflow.outputSchema, rawOutput, `Output from ${isTeamRun(state.run) ? "team" : "workflow"} "${name}" does not match outputSchema`), `Output from ${isTeamRun(state.run) ? "team" : "workflow"} "${name}" must be JSON-serializable`);
+			await state.commitQueue;
+			state.run.status = "completed";
+			state.run.pause = void 0;
+			state.run.output = output;
+			state.run.usage = state.checkpoint.budget?.usage;
+			const completedPayload = {
+				output,
+				...eventUsage(state.run.usage) === void 0 ? {} : { usage: eventUsage(state.run.usage) }
+			};
+			const completed = createCoordinatorEvent(state, "workflow.run.completed", completedPayload, "team.run.completed");
+			await commit(state, {
+				checkpoint: null,
+				events: [completed]
+			});
+			events.push(completed);
+			await releaseWorkflowExecution(state);
+			yield completed;
+			return {
+				runId: state.run.id,
+				sessionId: state.session.id,
+				output,
+				events,
+				...state.run.usage === void 0 ? {} : { usage: state.run.usage }
+			};
 		} catch (error) {
-			if (request.signal.aborted) {
-				const event = await cancelExecution(state);
+			let thrown = error;
+			if (state.request.signal.aborted) try {
+				const event = await cancelWorkflowExecution(state);
 				if (event) {
 					events.push(event);
 					yield event;
 				}
+			} catch (cancellationError) {
+				await releaseWorkflowExecution(state);
+				throw cancellationError;
+			}
+			else if (state.run.status === "paused") throw error;
+			else if (error instanceof FevexRunError && error.code === "RUN_CONFLICT") {
+				await releaseWorkflowExecution(state);
+				throw error;
 			} else if (state.run.status === "running") {
-				Object.assign(state.run, {
-					status: "failed",
-					error: toErrorMessage(error),
-					...usage === void 0 ? {} : { usage },
-					updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-				});
-				const failed = createEvent(state, "run.failed", { error: toErrorMessage(error) });
-				if (isDurableRunStore(runStore)) await commit(state, {
+				await state.commitQueue;
+				let failure = error;
+				try {
+					await runCompensations();
+				} catch (compensationError) {
+					failure = new AggregateError([error, compensationError], `Workflow failed: ${toErrorMessage(error)}; compensation failed: ${toErrorMessage(compensationError)}`);
+					thrown = failure;
+				}
+				state.run.status = "failed";
+				state.run.error = toErrorMessage(failure);
+				state.run.usage = state.checkpoint.budget?.usage;
+				const failedPayload = {
+					error: toErrorMessage(failure),
+					...runErrorPayload(failure)
+				};
+				const failed = createCoordinatorEvent(state, "workflow.run.failed", failedPayload, "team.run.failed");
+				await commit(state, {
 					checkpoint: null,
 					events: [failed]
 				});
-				else {
-					await runStore.saveRun(state.run);
-					await runStore.appendEvent(failed);
-					notifyObserver(failed);
-				}
 				events.push(failed);
-				await releaseExecution(state);
+				await releaseWorkflowExecution(state);
 				yield failed;
-			}
-			throw error;
+			} else await releaseWorkflowExecution(state);
+			throw thrown;
 		}
 	}
-	const nextEvent = async (state, execution) => {
+	const nextWorkflowEvent = async (state, execution) => {
 		state.advancing = true;
 		try {
 			return await execution.next();
@@ -1257,10 +3159,10 @@ function createRuntime({ models, agents, tools, runStore, credentialStore, polic
 			state.advancing = false;
 		}
 	};
-	const drainExecution = async (name, state, throwOnPause) => {
-		const execution = executeAgent(name, state);
+	const drainWorkflowExecution = async (name, state, throwOnPause) => {
+		const execution = executeWorkflow(name, state);
 		while (true) {
-			const next = await nextEvent(state, execution);
+			const next = await nextWorkflowEvent(state, execution);
 			if (next.done) {
 				if (next.value === void 0 && throwOnPause) {
 					const run = await runStore.getRun(state.run.id);
@@ -1270,141 +3172,216 @@ function createRuntime({ models, agents, tools, runStore, credentialStore, polic
 			}
 		}
 	};
-	const resume = async (runId, resolution) => {
+	const resumeWorkflow = async (runId, resolution, recoveryActor) => {
 		if (!isDurableRunStore(runStore)) throw new FevexRunError("DURABLE_STORE_REQUIRED", "resumeRun requires DurableRunStore", runId);
 		const run = await runStore.getRun(runId);
 		const checkpoint = await runStore.getCheckpoint(runId);
-		if (!run || !checkpoint) throw new FevexRunError("RUN_NOT_RESUMABLE", `Run "${runId}" cannot be resumed`, runId);
-		if (run.status !== "paused" && run.status !== "running") throw new FevexRunError("RUN_NOT_RESUMABLE", `Run "${runId}" is terminal`, runId);
-		const agent = agents.get(run.agentName);
-		if (!agent) throw new FevexRunError("RUN_DEFINITION_CHANGED", `Agent "${run.agentName}" is unavailable`, runId);
-		const modelName = typeof agent.model === "string" ? agent.model : "default";
-		const model = typeof agent.model === "string" ? models.get(agent.model) : agent.model ?? models.get("default");
-		if (!model || checkpoint.definitionHash !== await definitionHash(run.agentName, modelName, agent, tools)) throw new FevexRunError("RUN_DEFINITION_CHANGED", `Definition for agent "${run.agentName}" changed`, runId);
-		if (checkpoint.providerState !== void 0 && !model.stateCodec) throw new FevexRunError("RUN_NOT_RESUMABLE", "ModelGateway no longer provides its stateCodec", runId);
+		if (!run || !checkpoint) throw new FevexRunError(resolution ? "RUN_NOT_RESUMABLE" : "RUN_NOT_RECOVERABLE", `Run "${runId}" cannot be ${resolution ? "resumed" : "recovered"}`, runId);
+		if (checkpoint.version !== 2) throw new FevexRunError("CHECKPOINT_UNSUPPORTED", `Checkpoint for run "${runId}" is unsupported`, runId);
+		if (resolution && run.status !== "paused" && run.status !== "running" || !resolution && run.status !== "running") throw new FevexRunError(resolution ? "RUN_NOT_RESUMABLE" : "RUN_NOT_RECOVERABLE", `Run "${runId}" is not ${resolution ? "resumable" : "recoverable"}`, runId);
+		const name = coordinatorName(run);
+		const workflow = workflows.get(name);
+		const team = isTeamRun(run) ? teams.get(name) : void 0;
+		if (!workflow) throw new FevexRunError("RUN_DEFINITION_CHANGED", `${isTeamRun(run) ? "Team" : "Workflow"} "${name}" is unavailable`, runId);
+		const currentHash = isTeamRun(run) ? team && await teamDefinitionHash(name, team) : await workflowDefinitionHash(name, workflow);
+		if (!currentHash || checkpoint.definitionHash !== currentHash) throw new FevexRunError("RUN_DEFINITION_CHANGED", `Definition for ${isTeamRun(run) ? "team" : "workflow"} "${name}" changed`, runId);
+		if (resolution && run.pause?.type !== "workflow_child" && run.pause?.type !== "workflow_children" && run.pause?.type !== "workflow_timer" && run.pause?.type !== "workflow_event") throw new FevexRunError("RUN_NOT_RESUMABLE", `Run "${runId}" cannot be resumed`, runId);
 		const session = await runStore.getSession(run.sessionId);
 		if (!session) throw new Error(`Session "${run.sessionId}" does not exist`);
 		if (activeSessions.has(session.id)) throw new FevexRunError("RUN_CONFLICT", `Session "${session.id}" is active`, runId);
 		const ownerId = `${runtimeOwner}:${crypto.randomUUID()}`;
-		if (!await runStore.acquireLease({
+		const lease = {
+			generation: 0,
 			runId,
 			ownerId,
 			expiresAt: new Date(Date.now() + LEASE_MS).toISOString()
-		})) throw new FevexRunError("RUN_CONFLICT", `Run "${runId}" is leased`, runId);
+		};
+		if (!await runStore.acquireLease(lease)) throw new FevexRunError("RUN_CONFLICT", `Run "${runId}" is leased`, runId);
 		try {
+			if (!resolution) {
+				if (!recoveryActor?.id.trim()) throw new FevexRunError("RUN_NOT_RECOVERABLE", "Recovery actor is required", runId);
+				const controller = new AbortController();
+				const state = {
+					run,
+					session,
+					request: {
+						input: checkpoint.input,
+						...checkpoint.model === void 0 ? {} : { model: checkpoint.model },
+						...checkpoint.reasoning === void 0 ? {} : { reasoning: checkpoint.reasoning },
+						sessionId: session.id,
+						context: checkpoint.context,
+						limits: checkpoint.limits,
+						signal: controller.signal
+					},
+					controller,
+					eventSequence: (await runStore.listEvents(runId)).at(-1)?.sequence ?? 0,
+					checkpoint,
+					advancing: false,
+					lease,
+					commitQueue: Promise.resolve(),
+					recoveryActor
+				};
+				const recovered = createCoordinatorEvent(state, "workflow.run.recovered", { actorId: recoveryActor.id }, "team.run.recovered");
+				await commit(state, {
+					checkpoint,
+					events: [recovered]
+				});
+				state.initialEvents = [recovered];
+				activeWorkflowRuns.set(runId, state);
+				activeSessions.add(session.id);
+				startLease(state, runStore);
+				drainWorkflowExecution(name, state, false).catch(() => {});
+				return structuredClone(run);
+			}
+			const workflowPause = run.pause;
+			if (!workflowPause || workflowPause.type !== "workflow_child" && workflowPause.type !== "workflow_children" && workflowPause.type !== "workflow_timer" && workflowPause.type !== "workflow_event") throw new FevexRunError("RUN_NOT_RESUMABLE", `Run "${runId}" cannot be resumed`, runId);
+			if (workflowPause.type === "workflow_timer" || workflowPause.type === "workflow_event") {
+				const pause = workflowPause;
+				if (pause.type === "workflow_timer") {
+					if (resolution.type !== "timer") throw new FevexRunError("RUN_NOT_RESUMABLE", "Timer resolution is required", runId);
+					if (Date.now() < Date.parse(pause.resumeAt)) throw new FevexRunError("RUN_NOT_RESUMABLE", "Workflow timer has not elapsed", runId);
+				} else if (resolution.type !== "event" || resolution.eventName !== pause.eventName) throw new FevexRunError("RUN_NOT_RESUMABLE", "Workflow event does not match", runId);
+				const waiting = checkpoint.steps[pause.stepId];
+				if (waiting?.type !== "wait" || waiting.status !== "running") throw new FevexRunError("RUN_NOT_RESUMABLE", "Workflow wait is unavailable", runId);
+				let eventPayload;
+				const receivedAt = (/* @__PURE__ */ new Date()).toISOString();
+				if (resolution.type === "event") {
+					const eventDefinition = workflow.events?.[resolution.eventName];
+					if (!eventDefinition) throw new FevexRunError("RUN_DEFINITION_CHANGED", `Workflow event "${resolution.eventName}" is unavailable`, runId);
+					if (waiting.wait.type !== "event") throw new FevexRunError("RUN_NOT_RESUMABLE", "Workflow wait is unavailable", runId);
+					if (waiting.wait.requireActor && !resolution.actor?.id?.trim()) throw new FevexRunError("APPROVAL_INVALID", "Workflow event actor is required", runId);
+					const validatedPayload = eventDefinition.payloadSchema === void 0 ? resolution.payload : await validateSchema(eventDefinition.payloadSchema, resolution.payload, `Payload for workflow event "${resolution.eventName}" does not match payloadSchema`);
+					if (validatedPayload !== void 0) eventPayload = toJsonValue(validatedPayload, "Workflow event payload must be JSON-serializable");
+				}
+				const controller = new AbortController();
+				const state = {
+					run,
+					session,
+					request: {
+						input: checkpoint.input,
+						...checkpoint.model === void 0 ? {} : { model: checkpoint.model },
+						...checkpoint.reasoning === void 0 ? {} : { reasoning: checkpoint.reasoning },
+						sessionId: session.id,
+						context: checkpoint.context,
+						limits: checkpoint.limits,
+						signal: controller.signal
+					},
+					controller,
+					eventSequence: (await runStore.listEvents(runId)).at(-1)?.sequence ?? 0,
+					checkpoint,
+					advancing: false,
+					lease,
+					commitQueue: Promise.resolve()
+				};
+				run.status = "running";
+				run.pause = void 0;
+				const resumed = createCoordinatorEvent(state, "workflow.run.resumed", void 0, "team.run.resumed");
+				const completed = createEvent(state, "workflow.wait.completed", {
+					stepId: pause.stepId,
+					kind: waiting.wait.type,
+					...eventPayload === void 0 ? {} : { payload: eventPayload },
+					...resolution.type === "event" && resolution.actor ? { actorId: resolution.actor.id } : {},
+					...resolution.type === "event" ? { receivedAt } : {}
+				});
+				await commitWorkflow(state, () => {
+					state.checkpoint.steps[pause.stepId] = {
+						type: "wait",
+						status: "completed",
+						wait: waiting.wait,
+						...eventPayload === void 0 ? {} : { payload: eventPayload },
+						...resolution.type === "event" && resolution.actor ? { actor: resolution.actor } : {},
+						...resolution.type === "event" ? { receivedAt } : {}
+					};
+				}, [resumed, completed]);
+				activeWorkflowRuns.set(runId, state);
+				activeSessions.add(session.id);
+				startLease(state, runStore);
+				drainWorkflowExecution(name, state, false).catch(() => {});
+				return structuredClone(run);
+			}
+			if (resolution.type === "timer" || resolution.type === "event") throw new FevexRunError("RUN_NOT_RESUMABLE", `Run "${runId}" cannot be resumed`, runId);
+			const childRunId = workflowPause.type === "workflow_children" ? workflowPause.children.find(({ childPause }) => pauseMatchesResolution(childPause, resolution))?.childRunId : workflowPause.childRunId;
+			if (!childRunId) throw new FevexRunError("RUN_NOT_RESUMABLE", "Resolution does not match a paused child run", runId);
+			const childRun = await resumeAgent(childRunId, resolution, true);
 			const controller = new AbortController();
 			const state = {
 				run,
 				session,
 				request: {
-					input: "",
+					input: checkpoint.input,
+					...checkpoint.model === void 0 ? {} : { model: checkpoint.model },
+					...checkpoint.reasoning === void 0 ? {} : { reasoning: checkpoint.reasoning },
 					sessionId: session.id,
 					context: checkpoint.context,
+					limits: checkpoint.limits,
 					signal: controller.signal
 				},
 				controller,
 				eventSequence: (await runStore.listEvents(runId)).at(-1)?.sequence ?? 0,
-				advancing: false,
 				checkpoint,
-				leaseOwner: ownerId,
-				...resolution.type === "approval" ? { approvedToolCallId: run.pause?.type === "approval" ? run.pause.approval.toolCallId : void 0 } : {
-					approvedToolCallId: resolution.toolCallId,
-					...resolution.decision === "retry" ? { forcedRetryToolCallId: resolution.toolCallId } : {}
-				}
+				advancing: false,
+				lease,
+				commitQueue: Promise.resolve()
 			};
-			if (!resolution.actor?.id?.trim()) {
-				await runStore.releaseLease(runId, ownerId);
-				throw new FevexRunError("APPROVAL_INVALID", "Resolution actor is required", runId);
-			}
-			if (resolution.type === "approval") {
-				if (run.pause?.type !== "approval" || run.pause.approval.id !== resolution.approvalId) {
-					await runStore.releaseLease(runId, ownerId);
-					throw new FevexRunError("APPROVAL_INVALID", "Approval does not match the run", runId);
-				}
-				const pending = checkpoint.pendingTools[checkpoint.pendingIndex];
-				const tool = pending && tools.get(pending.call.name);
-				if (!pending || !tool) {
-					await runStore.releaseLease(runId, ownerId);
-					throw new FevexRunError("APPROVAL_INVALID", "Approval tool is unavailable", runId);
-				}
-				if (resolution.decision === "approve") await authorize(state, tool, pending.input, "approval.resolve", {
-					...state.request.context,
-					actor: resolution.actor
+			if (childRun.status === "cancelled") {
+				run.status = "cancelled";
+				run.pause = void 0;
+				run.error = childRun.error ?? "aborted";
+				const reason = childRun.error === "approval_rejected" ? "approval_rejected" : "aborted";
+				const cancelled = createCoordinatorEvent(state, "workflow.run.cancelled", { reason }, "team.run.cancelled");
+				await commit(state, {
+					checkpoint: null,
+					events: [cancelled]
 				});
-				if (resolution.decision === "reject") {
-					const toolCallId = run.pause.approval.toolCallId;
-					run.status = "cancelled";
-					run.pause = void 0;
-					run.error = "approval_rejected";
-					const resolved = createEvent(state, "approval.resolved", {
-						approvalId: resolution.approvalId,
-						toolCallId,
-						decision: "reject",
-						actorId: resolution.actor.id
-					});
-					const cancelled = createEvent(state, "run.cancelled", { reason: "approval_rejected" });
-					await commit(state, {
-						checkpoint: null,
-						events: [resolved, cancelled]
-					});
-					await releaseExecution(state);
-					return structuredClone(run);
-				}
-			} else {
-				const pending = checkpoint.pendingTools[checkpoint.pendingIndex];
-				const record = await runStore.getToolExecution(runId, resolution.toolCallId);
-				const matchesUnknownPause = run.pause?.type === "tool_execution_unknown" && run.pause.toolCallId === resolution.toolCallId;
-				const matchesInterruptedAttempt = run.status === "running" && pending?.call.id === resolution.toolCallId && (record?.status === "started" || record?.status === "completed");
-				if (!matchesUnknownPause && !matchesInterruptedAttempt) {
-					await runStore.releaseLease(runId, ownerId);
-					throw new FevexRunError("RUN_NOT_RESUMABLE", "Tool execution resolution does not match a pending attempt", runId);
-				}
-			}
-			if (resolution.type === "tool_execution" && resolution.decision === "use_output") {
-				const pending = checkpoint.pendingTools[checkpoint.pendingIndex];
-				const tool = tools.get(pending.call.name);
-				if (!tool) {
-					await runStore.releaseLease(runId, ownerId);
-					throw new FevexRunError("RUN_DEFINITION_CHANGED", "Pending tool is unavailable", runId);
-				}
-				const output = toJsonValue(tool.outputSchema === void 0 ? resolution.output : await validateSchema(tool.outputSchema, resolution.output, `Manual output for tool "${tool.name}" does not match outputSchema`), "Manual tool output must be JSON-serializable");
-				const current = await runStore.getToolExecution(runId, resolution.toolCallId);
-				await commit(state, { toolExecution: {
-					runId,
-					toolCallId: resolution.toolCallId,
-					toolName: pending.call.name,
-					input: pending.input,
-					status: "completed",
-					attempt: current?.attempt ?? 1,
-					idempotencyKey: current?.idempotencyKey ?? pending.idempotencyKey,
-					output,
-					updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-				} });
+				await releaseWorkflowExecution(state);
+				return structuredClone(run);
 			}
-			const approval = run.pause?.type === "approval" ? run.pause.approval : void 0;
 			run.status = "running";
 			run.pause = void 0;
-			const resumeEvents = [createEvent(state, "run.resumed", void 0)];
-			if (approval && resolution.type === "approval") resumeEvents.push(createEvent(state, "approval.resolved", {
-				approvalId: approval.id,
-				toolCallId: approval.toolCallId,
-				decision: "approve",
-				actorId: resolution.actor.id
-			}));
+			const resumed = createCoordinatorEvent(state, "workflow.run.resumed", void 0, "team.run.resumed");
 			await commit(state, {
 				checkpoint,
-				events: resumeEvents
+				events: [resumed]
 			});
-			activeRuns.set(runId, state);
+			activeWorkflowRuns.set(runId, state);
 			activeSessions.add(session.id);
 			startLease(state, runStore);
-			drainExecution(run.agentName, state, false).catch(() => {});
+			drainWorkflowExecution(name, state, false).catch(() => {});
 			return structuredClone(run);
 		} catch (error) {
-			await runStore.releaseLease(runId, ownerId).catch(() => {});
+			await runStore.releaseLease(runId, ownerId, lease.generation).catch(() => {});
 			throw error;
 		}
 	};
+	return {
+		prepareWorkflowExecution,
+		executeWorkflow,
+		nextWorkflowEvent,
+		drainWorkflowExecution,
+		resumeWorkflow,
+		cancelWorkflowExecution
+	};
+}
+//#endregion
+//#region src/internal/runtime.ts
+function createRuntime(composition) {
+	const { models, agents, workflows, teams, tools, contextProviders, memoryStore, runStore, credentialStore, sandbox, policies } = composition;
+	const core = createRunCore(composition);
+	const { activeRuns, activeWorkflowRuns, activeSessions, pendingExports, exportFailures, runtimeOwner, createEvent, createCoordinatorEvent, notifyObserver, commit, startLease, cancelExecution, releaseWorkflowExecution, commitWorkflow } = core;
+	const agentEngine = createAgentEngine(composition, core);
+	const { prepareExecution, executeAgent, nextEvent, drainExecution, resumeAgent, cancelStoredAgent } = agentEngine;
+	const { prepareWorkflowExecution, executeWorkflow, nextWorkflowEvent, drainWorkflowExecution, resumeWorkflow, cancelWorkflowExecution } = createWorkflowEngine(composition, core, agentEngine);
+	const resumeRun = async (runId, resolution) => {
+		const run = await runStore.getRun(runId);
+		if (run && isCoordinatorRun(run)) return resumeWorkflow(runId, resolution);
+		return resumeAgent(runId, resolution);
+	};
+	const recoverRun = async (runId, actor) => {
+		const run = await runStore.getRun(runId);
+		if (!run) throw new FevexRunError("RUN_NOT_RECOVERABLE", `Run "${runId}" cannot be recovered`, runId);
+		if (isCoordinatorRun(run)) return resumeWorkflow(runId, void 0, actor);
+		return resumeAgent(runId, void 0, false, actor);
+	};
 	return {
 		async startAgent(name, request) {
 			const state = await prepareExecution(name, request);
@@ -1441,6 +3418,54 @@ function createRuntime({ models, agents, tools, runStore, credentialStore, polic
 				}
 			} };
 		},
+		async startWorkflow(name, request) {
+			const state = await prepareWorkflowExecution(name, request);
+			drainWorkflowExecution(name, state, false).catch(() => {});
+			return structuredClone(state.run);
+		},
+		async runWorkflow(name, request) {
+			const state = await prepareWorkflowExecution(name, request);
+			return await drainWorkflowExecution(name, state, true);
+		},
+		async startTeam(name, request) {
+			const state = await prepareWorkflowExecution(name, request, "team");
+			drainWorkflowExecution(name, state, false).catch(() => {});
+			return structuredClone(state.run);
+		},
+		async runTeam(name, request) {
+			const state = await prepareWorkflowExecution(name, request, "team");
+			return await drainWorkflowExecution(name, state, true);
+		},
+		streamTeam(name, request) {
+			return { async *[Symbol.asyncIterator]() {
+				const state = await prepareWorkflowExecution(name, request, "team");
+				const execution = executeWorkflow(name, state);
+				let finished = false;
+				try {
+					while (true) {
+						const next = await nextWorkflowEvent(state, execution);
+						if (next.done) {
+							finished = true;
+							return;
+						}
+						yield next.value;
+					}
+				} finally {
+					if (!finished && state.run.status === "running") {
+						state.controller.abort(new DOMException("Stream abandoned", "AbortError"));
+						try {
+							while (state.run.status === "running") if ((await nextWorkflowEvent(state, execution)).done) break;
+						} catch {}
+						if (state.run.status === "running") await cancelWorkflowExecution(state);
+					}
+					await execution.return(void 0);
+				}
+			} };
+		},
+		async getTeamRun(runId) {
+			const run = await runStore.getRun(runId);
+			return run?.kind === "team" ? run : void 0;
+		},
 		getRun(runId) {
 			return runStore.getRun(runId);
 		},
@@ -1448,6 +3473,12 @@ function createRuntime({ models, agents, tools, runStore, credentialStore, polic
 			return runStore.listEvents(runId, options);
 		},
 		async cancelRun(runId) {
+			const activeWorkflow = activeWorkflowRuns.get(runId);
+			if (activeWorkflow && !activeWorkflow.request.signal.aborted) {
+				activeWorkflow.controller.abort(new DOMException("Run cancelled", "AbortError"));
+				if (!activeWorkflow.advancing) await cancelWorkflowExecution(activeWorkflow);
+				return true;
+			}
 			const active = activeRuns.get(runId);
 			if (active && !active.request.signal.aborted) {
 				active.controller.abort(new DOMException("Run cancelled", "AbortError"));
@@ -1455,39 +3486,66 @@ function createRuntime({ models, agents, tools, runStore, credentialStore, polic
 				return true;
 			}
 			const run = await runStore.getRun(runId);
-			if (run?.status !== "paused") return false;
+			if (!run || run.status !== "paused" && run.status !== "running") return false;
 			if (!isDurableRunStore(runStore)) return false;
 			const session = await runStore.getSession(run.sessionId);
 			if (!session) return false;
-			const state = {
-				run,
-				session,
-				request: {
-					input: "",
-					sessionId: session.id,
-					signal: new AbortController().signal
-				},
-				controller: new AbortController(),
-				eventSequence: (await runStore.listEvents(runId)).at(-1)?.sequence ?? 0,
-				advancing: false
-			};
-			run.status = "cancelled";
-			run.pause = void 0;
-			run.error = "aborted";
-			const cancelled = createEvent(state, "run.cancelled", { reason: "aborted" });
-			try {
-				await commit(state, {
-					checkpoint: null,
-					events: [cancelled]
-				});
-				return true;
-			} catch (error) {
-				if (error instanceof FevexRunError && error.code === "RUN_CONFLICT" && (await runStore.getRun(runId))?.status !== "paused") return false;
-				throw error;
+			if (isCoordinatorRun(run)) {
+				const checkpoint = await runStore.getCheckpoint(runId);
+				if (!checkpoint) return false;
+				const ownerId = `${runtimeOwner}:${crypto.randomUUID()}`;
+				const lease = {
+					generation: 0,
+					runId,
+					ownerId,
+					expiresAt: new Date(Date.now() + LEASE_MS).toISOString()
+				};
+				if (!await runStore.acquireLease(lease)) return false;
+				try {
+					const childRunIds = Object.values(checkpoint.steps).filter((record) => record.type === "agent" && record.status === "running").map(({ childRunId }) => childRunId);
+					for (const childRunId of childRunIds) if (!await cancelStoredAgent(childRunId)) return false;
+					const state = {
+						run,
+						session,
+						request: {
+							input: checkpoint.input,
+							...checkpoint.reasoning === void 0 ? {} : { reasoning: checkpoint.reasoning },
+							sessionId: session.id,
+							context: checkpoint.context,
+							limits: checkpoint.limits,
+							signal: new AbortController().signal
+						},
+						controller: new AbortController(),
+						eventSequence: (await runStore.listEvents(runId)).at(-1)?.sequence ?? 0,
+						checkpoint,
+						advancing: false,
+						lease,
+						commitQueue: Promise.resolve()
+					};
+					run.status = "cancelled";
+					run.pause = void 0;
+					run.error = "aborted";
+					run.usage = checkpoint.budget?.usage;
+					const cancelled = createCoordinatorEvent(state, "workflow.run.cancelled", { reason: "aborted" }, "team.run.cancelled");
+					await commit(state, {
+						checkpoint: null,
+						events: [cancelled]
+					});
+					return true;
+				} catch (error) {
+					if (error instanceof FevexRunError && error.code === "RUN_CONFLICT" && (await runStore.getRun(runId))?.status !== "paused") return false;
+					throw error;
+				} finally {
+					await runStore.releaseLease(runId, ownerId, lease.generation).catch(() => {});
+				}
 			}
+			return cancelStoredAgent(runId);
 		},
 		resumeRun(runId, resolution) {
-			return resume(runId, resolution);
+			return resumeRun(runId, resolution);
+		},
+		recoverRun(runId, options) {
+			return recoverRun(runId, options.actor);
 		},
 		async compactSession(sessionId, summary) {
 			if (typeof summary !== "string" || !summary.trim()) throw new Error("Session summary must be a non-empty string");
@@ -1513,8 +3571,14 @@ function createRuntime({ models, agents, tools, runStore, credentialStore, polic
 }
 //#endregion
 //#region src/fevex.ts
+/**
+* Validates a configuration snapshot and creates an isolated runtime.
+*
+* The runtime does not own external adapters; callers remain responsible for
+* closing model, connection, store, and exporter resources they provide.
+*/
 function createFevex(config) {
 	return createRuntime(createComposition(config));
 }
 //#endregion
-export { FevexConfigurationError, FevexRunError, InMemoryRunStore, PROVIDER_REASONING_UNSUPPORTED, PROVIDER_SCHEMA_UNSUPPORTED, RunPausedError, SCHEMA_NOT_TRANSPORTABLE, createFevex, defineAgent, definePolicy, defineTool, isDurableRunStore, toToolSpec };
+export { ChannelError, FEVEX_JSON_SCHEMA_PROFILE_VERSION, FevexConfigurationError, FevexRunError, InMemoryMemoryStore, InMemoryRunStore, IntegrationError, PROVIDER_REASONING_UNSUPPORTED, PROVIDER_SCHEMA_UNSUPPORTED, RunPausedError, SCHEMA_NOT_TRANSPORTABLE, SandboxError, compileFevexJsonSchema, createFevex, createLocalSandbox, createMemoryContextProvider, defineAgent, defineConnection, defineContextProvider, definePolicy, defineSkill, defineTeam, defineTool, defineWorkflow, handleChannelInput, isDurableRunStore, sandboxResultToJson, toToolSpec, validateFevexJsonSchemaProfile, validateListEventsOptions };