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

package/dist/{model-stream-u2xMsEaf.mjs → run-support-CmZ6Xo6H.mjs}

@@ -1,3 +1,4 @@
+import { t as FevexRunError } from "./run-error-Cr17wPGH.mjs";
 //#region src/internal/json.ts
 const invalidJsonValue = Symbol("invalid-json-value");
 function normalizeJsonValue(value, seen = /* @__PURE__ */ new WeakSet()) {
@@ -50,6 +51,45 @@ function serializeValue(value, errorMessage) {
 }
 //#endregion
 //#region src/internal/run-support.ts
+/** Largest delay accepted by Node and Bun timers. */
+const MAX_DEADLINE_MS = 2147483647;
+function deadlineAtFromMs(deadlineMs) {
+	if (deadlineMs === void 0) return void 0;
+	if (!Number.isSafeInteger(deadlineMs) || deadlineMs <= 0 || deadlineMs > 2147483647) throw new TypeError(`deadlineMs must be a positive safe integer up to ${MAX_DEADLINE_MS}`);
+	return new Date(Date.now() + deadlineMs).toISOString();
+}
+function runSignal(controller, request) {
+	const signals = [controller.signal];
+	if (request.signal) signals.push(request.signal);
+	if (request.deadlineMs !== void 0) {
+		deadlineAtFromMs(request.deadlineMs);
+		signals.push(AbortSignal.timeout(request.deadlineMs));
+	}
+	return AbortSignal.any(signals);
+}
+function resumeDeadlineSignal(deadlineAt, runId, code) {
+	if (deadlineAt === void 0) return void 0;
+	const expiresAt = Date.parse(deadlineAt);
+	if (!Number.isFinite(expiresAt)) throw new FevexRunError(code, `Run "${runId}" has an invalid deadline`, runId);
+	if (expiresAt <= Date.now()) throw new FevexRunError(code, `Run "${runId}" deadline has passed`, runId);
+	return AbortSignal.timeout(expiresAt - Date.now());
+}
+function remainingDeadlineMs(deadlineAt, runId) {
+	if (deadlineAt === void 0) return void 0;
+	const expiresAt = Date.parse(deadlineAt);
+	if (!Number.isFinite(expiresAt)) throw new FevexRunError("RUN_NOT_RESUMABLE", `Run "${runId}" has an invalid deadline`, runId);
+	const remaining = expiresAt - Date.now();
+	if (remaining <= 0) throw new FevexRunError("RUN_NOT_RESUMABLE", `Run "${runId}" deadline has passed`, runId);
+	return remaining;
+}
+function isTimeoutError(error) {
+	return typeof error === "object" && error !== null && error.name === "TimeoutError";
+}
+function minDeadline(first, second) {
+	if (first === void 0) return second;
+	if (second === void 0) return first;
+	return Math.min(first, second);
+}
 function toErrorMessage(error) {
 	if (error instanceof Error) return error.message;
 	if (typeof error === "string") return error;
@@ -119,133 +159,4 @@ function eventUsage(usage) {
 	return value;
 }
 //#endregion
-//#region src/internal/model-stream.ts
-const MAX_DELTA_CHARS = 512;
-const MAX_DELTA_DELAY_MS = 32;
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function canonicalJson(value) {
-	if (Array.isArray(value)) return value.map(canonicalJson);
-	if (!isRecord(value)) return value;
-	const prototype = Object.getPrototypeOf(value);
-	if (prototype !== Object.prototype && prototype !== null) return value;
-	return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, canonicalJson(item)]));
-}
-function assertConsistentOutput(result, outputText) {
-	if (result.output === void 0) {
-		if (outputText) throw new TypeError("Model stream emitted output without a final output");
-		return;
-	}
-	if (typeof result.output === "string") {
-		if (result.output !== outputText) throw new TypeError("Model stream deltas do not match the final output");
-		return;
-	}
-	if (!outputText) throw new TypeError("Model stream returned JSON output without output deltas");
-	let parsed;
-	try {
-		parsed = JSON.parse(outputText);
-	} catch (error) {
-		throw new TypeError("Model stream output deltas are not valid JSON", { cause: error });
-	}
-	if (JSON.stringify(canonicalJson(parsed)) !== JSON.stringify(canonicalJson(result.output))) throw new TypeError("Model stream deltas do not match the final JSON output");
-}
-function assertStreamEvent(value) {
-	if (!isRecord(value)) throw new TypeError("ModelGateway stream event must be an object");
-	if (value.type === "output.delta") {
-		if (typeof value.delta !== "string") throw new TypeError("ModelGateway output.delta must contain a string delta");
-		return;
-	}
-	if (value.type === "completed") {
-		if (!isRecord(value.result)) throw new TypeError("ModelGateway completed event must contain a result");
-		return;
-	}
-	throw new TypeError("ModelGateway returned an unknown stream event");
-}
-function takeCharacters(value, count) {
-	const characters = Array.from(value);
-	return [characters.slice(0, count).join(""), characters.slice(count).join("")];
-}
-async function* readModelStream(model, input) {
-	input.signal?.throwIfAborted();
-	const stream = model.stream(input);
-	if (!stream || typeof stream[Symbol.asyncIterator] !== "function") throw new TypeError("ModelGateway.stream must return an AsyncIterable");
-	const iterator = stream[Symbol.asyncIterator]();
-	let pending;
-	let completed;
-	let outputText = "";
-	let buffer = "";
-	let firstDelta = true;
-	let bufferedAt = 0;
-	const next = () => {
-		const promise = abortable(() => iterator.next(), input.signal);
-		promise.catch(() => {});
-		return promise;
-	};
-	try {
-		while (true) {
-			if (buffer && Array.from(buffer).length >= MAX_DELTA_CHARS) {
-				const [chunk, rest] = takeCharacters(buffer, MAX_DELTA_CHARS);
-				buffer = rest;
-				bufferedAt = performance.now();
-				yield chunk;
-				continue;
-			}
-			pending ??= next();
-			let item;
-			if (buffer) {
-				const remaining = Math.max(0, MAX_DELTA_DELAY_MS - (performance.now() - bufferedAt));
-				const raced = await Promise.race([pending.then((value) => ({
-					type: "item",
-					value
-				})), new Promise((resolve) => {
-					setTimeout(() => resolve({ type: "flush" }), remaining);
-				})]);
-				if (raced.type === "flush") {
-					const chunk = buffer;
-					buffer = "";
-					bufferedAt = 0;
-					yield chunk;
-					continue;
-				}
-				item = raced.value;
-			} else item = await pending;
-			pending = void 0;
-			if (item.done) {
-				if (!completed) throw new TypeError("ModelGateway stream ended without completed");
-				assertConsistentOutput(completed, outputText);
-				return completed;
-			}
-			assertStreamEvent(item.value);
-			if (completed) throw new TypeError("ModelGateway stream emitted an event after completed");
-			if (item.value.type === "completed") {
-				completed = item.value.result;
-				if (buffer) {
-					const chunk = buffer;
-					buffer = "";
-					bufferedAt = 0;
-					yield chunk;
-				}
-				continue;
-			}
-			if (!item.value.delta) continue;
-			outputText += item.value.delta;
-			buffer += item.value.delta;
-			if (firstDelta) {
-				const [chunk, rest] = takeCharacters(buffer, MAX_DELTA_CHARS);
-				firstDelta = false;
-				buffer = rest;
-				bufferedAt = performance.now();
-				yield chunk;
-			} else if (!bufferedAt) bufferedAt = performance.now();
-		}
-	} catch (error) {
-		if (buffer) yield buffer;
-		throw error;
-	} finally {
-		if (pending) pending.catch(() => {});
-		if (iterator.return) Promise.resolve(iterator.return()).catch(() => {});
-	}
-}
-//#endregion
-export { assertTokenBudget as a, remainingOutputTokens as c, serializeValue as d, toJsonValue as f, assertContinuationBudget as i, toErrorMessage as l, abortable as n, cancellationReason as o, addUsage as r, eventUsage as s, readModelStream as t, serializeJsonValue as u };
+export { serializeValue as _, assertTokenBudget as a, eventUsage as c, remainingDeadlineMs as d, remainingOutputTokens as f, serializeJsonValue as g, toErrorMessage as h, assertContinuationBudget as i, isTimeoutError as l, runSignal as m, abortable as n, cancellationReason as o, resumeDeadlineSignal as p, addUsage as r, deadlineAtFromMs as s, MAX_DEADLINE_MS as t, minDeadline as u, toJsonValue as v };

package/dist/runtime/index.d.mts

@@ -1,2 +1,2 @@
-import { C as isDurableRunStore, S as ToolExecutionStatus, _ as RunStore, a as DurableRunStore, b as ToolExecutionRecord, c as ListEventsOptions, d as RunCheckpoint, f as RunLease, g as RunStatus, h as RunResult, i as CredentialStore, l as PendingToolExecution, m as RunRequest, n as ApprovalRequest, o as ExecutionCommit, p as RunPause, r as ApprovalResolution, s as InMemoryRunStore, t as AgentRun, u as ResumeRunResolution, v as Session, x as ToolExecutionResolution, y as SessionId } from "../index-DGWOGXzc.mjs";
-export { AgentRun, ApprovalRequest, ApprovalResolution, CredentialStore, DurableRunStore, ExecutionCommit, InMemoryRunStore, ListEventsOptions, PendingToolExecution, ResumeRunResolution, RunCheckpoint, RunLease, RunPause, RunRequest, RunResult, RunStatus, RunStore, Session, SessionId, ToolExecutionRecord, ToolExecutionResolution, ToolExecutionStatus, isDurableRunStore };
+import { $ as SessionCompaction, A as ElicitationMode, B as ResumeRunResolution, C as ApprovalMode, D as CoordinatorRun, E as CoordinatorCheckpoint, F as ExecutionCreate, G as RunLease, H as RetainableRunStore, I as ListEventsOptions, J as RunRequest, K as RunPause, L as PendingToolExecution, M as ElicitationResolution, N as EventResolution, O as CredentialStore, P as ExecutionCommit, Q as Session, R as PurgeRunsOptions, S as AgentRunPause, T as ApprovalResolution, U as RunCheckpoint, V as RetainableRunStatus, W as RunCorrelation, X as RunStatus, Y as RunResult, Z as RunStore, _ as createDigestContextCompactor, _t as validatePurgeRunsOptions, at as ToolExecutionRecord, b as resolveContextBudget, c as InMemoryRunStore, ct as WorkflowBudgetUsage, d as ContextCompactionStats, dt as WorkflowRun, et as SessionId, f as ContextCompactor, ft as WorkflowStepRecord, g as ResolvedContextBudget, gt as validateListEventsOptions, h as ModelContextCompactorOptions, ht as isRetainableRunStore, it as TimerResolution, j as ElicitationRequest, k as DurableRunStore, l as ContextCompactionInput, lt as WorkflowCheckpoint, m as DigestContextCompactorOptions, mt as isDurableRunStore, nt as TeamCheckpoint, ot as ToolExecutionResolution, p as ContextTokenEstimator, pt as WorkflowWaitRecord, q as RunRecord, rt as TeamRun, st as ToolExecutionStatus, tt as StoredRunCheckpoint, u as ContextCompactionOptions, ut as WorkflowCompensationRecord, v as createModelContextCompactor, w as ApprovalRequest, x as AgentRun, y as estimateContextTokens, z as PurgeRunsResult } from "../index-lCCFokc6.mjs";
+export { AgentRun, AgentRunPause, ApprovalMode, ApprovalRequest, ApprovalResolution, ContextCompactionInput, ContextCompactionOptions, ContextCompactionStats, ContextCompactor, ContextTokenEstimator, CoordinatorCheckpoint, CoordinatorRun, CredentialStore, DigestContextCompactorOptions, DurableRunStore, ElicitationMode, ElicitationRequest, ElicitationResolution, EventResolution, ExecutionCommit, ExecutionCreate, InMemoryRunStore, ListEventsOptions, ModelContextCompactorOptions, PendingToolExecution, PurgeRunsOptions, PurgeRunsResult, ResolvedContextBudget, ResumeRunResolution, RetainableRunStatus, RetainableRunStore, RunCheckpoint, RunCorrelation, RunLease, RunPause, RunRecord, RunRequest, RunResult, RunStatus, RunStore, Session, SessionCompaction, SessionId, StoredRunCheckpoint, TeamCheckpoint, TeamRun, TimerResolution, ToolExecutionRecord, ToolExecutionResolution, ToolExecutionStatus, WorkflowBudgetUsage, WorkflowCheckpoint, WorkflowCompensationRecord, WorkflowRun, WorkflowStepRecord, WorkflowWaitRecord, createDigestContextCompactor, createModelContextCompactor, estimateContextTokens, isDurableRunStore, isRetainableRunStore, resolveContextBudget, validateListEventsOptions, validatePurgeRunsOptions };

package/dist/runtime/index.mjs

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

package/dist/sandbox/index.d.mts

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