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

package/dist/knowledge/index.d.mts

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

package/dist/knowledge/index.mjs

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

package/dist/model-stream-u2xMsEaf.mjs

@@ -0,0 +1,251 @@
+//#region src/internal/json.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;
+		Object.defineProperty(normalized, key, {
+			value: normalizedItem,
+			enumerable: true,
+			configurable: true,
+			writable: true
+		});
+	}
+	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));
+}
+//#endregion
+//#region src/internal/run-support.ts
+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);
+	}
+}
+async function abortable(operation, signal) {
+	signal?.throwIfAborted();
+	if (!signal) return await operation();
+	const result = await new Promise((resolve, reject) => {
+		let settled = false;
+		const finish = (callback) => {
+			if (settled) return;
+			settled = true;
+			signal.removeEventListener("abort", onAbort);
+			callback();
+		};
+		const onAbort = () => finish(() => reject(signal.reason));
+		signal.addEventListener("abort", onAbort, { once: true });
+		if (signal.aborted) {
+			onAbort();
+			return;
+		}
+		Promise.resolve().then(() => {
+			signal.throwIfAborted();
+			return operation();
+		}).then((value) => finish(() => resolve(value)), (error) => finish(() => reject(error)));
+	});
+	signal.throwIfAborted();
+	return result;
+}
+function cancellationReason(signal) {
+	return signal.reason instanceof Error && signal.reason.name === "TimeoutError" ? "timeout" : "aborted";
+}
+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 assertTokenBudget(agentName, limitName, usageName, limit, stepUsage, totalUsage) {
+	if (limit === void 0 || limit === false) return;
+	const stepTokens = stepUsage?.[usageName];
+	if (stepTokens === void 0 || !Number.isFinite(stepTokens) || stepTokens < 0) throw new Error(`Agent "${agentName}" cannot enforce ${limitName}: model usage.${usageName} is missing or invalid`);
+	if ((totalUsage?.[usageName] ?? 0) > limit) throw new Error(`Agent "${agentName}" exceeded ${limitName} limit of ${limit}`);
+}
+function assertContinuationBudget(agentName, limitName, usageName, limit, totalUsage) {
+	if (limit !== void 0 && limit !== false && (totalUsage?.[usageName] ?? 0) >= limit) throw new Error(`Agent "${agentName}" exhausted ${limitName} limit of ${limit} before completing`);
+}
+function remainingOutputTokens(limit, usage) {
+	if (limit === void 0 || limit === false) return void 0;
+	return limit - (usage?.outputTokens ?? 0);
+}
+function eventUsage(usage) {
+	if (usage === void 0) return void 0;
+	const value = toJsonValue(usage, "Model usage must be JSON-serializable");
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new TypeError("Model usage must be a JSON object");
+	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 };

package/dist/models/index.d.mts

@@ -1,27 +1,2 @@
-import { d as ToolCall, f as ToolSpec, o as JsonObject, r as AgentMessage } from "../index-D_RBJmVt.mjs";
-//#region src/models/index.d.ts
-type ReasoningEffort = 'provider-default' | 'none' | 'minimal' | 'low' | 'medium' | 'high';
-interface ModelUsage {
-  inputTokens?: number;
-  outputTokens?: number;
-  totalTokens?: number;
-}
-interface ModelGenerateInput {
-  messages: AgentMessage[];
-  tools?: ToolSpec[];
-  reasoning?: ReasoningEffort;
-  modelOptions?: Record<string, unknown>;
-  outputSchema?: JsonObject;
-  signal?: AbortSignal;
-}
-interface ModelGenerateResult<TOutput = unknown> {
-  output?: TOutput;
-  toolCalls?: ToolCall[];
-  usage?: ModelUsage;
-}
-interface ModelGateway {
-  generate(input: ModelGenerateInput): Promise<ModelGenerateResult>;
-}
-type ModelRef = string | ModelGateway;
-//#endregion
-export { ModelGateway, ModelGenerateInput, ModelGenerateResult, ModelRef, ModelUsage, ReasoningEffort };
+import { a as ModelResult, c as ReasoningEffort, i as ModelRef, l as ToolChoice, n as ModelInput, o as ModelStreamEvent, r as ModelMetadata, s as ModelUsage, t as ModelGateway } from "../index-CTIwrVf9.mjs";
+export { ModelGateway, ModelInput, ModelMetadata, ModelRef, ModelResult, ModelStreamEvent, ModelUsage, ReasoningEffort, ToolChoice };

package/dist/observability/index.d.mts

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

package/dist/observability/index.mjs

@@ -0,0 +1 @@
+export {};

package/dist/policies/index.d.mts

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

package/dist/policies/index.mjs

@@ -0,0 +1,6 @@
+//#region src/policies/policy.ts
+function definePolicy(policy) {
+	return policy;
+}
+//#endregion
+export { definePolicy };

package/dist/run-error-Cr17wPGH.mjs

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

package/dist/runtime/index.d.mts

@@ -1,17 +1,2 @@
-import { a as ExecutionContext, t as AgentEvent } from "../index-D_RBJmVt.mjs";
-import { ModelUsage } from "../models/index.mjs";
-import { StandardSchemaV1 } from "@standard-schema/spec";
-//#region src/runtime/index.d.ts
-interface RunRequest<TInput = unknown, TOutput = unknown> {
-  input: TInput;
-  context?: ExecutionContext;
-  outputSchema?: StandardSchemaV1<unknown, TOutput>;
-  signal?: AbortSignal;
-}
-interface RunResult<TOutput = unknown> {
-  output: TOutput;
-  events?: AgentEvent[];
-  usage?: ModelUsage;
-}
-//#endregion
-export { RunRequest, RunResult };
+import { A as RunStore, B as WorkflowBudgetUsage, C as RunCheckpoint, D as RunRequest, E as RunRecord, F as TeamRun, G as WorkflowWaitRecord, H as WorkflowCompensationRecord, I as TimerResolution, K as isDurableRunStore, L as ToolExecutionRecord, M as SessionId, N as StoredRunCheckpoint, O as RunResult, P as TeamCheckpoint, R as ToolExecutionResolution, S as ResumeRunResolution, T as RunPause, U as WorkflowRun, V as WorkflowCheckpoint, W as WorkflowStepRecord, _ as EventResolution, a as AgentRun, b as ListEventsOptions, c as ApprovalRequest, d as CoordinatorRun, f as CredentialStore, g as ElicitationResolution, h as ElicitationRequest, i as InMemoryRunStore, j as Session, k as RunStatus, l as ApprovalResolution, m as ElicitationMode, o as AgentRunPause, p as DurableRunStore, q as validateListEventsOptions, s as ApprovalMode, u as CoordinatorCheckpoint, v as ExecutionCommit, w as RunLease, x as PendingToolExecution, y as ExecutionCreate, z as ToolExecutionStatus } from "../index-Dx_LotWZ.mjs";
+export { AgentRun, AgentRunPause, ApprovalMode, ApprovalRequest, ApprovalResolution, CoordinatorCheckpoint, CoordinatorRun, CredentialStore, DurableRunStore, ElicitationMode, ElicitationRequest, ElicitationResolution, EventResolution, ExecutionCommit, ExecutionCreate, InMemoryRunStore, ListEventsOptions, PendingToolExecution, ResumeRunResolution, RunCheckpoint, RunLease, RunPause, RunRecord, RunRequest, RunResult, RunStatus, RunStore, Session, SessionId, StoredRunCheckpoint, TeamCheckpoint, TeamRun, TimerResolution, ToolExecutionRecord, ToolExecutionResolution, ToolExecutionStatus, WorkflowBudgetUsage, WorkflowCheckpoint, WorkflowCompensationRecord, WorkflowRun, WorkflowStepRecord, WorkflowWaitRecord, isDurableRunStore, validateListEventsOptions };

package/dist/runtime/index.mjs

@@ -1 +1,141 @@
-export {};
+import { t as FevexRunError } from "../run-error-Cr17wPGH.mjs";
+//#region src/runtime/run-store.ts
+function validateListEventsOptions(options) {
+	if (options.limit !== void 0 && (!Number.isSafeInteger(options.limit) || options.limit < 1)) throw new TypeError("Event limit must be a positive safe integer");
+	if (options.order !== void 0 && options.order !== "asc" && options.order !== "desc") throw new TypeError("Event order must be asc or desc");
+}
+function isDurableRunStore(store) {
+	const value = store;
+	return [
+		value.getCheckpoint,
+		value.getToolExecution,
+		value.createExecution,
+		value.commitExecution,
+		value.acquireLease,
+		value.renewLease,
+		value.releaseLease
+	].every((method) => typeof method === "function");
+}
+//#endregion
+//#region src/runtime/in-memory-run-store.ts
+/**
+* In-process durable store intended for development and tests.
+*
+* Values are cloned at the boundary so callers cannot mutate persisted state.
+* Data is lost when the process exits.
+*/
+var InMemoryRunStore = class {
+	#runs = /* @__PURE__ */ new Map();
+	#sessions = /* @__PURE__ */ new Map();
+	#events = /* @__PURE__ */ new Map();
+	#checkpoints = /* @__PURE__ */ new Map();
+	#toolExecutions = /* @__PURE__ */ new Map();
+	#leases = /* @__PURE__ */ new Map();
+	async getRun(runId) {
+		const run = this.#runs.get(runId);
+		return run === void 0 ? void 0 : structuredClone(run);
+	}
+	async saveRun(run) {
+		this.#runs.set(run.id, structuredClone(run));
+		if (!this.#events.has(run.id)) this.#events.set(run.id, []);
+	}
+	async getSession(sessionId) {
+		const session = this.#sessions.get(sessionId);
+		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) {
+		const events = this.#events.get(event.runId);
+		if (!events) throw new Error(`Run "${event.runId}" does not exist`);
+		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 FevexRunError("INVALID_CURSOR", `Event cursor "${options.after}" does not exist in run "${runId}"`, runId);
+			start = cursor + 1;
+		}
+		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);
+		return checkpoint === void 0 ? void 0 : structuredClone(checkpoint);
+	}
+	async getToolExecution(runId, toolCallId) {
+		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) {
+			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));
+		const events = this.#events.get(run.id);
+		if (!events) throw new Error(`Run "${run.id}" does not exist`);
+		for (const event of commit.events ?? []) events.push(structuredClone(event));
+		return true;
+	}
+	#sessionBusy(sessionId, exceptRunId) {
+		return [...this.#runs.values()].some((run) => run.sessionId === sessionId && run.id !== exceptRunId && (run.status === "running" || run.status === "paused"));
+	}
+	async acquireLease(lease) {
+		const current = this.#leases.get(lease.runId);
+		if (current && 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 || 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, 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, validateListEventsOptions };

package/dist/sandbox/index.d.mts

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