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

package/dist/index.mjs

@@ -1,55 +1,25 @@
-import { defineTool, toToolSpec } from "./tools/index.mjs";
 import { defineAgent } from "./agents/index.mjs";
+import { InMemoryRunStore, isDurableRunStore } from "./runtime/index.mjs";
+import { a as assertTokenBudget, c as remainingOutputTokens, d as serializeValue, f as toJsonValue, i as assertContinuationBudget, l as toErrorMessage, n as abortable, o as cancellationReason, r as addUsage, s as eventUsage, t as readModelStream, u as serializeJsonValue } from "./model-stream-u2xMsEaf.mjs";
+import { defineTool, toToolSpec } from "./tools/index.mjs";
 import "./models/index.mjs";
-import "./runtime/index.mjs";
+import { definePolicy } from "./policies/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/index.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"];
@@ -91,183 +61,1460 @@ 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"
+]);
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-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);
-	return {
-		...inputTokens !== void 0 ? { inputTokens } : {},
-		...outputTokens !== void 0 ? { outputTokens } : {},
-		...totalTokens !== void 0 ? { totalTokens } : {}
-	};
+function configurationError(code, message) {
+	return new FevexConfigurationError(code, message);
 }
-function createFevex(config) {
-	const models = new Map(Object.entries(config.models));
+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 assertLimit(value, name, minimum, agentName, allowFalse = false) {
+	if (value === void 0 || allowFalse && value === false) return;
+	if (typeof value !== "number" || !Number.isInteger(value) || value < minimum) throw configurationError("INVALID_AGENT", `Agent "${agentName}" limit "${name}" must be ${minimum === 0 ? "a non-negative" : "a positive"} integer${allowFalse ? " or false" : ""}`);
+}
+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.tools === void 0 || Array.isArray(config.tools), "INVALID_CONFIG", "Fevex config \"tools\" must be an array");
+	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.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 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`);
+	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 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);
+	for (const [index, definition] of (config.tools ?? []).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(!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`);
+		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.outputSchema !== void 0) assertConfiguration(isStandardSchema(definition.outputSchema), "INVALID_TOOL", `Output schema for tool "${name}" must implement Standard Schema`);
+		tools.set(name, {
+			name,
+			...definition.description === void 0 ? {} : { description: definition.description },
+			...definition.inputSchema === void 0 ? {} : { inputSchema: definition.inputSchema },
+			...definition.outputSchema === void 0 ? {} : { outputSchema: definition.outputSchema },
+			...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] },
+			execute: definition.execute
+		});
+	}
+	const policies = [];
+	for (const [index, policy] of (config.policies ?? []).entries()) {
+		assertConfiguration(isRecord(policy) && typeof policy.name === "string" && Boolean(policy.name.trim()) && typeof policy.authorize === "function", "INVALID_CONFIG", `Policy at index ${index} must have a name and authorize`);
+		policies.push({
+			name: policy.name,
+			authorize: policy.authorize
+		});
 	}
-	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);
+	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);
+			}
+		}
+		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.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 },
+			...definition.reasoning === void 0 ? {} : { reasoning: definition.reasoning },
+			...definition.modelOptions === void 0 ? {} : { modelOptions: { ...definition.modelOptions } },
+			...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`);
+	}
+	return {
+		models,
+		agents,
+		tools,
+		runStore: config.runStore ?? new InMemoryRunStore(),
+		credentialStore: config.credentialStore,
+		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/run-error.ts
+var FevexRunError = class extends Error {
+	code;
+	runId;
+	name = "FevexRunError";
+	constructor(code, message, runId, options) {
+		super(message, options);
+		this.code = code;
+		this.runId = runId;
 	}
-	return { async runAgent(name, request) {
+};
+var RunPausedError = class extends FevexRunError {
+	runId;
+	pause;
+	name = "RunPausedError";
+	constructor(runId, pause) {
+		super("RUN_PAUSED", `Run "${runId}" is paused`, runId);
+		this.runId = runId;
+		this.pause = pause;
+	}
+};
+//#endregion
+//#region src/internal/observability.ts
+const TERMINAL_TYPES = /* @__PURE__ */ new Set([
+	"run.completed",
+	"run.failed",
+	"run.cancelled"
+]);
+const SENSITIVE_KEY = /api[-_]?key|authorization|cookie|credential|password|secret|token/i;
+function durationMs(startedAt, endedAt) {
+	return Math.max(0, Date.parse(endedAt) - Date.parse(startedAt));
+}
+function traceStatus(event) {
+	if (event.type === "run.completed") return "completed";
+	if (event.type === "run.cancelled") return "cancelled";
+	return "failed";
+}
+function redactKeys(value) {
+	if (Array.isArray(value)) return value.map(redactKeys);
+	if (value === null || typeof value !== "object") return value;
+	const result = {};
+	for (const [key, item] of Object.entries(value)) result[key] = SENSITIVE_KEY.test(key) ? "[REDACTED]" : redactKeys(item);
+	return result;
+}
+function content(options, kind, value) {
+	if (!options.content?.include.includes(kind)) return void 0;
+	let parsed = value;
+	if (typeof value === "string") try {
+		parsed = JSON.parse(value);
+	} catch {}
+	const redacted = redactKeys(parsed);
+	const safe = options.content.redact ? options.content.redact({
+		kind,
+		value: redacted
+	}) : redacted;
+	return safe === void 0 ? void 0 : {
+		kind,
+		value: toJsonValue(safe, `TraceRedactor output for "${kind}" must be JSON-serializable`)
+	};
+}
+function usageFrom(value) {
+	if (!value) return void 0;
+	const usage = {};
+	if (typeof value.inputTokens === "number") usage.inputTokens = value.inputTokens;
+	if (typeof value.outputTokens === "number") usage.outputTokens = value.outputTokens;
+	if (typeof value.totalTokens === "number") usage.totalTokens = value.totalTokens;
+	return Object.keys(usage).length ? usage : void 0;
+}
+function subtractUsage(current, previous) {
+	if (!current) return void 0;
+	const usage = {};
+	for (const key of [
+		"inputTokens",
+		"outputTokens",
+		"totalTokens"
+	]) if (current[key] !== void 0) usage[key] = Math.max(0, current[key] - (previous[key] ?? 0));
+	return Object.keys(usage).length ? usage : void 0;
+}
+function costFor(options, modelRegistryName, model, usage) {
+	if (!options.calculateCost || !usage) return void 0;
+	const cost = options.calculateCost({
+		modelRegistryName,
+		model,
+		usage
+	});
+	if (!cost) return void 0;
+	if (!Number.isFinite(cost.amount) || cost.amount < 0 || !cost.currency.trim()) throw new TypeError("CostCalculator must return a non-negative amount and currency");
+	return {
+		amount: cost.amount,
+		currency: cost.currency
+	};
+}
+function annotation(event) {
+	switch (event.type) {
+		case "run.paused": return {
+			name: event.type,
+			timestamp: event.timestamp,
+			attributes: {
+				reason: event.payload.reason,
+				toolCallId: event.payload.toolCallId
+			}
+		};
+		case "run.resumed": return {
+			name: event.type,
+			timestamp: event.timestamp
+		};
+		case "approval.requested": return {
+			name: event.type,
+			timestamp: event.timestamp,
+			attributes: {
+				approvalId: event.payload.approvalId,
+				toolCallId: event.payload.toolCallId,
+				toolName: event.payload.toolName
+			}
+		};
+		case "approval.resolved": return {
+			name: event.type,
+			timestamp: event.timestamp,
+			attributes: {
+				approvalId: event.payload.approvalId,
+				toolCallId: event.payload.toolCallId,
+				decision: event.payload.decision
+			}
+		};
+		case "tool.retrying": return {
+			name: event.type,
+			timestamp: event.timestamp,
+			attributes: {
+				toolCallId: event.payload.toolCallId,
+				toolName: event.payload.toolName,
+				attempt: event.payload.attempt,
+				delayMs: event.payload.delayMs
+			}
+		};
+		case "tool.execution_unknown": return {
+			name: event.type,
+			timestamp: event.timestamp,
+			attributes: {
+				toolCallId: event.payload.toolCallId,
+				toolName: event.payload.toolName
+			}
+		};
+		default: return;
+	}
+}
+function buildRunTrace(run, rawEvents, modelRegistryName, model, options) {
+	const events = [...rawEvents].sort((left, right) => left.sequence - right.sequence);
+	const terminal = [...events].reverse().find((event) => TERMINAL_TYPES.has(event.type));
+	if (!terminal) throw new TypeError(`Run "${run.id}" has no terminal event`);
+	const started = events.find((event) => event.type === "run.started") ?? events[0];
+	if (!started) throw new TypeError(`Run "${run.id}" has no events`);
+	const status = traceStatus(terminal);
+	const annotations = [];
+	const spans = [];
+	const openModels = /* @__PURE__ */ new Map();
+	const openTools = /* @__PURE__ */ new Map();
+	const previousUsage = {};
+	const closeModel = (step, endedAt, spanStatus) => {
+		const open = openModels.get(step);
+		if (!open) return;
+		openModels.delete(step);
+		const completed = events.find((event) => event.type === "model.completed" && event.payload.step === step && event.sequence >= open.event.sequence);
+		const cumulative = completed?.type === "model.completed" ? usageFrom(completed.payload.usage) : void 0;
+		const usage = subtractUsage(cumulative, previousUsage);
+		if (cumulative) Object.assign(previousUsage, cumulative);
+		const spanContent = open.output.length ? content(options, "model.output", open.output.join("")) : void 0;
+		const span = {
+			id: open.event.id,
+			parentId: run.id,
+			kind: "model",
+			name: `model step ${step}`,
+			startedAt: open.event.timestamp,
+			endedAt,
+			durationMs: durationMs(open.event.timestamp, endedAt),
+			status: spanStatus,
+			attributes: {
+				step,
+				modelRegistryName
+			},
+			annotations: open.annotations,
+			...usage ? { usage } : {},
+			...spanContent ? { content: [spanContent] } : {}
+		};
+		const spanCost = costFor(options, modelRegistryName, model, usage);
+		if (spanCost) span.cost = spanCost;
+		spans.push(span);
+	};
+	const findOpenTool = (toolCallId) => {
+		const entries = [...openTools.entries()];
+		for (let index = entries.length - 1; index >= 0; index -= 1) {
+			const entry = entries[index];
+			const event = entry[1].event;
+			if (event.type === "tool.started" && event.payload.toolCallId === toolCallId) return entry;
+		}
+	};
+	const closeTool = (toolCallId, endedAt, spanStatus, error) => {
+		const entry = findOpenTool(toolCallId);
+		if (!entry) return;
+		const [key, open] = entry;
+		openTools.delete(key);
+		const event = open.event;
+		if (event.type !== "tool.started") return;
+		const errorContent = error ? content(options, "error.message", error) : void 0;
+		spans.push({
+			id: event.id,
+			parentId: run.id,
+			kind: "tool",
+			name: event.payload.toolName,
+			startedAt: event.timestamp,
+			endedAt,
+			durationMs: durationMs(event.timestamp, endedAt),
+			status: spanStatus,
+			attributes: {
+				step: event.payload.step,
+				toolCallId,
+				toolName: event.payload.toolName,
+				attempt: event.payload.attempt ?? 1
+			},
+			annotations: open.annotations,
+			...errorContent ? { content: [errorContent] } : {}
+		});
+	};
+	for (const event of events) {
+		const item = annotation(event);
+		if (item) annotations.push(item);
+		switch (event.type) {
+			case "model.started":
+				openModels.set(event.payload.step, {
+					event,
+					annotations: [],
+					output: []
+				});
+				break;
+			case "model.output.delta":
+				openModels.get(event.payload.step)?.output.push(event.payload.delta);
+				break;
+			case "model.completed":
+				closeModel(event.payload.step, event.timestamp, "completed");
+				break;
+			case "tool.started": {
+				const attempt = event.payload.attempt ?? 1;
+				openTools.set(`${event.payload.toolCallId}:${attempt}`, {
+					event,
+					annotations: [],
+					output: []
+				});
+				break;
+			}
+			case "tool.retrying": {
+				const open = findOpenTool(event.payload.toolCallId)?.[1];
+				const retry = annotation(event);
+				if (open && retry) open.annotations.push(retry);
+				closeTool(event.payload.toolCallId, event.timestamp, "failed", event.payload.error);
+				break;
+			}
+			case "tool.completed":
+				closeTool(event.payload.toolCallId, event.timestamp, "completed");
+				break;
+			case "tool.failed":
+				closeTool(event.payload.toolCallId, event.timestamp, "failed", event.payload.error);
+				break;
+			case "tool.execution_unknown":
+				closeTool(event.payload.toolCallId, event.timestamp, "failed");
+				break;
+		}
+	}
+	for (const step of [...openModels.keys()]) closeModel(step, terminal.timestamp, status);
+	for (const open of [...openTools.values()]) if (open.event.type === "tool.started") closeTool(open.event.payload.toolCallId, terminal.timestamp, status);
+	const finalUsage = run.usage ?? previousUsage;
+	const totalCost = costFor(options, modelRegistryName, model, finalUsage);
+	const traceContent = [];
+	if (terminal.type === "run.completed") {
+		const output = content(options, "run.output", terminal.payload.output);
+		if (output) traceContent.push(output);
+	} else if (terminal.type === "run.failed") {
+		const error = content(options, "error.message", terminal.payload.error);
+		if (error) traceContent.push(error);
+	}
+	return {
+		schemaVersion: "1",
+		traceId: run.id,
+		runId: run.id,
+		sessionId: run.sessionId,
+		agentName: run.agentName,
+		modelRegistryName,
+		...model ? { model: { ...model } } : {},
+		startedAt: started.timestamp,
+		endedAt: terminal.timestamp,
+		durationMs: durationMs(started.timestamp, terminal.timestamp),
+		status,
+		attributes: {
+			eventCount: events.length,
+			modelCallCount: spans.filter(({ kind }) => kind === "model").length,
+			toolCallCount: spans.filter(({ kind }) => kind === "tool").length
+		},
+		annotations,
+		spans,
+		...Object.keys(finalUsage).length ? { usage: { ...finalUsage } } : {},
+		...totalCost ? { cost: totalCost } : {},
+		...traceContent.length ? { content: traceContent } : {}
+	};
+}
+//#endregion
+//#region src/internal/runtime.ts
+const LEASE_MS = 3e4;
+const LEASE_RENEW_MS = 1e4;
+function redact(message, secrets) {
+	return secrets.reduce((safe, secret) => secret ? safe.split(secret).join("[REDACTED]") : safe, message);
+}
+function containsSecret(value, secrets) {
+	if (typeof value === "string") return secrets.some((secret) => secret && value.includes(secret));
+	if (Array.isArray(value)) return value.some((item) => containsSecret(item, secrets));
+	if (value && typeof value === "object") return Object.values(value).some((item) => containsSecret(item, secrets));
+	return false;
+}
+function canonicalize(value) {
+	if (Array.isArray(value)) return value.map(canonicalize);
+	if (typeof value !== "object" || value === null) return value;
+	return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, canonicalize(item)]));
+}
+async function definitionHash(name, modelName, agent, tools) {
+	const portable = JSON.stringify(canonicalize({
+		name,
+		modelName,
+		instructions: agent.instructions,
+		tools: (agent.tools ?? []).map((toolName) => {
+			const tool = tools.get(toolName);
+			return {
+				name: tool.name,
+				description: tool.description,
+				inputSchema: tool.inputSchema === void 0 ? void 0 : toTransportableSchema(tool.inputSchema, "input", `Input schema for tool "${tool.name}" is not transportable`),
+				outputSchema: tool.outputSchema === void 0 ? void 0 : toTransportableSchema(tool.outputSchema, "output", `Output schema for tool "${tool.name}" is not transportable`),
+				risk: tool.risk ?? "read",
+				approval: tool.approval ?? "never",
+				idempotency: tool.idempotency ?? "none",
+				retry: tool.retry,
+				credentials: tool.credentials ?? []
+			};
+		}),
+		reasoning: agent.reasoning,
+		modelOptions: agent.modelOptions,
+		limits: agent.limits,
+		outputSchema: agent.outputSchema === void 0 ? void 0 : toTransportableSchema(agent.outputSchema, "output", `Output schema for agent "${name}" is not transportable`)
+	}));
+	const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(portable));
+	return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function createRuntime({ models, agents, tools, runStore, credentialStore, policies, onEvent, observability }) {
+	const activeRuns = /* @__PURE__ */ new Map();
+	const activeSessions = /* @__PURE__ */ new Set();
+	const pendingExports = /* @__PURE__ */ new Set();
+	const exportFailures = [];
+	const exportedRuns = /* @__PURE__ */ new Set();
+	const runtimeOwner = crypto.randomUUID();
+	const scheduleTraceExport = (event) => {
+		if (!observability || ![
+			"run.completed",
+			"run.failed",
+			"run.cancelled"
+		].includes(event.type) || exportedRuns.has(event.runId)) return;
+		exportedRuns.add(event.runId);
+		let task;
+		task = (async () => {
+			const run = await runStore.getRun(event.runId);
+			if (!run) throw new Error(`Run "${event.runId}" does not exist`);
+			const agent = agents.get(run.agentName);
+			if (!agent) throw new Error(`Agent "${run.agentName}" is not registered`);
+			const modelRegistryName = typeof agent.model === "string" ? agent.model : "default";
+			const gateway = typeof agent.model === "string" ? models.get(agent.model) : agent.model ?? models.get("default");
+			const trace = buildRunTrace(run, await runStore.listEvents(run.id), modelRegistryName, gateway?.metadata, observability);
+			const failures = (await Promise.allSettled(observability.exporters.map((exporter) => Promise.resolve().then(() => exporter.export(trace))))).filter((result) => result.status === "rejected").map(({ reason }) => reason);
+			if (failures.length) throw new AggregateError(failures, "Trace export failed");
+		})().catch((error) => {
+			exportFailures.push(error);
+		}).finally(() => pendingExports.delete(task));
+		pendingExports.add(task);
+	};
+	const notifyObserver = (event) => {
+		scheduleTraceExport(event);
+		if (!onEvent) return;
+		try {
+			Promise.resolve(onEvent(event)).catch(() => {});
+		} catch {}
+	};
+	const createEvent = (state, type, payload) => ({
+		id: crypto.randomUUID(),
+		sequence: state.eventSequence += 1,
+		type,
+		runId: state.run.id,
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		...payload === void 0 ? {} : { payload }
+	});
+	const emitEvent = async (state, type, payload) => {
+		const event = createEvent(state, type, payload);
+		await runStore.appendEvent(event);
+		notifyObserver(event);
+		return event;
+	};
+	const releaseExecution = async (state) => {
+		activeRuns.delete(state.run.id);
+		activeSessions.delete(state.session.id);
+		if (state.leaseTimer) clearInterval(state.leaseTimer);
+		if (state.leaseOwner && isDurableRunStore(runStore)) await runStore.releaseLease(state.run.id, state.leaseOwner).catch(() => {});
+	};
+	const commit = async (state, options = {}) => {
+		if (!isDurableRunStore(runStore)) throw new FevexRunError("DURABLE_STORE_REQUIRED", "This run requires a DurableRunStore", state.run.id);
+		state.run.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+		if (!await runStore.commitExecution({
+			expectedRevision: state.run.revision,
+			run: state.run,
+			...options
+		})) throw new FevexRunError("RUN_CONFLICT", `Run "${state.run.id}" was modified`, state.run.id);
+		for (const event of options.events ?? []) notifyObserver(event);
+	};
+	const startLease = (state, store) => {
+		state.leaseTimer = setInterval(() => {
+			if (!state.leaseOwner || state.request.signal.aborted) return;
+			const expiresAt = new Date(Date.now() + LEASE_MS).toISOString();
+			store.renewLease({
+				runId: state.run.id,
+				ownerId: state.leaseOwner,
+				expiresAt
+			}).then((renewed) => {
+				if (!renewed) state.controller.abort(/* @__PURE__ */ new Error("Run lease was lost"));
+			});
+		}, LEASE_RENEW_MS);
+	};
+	const cancelExecution = async (state, reason = cancellationReason(state.request.signal)) => {
+		if (state.run.status === "completed" || state.run.status === "failed" || state.run.status === "cancelled") return;
+		Object.assign(state.run, {
+			status: "cancelled",
+			pause: void 0,
+			error: reason,
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		const event = createEvent(state, "run.cancelled", { reason });
+		if (isDurableRunStore(runStore)) await commit(state, {
+			checkpoint: null,
+			events: [event]
+		});
+		else {
+			await runStore.saveRun(state.run);
+			await runStore.appendEvent(event);
+			notifyObserver(event);
+		}
+		await releaseExecution(state);
+		return event;
+	};
+	const prepareExecution = async (name, request) => {
+		if (!agents.has(name)) throw new Error(`Agent "${name}" is not registered`);
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		let session;
+		if (request.sessionId === void 0) {
+			session = {
+				id: crypto.randomUUID(),
+				history: [],
+				createdAt: now,
+				updatedAt: now
+			};
+			await runStore.saveSession(session);
+		} else {
+			const stored = await runStore.getSession(request.sessionId);
+			if (!stored) throw new Error(`Session "${request.sessionId}" does not exist`);
+			session = stored;
+		}
+		if (activeSessions.has(session.id)) throw new Error(`Session "${session.id}" already has an active run`);
+		activeSessions.add(session.id);
+		const controller = new AbortController();
+		const signal = request.signal ? AbortSignal.any([controller.signal, request.signal]) : controller.signal;
+		const run = {
+			id: crypto.randomUUID(),
+			sessionId: session.id,
+			agentName: name,
+			status: "running",
+			revision: 0,
+			createdAt: now,
+			updatedAt: now
+		};
+		const state = {
+			run,
+			session,
+			request: {
+				...request,
+				sessionId: session.id,
+				signal
+			},
+			controller,
+			eventSequence: 0,
+			advancing: false
+		};
+		try {
+			await runStore.saveRun(run);
+		} catch (error) {
+			activeSessions.delete(session.id);
+			throw error;
+		}
+		activeRuns.set(run.id, state);
+		return state;
+	};
+	const authorize = async (state, tool, input, action, context = state.request.context) => {
+		let approval = false;
+		for (const policy of policies) {
+			const decision = await policy.authorize({
+				runId: state.run.id,
+				agentName: state.run.agentName,
+				toolName: tool.name,
+				risk: tool.risk ?? "read",
+				input,
+				action,
+				context
+			});
+			if (decision === "deny") throw new FevexRunError("POLICY_DENIED", `Policy "${policy.name}" denied tool "${tool.name}"`, state.run.id);
+			if (decision === "require_approval") approval = true;
+		}
+		return approval ? "require_approval" : "allow";
+	};
+	const durableCheckpoint = async (state, model, modelName, messages, inputContent, usage, providerState, step, toolCallCount, seenToolCallIds, pendingTools, pendingIndex) => {
+		const agent = agents.get(state.run.agentName);
+		if (agent.model !== void 0 && typeof agent.model !== "string") throw new FevexRunError("RUN_NOT_RESUMABLE", "Durable continuation requires a named model", state.run.id);
+		if (state.request.outputSchema !== void 0) throw new FevexRunError("RUN_NOT_RESUMABLE", "Durable runs must declare outputSchema on the agent", state.run.id);
+		let serializedState;
+		if (providerState !== void 0) {
+			if (!model.stateCodec) throw new FevexRunError("RUN_NOT_RESUMABLE", "ModelGateway must provide stateCodec for durable continuation", state.run.id);
+			serializedState = toJsonValue(model.stateCodec.serialize(providerState), "Model provider state must be JSON-serializable");
+		}
+		return {
+			runId: state.run.id,
+			definitionHash: await definitionHash(state.run.agentName, modelName, agent, tools),
+			messages: structuredClone(messages),
+			inputContent,
+			context: state.request.context,
+			usage,
+			providerState: serializedState,
+			step,
+			toolCallCount,
+			seenToolCallIds: [...seenToolCallIds],
+			pendingTools: structuredClone(pendingTools),
+			pendingIndex
+		};
+	};
+	async function* executeAgent(name, state) {
+		const { request } = state;
 		const agent = agents.get(name);
-		if (!agent) throw new Error(`Agent "${name}" is not registered`);
+		const modelName = typeof agent.model === "string" ? agent.model : "default";
 		const model = typeof agent.model === "string" ? models.get(agent.model) : agent.model ?? models.get("default");
-		const runId = globalThis.crypto.randomUUID();
 		const events = [];
-		const createEvent = (type, payload) => ({
-			type,
-			runId,
-			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-			...payload === void 0 ? {} : { payload }
-		});
-		const emit = (type, payload) => {
-			const event = createEvent(type, payload);
-			config.onEvent?.(event);
-			events.push(event);
-		};
-		const emitFailure = (type, payload) => {
-			const event = createEvent(type, payload);
-			try {
-				config.onEvent?.(event);
-			} catch {}
+		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;
+			if (state.checkpoint) {
+				const checkpoint = state.checkpoint;
+				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();
+				if (request.outputSchema !== void 0) assertStandardSchema(request.outputSchema, `Output schema for request to agent "${name}" must implement Standard Schema`);
+				inputContent = serializeValue(request.input, "Run input must be a string or JSON-serializable value");
+				messages = [
+					{
+						role: "system",
+						content: agent.instructions
+					},
+					...state.session.history,
+					{
+						role: "user",
+						content: inputContent
+					}
+				];
+				step = 1;
+				toolCallCount = 0;
+				seenToolCallIds = /* @__PURE__ */ new Set();
+				pendingTools = [];
+				pendingIndex = 0;
+			}
+			const activeOutputSchema = request.outputSchema ?? 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 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 result = await model.generate({
-				messages,
-				tools: agentTools.length > 0 ? agentTools : void 0,
-				reasoning: agent.reasoning,
-				modelOptions: agent.modelOptions,
-				outputSchema,
-				signal: request.signal
-			});
-			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
-				};
+			const maxSteps = agent.limits?.maxSteps ?? 8;
+			const maxToolCalls = agent.limits?.maxToolCalls ?? 16;
+			while (step <= maxSteps) {
+				request.signal.throwIfAborted();
+				if (pendingTools.length === 0) {
+					const hasToolBudget = step < maxSteps && toolCallCount < maxToolCalls;
+					yield await emit("model.started", { step });
+					const modelStream = readModelStream(model, {
+						messages: [...messages],
+						tools: hasToolBudget && agentTools.length ? agentTools : void 0,
+						reasoning: agent.reasoning,
+						modelOptions: agent.modelOptions,
+						outputSchema,
+						...remainingOutputTokens(agent.limits?.maxOutputTokens, usage) === void 0 ? {} : { maxOutputTokens: remainingOutputTokens(agent.limits?.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", agent.limits?.maxInputTokens, result.usage, usage);
+					assertTokenBudget(name, "maxOutputTokens", "outputTokens", agent.limits?.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`);
+						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", agent.limits?.maxInputTokens, usage);
+					assertContinuationBudget(name, "maxOutputTokens", "outputTokens", agent.limits?.maxOutputTokens, usage);
+					if (result.toolCalls.length > maxToolCalls - toolCallCount) throw new Error(`Agent "${name}" exceeded maxToolCalls limit of ${maxToolCalls}`);
+					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)
+							});
+							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);
+					const policy = await authorize(state, tool, pending.input, "tool.execute");
+					if ((tool.approval === "required" || policy === "require_approval") && state.approvedToolCallId !== pending.call.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,
+							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
+						});
+						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;
+					}
+					let record = durable ? await durable.getToolExecution(state.run.id, pending.call.id) : void 0;
+					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
+						});
+						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;
+					}
+					state.forcedRetryToolCallId = void 0;
+					const maxAttempts = tool.retry?.maxAttempts ?? 1;
+					let output;
+					let attempt = record?.attempt ?? 0;
+					while (attempt < maxAttempts) {
+						if (attempt > 0) {
+							if (await authorize(state, tool, pending.input, "tool.execute") === "require_approval") {
+								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,
+									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
+								});
+								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);
+						};
+						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,
+							...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,
+								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,
+								...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
+								});
+								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
+							});
+							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;
 			}
-			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
+			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()
 				});
-				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)
+				const failed = createEvent(state, "run.failed", { error: toErrorMessage(error) });
+				if (isDurableRunStore(runStore)) await commit(state, {
+					checkpoint: null,
+					events: [failed]
 				});
-				throw error;
+				else {
+					await runStore.saveRun(state.run);
+					await runStore.appendEvent(failed);
+					notifyObserver(failed);
+				}
+				events.push(failed);
+				await releaseExecution(state);
+				yield failed;
 			}
-			emit("tool.completed", {
-				toolCallId: toolCall.id,
-				toolName: toolCall.name
-			});
-			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
-					}
-				],
-				tools: void 0,
-				reasoning: agent.reasoning,
-				modelOptions: agent.modelOptions,
-				outputSchema,
-				signal: request.signal
-			});
-			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");
-			return {
-				output,
-				events,
-				usage: addUsage(result.usage, finalResult.usage)
+			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 resume = async (runId, resolution) => {
+		if (!isDurableRunStore(runStore)) throw new FevexRunError("DURABLE_STORE_REQUIRED", "resumeRun requires DurableRunStore", runId);
+		const run = await runStore.getRun(runId);
+		const checkpoint = await runStore.getCheckpoint(runId);
+		if (!run || !checkpoint) throw new FevexRunError("RUN_NOT_RESUMABLE", `Run "${runId}" cannot be resumed`, runId);
+		if (run.status !== "paused" && run.status !== "running") throw new FevexRunError("RUN_NOT_RESUMABLE", `Run "${runId}" is terminal`, runId);
+		const agent = agents.get(run.agentName);
+		if (!agent) throw new FevexRunError("RUN_DEFINITION_CHANGED", `Agent "${run.agentName}" is unavailable`, runId);
+		const modelName = typeof agent.model === "string" ? agent.model : "default";
+		const model = typeof agent.model === "string" ? models.get(agent.model) : agent.model ?? models.get("default");
+		if (!model || checkpoint.definitionHash !== await definitionHash(run.agentName, modelName, agent, tools)) throw new FevexRunError("RUN_DEFINITION_CHANGED", `Definition for agent "${run.agentName}" changed`, runId);
+		if (checkpoint.providerState !== void 0 && !model.stateCodec) throw new FevexRunError("RUN_NOT_RESUMABLE", "ModelGateway no longer provides its stateCodec", runId);
+		const session = await runStore.getSession(run.sessionId);
+		if (!session) throw new Error(`Session "${run.sessionId}" does not exist`);
+		if (activeSessions.has(session.id)) throw new FevexRunError("RUN_CONFLICT", `Session "${session.id}" is active`, runId);
+		const ownerId = `${runtimeOwner}:${crypto.randomUUID()}`;
+		if (!await runStore.acquireLease({
+			runId,
+			ownerId,
+			expiresAt: new Date(Date.now() + LEASE_MS).toISOString()
+		})) throw new FevexRunError("RUN_CONFLICT", `Run "${runId}" is leased`, runId);
+		try {
+			const controller = new AbortController();
+			const state = {
+				run,
+				session,
+				request: {
+					input: "",
+					sessionId: session.id,
+					context: checkpoint.context,
+					signal: controller.signal
+				},
+				controller,
+				eventSequence: (await runStore.listEvents(runId)).at(-1)?.sequence ?? 0,
+				advancing: false,
+				checkpoint,
+				leaseOwner: ownerId,
+				...resolution.type === "approval" ? { approvedToolCallId: run.pause?.type === "approval" ? run.pause.approval.toolCallId : void 0 } : {
+					approvedToolCallId: resolution.toolCallId,
+					...resolution.decision === "retry" ? { forcedRetryToolCallId: resolution.toolCallId } : {}
+				}
 			};
+			if (!resolution.actor?.id?.trim()) {
+				await runStore.releaseLease(runId, ownerId);
+				throw new FevexRunError("APPROVAL_INVALID", "Resolution actor is required", runId);
+			}
+			if (resolution.type === "approval") {
+				if (run.pause?.type !== "approval" || run.pause.approval.id !== resolution.approvalId) {
+					await runStore.releaseLease(runId, ownerId);
+					throw new FevexRunError("APPROVAL_INVALID", "Approval does not match the run", runId);
+				}
+				const pending = checkpoint.pendingTools[checkpoint.pendingIndex];
+				const tool = pending && tools.get(pending.call.name);
+				if (!pending || !tool) {
+					await runStore.releaseLease(runId, ownerId);
+					throw new FevexRunError("APPROVAL_INVALID", "Approval tool is unavailable", runId);
+				}
+				if (resolution.decision === "approve") await authorize(state, tool, pending.input, "approval.resolve", {
+					...state.request.context,
+					actor: resolution.actor
+				});
+				if (resolution.decision === "reject") {
+					const toolCallId = run.pause.approval.toolCallId;
+					run.status = "cancelled";
+					run.pause = void 0;
+					run.error = "approval_rejected";
+					const resolved = createEvent(state, "approval.resolved", {
+						approvalId: resolution.approvalId,
+						toolCallId,
+						decision: "reject",
+						actorId: resolution.actor.id
+					});
+					const cancelled = createEvent(state, "run.cancelled", { reason: "approval_rejected" });
+					await commit(state, {
+						checkpoint: null,
+						events: [resolved, cancelled]
+					});
+					await releaseExecution(state);
+					return structuredClone(run);
+				}
+			} else {
+				const pending = checkpoint.pendingTools[checkpoint.pendingIndex];
+				const record = await runStore.getToolExecution(runId, resolution.toolCallId);
+				const matchesUnknownPause = run.pause?.type === "tool_execution_unknown" && run.pause.toolCallId === resolution.toolCallId;
+				const matchesInterruptedAttempt = run.status === "running" && pending?.call.id === resolution.toolCallId && (record?.status === "started" || record?.status === "completed");
+				if (!matchesUnknownPause && !matchesInterruptedAttempt) {
+					await runStore.releaseLease(runId, ownerId);
+					throw new FevexRunError("RUN_NOT_RESUMABLE", "Tool execution resolution does not match a pending attempt", runId);
+				}
+			}
+			if (resolution.type === "tool_execution" && resolution.decision === "use_output") {
+				const pending = checkpoint.pendingTools[checkpoint.pendingIndex];
+				const tool = tools.get(pending.call.name);
+				if (!tool) {
+					await runStore.releaseLease(runId, ownerId);
+					throw new FevexRunError("RUN_DEFINITION_CHANGED", "Pending tool is unavailable", runId);
+				}
+				const output = toJsonValue(tool.outputSchema === void 0 ? resolution.output : await validateSchema(tool.outputSchema, resolution.output, `Manual output for tool "${tool.name}" does not match outputSchema`), "Manual tool output must be JSON-serializable");
+				const current = await runStore.getToolExecution(runId, resolution.toolCallId);
+				await commit(state, { toolExecution: {
+					runId,
+					toolCallId: resolution.toolCallId,
+					toolName: pending.call.name,
+					input: pending.input,
+					status: "completed",
+					attempt: current?.attempt ?? 1,
+					idempotencyKey: current?.idempotencyKey ?? pending.idempotencyKey,
+					output,
+					updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+				} });
+			}
+			const approval = run.pause?.type === "approval" ? run.pause.approval : void 0;
+			run.status = "running";
+			run.pause = void 0;
+			const resumeEvents = [createEvent(state, "run.resumed", void 0)];
+			if (approval && resolution.type === "approval") resumeEvents.push(createEvent(state, "approval.resolved", {
+				approvalId: approval.id,
+				toolCallId: approval.toolCallId,
+				decision: "approve",
+				actorId: resolution.actor.id
+			}));
+			await commit(state, {
+				checkpoint,
+				events: resumeEvents
+			});
+			activeRuns.set(runId, state);
+			activeSessions.add(session.id);
+			startLease(state, runStore);
+			drainExecution(run.agentName, state, false).catch(() => {});
+			return structuredClone(run);
 		} catch (error) {
-			emitFailure("run.failed", { error: toErrorMessage(error) });
+			await runStore.releaseLease(runId, ownerId).catch(() => {});
 			throw error;
 		}
-	} };
+	};
+	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);
+				}
+			} };
+		},
+		getRun(runId) {
+			return runStore.getRun(runId);
+		},
+		listEvents(runId, options) {
+			return runStore.listEvents(runId, options);
+		},
+		async cancelRun(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;
+			}
+			const run = await runStore.getRun(runId);
+			if (run?.status !== "paused") return false;
+			if (!isDurableRunStore(runStore)) return false;
+			const session = await runStore.getSession(run.sessionId);
+			if (!session) return false;
+			const state = {
+				run,
+				session,
+				request: {
+					input: "",
+					sessionId: session.id,
+					signal: new AbortController().signal
+				},
+				controller: new AbortController(),
+				eventSequence: (await runStore.listEvents(runId)).at(-1)?.sequence ?? 0,
+				advancing: false
+			};
+			run.status = "cancelled";
+			run.pause = void 0;
+			run.error = "aborted";
+			const cancelled = createEvent(state, "run.cancelled", { reason: "aborted" });
+			try {
+				await commit(state, {
+					checkpoint: null,
+					events: [cancelled]
+				});
+				return true;
+			} catch (error) {
+				if (error instanceof FevexRunError && error.code === "RUN_CONFLICT" && (await runStore.getRun(runId))?.status !== "paused") return false;
+				throw error;
+			}
+		},
+		resumeRun(runId, resolution) {
+			return resume(runId, resolution);
+		},
+		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
+function createFevex(config) {
+	return createRuntime(createComposition(config));
 }
 //#endregion
-export { SCHEMA_NOT_TRANSPORTABLE, createFevex, defineAgent, defineTool, toToolSpec };
+export { FevexConfigurationError, FevexRunError, InMemoryRunStore, PROVIDER_REASONING_UNSUPPORTED, PROVIDER_SCHEMA_UNSUPPORTED, RunPausedError, SCHEMA_NOT_TRANSPORTABLE, createFevex, defineAgent, definePolicy, defineTool, isDurableRunStore, toToolSpec };