@fevex/core 0.1.0-alpha.4 → 0.1.0-alpha.6

package/dist/knowledge/index.d.mts

@@ -1,2 +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-hhbgvfIt.mjs";
+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-BJktlD4E.mjs";
 export { ContextBlock, ContextProvider, InMemoryMemoryStore, KnowledgeContext, MemoryQuery, MemoryRecord, MemoryStore, MemoryWrite, SkillDefinition, createMemoryContextProvider, defineContextProvider, defineSkill };

package/dist/model-stream-JQdHDDcj.mjs

@@ -0,0 +1,131 @@
+import { n as abortable } from "./run-support-CmZ6Xo6H.mjs";
+//#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 { readModelStream as t };

package/dist/models/index.d.mts

@@ -1,2 +1,2 @@
-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";
+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-BgKFd9yw.mjs";
 export { ModelGateway, ModelInput, ModelMetadata, ModelRef, ModelResult, ModelStreamEvent, ModelUsage, ReasoningEffort, ToolChoice };

package/dist/observability/index.d.mts

@@ -1,2 +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-voIZhQXB.mjs";
-export { CostCalculator, CostCalculatorInput, ObservabilityOptions, RunTrace, TraceAnnotation, TraceContent, TraceContentKind, TraceContentPolicy, TraceCost, TraceExporter, TraceRedactor, TraceRedactorInput, TraceSpan, TraceSpanKind, TraceStatus };
+import { _ as TraceSpanKind, a as RunTrace, c as TraceContentKind, d as TraceExportQueueOptions, f as TraceExporter, g as TraceSpan, h as TraceRunKind, i as ObservabilityStats, l as TraceContentPolicy, m as TraceRedactorInput, n as CostCalculatorInput, o as TraceAnnotation, p as TraceRedactor, r as ObservabilityOptions, s as TraceContent, t as CostCalculator, u as TraceCost, v as TraceStatus } from "../index-CpLDt6Rw.mjs";
+export { CostCalculator, CostCalculatorInput, ObservabilityOptions, ObservabilityStats, RunTrace, TraceAnnotation, TraceContent, TraceContentKind, TraceContentPolicy, TraceCost, TraceExportQueueOptions, TraceExporter, TraceRedactor, TraceRedactorInput, TraceRunKind, TraceSpan, TraceSpanKind, TraceStatus };

package/dist/policies/index.d.mts

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

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 { 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-CaE864Kz.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 };
+import { $ as validateListEventsOptions, A as RunPause, B as TeamRun, C as PurgeRunsResult, D as RunCheckpoint, E as RetainableRunStore, F as RunStore, G as WorkflowBudgetUsage, H as ToolExecutionRecord, I as Session, J as WorkflowRun, K as WorkflowCheckpoint, L as SessionId, M as RunRequest, N as RunResult, O as RunCorrelation, P as RunStatus, Q as isRetainableRunStore, R as StoredRunCheckpoint, S as PurgeRunsOptions, T as RetainableRunStatus, U as ToolExecutionResolution, V as TimerResolution, W as ToolExecutionStatus, X as WorkflowWaitRecord, Y as WorkflowStepRecord, Z as isDurableRunStore, _ as EventResolution, a as AgentRun, b as ListEventsOptions, c as ApprovalRequest, d as CoordinatorRun, et as validatePurgeRunsOptions, f as CredentialStore, g as ElicitationResolution, h as ElicitationRequest, i as InMemoryRunStore, j as RunRecord, k as RunLease, l as ApprovalResolution, m as ElicitationMode, o as AgentRunPause, p as DurableRunStore, q as WorkflowCompensationRecord, s as ApprovalMode, u as CoordinatorCheckpoint, v as ExecutionCommit, w as ResumeRunResolution, x as PendingToolExecution, y as ExecutionCreate, z as TeamCheckpoint } from "../index-CzAi2Y_Z.mjs";
+export { AgentRun, AgentRunPause, ApprovalMode, ApprovalRequest, ApprovalResolution, CoordinatorCheckpoint, CoordinatorRun, CredentialStore, DurableRunStore, ElicitationMode, ElicitationRequest, ElicitationResolution, EventResolution, ExecutionCommit, ExecutionCreate, InMemoryRunStore, ListEventsOptions, PendingToolExecution, PurgeRunsOptions, PurgeRunsResult, ResumeRunResolution, RetainableRunStatus, RetainableRunStore, RunCheckpoint, RunCorrelation, RunLease, RunPause, RunRecord, RunRequest, RunResult, RunStatus, RunStore, Session, SessionId, StoredRunCheckpoint, TeamCheckpoint, TeamRun, TimerResolution, ToolExecutionRecord, ToolExecutionResolution, ToolExecutionStatus, WorkflowBudgetUsage, WorkflowCheckpoint, WorkflowCompensationRecord, WorkflowRun, WorkflowStepRecord, WorkflowWaitRecord, isDurableRunStore, isRetainableRunStore, validateListEventsOptions, validatePurgeRunsOptions };

package/dist/runtime/index.mjs

@@ -4,6 +4,24 @@ 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 [
@@ -118,6 +136,30 @@ var InMemoryRunStore = class {
 	#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 && Date.parse(current.expiresAt) > Date.now()) return false;
@@ -138,4 +180,4 @@ var InMemoryRunStore = class {
 	}
 };
 //#endregion
-export { InMemoryRunStore, isDurableRunStore, validateListEventsOptions };
+export { InMemoryRunStore, isDurableRunStore, isRetainableRunStore, validateListEventsOptions, validatePurgeRunsOptions };

package/dist/sandbox/index.d.mts

@@ -1,2 +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";
+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-Df84VWmN.mjs";
 export { LocalSandboxOptions, Sandbox, SandboxCapabilities, SandboxError, SandboxRunRequest, SandboxRunResult, createLocalSandbox, sandboxResultToJson };

package/dist/sandbox/index.mjs

@@ -1,6 +1,6 @@
+import { relative, resolve } from "node:path";
 import { spawn } from "node:child_process";
 import { realpathSync } from "node:fs";
-import { relative, resolve } from "node:path";
 //#region src/sandbox/sandbox.ts
 var SandboxError = class extends Error {
 	code;

package/dist/teams/index.d.mts

@@ -1,2 +1,2 @@
-import { a as TeamMember, c as defineTeam, i as TeamLimits, n as TeamDelegation, o as TeamStep, r as TeamHandoff, s as TeamTaskResult, t as TeamDefinition } from "../index-C-IFfCNw.mjs";
+import { a as TeamMember, c as defineTeam, i as TeamLimits, n as TeamDelegation, o as TeamStep, r as TeamHandoff, s as TeamTaskResult, t as TeamDefinition } from "../index-1cHr7KB_.mjs";
 export { type TeamDefinition, type TeamDelegation, type TeamHandoff, type TeamLimits, type TeamMember, type TeamStep, type TeamTaskResult, defineTeam };

package/dist/testing/index.d.mts

@@ -1,9 +1,9 @@
-import { m as ToolCall } from "../types-CuoRx12Q.mjs";
-import { a as ModelResult, n as ModelInput, t as ModelGateway } from "../index-CTIwrVf9.mjs";
-import { h as ElicitationRequest, p as DurableRunStore } from "../index-CaE864Kz.mjs";
-import { s as MemoryStore } from "../index-hhbgvfIt.mjs";
-import { d as ToolProvider } from "../index-CqOjvtQ9.mjs";
-import { d as ChannelMessage, f as ChannelOutput, o as ChannelElicitationContext, r as ChannelAdapter } from "../index-DyyNLuwO.mjs";
+import { m as ToolCall } from "../types-B8laW1hM.mjs";
+import { a as ModelResult, n as ModelInput, t as ModelGateway } from "../index-BgKFd9yw.mjs";
+import { h as ElicitationRequest, p as DurableRunStore } from "../index-CzAi2Y_Z.mjs";
+import { s as MemoryStore } from "../index-BJktlD4E.mjs";
+import { d as ToolProvider } from "../index-5p3q2yIp.mjs";
+import { d as ChannelMessage, f as ChannelOutput, o as ChannelElicitationContext, r as ChannelAdapter } from "../index-DVw0zOc_.mjs";
 //#region src/testing/contracts.d.ts
 interface ModelGatewayContract {
   output?: unknown;
@@ -36,6 +36,7 @@ declare function testToolProvider(provider: ToolProvider, contract: ToolProvider
 declare function testChannelAdapter<TInput, TOutput>(adapter: ChannelAdapter<TInput, TOutput>, contract: ChannelAdapterContract<TInput, TOutput>): Promise<void>;
 declare function testModelGateway(model: ModelGateway, contract?: ModelGatewayContract): Promise<void>;
 declare function testRunStore(store: DurableRunStore): Promise<void>;
+declare function testRetentionStore(store: DurableRunStore): Promise<void>;
 //#endregion
 //#region src/testing/fake-model.d.ts
 interface FakeModel extends ModelGateway {
@@ -44,4 +45,4 @@ interface FakeModel extends ModelGateway {
 /** Creates a deterministic model gateway for unit tests. */
 declare function fakeModel(...responses: ModelResult[]): FakeModel;
 //#endregion
-export { ChannelAdapterContract, FakeModel, ModelGatewayContract, ToolProviderContract, fakeModel, testChannelAdapter, testMemoryStore, testModelGateway, testRunStore, testToolProvider };
+export { ChannelAdapterContract, FakeModel, ModelGatewayContract, ToolProviderContract, fakeModel, testChannelAdapter, testMemoryStore, testModelGateway, testRetentionStore, testRunStore, testToolProvider };

package/dist/testing/index.mjs

@@ -1,5 +1,6 @@
+import { isRetainableRunStore } from "../runtime/index.mjs";
 import { IntegrationError } from "../tools/index.mjs";
-import { t as readModelStream } from "../model-stream-u2xMsEaf.mjs";
+import { t as readModelStream } from "../model-stream-JQdHDDcj.mjs";
 //#region src/testing/contracts.ts
 const contractOutputSchema = {
 	type: "object",
@@ -599,6 +600,97 @@ async function testRunStore(store) {
 	}), "The current generation must be able to commit");
 	await store.releaseLease(runId, takeoverLease.ownerId, takeoverLease.generation);
 }
+async function testRetentionStore(store) {
+	assert(isRetainableRunStore(store), "RunStore must implement purgeRuns");
+	const suffix = crypto.randomUUID();
+	const now = Date.now();
+	const old = (/* @__PURE__ */ new Date(now - 2 * 864e5)).toISOString();
+	const before = (/* @__PURE__ */ new Date(now - 864e5)).toISOString();
+	const recent = new Date(now).toISOString();
+	const entries = [
+		{
+			id: `retention-old-completed-${suffix}`,
+			status: "completed",
+			createdAt: old
+		},
+		{
+			id: `retention-old-failed-${suffix}`,
+			status: "failed",
+			createdAt: old
+		},
+		{
+			id: `retention-recent-completed-${suffix}`,
+			status: "completed",
+			createdAt: recent
+		},
+		{
+			id: `retention-old-running-${suffix}`,
+			status: "running",
+			createdAt: old
+		}
+	];
+	for (const entry of entries) {
+		const sessionId = `retention-session-${entry.id}`;
+		await store.saveSession({
+			id: sessionId,
+			history: [],
+			createdAt: entry.createdAt,
+			updatedAt: entry.createdAt
+		});
+		await store.saveRun({
+			id: entry.id,
+			sessionId,
+			agentName: "retention-agent",
+			status: entry.status,
+			revision: 1,
+			createdAt: entry.createdAt,
+			updatedAt: entry.createdAt
+		});
+		await store.appendEvent({
+			id: `retention-event-${entry.id}`,
+			sequence: 1,
+			type: "run.started",
+			runId: entry.id,
+			timestamp: entry.createdAt
+		});
+	}
+	const purged = await store.purgeRuns({ before });
+	assert(purged.runs === 2, "Retention must delete only old terminal runs");
+	assert(purged.sessions === 2, "Retention must delete sessions left without runs");
+	assert(!await store.getRun(entries[0].id), "Retention must delete the completed run");
+	assert(!await store.getRun(entries[1].id), "Retention must delete the failed run");
+	assert(await store.getRun(entries[2].id), "Retention must keep recent terminal runs");
+	assert(await store.getRun(entries[3].id), "Retention must keep active runs");
+	assert(!await store.getSession(`retention-session-${entries[0].id}`), "Retention must delete empty sessions");
+	assert(await store.getSession(`retention-session-${entries[2].id}`), "Retention must keep sessions with runs");
+	assert((await store.purgeRuns({ limit: 1 })).runs === 1, "Retention must honor the limit");
+	await store.purgeRuns({ before: new Date(Date.now() + 864e5).toISOString() });
+	assert(!await store.getRun(entries[2].id), "Retention must purge remaining terminal runs");
+	assert(await store.getRun(entries[3].id), "Retention must keep active runs after a full purge");
+	const boundaryId = `retention-boundary-${suffix}`;
+	const boundarySessionId = `retention-boundary-session-${suffix}`;
+	const boundaryCreatedAt = "2020-01-01T00:00:00.100Z";
+	await store.saveSession({
+		id: boundarySessionId,
+		history: [],
+		createdAt: boundaryCreatedAt,
+		updatedAt: boundaryCreatedAt
+	});
+	await store.saveRun({
+		id: boundaryId,
+		sessionId: boundarySessionId,
+		agentName: "retention-agent",
+		status: "completed",
+		revision: 1,
+		createdAt: boundaryCreatedAt,
+		updatedAt: boundaryCreatedAt
+	});
+	assert((await store.purgeRuns({
+		before: "2020-01-01T00:00:00.500Z",
+		statuses: ["completed"]
+	})).runs === 1, "Retention must compare subsecond timestamps");
+	assert(!await store.getRun(boundaryId), "Retention must delete the boundary run");
+}
 //#endregion
 //#region src/testing/fake-model.ts
 /** Creates a deterministic model gateway for unit tests. */
@@ -626,4 +718,4 @@ function fakeModel(...responses) {
 	};
 }
 //#endregion
-export { fakeModel, testChannelAdapter, testMemoryStore, testModelGateway, testRunStore, testToolProvider };
+export { fakeModel, testChannelAdapter, testMemoryStore, testModelGateway, testRetentionStore, testRunStore, testToolProvider };

package/dist/tools/index.d.mts

@@ -1,3 +1,3 @@
-import { g as ToolSpec, m as ToolCall } from "../types-CuoRx12Q.mjs";
-import { C as toToolSpec, S as defineTool, _ as ToolExecutionContext, a as compileFevexJsonSchema, b as ToolRetryPolicy, c as ConnectionToolPolicy, d as ToolProvider, f as ToolProviderContext, g as ToolDefinition, h as ToolApproval, i as FevexJsonSchemaValidator, l as IntegrationError, m as defineConnection, n as FevexJsonSchemaProfileLimits, o as validateFevexJsonSchemaProfile, p as ToolProviderTool, r as FevexJsonSchemaProfileOptions, s as ConnectionDefinition, t as FEVEX_JSON_SCHEMA_PROFILE_VERSION, u as IntegrationErrorCategory, v as ToolIdempotency, x as ToolRisk, y as ToolResult } from "../index-CqOjvtQ9.mjs";
+import { g as ToolSpec, m as ToolCall } from "../types-B8laW1hM.mjs";
+import { C as toToolSpec, S as defineTool, _ as ToolExecutionContext, a as compileFevexJsonSchema, b as ToolRetryPolicy, c as ConnectionToolPolicy, d as ToolProvider, f as ToolProviderContext, g as ToolDefinition, h as ToolApproval, i as FevexJsonSchemaValidator, l as IntegrationError, m as defineConnection, n as FevexJsonSchemaProfileLimits, o as validateFevexJsonSchemaProfile, p as ToolProviderTool, r as FevexJsonSchemaProfileOptions, s as ConnectionDefinition, t as FEVEX_JSON_SCHEMA_PROFILE_VERSION, u as IntegrationErrorCategory, v as ToolIdempotency, x as ToolRisk, y as ToolResult } from "../index-5p3q2yIp.mjs";
 export { ConnectionDefinition, ConnectionToolPolicy, FEVEX_JSON_SCHEMA_PROFILE_VERSION, FevexJsonSchemaProfileLimits, FevexJsonSchemaProfileOptions, FevexJsonSchemaValidator, IntegrationError, IntegrationErrorCategory, ToolApproval, type ToolCall, ToolDefinition, ToolExecutionContext, ToolIdempotency, ToolProvider, ToolProviderContext, ToolProviderTool, ToolResult, ToolRetryPolicy, ToolRisk, type ToolSpec, compileFevexJsonSchema, defineConnection, defineTool, toToolSpec, validateFevexJsonSchemaProfile };