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

package/dist/index.mjs

@@ -1,63 +1,36 @@
-import { defineTool, toToolSpec } from "./tools/index.mjs";
 import { defineAgent } from "./agents/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 "./models/index.mjs";
-import "./runtime/index.mjs";
-//#region src/core/index.ts
+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;
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "FevexConfigurationError";
+	}
+};
+//#endregion
+//#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";
 //#endregion
-//#region src/index.ts
-const invalidJsonValue = Symbol("invalid-json-value");
-function normalizeJsonValue(value, seen = /* @__PURE__ */ new WeakSet()) {
-	if (value === null || typeof value === "string" || typeof value === "boolean") return value;
-	if (typeof value === "number") return Number.isFinite(value) ? value : invalidJsonValue;
-	if (Array.isArray(value)) {
-		const normalized = [];
-		for (const item of value) {
-			const normalizedItem = normalizeJsonValue(item, seen);
-			if (normalizedItem === invalidJsonValue) return invalidJsonValue;
-			normalized.push(normalizedItem);
-		}
-		return normalized;
-	}
-	if (typeof value !== "object" || value === void 0) return invalidJsonValue;
-	const prototype = Object.getPrototypeOf(value);
-	if (prototype !== null && prototype !== Object.prototype) return invalidJsonValue;
-	if (seen.has(value)) return invalidJsonValue;
-	seen.add(value);
-	const normalized = {};
-	for (const [key, item] of Object.entries(value)) {
-		if (item === void 0) continue;
-		const normalizedItem = normalizeJsonValue(item, seen);
-		if (normalizedItem === invalidJsonValue) return invalidJsonValue;
-		normalized[key] = normalizedItem;
-	}
-	seen.delete(value);
-	return normalized;
-}
-function toJsonValue(value, errorMessage) {
-	let normalized;
-	try {
-		normalized = normalizeJsonValue(value);
-	} catch {
-		throw new TypeError(errorMessage);
-	}
-	if (normalized === invalidJsonValue) throw new TypeError(errorMessage);
-	return normalized;
-}
-function serializeJsonValue(value) {
-	return typeof value === "string" ? value : JSON.stringify(value);
-}
-function serializeValue(value, errorMessage) {
-	return serializeJsonValue(toJsonValue(value, errorMessage));
-}
+//#region src/internal/schemas.ts
 function isStandardSchema(value) {
 	if (typeof value !== "object" || value === null || !("~standard" in value)) return false;
 	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;
@@ -91,183 +64,3521 @@ async function validateSchema(schema, value, errorMessage) {
 	}
 	return result.value;
 }
-function toErrorMessage(error) {
-	if (error instanceof Error) return error.message;
-	if (typeof error === "string") return error;
-	try {
-		return JSON.stringify(error) ?? String(error);
-	} catch {
-		return String(error);
+//#endregion
+//#region src/internal/configuration.ts
+const REASONING_EFFORTS = /* @__PURE__ */ new Set([
+	"provider-default",
+	"none",
+	"minimal",
+	"low",
+	"medium",
+	"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);
+}
+function configurationError(code, message) {
+	return new FevexConfigurationError(code, message);
+}
+function assertConfiguration(condition, code, message) {
+	if (!condition) throw configurationError(code, message);
+}
+function isModelGateway(value) {
+	return (typeof value === "object" && value !== null || typeof value === "function") && typeof value.stream === "function";
+}
+function isRunStore(value) {
+	return (typeof value === "object" && value !== null || typeof value === "function") && [
+		"getRun",
+		"saveRun",
+		"getSession",
+		"saveSession",
+		"appendEvent",
+		"listEvents"
+	].every((method) => typeof value[method] === "function");
+}
+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 addUsage(first, second) {
-	if (!first) return second;
-	if (!second) return first;
-	const inputTokens = first.inputTokens === void 0 && second.inputTokens === void 0 ? void 0 : (first.inputTokens ?? 0) + (second.inputTokens ?? 0);
-	const outputTokens = first.outputTokens === void 0 && second.outputTokens === void 0 ? void 0 : (first.outputTokens ?? 0) + (second.outputTokens ?? 0);
-	const totalTokens = first.totalTokens === void 0 && second.totalTokens === void 0 ? void 0 : (first.totalTokens ?? 0) + (second.totalTokens ?? 0);
+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(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 {
-		...inputTokens !== void 0 ? { inputTokens } : {},
-		...outputTokens !== void 0 ? { outputTokens } : {},
-		...totalTokens !== void 0 ? { totalTokens } : {}
+		...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 createFevex(config) {
-	const models = new Map(Object.entries(config.models));
+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");
+		assertConfiguration(Array.isArray(config.observability.exporters) && config.observability.exporters.every((exporter) => isRecord(exporter) && typeof exporter.export === "function"), "INVALID_CONFIG", "Fevex config \"observability.exporters\" must contain TraceExporters");
+		assertConfiguration(config.observability.calculateCost === void 0 || typeof config.observability.calculateCost === "function", "INVALID_CONFIG", "Fevex config \"observability.calculateCost\" must be a function");
+		if (config.observability.content !== void 0) {
+			const content = config.observability.content;
+			assertConfiguration(isRecord(content) && Array.isArray(content.include) && content.include.every((kind) => [
+				"run.output",
+				"model.output",
+				"error.message"
+			].includes(kind)) && (content.redact === void 0 || typeof content.redact === "function"), "INVALID_CONFIG", "Fevex config \"observability.content\" is invalid");
+		}
+	}
+	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();
-	for (const [name, model] of models) {
-		if (!name.trim()) throw new Error("Model name cannot be empty");
-		if (!model || typeof model.generate !== "function") throw new Error(`Model "${name}" must implement generate`);
+	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, 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);
 	}
-	for (const tool of config.tools ?? []) {
-		if (!tool.name.trim()) throw new Error("Tool name cannot be empty");
-		if (tools.has(tool.name)) throw new Error(`Tool "${tool.name}" is duplicated`);
-		if (tool.inputSchema !== void 0) assertStandardSchema(tool.inputSchema, `Input schema for tool "${tool.name}" must implement Standard Schema`);
-		if (tool.outputSchema !== void 0) assertStandardSchema(tool.outputSchema, `Output schema for tool "${tool.name}" must implement Standard Schema`);
-		tools.set(tool.name, tool);
+	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`);
+		assertConfiguration(definition.risk === void 0 || [
+			"read",
+			"write",
+			"sensitive",
+			"destructive"
+		].includes(definition.risk), "INVALID_TOOL", `Tool "${name}" risk is invalid`);
+		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
+		});
 	}
-	for (const agent of config.agents) {
-		if (!agent.name.trim()) throw new Error("Agent name cannot be empty");
-		if (!agent.instructions.trim()) throw new Error(`Agent "${agent.name}" instructions cannot be empty`);
-		if (agents.has(agent.name)) throw new Error(`Agent "${agent.name}" is duplicated`);
-		if (agent.outputSchema !== void 0) assertStandardSchema(agent.outputSchema, `Output schema for agent "${agent.name}" must implement Standard Schema`);
-		agents.set(agent.name, agent);
+	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_POLICY", `Policy at index ${index} must have a name and authorize`);
+		policies.push({
+			name: policy.name,
+			authorize: policy.authorize
+		});
+	}
+	for (const [index, definition] of config.agents.entries()) {
+		assertConfiguration(isRecord(definition), "INVALID_AGENT", `Agent at index ${index} must be an object`);
+		assertConfiguration(typeof definition.name === "string", "INVALID_AGENT", "Agent name must be a string");
+		const name = definition.name;
+		assertConfiguration(name.trim(), "INVALID_AGENT", "Agent name cannot be empty");
+		assertConfiguration(typeof definition.instructions === "string", "INVALID_AGENT", `Agent "${name}" instructions must be a string`);
+		assertConfiguration(definition.instructions.trim(), "INVALID_AGENT", `Agent "${name}" instructions cannot be empty`);
+		assertConfiguration(!agents.has(name), "DUPLICATE_AGENT", `Agent "${name}" is duplicated`);
+		const model = definition.model;
+		if (model !== void 0) if (typeof model === "string") assertConfiguration(model.trim(), "INVALID_MODEL", `Model name required by agent "${name}" cannot be empty`);
+		else assertConfiguration(isModelGateway(model), "INVALID_MODEL", `Model for agent "${name}" must implement stream`);
+		let agentTools;
+		if (definition.tools !== void 0) {
+			assertConfiguration(Array.isArray(definition.tools), "INVALID_AGENT", `Agent "${name}" tools must be an array`);
+			agentTools = [];
+			const seenTools = /* @__PURE__ */ new Set();
+			for (const [toolIndex, toolName] of definition.tools.entries()) {
+				assertConfiguration(typeof toolName === "string" && Boolean(toolName.trim()), "INVALID_AGENT", `Tool name at index ${toolIndex} for agent "${name}" must be a non-empty string`);
+				assertConfiguration(!seenTools.has(toolName), "DUPLICATE_TOOL", `Tool "${toolName}" is duplicated in agent "${name}"`);
+				seenTools.add(toolName);
+				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;
+		assertLimit(rawLimits?.maxSteps, "maxSteps", 1, name);
+		assertLimit(rawLimits?.maxToolCalls, "maxToolCalls", 0, name);
+		assertLimit(rawLimits?.maxInputTokens, "maxInputTokens", 1, name, true);
+		assertLimit(rawLimits?.maxOutputTokens, "maxOutputTokens", 1, name, true);
+		agents.set(name, {
+			name,
+			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 },
+				...rawLimits.maxToolCalls === void 0 ? {} : { maxToolCalls: rawLimits.maxToolCalls },
+				...rawLimits.maxInputTokens === void 0 ? {} : { maxInputTokens: rawLimits.maxInputTokens },
+				...rawLimits.maxOutputTokens === void 0 ? {} : { maxOutputTokens: rawLimits.maxOutputTokens }
+			} }
+		});
 	}
 	for (const agent of agents.values()) {
-		if (typeof agent.model === "string" && !models.has(agent.model)) throw new Error(`Model "${agent.model}" required by agent "${agent.name}" is not registered`);
-		if (agent.model && typeof agent.model !== "string" && typeof agent.model.generate !== "function") throw new Error(`Model for agent "${agent.name}" must implement generate`);
-		if (!agent.model && !models.has("default")) throw new Error(`Default model "default" required by agent "${agent.name}" is not registered`);
-		for (const toolName of agent.tools ?? []) if (!tools.has(toolName)) throw new Error(`Tool "${toolName}" required by agent "${agent.name}" is not registered`);
+		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`);
 	}
-	return { async runAgent(name, request) {
-		const agent = agents.get(name);
-		if (!agent) throw new Error(`Agent "${name}" is not registered`);
-		const model = typeof agent.model === "string" ? models.get(agent.model) : agent.model ?? models.get("default");
-		const runId = globalThis.crypto.randomUUID();
-		const events = [];
-		const createEvent = (type, payload) => ({
-			type,
-			runId,
-			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-			...payload === void 0 ? {} : { payload }
+	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
 		});
-		const emit = (type, payload) => {
-			const event = createEvent(type, payload);
-			config.onEvent?.(event);
-			events.push(event);
+	}
+	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
 		};
-		const emitFailure = (type, payload) => {
-			const event = createEvent(type, payload);
-			try {
-				config.onEvent?.(event);
-			} catch {}
+		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 : {
+			exporters: [...config.observability.exporters],
+			...config.observability.calculateCost ? { calculateCost: config.observability.calculateCost } : {},
+			...config.observability.content ? { content: {
+				include: [...config.observability.content.include],
+				...config.observability.content.redact ? { redact: config.observability.content.redact } : {}
+			} } : {}
+		}
+	};
+}
+//#endregion
+//#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;
+	}
+};
+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/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)]));
+}
+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
+	};
+}
+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("");
+}
+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 subtractLimit(limit, used) {
+	if (limit === void 0 || limit === false) return limit;
+	return Math.max(0, limit - (used ?? 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 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 {
+		usage: addUsage(first?.usage, second.usage),
+		steps: (first?.steps ?? 0) + second.steps,
+		toolCalls: (first?.toolCalls ?? 0) + second.toolCalls
+	};
+}
+//#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
+		};
+		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
+		};
+		const state = {
+			run,
+			session,
+			request: {
+				...request,
+				sessionId: session.id,
+				signal
+			},
+			controller,
+			eventSequence: 0,
+			advancing: false
+		};
+		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)
+		};
+	};
+	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 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)
+		};
+	};
+	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 });
+		}
+	};
+	async function* executeAgent(name, state) {
+		const { request } = state;
+		const agent = agents.get(name);
+		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);
+			return event;
 		};
+		let inputContent;
+		let messages;
+		let usage;
+		let providerState;
+		let step;
+		let toolCallCount;
+		let seenToolCallIds;
+		let pendingTools;
+		let pendingIndex;
 		try {
-			emit("run.started");
-			request.signal?.throwIfAborted();
-			if (request.outputSchema !== void 0) assertStandardSchema(request.outputSchema, `Output schema for request to agent "${name}" must implement Standard Schema`);
-			const messages = [{
-				role: "system",
-				content: agent.instructions
-			}, {
-				role: "user",
-				content: serializeValue(request.input, "Run input must be a string or JSON-serializable value")
-			}];
-			const activeOutputSchema = request.outputSchema !== void 0 ? request.outputSchema : agent.outputSchema;
+			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;
+				messages = checkpoint.messages;
+				usage = checkpoint.usage;
+				providerState = checkpoint.providerState === void 0 ? void 0 : model.stateCodec?.restore(checkpoint.providerState);
+				step = checkpoint.step;
+				toolCallCount = checkpoint.toolCallCount;
+				seenToolCallIds = new Set(checkpoint.seenToolCallIds);
+				pendingTools = checkpoint.pendingTools;
+				pendingIndex = checkpoint.pendingIndex;
+			} else {
+				yield await emit("run.started", void 0);
+				request.signal.throwIfAborted();
+				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
+					}
+				];
+				step = 1;
+				toolCallCount = 0;
+				seenToolCallIds = /* @__PURE__ */ new Set();
+				pendingTools = [];
+				pendingIndex = 0;
+			}
+			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 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 && allTools.length ? allTools : void 0,
+						...modelToolChoice === void 0 ? {} : { toolChoice: modelToolChoice },
+						reasoning: state.request.reasoning ?? agent.reasoning,
+						modelOptions: agent.modelOptions,
+						outputSchema,
+						...remainingOutputTokens(effectiveLimits?.maxOutputTokens, usage) === void 0 ? {} : { maxOutputTokens: remainingOutputTokens(effectiveLimits?.maxOutputTokens, usage) },
+						...providerState === void 0 ? {} : { providerState },
+						signal: request.signal
+					});
+					let modelResult = await modelStream.next();
+					while (!modelResult.done) {
+						yield await emit("model.output.delta", {
+							step,
+							delta: modelResult.value
+						});
+						modelResult = await modelStream.next();
+					}
+					const result = modelResult.value;
+					providerState = result.providerState;
+					usage = addUsage(usage, result.usage);
+					const usagePayload = eventUsage(usage);
+					yield await emit("model.completed", {
+						step,
+						...usagePayload === void 0 ? {} : { usage: usagePayload }
+					});
+					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
+						}, {
+							role: "assistant",
+							content: serializeValue(output, "Output must be serializable")
+						});
+						state.session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+						Object.assign(state.run, {
+							status: "completed",
+							pause: void 0,
+							output,
+							...usage === void 0 ? {} : { usage },
+							updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+						});
+						const payload = { output };
+						const finalUsage = eventUsage(usage);
+						if (finalUsage) payload.usage = finalUsage;
+						const completed = createEvent(state, "run.completed", payload);
+						if (isDurableRunStore(runStore)) await commit(state, {
+							checkpoint: null,
+							session: state.session,
+							events: [completed]
+						});
+						else {
+							await runStore.saveSession(state.session);
+							await runStore.saveRun(state.run);
+							await runStore.appendEvent(completed);
+							notifyObserver(completed);
+						}
+						events.push(completed);
+						await releaseExecution(state);
+						yield completed;
+						return {
+							runId: state.run.id,
+							sessionId: state.session.id,
+							output,
+							events,
+							usage
+						};
+					}
+					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", 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) {
+						if (!call.id?.trim()) throw new Error("Tool call id cannot be empty");
+						if (!call.name?.trim()) throw new Error("Tool call name cannot be empty");
+						if (seenToolCallIds.has(call.id) || batch.has(call.id)) throw new Error(`Tool call id "${call.id}" is duplicated in run "${state.run.id}"`);
+						batch.add(call.id);
+						const tool = agent.tools?.includes(call.name) ? tools.get(call.name) : void 0;
+						if (!tool) throw new Error(`Tool "${call.name}" is not available to agent "${name}"`);
+						const rawInput = toJsonValue(call.input, `Input for tool "${call.name}" must be JSON-serializable`);
+						let validated;
+						try {
+							validated = tool.inputSchema === void 0 ? rawInput : await validateSchema(tool.inputSchema, rawInput, `Input for tool "${call.name}" does not match inputSchema`);
+						} catch (error) {
+							yield await emit("tool.failed", {
+								step,
+								toolCallId: call.id,
+								toolName: call.name,
+								error: toErrorMessage(error),
+								...toolErrorPayload(tool, error)
+							});
+							throw error;
+						}
+						pendingTools.push({
+							call: {
+								...call,
+								input: rawInput
+							},
+							input: toJsonValue(validated, `Input for tool "${call.name}" must be serializable`),
+							idempotencyKey: crypto.randomUUID(),
+							attempt: 0
+						});
+					}
+					for (const id of batch) seenToolCallIds.add(id);
+					messages.push({
+						role: "assistant",
+						content: result.output === void 0 ? "" : serializeValue(result.output, `Model output for agent "${name}" must be serializable`),
+						toolCalls: pendingTools.map(({ call }) => call)
+					});
+					pendingIndex = 0;
+				}
+				while (pendingIndex < pendingTools.length) {
+					request.signal.throwIfAborted();
+					const pending = pendingTools[pendingIndex];
+					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 && 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()
+						};
+						state.run.status = "paused";
+						state.run.pause = {
+							type: "approval",
+							approval
+						};
+						const requested = createEvent(state, "approval.requested", {
+							approvalId: approval.id,
+							toolCallId: approval.toolCallId,
+							toolName: approval.toolName,
+							...toolLabelPayload(tool),
+							...toolSourcePayload(tool)
+						});
+						const paused = createEvent(state, "run.paused", {
+							reason: "approval",
+							toolCallId: pending.call.id
+						});
+						await commit(state, {
+							checkpoint,
+							events: [requested, paused]
+						});
+						events.push(requested, paused);
+						await releaseExecution(state);
+						yield requested;
+						yield paused;
+						return void 0;
+					}
+					state.approvedToolCallId = void 0;
+					if (Boolean(durable && (state.checkpoint || tool.risk && tool.risk !== "read" || tool.idempotency === "keyed" || tool.retry || tool.credentials?.length || policies.length))) {
+						const checkpoint = await durableCheckpoint(state, model, modelName, messages, inputContent, usage, providerState, step, toolCallCount, seenToolCallIds, pendingTools, pendingIndex);
+						await commit(state, { checkpoint });
+						state.checkpoint = checkpoint;
+					}
+					if (record?.status === "completed") {
+						messages.push({
+							role: "tool",
+							name: pending.call.name,
+							toolCallId: pending.call.id,
+							content: serializeJsonValue(record.output)
+						});
+						toolCallCount += 1;
+						pendingIndex += 1;
+						continue;
+					}
+					if (record?.status === "started" && tool.idempotency !== "keyed" && state.forcedRetryToolCallId !== pending.call.id) {
+						const checkpoint = await durableCheckpoint(state, model, modelName, messages, inputContent, usage, providerState, step, toolCallCount, seenToolCallIds, pendingTools, pendingIndex);
+						state.run.status = "paused";
+						state.run.pause = {
+							type: "tool_execution_unknown",
+							toolCallId: pending.call.id,
+							toolName: pending.call.name,
+							input: pending.input
+						};
+						const unknown = createEvent(state, "tool.execution_unknown", {
+							step,
+							toolCallId: pending.call.id,
+							toolName: pending.call.name,
+							...toolSourcePayload(tool)
+						});
+						const paused = createEvent(state, "run.paused", {
+							reason: "tool_execution_unknown",
+							toolCallId: pending.call.id
+						});
+						await commit(state, {
+							checkpoint,
+							events: [unknown, paused]
+						});
+						events.push(unknown, paused);
+						await releaseExecution(state);
+						yield unknown;
+						yield paused;
+						return void 0;
+					}
+					const forcedRetry = state.forcedRetryToolCallId === pending.call.id;
+					state.forcedRetryToolCallId = void 0;
+					const configuredMaxAttempts = tool.retry?.maxAttempts ?? 1;
+					const maxAttempts = forcedRetry ? Math.max(configuredMaxAttempts, (record?.attempt ?? 0) + 1) : configuredMaxAttempts;
+					let output;
+					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()
+								};
+								state.run.status = "paused";
+								state.run.pause = {
+									type: "approval",
+									approval
+								};
+								const requested = createEvent(state, "approval.requested", {
+									approvalId: approval.id,
+									toolCallId: approval.toolCallId,
+									toolName: approval.toolName,
+									...toolLabelPayload(tool),
+									...toolSourcePayload(tool)
+								});
+								const paused = createEvent(state, "run.paused", {
+									reason: "approval",
+									toolCallId: pending.call.id
+								});
+								await commit(state, {
+									checkpoint,
+									events: [requested, paused]
+								});
+								events.push(requested, paused);
+								await releaseExecution(state);
+								yield requested;
+								yield paused;
+								return void 0;
+							}
+						}
+						attempt += 1;
+						const secrets = [];
+						const resolvedCredentials = /* @__PURE__ */ new Map();
+						for (const credentialName of tool.credentials ?? []) {
+							const value = await credentialStore?.resolve({
+								name: credentialName,
+								namespace: request.context?.namespace,
+								actor: request.context?.actor
+							});
+							if (!value) throw new FevexRunError("CREDENTIAL_NOT_FOUND", `Credential "${credentialName}" was not found`, state.run.id);
+							resolvedCredentials.set(credentialName, value);
+							secrets.push(value);
+						}
+						const getCredential = async (credentialName) => {
+							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,
+							toolName: pending.call.name,
+							input: pending.input,
+							status: "started",
+							attempt,
+							idempotencyKey: pending.idempotencyKey,
+							updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+						};
+						const started = createEvent(state, "tool.started", {
+							step,
+							toolCallId: pending.call.id,
+							toolName: pending.call.name,
+							...toolSourcePayload(tool),
+							...attempt > 1 ? { attempt } : {}
+						});
+						if (durable) await commit(state, {
+							toolExecution: record,
+							events: [started]
+						});
+						else {
+							await runStore.appendEvent(started);
+							notifyObserver(started);
+						}
+						events.push(started);
+						yield started;
+						try {
+							const raw = await abortable(() => tool.execute(pending.input, {
+								runId: state.run.id,
+								toolCallId: pending.call.id,
+								attempt,
+								idempotencyKey: pending.idempotencyKey,
+								getCredential,
+								...scopedSandbox === void 0 ? {} : { sandbox: scopedSandbox },
+								context: request.context,
+								signal: request.signal
+							}), request.signal);
+							output = toJsonValue(tool.outputSchema === void 0 ? raw : await validateSchema(tool.outputSchema, raw, `Output from tool "${tool.name}" does not match outputSchema`), `Output from tool "${tool.name}" must be JSON-serializable`);
+							if (containsSecret(output, secrets)) throw new Error(`Output from tool "${tool.name}" contains a credential`);
+							record = {
+								...record,
+								status: "completed",
+								output,
+								updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+							};
+							const completed = createEvent(state, "tool.completed", {
+								step,
+								toolCallId: pending.call.id,
+								toolName: pending.call.name,
+								...toolSourcePayload(tool),
+								...attempt > 1 ? { attempt } : {}
+							});
+							if (durable) await commit(state, {
+								toolExecution: record,
+								events: [completed]
+							});
+							else {
+								await runStore.appendEvent(completed);
+								notifyObserver(completed);
+							}
+							events.push(completed);
+							yield completed;
+							break;
+						} catch (error) {
+							if (request.signal.aborted) throw error;
+							const safeError = redact(toErrorMessage(error), secrets);
+							record = {
+								...record,
+								status: "failed",
+								error: safeError,
+								updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+							};
+							if (durable) await commit(state, { toolExecution: record });
+							if (attempt >= maxAttempts || tool.idempotency !== "keyed") {
+								yield await emit("tool.failed", {
+									step,
+									toolCallId: pending.call.id,
+									toolName: pending.call.name,
+									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,
+								...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
 			});
-			const result = await model.generate({
-				messages,
-				tools: agentTools.length > 0 ? agentTools : void 0,
-				reasoning: agent.reasoning,
-				modelOptions: agent.modelOptions,
-				outputSchema,
-				signal: request.signal
+			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]
 			});
-			emit("model.completed");
-			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 validateSchema(activeOutputSchema, result.output, `Output from agent "${name}" does not match outputSchema`), `Output from agent "${name}" must be JSON-serializable`);
-				emit("run.completed");
-				return {
-					output,
-					events,
-					usage: result.usage
-				};
+			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
 			}
-			if (result.toolCalls.length > 1) throw new Error(`Agent "${name}" requested multiple tools, but this runtime supports one tool call`);
-			const toolCall = result.toolCalls[0];
-			if (typeof toolCall.id !== "string" || !toolCall.id.trim()) throw new Error("Tool call id cannot be empty");
-			if (typeof toolCall.name !== "string" || !toolCall.name.trim()) throw new Error("Tool call name cannot be empty");
-			const assistantContent = result.output === void 0 ? "" : serializeValue(result.output, `Model output for agent "${name}" must be JSON-serializable`);
-			request.signal?.throwIfAborted();
-			let toolContent;
-			try {
-				const tool = agent.tools?.includes(toolCall.name) ? tools.get(toolCall.name) : void 0;
-				if (!tool) throw new Error(`Tool "${toolCall.name}" is not available to agent "${name}"`);
-				const rawToolInput = toJsonValue(toolCall.input, `Input for tool "${toolCall.name}" must be JSON-serializable`);
-				const toolInput = toJsonValue(tool.inputSchema === void 0 ? rawToolInput : await validateSchema(tool.inputSchema, rawToolInput, `Input for tool "${toolCall.name}" does not match inputSchema`), `Input for tool "${toolCall.name}" must be JSON-serializable`);
-				const rawToolOutput = await tool.execute(toolInput, {
-					runId,
-					toolCallId: toolCall.id,
-					context: request.context,
-					signal: request.signal
+		};
+		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: []
 				});
-				toolContent = serializeJsonValue(toJsonValue(tool.outputSchema === void 0 ? rawToolOutput : await validateSchema(tool.outputSchema, rawToolOutput, `Output from tool "${toolCall.name}" does not match outputSchema`), `Output from tool "${toolCall.name}" must be JSON-serializable`));
-			} catch (error) {
-				emitFailure("tool.failed", {
-					toolCallId: toolCall.id,
-					toolName: toolCall.name,
-					error: toErrorMessage(error)
+				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: []
 				});
-				throw error;
+				break;
 			}
-			emit("tool.completed", {
-				toolCallId: toolCall.id,
-				toolName: toolCall.name
+			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;
 			});
-			request.signal?.throwIfAborted();
-			const finalResult = await model.generate({
-				messages: [
-					...messages,
-					{
-						role: "assistant",
-						content: assistantContent,
-						toolCalls: [toolCall]
-					},
-					{
-						role: "tool",
-						name: toolCall.name,
-						toolCallId: toolCall.id,
-						content: toolContent
+		}, 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);
 					}
-				],
-				tools: void 0,
-				reasoning: agent.reasoning,
-				modelOptions: agent.modelOptions,
-				outputSchema,
-				signal: request.signal
+					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
+							});
+							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);
+					}
+					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)
+					});
+					await commitWorkflow(state, () => {}, [failed]);
+					events.push(failed);
+					throw error;
+				}
+			},
+			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);
+			}
+		};
+		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]
 			});
-			emit("model.completed");
-			if (finalResult.toolCalls?.length) throw new Error(`Agent "${name}" requested another tool, but this runtime supports one tool call`);
-			if (finalResult.output === void 0) throw new Error(`Model for agent "${name}" returned no output`);
-			const output = toJsonValue(activeOutputSchema === void 0 ? finalResult.output : await validateSchema(activeOutputSchema, finalResult.output, `Output from agent "${name}" does not match outputSchema`), `Output from agent "${name}" must be JSON-serializable`);
-			emit("run.completed");
+			events.push(completed);
+			await releaseWorkflowExecution(state);
+			yield completed;
 			return {
+				runId: state.run.id,
+				sessionId: state.session.id,
 				output,
 				events,
-				usage: addUsage(result.usage, finalResult.usage)
+				...state.run.usage === void 0 ? {} : { usage: state.run.usage }
 			};
 		} catch (error) {
-			emitFailure("run.failed", { error: toErrorMessage(error) });
+			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") {
+				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]
+				});
+				events.push(failed);
+				await releaseWorkflowExecution(state);
+				yield failed;
+			} else await releaseWorkflowExecution(state);
+			throw thrown;
+		}
+	}
+	const nextWorkflowEvent = async (state, execution) => {
+		state.advancing = true;
+		try {
+			return await execution.next();
+		} finally {
+			state.advancing = false;
+		}
+	};
+	const drainWorkflowExecution = async (name, state, throwOnPause) => {
+		const execution = executeWorkflow(name, state);
+		while (true) {
+			const next = await nextWorkflowEvent(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 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(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()}`;
+		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 {
+			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: 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()
+			};
+			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]
+				});
+				await releaseWorkflowExecution(state);
+				return structuredClone(run);
+			}
+			run.status = "running";
+			run.pause = void 0;
+			const resumed = createCoordinatorEvent(state, "workflow.run.resumed", void 0, "team.run.resumed");
+			await commit(state, {
+				checkpoint,
+				events: [resumed]
+			});
+			activeWorkflowRuns.set(runId, state);
+			activeSessions.add(session.id);
+			startLease(state, runStore);
+			drainWorkflowExecution(name, state, false).catch(() => {});
+			return structuredClone(run);
+		} catch (error) {
+			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);
+			drainExecution(name, state, false).catch(() => {});
+			return structuredClone(state.run);
+		},
+		async runAgent(name, request) {
+			const state = await prepareExecution(name, request);
+			return await drainExecution(name, state, true);
+		},
+		streamAgent(name, request) {
+			return { async *[Symbol.asyncIterator]() {
+				const state = await prepareExecution(name, request);
+				const execution = executeAgent(name, state);
+				let finished = false;
+				try {
+					while (true) {
+						const next = await nextEvent(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 nextEvent(state, execution)).done) break;
+						} catch {}
+						if (state.run.status === "running") await cancelExecution(state);
+					}
+					await execution.return(void 0);
+				}
+			} };
+		},
+		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);
+		},
+		listEvents(runId, options) {
+			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"));
+				if (!active.advancing) await cancelExecution(active);
+				return true;
+			}
+			const run = await runStore.getRun(runId);
+			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;
+			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 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");
+			if (activeSessions.has(sessionId)) throw new Error(`Session "${sessionId}" has an active run`);
+			const session = await runStore.getSession(sessionId);
+			if (!session) throw new Error(`Session "${sessionId}" does not exist`);
+			session.history = [{
+				role: "system",
+				content: summary
+			}];
+			session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+			await runStore.saveSession(session);
+			return structuredClone(session);
+		},
+		async flushObservability() {
+			while (pendingExports.size) await Promise.all([...pendingExports]);
+			if (exportFailures.length) {
+				const failures = exportFailures.splice(0);
+				throw new AggregateError(failures, "Observability export failed");
+			}
+		}
+	};
+}
+//#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 { SCHEMA_NOT_TRANSPORTABLE, createFevex, defineAgent, defineTool, 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 };