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

package/dist/evals/index.d.mts

@@ -1,8 +1,12 @@
-import { l as JsonValue, o as ExecutionContext, t as AgentEvent } from "../index-C_Zpr13f.mjs";
-import { ModelMetadata, ModelUsage } from "../models/index.mjs";
-import { l as TraceCost, t as CostCalculator } from "../index-ojCY3lwm.mjs";
-import { t as Fevex } from "../fevex-Dz6GBz9o.mjs";
-//#region src/evals/index.d.ts
+import { r as ModelMetadata, s as ModelUsage } from "../index-D7r0puBi.mjs";
+import { l as JsonValue, o as ExecutionContext, t as AgentEvent } from "../types-CckDlhYo.mjs";
+import { t as CostCalculator, u as TraceCost } from "../index-BEqYWean.mjs";
+import { t as Fevex } from "../fevex-_KOsOsB8.mjs";
+//#region src/evals/canonical-json.d.ts
+/** Serializes JSON-like data with stable object-key ordering. */
+declare function serializeCanonical(value: unknown): string;
+//#endregion
+//#region src/evals/types.d.ts
 interface EvalExpectation {
   output?: JsonValue;
   tools?: string[];
@@ -121,7 +125,17 @@ interface RegressionOptions {
   maxLatencyIncreaseRatio?: number;
   maxCostIncreaseRatio?: number;
 }
+//#endregion
+//#region src/evals/evaluation.d.ts
+/** Runs every case and scorer, producing a deterministic aggregate report. */
 declare function runEvaluation<TInput = unknown>(options: RunEvaluationOptions<TInput>): Promise<EvalReport>;
+declare function serializeEvalReport(report: EvalReport): string;
+declare function parseEvalReport(json: string): EvalReport;
+declare function jsonReporter(write: (output: string) => void | Promise<void>): EvalReporter;
+declare function textReporter(write: (output: string) => void | Promise<void>): EvalReporter;
+declare function compareEvaluationReports(baseline: EvalReport, current: EvalReport, options?: RegressionOptions): RegressionReport;
+//#endregion
+//#region src/evals/scorers.d.ts
 declare function exactOutputScorer(id?: string): EvalScorer;
 declare function toolSelectionScorer(options?: {
   id?: string;
@@ -135,11 +149,5 @@ declare function maxTokensScorer(limits: {
   total?: number;
 }, id?: string): EvalScorer;
 declare function maxCostScorer(maxAmount: number, currency: string, id?: string): EvalScorer;
-declare function serializeCanonical(value: unknown): string;
-declare function serializeEvalReport(report: EvalReport): string;
-declare function parseEvalReport(json: string): EvalReport;
-declare function jsonReporter(write: (output: string) => void | Promise<void>): EvalReporter;
-declare function textReporter(write: (output: string) => void | Promise<void>): EvalReporter;
-declare function compareEvaluationReports(baseline: EvalReport, current: EvalReport, options?: RegressionOptions): RegressionReport;
 //#endregion
 export { EvalCase, EvalCaseReport, EvalCostOptions, EvalDataset, EvalExpectation, EvalReport, EvalReporter, EvalScore, EvalScoreStatus, EvalScorer, EvalScorerContext, EvalScorerResult, EvalSummary, Regression, RegressionOptions, RegressionReport, RunEvaluationOptions, compareEvaluationReports, exactOutputScorer, forbiddenToolsScorer, jsonReporter, maxCostScorer, maxLatencyScorer, maxTokensScorer, parseEvalReport, runEvaluation, serializeCanonical, serializeEvalReport, textReporter, toolSelectionScorer };

package/dist/evals/index.mjs

@@ -1,13 +1,21 @@
-//#region src/evals/index.ts
+//#region src/evals/canonical-json.ts
+function canonicalize(value) {
+	if (Array.isArray(value)) return value.map(canonicalize);
+	if (value === null || typeof value !== "object") return value;
+	return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, canonicalize(item)]));
+}
+/** Serializes JSON-like data with stable object-key ordering. */
+function serializeCanonical(value) {
+	return JSON.stringify(canonicalize(value), null, 2);
+}
+//#endregion
+//#region src/evals/evaluation.ts
 function assertNonEmpty(value, name) {
 	if (typeof value !== "string" || !value.trim()) throw new TypeError(`${name} must be non-empty`);
 }
 function errorMessage(error) {
 	return error instanceof Error ? error.message : String(error);
 }
-function equalJson(left, right) {
-	return serializeCanonical(left) === serializeCanonical(right);
-}
 function addUsage(target, usage) {
 	if (!usage) return;
 	for (const key of [
@@ -157,6 +165,7 @@ function summarize(cases) {
 		latencyMs: cases.reduce((sum, testCase) => sum + testCase.latencyMs, 0)
 	};
 }
+/** Runs every case and scorer, producing a deterministic aggregate report. */
 async function runEvaluation(options) {
 	validateOptions(options);
 	const cases = [];
@@ -177,6 +186,116 @@ async function runEvaluation(options) {
 	for (const reporter of options.reporters ?? []) await reporter.report(report);
 	return report;
 }
+function serializeEvalReport(report) {
+	return `${serializeCanonical(report)}\n`;
+}
+function parseEvalReport(json) {
+	const value = JSON.parse(json);
+	if (typeof value !== "object" || value === null || value.schemaVersion !== "fevex.eval.v1" || typeof value.suiteName !== "string" || typeof value.targetVersion !== "string" || typeof value.agentName !== "string" || typeof value.dataset !== "object" || value.dataset === null || typeof value.dataset.name !== "string" || typeof value.dataset.version !== "string" || !Array.isArray(value.cases) || !Array.isArray(value.scorerIds) || !value.scorerIds.every((scorerId) => typeof scorerId === "string" && Boolean(scorerId)) || typeof value.summary !== "object" || value.summary === null) throw new TypeError("Invalid fevex.eval.v1 report");
+	const report = value;
+	const caseIds = /* @__PURE__ */ new Set();
+	for (const testCase of report.cases) {
+		if (typeof testCase !== "object" || testCase === null || typeof testCase.caseId !== "string" || !testCase.caseId || caseIds.has(testCase.caseId) || !["completed", "failed"].includes(testCase.status) || !Array.isArray(testCase.tools) || !testCase.tools.every((tool) => typeof tool === "string") || !Number.isFinite(testCase.latencyMs) || testCase.latencyMs < 0 || !Array.isArray(testCase.scores)) throw new TypeError("Invalid fevex.eval.v1 report");
+		caseIds.add(testCase.caseId);
+		for (const score of testCase.scores) if (typeof score !== "object" || score === null || typeof score.scorerId !== "string" || !report.scorerIds.includes(score.scorerId) || ![
+			"passed",
+			"failed",
+			"skipped",
+			"error"
+		].includes(score.status) || score.score !== void 0 && (!Number.isFinite(score.score) || score.score < 0 || score.score > 1)) throw new TypeError("Invalid fevex.eval.v1 report");
+	}
+	return value;
+}
+function jsonReporter(write) {
+	return { report: (report) => write(serializeEvalReport(report)) };
+}
+function textReporter(write) {
+	return { report(report) {
+		return write(`${[
+			`${report.suiteName} (${report.targetVersion})`,
+			`dataset ${report.dataset.name}@${report.dataset.version}`,
+			...report.cases.map((testCase) => {
+				const passed = testCase.scores.filter(({ status }) => status === "passed").length;
+				const failed = testCase.scores.filter(({ status }) => status === "failed" || status === "error").length;
+				return `${testCase.caseId}: ${testCase.status}; ${passed} passed, ${failed} failed`;
+			}),
+			`summary: ${report.summary.completedCount}/${report.summary.caseCount} completed; ${report.summary.failedScoreCount + report.summary.errorScoreCount} failed scores`
+		].join("\n")}\n`);
+	} };
+}
+function assertRatio(value, name) {
+	if (value !== void 0 && (!Number.isFinite(value) || value < 0)) throw new TypeError(`${name} must be non-negative`);
+}
+function compareEvaluationReports(baseline, current, options = {}) {
+	if (baseline.suiteName !== current.suiteName || baseline.dataset.name !== current.dataset.name || baseline.dataset.version !== current.dataset.version) throw new TypeError("Evaluation reports must use the same suite and dataset version");
+	assertRatio(options.maxScoreDrop, "maxScoreDrop");
+	assertRatio(options.maxLatencyIncreaseRatio, "maxLatencyIncreaseRatio");
+	assertRatio(options.maxCostIncreaseRatio, "maxCostIncreaseRatio");
+	const maxScoreDrop = options.maxScoreDrop ?? 0;
+	const regressions = [];
+	const currentCases = new Map(current.cases.map((testCase) => [testCase.caseId, testCase]));
+	for (const baselineCase of baseline.cases) {
+		const currentCase = currentCases.get(baselineCase.caseId);
+		if (!currentCase) {
+			regressions.push({
+				kind: "case_removed",
+				caseId: baselineCase.caseId,
+				message: `Case "${baselineCase.caseId}" was removed`
+			});
+			continue;
+		}
+		if (baselineCase.status === "completed" && currentCase.status === "failed") regressions.push({
+			kind: "case_failed",
+			caseId: baselineCase.caseId,
+			message: `Case "${baselineCase.caseId}" no longer completes`
+		});
+		const currentScores = new Map(currentCase.scores.map((score) => [score.scorerId, score]));
+		for (const baselineScore of baselineCase.scores) {
+			const currentScore = currentScores.get(baselineScore.scorerId);
+			if (!currentScore) {
+				regressions.push({
+					kind: "scorer_removed",
+					caseId: baselineCase.caseId,
+					scorerId: baselineScore.scorerId,
+					message: `Scorer "${baselineScore.scorerId}" was removed from "${baselineCase.caseId}"`
+				});
+				continue;
+			}
+			if (baselineScore.status === "passed" && currentScore.status !== "passed") regressions.push({
+				kind: "score_failed",
+				caseId: baselineCase.caseId,
+				scorerId: baselineScore.scorerId,
+				message: `Scorer "${baselineScore.scorerId}" changed from pass to fail`
+			});
+			else if (baselineScore.score !== void 0 && currentScore.score !== void 0 && baselineScore.score - currentScore.score > maxScoreDrop) regressions.push({
+				kind: "score_dropped",
+				caseId: baselineCase.caseId,
+				scorerId: baselineScore.scorerId,
+				message: `Scorer "${baselineScore.scorerId}" dropped from ${baselineScore.score} to ${currentScore.score}`
+			});
+		}
+		if (options.maxLatencyIncreaseRatio !== void 0 && baselineCase.latencyMs > 0 && currentCase.latencyMs / baselineCase.latencyMs - 1 > options.maxLatencyIncreaseRatio) regressions.push({
+			kind: "latency_increased",
+			caseId: baselineCase.caseId,
+			message: `Latency increased from ${baselineCase.latencyMs}ms to ${currentCase.latencyMs}ms`
+		});
+		if (options.maxCostIncreaseRatio !== void 0 && baselineCase.cost && currentCase.cost) {
+			if (baselineCase.cost.currency !== currentCase.cost.currency || baselineCase.cost.amount > 0 && currentCase.cost.amount / baselineCase.cost.amount - 1 > options.maxCostIncreaseRatio) regressions.push({
+				kind: "cost_increased",
+				caseId: baselineCase.caseId,
+				message: `Cost changed from ${baselineCase.cost.amount} ${baselineCase.cost.currency} to ${currentCase.cost.amount} ${currentCase.cost.currency}`
+			});
+		}
+	}
+	return {
+		passed: regressions.length === 0,
+		baselineTargetVersion: baseline.targetVersion,
+		currentTargetVersion: current.targetVersion,
+		regressions
+	};
+}
+//#endregion
+//#region src/evals/scorers.ts
 function exactOutputScorer(id = "output.exact") {
 	return {
 		id,
@@ -185,7 +304,7 @@ function exactOutputScorer(id = "output.exact") {
 				skipped: true,
 				reason: "No expected output"
 			};
-			const passed = equalJson(output, testCase.expected.output);
+			const passed = serializeCanonical(output) === serializeCanonical(testCase.expected.output);
 			return {
 				passed,
 				score: passed ? 1 : 0
@@ -272,7 +391,7 @@ function maxTokensScorer(limits, id = "tokens.max") {
 }
 function maxCostScorer(maxAmount, currency, id = "cost.max") {
 	if (!Number.isFinite(maxAmount) || maxAmount < 0) throw new TypeError("maxAmount must be non-negative");
-	assertNonEmpty(currency, "currency");
+	if (!currency.trim()) throw new TypeError("currency must be non-empty");
 	return {
 		id,
 		score({ cost }) {
@@ -299,121 +418,5 @@ function maxCostScorer(maxAmount, currency, id = "cost.max") {
 		}
 	};
 }
-function canonicalize(value) {
-	if (Array.isArray(value)) return value.map(canonicalize);
-	if (value === null || typeof value !== "object") return value;
-	return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, canonicalize(item)]));
-}
-function serializeCanonical(value) {
-	return JSON.stringify(canonicalize(value), null, 2);
-}
-function serializeEvalReport(report) {
-	return `${serializeCanonical(report)}\n`;
-}
-function parseEvalReport(json) {
-	const value = JSON.parse(json);
-	if (typeof value !== "object" || value === null || value.schemaVersion !== "fevex.eval.v1" || typeof value.suiteName !== "string" || typeof value.targetVersion !== "string" || typeof value.agentName !== "string" || typeof value.dataset !== "object" || value.dataset === null || typeof value.dataset.name !== "string" || typeof value.dataset.version !== "string" || !Array.isArray(value.cases) || !Array.isArray(value.scorerIds) || !value.scorerIds.every((scorerId) => typeof scorerId === "string" && Boolean(scorerId)) || typeof value.summary !== "object" || value.summary === null) throw new TypeError("Invalid fevex.eval.v1 report");
-	const report = value;
-	const caseIds = /* @__PURE__ */ new Set();
-	for (const testCase of report.cases) {
-		if (typeof testCase !== "object" || testCase === null || typeof testCase.caseId !== "string" || !testCase.caseId || caseIds.has(testCase.caseId) || !["completed", "failed"].includes(testCase.status) || !Array.isArray(testCase.tools) || !testCase.tools.every((tool) => typeof tool === "string") || !Number.isFinite(testCase.latencyMs) || testCase.latencyMs < 0 || !Array.isArray(testCase.scores)) throw new TypeError("Invalid fevex.eval.v1 report");
-		caseIds.add(testCase.caseId);
-		for (const score of testCase.scores) if (typeof score !== "object" || score === null || typeof score.scorerId !== "string" || !report.scorerIds.includes(score.scorerId) || ![
-			"passed",
-			"failed",
-			"skipped",
-			"error"
-		].includes(score.status) || score.score !== void 0 && (!Number.isFinite(score.score) || score.score < 0 || score.score > 1)) throw new TypeError("Invalid fevex.eval.v1 report");
-	}
-	return value;
-}
-function jsonReporter(write) {
-	return { report: (report) => write(serializeEvalReport(report)) };
-}
-function textReporter(write) {
-	return { report(report) {
-		return write(`${[
-			`${report.suiteName} (${report.targetVersion})`,
-			`dataset ${report.dataset.name}@${report.dataset.version}`,
-			...report.cases.map((testCase) => {
-				const passed = testCase.scores.filter(({ status }) => status === "passed").length;
-				const failed = testCase.scores.filter(({ status }) => status === "failed" || status === "error").length;
-				return `${testCase.caseId}: ${testCase.status}; ${passed} passed, ${failed} failed`;
-			}),
-			`summary: ${report.summary.completedCount}/${report.summary.caseCount} completed; ${report.summary.failedScoreCount + report.summary.errorScoreCount} failed scores`
-		].join("\n")}\n`);
-	} };
-}
-function assertRatio(value, name) {
-	if (value !== void 0 && (!Number.isFinite(value) || value < 0)) throw new TypeError(`${name} must be non-negative`);
-}
-function compareEvaluationReports(baseline, current, options = {}) {
-	if (baseline.suiteName !== current.suiteName || baseline.dataset.name !== current.dataset.name || baseline.dataset.version !== current.dataset.version) throw new TypeError("Evaluation reports must use the same suite and dataset version");
-	assertRatio(options.maxScoreDrop, "maxScoreDrop");
-	assertRatio(options.maxLatencyIncreaseRatio, "maxLatencyIncreaseRatio");
-	assertRatio(options.maxCostIncreaseRatio, "maxCostIncreaseRatio");
-	const maxScoreDrop = options.maxScoreDrop ?? 0;
-	const regressions = [];
-	const currentCases = new Map(current.cases.map((testCase) => [testCase.caseId, testCase]));
-	for (const baselineCase of baseline.cases) {
-		const currentCase = currentCases.get(baselineCase.caseId);
-		if (!currentCase) {
-			regressions.push({
-				kind: "case_removed",
-				caseId: baselineCase.caseId,
-				message: `Case "${baselineCase.caseId}" was removed`
-			});
-			continue;
-		}
-		if (baselineCase.status === "completed" && currentCase.status === "failed") regressions.push({
-			kind: "case_failed",
-			caseId: baselineCase.caseId,
-			message: `Case "${baselineCase.caseId}" no longer completes`
-		});
-		const currentScores = new Map(currentCase.scores.map((score) => [score.scorerId, score]));
-		for (const baselineScore of baselineCase.scores) {
-			const currentScore = currentScores.get(baselineScore.scorerId);
-			if (!currentScore) {
-				regressions.push({
-					kind: "scorer_removed",
-					caseId: baselineCase.caseId,
-					scorerId: baselineScore.scorerId,
-					message: `Scorer "${baselineScore.scorerId}" was removed from "${baselineCase.caseId}"`
-				});
-				continue;
-			}
-			if (baselineScore.status === "passed" && currentScore.status !== "passed") regressions.push({
-				kind: "score_failed",
-				caseId: baselineCase.caseId,
-				scorerId: baselineScore.scorerId,
-				message: `Scorer "${baselineScore.scorerId}" changed from pass to fail`
-			});
-			else if (baselineScore.score !== void 0 && currentScore.score !== void 0 && baselineScore.score - currentScore.score > maxScoreDrop) regressions.push({
-				kind: "score_dropped",
-				caseId: baselineCase.caseId,
-				scorerId: baselineScore.scorerId,
-				message: `Scorer "${baselineScore.scorerId}" dropped from ${baselineScore.score} to ${currentScore.score}`
-			});
-		}
-		if (options.maxLatencyIncreaseRatio !== void 0 && baselineCase.latencyMs > 0 && currentCase.latencyMs / baselineCase.latencyMs - 1 > options.maxLatencyIncreaseRatio) regressions.push({
-			kind: "latency_increased",
-			caseId: baselineCase.caseId,
-			message: `Latency increased from ${baselineCase.latencyMs}ms to ${currentCase.latencyMs}ms`
-		});
-		if (options.maxCostIncreaseRatio !== void 0 && baselineCase.cost && currentCase.cost) {
-			if (baselineCase.cost.currency !== currentCase.cost.currency || baselineCase.cost.amount > 0 && currentCase.cost.amount / baselineCase.cost.amount - 1 > options.maxCostIncreaseRatio) regressions.push({
-				kind: "cost_increased",
-				caseId: baselineCase.caseId,
-				message: `Cost changed from ${baselineCase.cost.amount} ${baselineCase.cost.currency} to ${currentCase.cost.amount} ${currentCase.cost.currency}`
-			});
-		}
-	}
-	return {
-		passed: regressions.length === 0,
-		baselineTargetVersion: baseline.targetVersion,
-		currentTargetVersion: current.targetVersion,
-		regressions
-	};
-}
 //#endregion
 export { compareEvaluationReports, exactOutputScorer, forbiddenToolsScorer, jsonReporter, maxCostScorer, maxLatencyScorer, maxTokensScorer, parseEvalReport, runEvaluation, serializeCanonical, serializeEvalReport, textReporter, toolSelectionScorer };

package/dist/fevex-_KOsOsB8.d.mts

@@ -0,0 +1,129 @@
+import { S as ConnectionDefinition, j as ToolDefinition, o as ToolEmbeddingCache } from "./index-DHcfIfh-.mjs";
+import { t as ModelGateway } from "./index-D7r0puBi.mjs";
+import { F as ArtifactStore, f as RunId, o as ExecutionContext, t as AgentEvent } from "./types-CckDlhYo.mjs";
+import { r as Sandbox } from "./index-DUhNa7IR.mjs";
+import { B as ResumeRunResolution, I as ListEventsOptions, J as RunRequest, O as CredentialStore, Q as Session, R as PurgeRunsOptions, Y as RunResult, Z as RunStore, a as ToolSearchOptions, d as ContextCompactionStats, dt as WorkflowRun, et as SessionId, q as RunRecord, r as ContextBudget, rt as TeamRun, t as AgentDefinition, u as ContextCompactionOptions, x as AgentRun, z as PurgeRunsResult } from "./index-lCCFokc6.mjs";
+import { c as ContextProvider, f as MemoryStore } from "./index-CIHWc5V1.mjs";
+import { i as ObservabilityStats, r as ObservabilityOptions } from "./index-BEqYWean.mjs";
+import { r as PolicyDefinition } from "./index-CFzrvDQ0.mjs";
+import { n as WorkflowDefinition } from "./index-Btth7rdL.mjs";
+import { t as TeamDefinition } from "./index-26ilbzAs.mjs";
+//#region src/fevex.d.ts
+interface FevexAdmissionRequest {
+  kind: 'agent' | 'workflow' | 'team';
+  name: string;
+  request: RunRequest;
+  activeRuns: number;
+  activeTenantRuns: number;
+}
+/** Optional host-level admission controls applied before a top-level run starts. */
+interface FevexAdmission {
+  /** Maximum concurrent top-level runs in this runtime. */
+  maxActiveRuns?: number;
+  /** Maximum concurrent top-level runs for one tenant. */
+  maxActiveRunsPerTenant?: number;
+  /** Defaults to a non-empty `context.attributes.tenantId` string. */
+  tenantKey?: (context?: ExecutionContext) => string | undefined;
+  /** Custom admission check, called after the built-in limits. */
+  authorize?: (request: FevexAdmissionRequest) => boolean | Promise<boolean>;
+}
+interface FevexShutdownOptions {
+  /**
+   * Maximum time to wait for active runs before cancelling them. Defaults to
+   * 30 seconds. Use `0` to cancel immediately. If the deadline expires,
+   * shutdown allows up to 5 additional seconds for forced cancellation and the
+   * final trace flush.
+   */
+  timeoutMs?: number;
+}
+interface FevexShutdownResult {
+  /** Runs that were still active when the grace period expired. */
+  cancelledRunIds: RunId[];
+  /** True when the grace deadline expired before all active runs finished. */
+  timedOut: boolean;
+  /** Error surfaced while flushing pending traces, if any. */
+  exportError?: unknown;
+  /** Observability counters after the shutdown flush. */
+  observability: ObservabilityStats;
+}
+interface FevexLimits {
+  /**
+   * Maximum non-control events persisted for one run. Control events such as
+   * pause, resume, approval and terminal transitions are always persisted.
+   */
+  maxEventsPerRun?: number;
+}
+/** Provider-neutral definitions and adapters used to create one Fevex runtime. */
+interface FevexConfig {
+  models: Record<string, ModelGateway>;
+  agents: AgentDefinition[];
+  workflows?: WorkflowDefinition[];
+  teams?: TeamDefinition[];
+  tools?: ToolDefinition[];
+  connections?: ConnectionDefinition[];
+  contextProviders?: ContextProvider[];
+  /** Default context budget for agents that do not declare one. */
+  contextBudget?: ContextBudget;
+  /** Optional context compactor and token estimator. */
+  compaction?: ContextCompactionOptions;
+  /** Default on-demand tool search for agents that do not declare one. */
+  toolSearch?: ToolSearchOptions;
+  /** Optional durable cache for semantic tool embeddings. */
+  toolSearchCache?: ToolEmbeddingCache;
+  memoryStore?: MemoryStore;
+  runStore?: RunStore;
+  credentialStore?: CredentialStore;
+  sandbox?: Sandbox;
+  /** Optional artifact store exposed to tools as `context.artifacts`. */
+  artifacts?: ArtifactStore;
+  policies?: PolicyDefinition[];
+  onEvent?: (event: AgentEvent) => void;
+  observability?: ObservabilityOptions;
+  admission?: FevexAdmission;
+  limits?: FevexLimits;
+}
+interface Fevex {
+  startAgent<TInput = unknown, TOutput = unknown>(name: string, request: RunRequest<TInput, TOutput>): Promise<AgentRun<TOutput>>;
+  runAgent<TInput = unknown, TOutput = unknown>(name: string, request: RunRequest<TInput, TOutput>): Promise<RunResult<TOutput>>;
+  streamAgent<TInput = unknown, TOutput = unknown>(name: string, request: RunRequest<TInput, TOutput>): AsyncIterable<AgentEvent>;
+  startWorkflow<TInput = unknown, TOutput = unknown>(name: string, request: RunRequest<TInput, TOutput>): Promise<WorkflowRun<TOutput>>;
+  runWorkflow<TInput = unknown, TOutput = unknown>(name: string, request: RunRequest<TInput, TOutput>): Promise<RunResult<TOutput>>;
+  startTeam<TInput = unknown, TOutput = unknown>(name: string, request: RunRequest<TInput, TOutput>): Promise<TeamRun<TOutput>>;
+  runTeam<TInput = unknown, TOutput = unknown>(name: string, request: RunRequest<TInput, TOutput>): Promise<RunResult<TOutput>>;
+  streamTeam<TInput = unknown, TOutput = unknown>(name: string, request: RunRequest<TInput, TOutput>): AsyncIterable<AgentEvent>;
+  getTeamRun<TOutput = unknown>(runId: RunId): Promise<TeamRun<TOutput> | undefined>;
+  getRun<TOutput = unknown>(runId: RunId): Promise<RunRecord<TOutput> | undefined>;
+  listEvents(runId: RunId, options?: ListEventsOptions): Promise<AgentEvent[]>;
+  cancelRun(runId: RunId): Promise<boolean>;
+  resumeRun<TOutput = unknown>(runId: RunId, resolution: ResumeRunResolution): Promise<RunRecord<TOutput>>;
+  recoverRun<TOutput = unknown>(runId: RunId, options: {
+    actor: {
+      id: string;
+      type?: string;
+    };
+  }): Promise<RunRecord<TOutput>>;
+  purgeRuns(options?: PurgeRunsOptions): Promise<PurgeRunsResult>;
+  compactSession(sessionId: SessionId, summary: string): Promise<Session>;
+  /** Waits for queued exports and rejects with failures accumulated since the previous flush. */
+  flushObservability(options?: {
+    timeoutMs?: number;
+  }): Promise<void>;
+  /** Cumulative trace export counters for this runtime. */
+  getObservabilityStats(): ObservabilityStats;
+  /** Cumulative context compaction counters for this runtime. */
+  getCompactionStats(): ContextCompactionStats;
+  /**
+   * Stops admitting new work, drains or cancels active runs, and flushes trace
+   * exports. The host still owns closing its stores and external adapters.
+   */
+  shutdown(options?: FevexShutdownOptions): Promise<FevexShutdownResult>;
+}
+/**
+ * Validates a configuration snapshot and creates an isolated runtime.
+ *
+ * The runtime does not own external adapters; callers remain responsible for
+ * closing model, connection, store, and exporter resources they provide.
+ */
+declare function createFevex(config: FevexConfig): Fevex;
+//#endregion
+export { FevexLimits as a, createFevex as c, FevexConfig as i, FevexAdmission as n, FevexShutdownOptions as o, FevexAdmissionRequest as r, FevexShutdownResult as s, Fevex as t };

package/dist/http/index.d.mts

@@ -0,0 +1,150 @@
+import { c as ReasoningEffort } from "../index-D7r0puBi.mjs";
+import { D as ArtifactCatalog, F as ArtifactStore, f as RunId, k as ArtifactDescriptor, l as JsonValue, o as ExecutionContext, t as AgentEvent } from "../types-CckDlhYo.mjs";
+import { dt as WorkflowRun, et as SessionId, q as RunRecord, rt as TeamRun, x as AgentRun } from "../index-lCCFokc6.mjs";
+import { t as Fevex } from "../fevex-_KOsOsB8.mjs";
+//#region src/http/protocol.d.ts
+declare const FEVEX_HTTP_PROTOCOL_VERSION = "3";
+declare const FEVEX_HTTP_PROTOCOL_VERSION_HEADER = "Fevex-Protocol-Version";
+interface StartRunHttpRequest<TInput extends JsonValue = JsonValue> {
+  input: TInput;
+  model?: string;
+  reasoning?: ReasoningEffort;
+  sessionId?: SessionId;
+  /** Maximum wall-clock time for the run, including time spent paused. */
+  deadlineMs?: number;
+}
+type ResumeRunHttpRequest = {
+  type: 'elicitation';
+  requestId: string;
+  value: JsonValue;
+} | {
+  type: 'approval';
+  approvalId: string;
+  decision: 'approve' | 'reject';
+} | {
+  type: 'tool_execution';
+  toolCallId: string;
+  decision: 'use_output';
+  output: JsonValue;
+} | {
+  type: 'tool_execution';
+  toolCallId: string;
+  decision: 'retry';
+} | {
+  type: 'timer';
+} | {
+  type: 'event';
+  eventName: string;
+  payload?: JsonValue;
+};
+/** RFC 9457-compatible problem returned by the Fevex HTTP protocol. */
+interface FevexProblemDetails {
+  type: string;
+  title: string;
+  status: number;
+  code: string;
+  detail?: string;
+  instance?: string;
+}
+interface FevexHttpHandlerContext {
+  context?: ExecutionContext;
+}
+/** Host-facing resource access check. */
+type FevexHttpAccess = {
+  action: 'start';
+  kind: 'agent' | 'workflow' | 'team';
+  name: string;
+  sessionId?: SessionId;
+  context?: ExecutionContext;
+} | {
+  action: 'read' | 'observe' | 'cancel' | 'resume' | 'recover';
+  runId: RunId;
+  context?: ExecutionContext;
+};
+/** Host-facing artifact access check. */
+type FevexArtifactAccess = {
+  action: 'read' | 'delete';
+  kind: 'artifact';
+  artifactId: string;
+  context?: ExecutionContext;
+} | {
+  action: 'read';
+  kind: 'artifacts';
+  runId: RunId;
+  context?: ExecutionContext;
+};
+interface FevexHttpHandlerOptions {
+  fevex: Fevex;
+  pollIntervalMs?: number;
+  /** Events per SSE read (default 100, maximum 1000). */
+  eventPageSize?: number;
+  /** Maximum concurrent SSE streams (default unlimited). */
+  maxConnections?: number;
+  /**
+   * Authorizes a resource operation before the handler reads or mutates a run,
+   * or starts a run (new or existing session). Return false for a 403 response.
+   * Omit to preserve the host's existing trusted-network behavior.
+   */
+  authorize?: (access: FevexHttpAccess) => boolean | Promise<boolean>;
+  /**
+   * Byte store used by the artifact routes. When omitted, artifact routes
+   * return 501.
+   */
+  artifacts?: ArtifactStore;
+  /**
+   * Metadata catalog used to list artifacts for a run. When omitted, the
+   * run-artifact listing route returns 501.
+   */
+  artifactCatalog?: ArtifactCatalog;
+  /**
+   * Authorizes artifact reads, listings and deletions. Omit to preserve the
+   * host's existing trusted-network behavior.
+   */
+  authorizeArtifact?: (access: FevexArtifactAccess) => boolean | Promise<boolean>;
+  /**
+   * Called after a run starts so the host can persist run and session ownership.
+   * If it throws, the handler cancels the new run and returns 500. A process
+   * crash between start and this callback leaves the run unowned; hosts must
+   * treat unowned runs as inaccessible. Runs created outside the HTTP handler
+   * are not reported.
+   */
+  onRunStarted?: (run: RunRecord, context?: ExecutionContext) => void | Promise<void>;
+  onError?: (error: unknown, problem: FevexProblemDetails) => void;
+}
+type FevexHttpHandler = (request: Request, context?: FevexHttpHandlerContext) => Promise<Response>;
+interface FevexHttpClientOptions {
+  baseUrl: string;
+  fetch?: FevexHttpFetch;
+}
+type FevexHttpFetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+interface ObserveRunOptions {
+  after?: AgentEvent['id'];
+  signal?: AbortSignal;
+}
+interface FevexHttpClient {
+  startRun<TInput extends JsonValue = JsonValue, TOutput = JsonValue>(agentName: string, request: StartRunHttpRequest<TInput>): Promise<AgentRun<TOutput>>;
+  startWorkflow<TInput extends JsonValue = JsonValue, TOutput = JsonValue>(workflowName: string, request: StartRunHttpRequest<TInput>): Promise<WorkflowRun<TOutput>>;
+  startTeam<TInput extends JsonValue = JsonValue, TOutput = JsonValue>(teamName: string, request: StartRunHttpRequest<TInput>): Promise<TeamRun<TOutput>>;
+  getRun<TOutput = JsonValue>(runId: string): Promise<RunRecord<TOutput>>;
+  observeRun(runId: string, options?: ObserveRunOptions): AsyncIterable<AgentEvent>;
+  resumeRun<TOutput = JsonValue>(runId: string, request: ResumeRunHttpRequest): Promise<RunRecord<TOutput>>;
+  recoverRun<TOutput = JsonValue>(runId: string): Promise<RunRecord<TOutput>>;
+  cancelRun(runId: string): Promise<void>;
+  getArtifact(artifactId: string): Promise<Response>;
+  listArtifacts(runId: string): Promise<ArtifactDescriptor[]>;
+  deleteArtifact(artifactId: string): Promise<void>;
+}
+//#endregion
+//#region src/http/transport.d.ts
+/** Exposes a Fevex instance through the versioned HTTP protocol. */
+declare function createFevexHttpHandler(options: FevexHttpHandlerOptions): FevexHttpHandler;
+declare class FevexHttpError extends Error {
+  readonly problem: FevexProblemDetails;
+  readonly name = "FevexHttpError";
+  constructor(problem: FevexProblemDetails);
+  get status(): number;
+  get code(): string;
+}
+declare function createFevexHttpClient(options: FevexHttpClientOptions): FevexHttpClient;
+//#endregion
+export { FEVEX_HTTP_PROTOCOL_VERSION, FEVEX_HTTP_PROTOCOL_VERSION_HEADER, FevexArtifactAccess, FevexHttpAccess, FevexHttpClient, FevexHttpClientOptions, FevexHttpError, FevexHttpFetch, FevexHttpHandler, FevexHttpHandlerContext, FevexHttpHandlerOptions, FevexProblemDetails, ObserveRunOptions, ResumeRunHttpRequest, StartRunHttpRequest, createFevexHttpClient, createFevexHttpHandler };