@fevex/core 0.1.0-alpha.10 → 0.1.0-alpha.12

package/README.md

@@ -35,12 +35,13 @@ npm install @fevex/core @fevex/openai
 npm install @fevex/core @fevex/deepseek
 ```
 
-CI builds, typechecks, tests and tarball-smokes all ten packages. The
+CI builds, typechecks, tests and tarball-smokes all eleven packages. The
 repository-only integrations below are **not published to npm** by the release
 pipeline; use them from this repository until they are published:
 
 | Package | Purpose |
 | --- | --- |
+| `@fevex/anthropic` | Anthropic Messages API model adapter |
 | `@fevex/mcp` | Model Context Protocol tools and connections |
 | `@fevex/openapi` | Tools generated from an OpenAPI document |
 | `@fevex/sqlite` | SQLite run and session store |
@@ -320,6 +321,20 @@ const model = createDeepSeek({
 })('deepseek-v4-flash');
 ```
 
+Anthropic is available from this repository until it is published:
+
+```ts
+import { createAnthropic } from '@fevex/anthropic';
+
+const model = createAnthropic({
+  apiKey: process.env.ANTHROPIC_API_KEY!,
+})('claude-opus-5-5');
+```
+
+The Anthropic adapter streams Messages API events, replays native thinking and
+`tool_use` blocks through `providerState`, maps reasoning effort to
+`output_config.effort`, and supports strict JSON outputs and tool schemas.
+
 Applications can still implement `ModelGateway` directly as shown above.
 
 Official adapters preserve ordinary model text exactly. JSON-looking text is
@@ -432,9 +447,11 @@ model.started
 model.output.delta
 model.completed
 context.compacted
+memory.completed
 tool.started
 tool.completed
 tool.failed
+policy.evaluated
 run.completed
 run.failed
 run.cancelled
@@ -532,6 +549,7 @@ const started = await app.startAgent('support', {
 });
 
 const run = await app.getRun(started.id);
+const finished = await app.waitForRun(started.id, { timeoutMs: 30_000 });
 const events = await app.listEvents(started.id);
 const laterEvents = await app.listEvents(started.id, {
   after: events.at(-1)?.id,
@@ -540,9 +558,11 @@ const laterEvents = await app.listEvents(started.id, {
 await app.cancelRun(started.id);
 ```
 
-`AgentRun`, `Session` and events are serializable snapshots. `listEvents` orders
-by `sequence`; `after` accepts an event ID from the same run as a stable cursor.
-Unknown cursors fail instead of silently replaying events.
+`waitForRun` waits for the run to leave `running` (paused or terminal) without
+polling, and accepts an optional `signal` and `timeoutMs`. `AgentRun`, `Session`
+and events are serializable snapshots. `listEvents` orders by `sequence`; `after`
+accepts an event ID from the same run as a stable cursor. Unknown cursors fail
+instead of silently replaying events.
 
 `createFevex` uses `InMemoryRunStore` by default. Supply `runStore` to replace
 it. The default survives only while the process lives, and one run at a time
@@ -691,7 +711,23 @@ remain explicit and are intended for server deployments.
 
 Policies run before approval resolution, credentials and each effect or retry.
 Credential values are not stored or sent to the model, and tool outputs that
-contain a resolved value are rejected.
+contain a resolved value are rejected. Every decision emits `policy.evaluated`
+and appears in local traces and OpenTelemetry span events.
+
+For a static baseline, `riskGuardrail()` denies `destructive` tools and requires
+approval for `sensitive` tools. Tools without an explicit `risk` default to
+`read`; set `undeclaredRisk: 'require_approval'` or `'deny'` to fail closed:
+
+```ts
+import { riskGuardrail } from '@fevex/core/policies';
+
+createFevex({
+  models,
+  agents,
+  tools,
+  policies: [riskGuardrail({ undeclaredRisk: 'require_approval' })],
+});
+```
 
 ## Limits
 
@@ -735,7 +771,7 @@ tenant. The default tenant key is a non-empty `context.attributes.tenantId`;
 one runtime process.
 
 `createFevex({ limits: { maxEventsPerRun } })` caps non-control events per run.
-Pause, resume, approval, elicitation, wait and terminal events are always
+Pause, resume, approval, policy, elicitation, wait and terminal events are always
 persisted so a run can always reach a durable state; use retention for a total
 storage cap.
 
@@ -799,7 +835,11 @@ console.log(app.getObservabilityStats());
 
 Workflow and team traces carry `kind` and a span per step. Agent steps expose
 `childRunId`; child agent traces carry `parentRunId` and `rootRunId`, and tool
-spans are nested under the model call that requested them. A dropped trace or a
+spans are nested under the model call that requested them. Memory search and
+write operations produce `search_memory` and `create_memory` GenAI spans. Policy
+decisions are trace annotations and OpenTelemetry span events, with
+`fevex.tool.risk` on tool spans and `gen_ai.memory.*` attributes on memory
+spans. A dropped trace or a
 failed export is counted in `getObservabilityStats()`, and the next
 `flushObservability()` rejects with the failures accumulated since the previous
 flush. OpenTelemetry SDK setup, OTLP export and shutdown remain application
@@ -854,11 +894,60 @@ const report = await runEvaluation({
 ```
 
 Built-in deterministic scorers cover exact output, ordered or unordered tool
-selection, forbidden tools, max latency, max tokens and max cost. Use
-`serializeEvalReport` for a canonical, versionable JSON baseline, `jsonReporter`
-or `textReporter` with your own write callback, and `compareEvaluationReports`
-to fail CI when cases disappear, passing scores fail or scores drop beyond the
-configured tolerance.
+selection, forbidden tools, max latency, max tokens and max cost. Cases can also
+resolve paused approvals and assert the full trajectory:
+
+```ts
+import {
+  riskGuardrailScorer,
+  runEvaluation,
+  trajectoryExpectationScorer,
+} from '@fevex/core/evals';
+
+const report = await runEvaluation({
+  app,
+  suiteName: 'support-regression',
+  targetVersion: 'v2',
+  agentName: 'support',
+  dataset: {
+    name: 'support',
+    version: '1',
+    cases: [{
+      id: 'sensitive-write',
+      input: 'Update account 42',
+      approvals: [{ toolName: 'accounts_update', decision: 'approve' }],
+      expected: {
+        output: { answer: 'Account 42 updated.' },
+        tools: ['accounts_update'],
+        trajectory: [
+          { type: 'policy', toolName: 'accounts_update', decision: 'require_approval' },
+          { type: 'approval', toolName: 'accounts_update', decision: 'approve' },
+          { type: 'tool', name: 'accounts_update', status: 'completed' },
+        ],
+      },
+    }],
+  },
+  scorers: [
+    trajectoryExpectationScorer({ allowAdditional: true }),
+    riskGuardrailScorer(),
+  ],
+});
+```
+
+Trajectory entries cover tool attempts, approval decisions, elicitation
+resolutions and non-allow policy decisions. Cases can also answer elicitation
+pauses with `elicitations`, matched by prompt when provided; the runtime still
+validates each value against its `responseSchema`. Each case has a 10-minute deadline by default; set `deadlineMs`
+on the suite or case to change it. Use `serializeEvalReport` for a canonical,
+versionable JSON baseline,
+`jsonReporter` or `textReporter` with your own write callback, and
+`compareEvaluationReports` to fail CI when cases disappear, passing scores fail
+or scores drop beyond the configured tolerance. Cases warn when an `approvals`
+or `elicitations` fixture was never used; the gate rejects warnings by default.
+`evaluateReleaseGate` adds minimum completion, pass, score, warning, latency and
+cost thresholds; `assertReleaseGate` throws `ReleaseGateError` with the failed
+checks. The repository runs a deterministic release suite with
+`bun run eval:gate` and the built package with `bun run eval:gate:package`.
 
 ## Connections
 
@@ -1189,9 +1278,9 @@ the artifact available.
 | `@fevex/core/teams` | Multiagent team definitions |
 | `@fevex/core/runtime` | Runs, sessions and store contracts |
 | `@fevex/core/sandbox` | Sandbox contract and local development sandbox |
-| `@fevex/core/policies` | Authorization policy contracts |
+| `@fevex/core/policies` | Authorization policy contracts and the risk guardrail |
 | `@fevex/core/observability` | Trace, bounded export queue, redaction and cost contracts |
-| `@fevex/core/evals` | Datasets, scorers, reporters and regressions |
+| `@fevex/core/evals` | Datasets, trajectory and policy scorers, release gates and regressions |
 | `@fevex/core/testing` | Deterministic testing helpers |
 
 All subpaths ship in the same `@fevex/core` package.
@@ -1222,7 +1311,8 @@ The MVP intentionally supports:
 - bounded multi-step model-tool loops with sequential tool execution;
 - native provider streaming and durable, consultable runs;
 - synchronous event observers and `AsyncIterable` event streaming;
-- local traces, OpenTelemetry export and deterministic evaluation suites;
+- local traces, OpenTelemetry export and deterministic evaluation suites with
+  trajectory, policy, approval, cost and release-gate assertions;
 - optional Standard Schema validation;
 - immediate `AbortSignal` cancellation with cooperative underlying work.
 

package/dist/agents/index.d.mts

@@ -1,2 +1,2 @@
-import { a as ToolSearchOptions, i as ToolSearchCheckpointOptions, n as AgentLimits, o as ToolSearchSemanticOptions, r as ContextBudget, s as defineAgent, t as AgentDefinition } from "../index-lCCFokc6.mjs";
+import { a as ToolSearchOptions, i as ToolSearchCheckpointOptions, n as AgentLimits, o as ToolSearchSemanticOptions, r as ContextBudget, s as defineAgent, t as AgentDefinition } from "../index-giFR5t0x.mjs";
 export { AgentDefinition, AgentLimits, ContextBudget, ToolSearchCheckpointOptions, ToolSearchOptions, ToolSearchSemanticOptions, defineAgent };

package/dist/artifacts/index.d.mts

@@ -1,2 +1,2 @@
-import { A as ArtifactError, C as FileSystemArtifactStore, D as ArtifactCatalog, E as CatalogedArtifactStoreOptions, F as ArtifactStore, I as ArtifactStoreContext, L as ArtifactWrite, M as ArtifactId, N as ArtifactQuery, O as ArtifactContent, P as ArtifactRecord, R as artifactTenantId, S as InMemoryArtifactCatalog, T as CatalogedArtifactStore, _ as S3ArtifactStore, b as InMemoryArtifactStore, j as ArtifactErrorCode, k as ArtifactDescriptor, v as S3ArtifactStoreOptions, w as FileSystemArtifactStoreOptions, x as InMemoryArtifactStoreOptions, y as S3ObjectClient, z as assertArtifactId } from "../types-CckDlhYo.mjs";
+import { A as ArtifactError, C as FileSystemArtifactStore, D as ArtifactCatalog, E as CatalogedArtifactStoreOptions, F as ArtifactStore, I as ArtifactStoreContext, L as ArtifactWrite, M as ArtifactId, N as ArtifactQuery, O as ArtifactContent, P as ArtifactRecord, R as artifactTenantId, S as InMemoryArtifactCatalog, T as CatalogedArtifactStore, _ as S3ArtifactStore, b as InMemoryArtifactStore, j as ArtifactErrorCode, k as ArtifactDescriptor, v as S3ArtifactStoreOptions, w as FileSystemArtifactStoreOptions, x as InMemoryArtifactStoreOptions, y as S3ObjectClient, z as assertArtifactId } from "../types-B6hD1o2I.mjs";
 export { ArtifactCatalog, ArtifactContent, ArtifactDescriptor, ArtifactError, ArtifactErrorCode, ArtifactId, ArtifactQuery, ArtifactRecord, ArtifactStore, ArtifactStoreContext, ArtifactWrite, CatalogedArtifactStore, CatalogedArtifactStoreOptions, FileSystemArtifactStore, FileSystemArtifactStoreOptions, InMemoryArtifactCatalog, InMemoryArtifactStore, InMemoryArtifactStoreOptions, S3ArtifactStore, S3ArtifactStoreOptions, S3ObjectClient, artifactTenantId, assertArtifactId };

package/dist/channels/index.d.mts

@@ -1,2 +1,2 @@
-import { a as ChannelDeliveryOptions, c as ChannelEvent, d as ChannelMessage, f as ChannelOutput, h as ChannelRunResult, i as ChannelContext, l as ChannelEventType, m as ChannelRunOptions, n as handleChannelInput, o as ChannelElicitationContext, p as ChannelRunEvent, r as ChannelAdapter, s as ChannelError, t as deliverChannelRun, u as ChannelFailurePhase } from "../index-B8EcvWeN.mjs";
+import { a as ChannelDeliveryOptions, c as ChannelEvent, d as ChannelMessage, f as ChannelOutput, h as ChannelRunResult, i as ChannelContext, l as ChannelEventType, m as ChannelRunOptions, n as handleChannelInput, o as ChannelElicitationContext, p as ChannelRunEvent, r as ChannelAdapter, s as ChannelError, t as deliverChannelRun, u as ChannelFailurePhase } from "../index-AVlWktA8.mjs";
 export { ChannelAdapter, ChannelContext, ChannelDeliveryOptions, ChannelElicitationContext, ChannelError, ChannelEvent, ChannelEventType, ChannelFailurePhase, ChannelMessage, ChannelOutput, ChannelRunEvent, ChannelRunOptions, ChannelRunResult, deliverChannelRun, handleChannelInput };

package/dist/evals/index.d.mts

@@ -1,7 +1,9 @@
-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";
+import { I as ToolRisk } from "../index-AOouohIx.mjs";
+import { r as ModelMetadata, s as ModelUsage } from "../index-Cbe1ZiyN.mjs";
+import { l as JsonValue, o as ExecutionContext, t as AgentEvent } from "../types-B6hD1o2I.mjs";
+import { t as CostCalculator, u as TraceCost } from "../index-B7fxPgn_.mjs";
+import { n as PolicyDecision } from "../index-KKq-_SiK.mjs";
+import { t as Fevex } from "../fevex-B4eNkGTa.mjs";
 //#region src/evals/canonical-json.d.ts
 /** Serializes JSON-like data with stable object-key ordering. */
 declare function serializeCanonical(value: unknown): string;
@@ -10,12 +12,98 @@ declare function serializeCanonical(value: unknown): string;
 interface EvalExpectation {
   output?: JsonValue;
   tools?: string[];
+  trajectory?: EvalTrajectoryExpectation[];
+}
+/** One decision point recorded while an evaluation case runs. */
+type EvalTrajectoryEntry = {
+  type: 'tool';
+  step: number;
+  toolCallId: string;
+  name: string;
+  attempt: number;
+  risk: ToolRisk;
+  declaredRisk?: ToolRisk;
+  status: 'started' | 'completed' | 'failed' | 'unknown' | 'retrying';
+} | {
+  type: 'approval';
+  toolCallId: string;
+  toolName: string;
+  decision: 'approve' | 'reject';
+  actorId: string;
+} | {
+  type: 'elicitation';
+  requestId: string;
+  toolCallId: string;
+  prompt?: string;
+  actorId: string;
+} | {
+  type: 'policy';
+  policyName: string;
+  toolName: string;
+  toolCallId?: string;
+  action: 'tool.execute' | 'approval.resolve';
+  decision: Exclude<PolicyDecision, 'allow'>;
+  risk: ToolRisk;
+  declaredRisk?: ToolRisk;
+};
+/** Expected trajectory step. Omitted fields match any value. */
+type EvalTrajectoryExpectation = {
+  type: 'tool';
+  name: string;
+  status?: 'started' | 'completed' | 'failed' | 'unknown' | 'retrying';
+  attempt?: number;
+  risk?: ToolRisk;
+  declaredRisk?: ToolRisk;
+} | {
+  type: 'approval';
+  toolName: string;
+  decision: 'approve' | 'reject';
+  actorId?: string;
+} | {
+  type: 'elicitation';
+  requestId?: string;
+  toolCallId?: string;
+  prompt?: string;
+  actorId?: string;
+} | {
+  type: 'policy';
+  toolName: string;
+  decision: Exclude<PolicyDecision, 'allow'>;
+  policyName?: string;
+  action?: 'tool.execute' | 'approval.resolve';
+  declaredRisk?: ToolRisk;
+};
+/** Approval resolution supplied by an evaluation case when a run pauses. */
+interface EvalApproval {
+  /** Tool name required to match the paused approval. Omit to accept any tool. */
+  toolName?: string;
+  decision: 'approve' | 'reject';
+  actor?: {
+    id: string;
+    type?: string;
+  };
+}
+/** Elicitation value supplied by an evaluation case when a run pauses. */
+interface EvalElicitation {
+  /** Prompt text required to match the paused request. Omit to accept any prompt. */
+  prompt?: string;
+  value: JsonValue;
+  actor?: {
+    id: string;
+    type?: string;
+  };
 }
 interface EvalCase<TInput = unknown> {
   id: string;
   input: TInput;
   expected?: EvalExpectation;
   context?: ExecutionContext;
+  /** Resolutions consumed in order when the run pauses for approval. */
+  approvals?: readonly EvalApproval[];
+  /** Values consumed in order when the run pauses for elicitation. */
+  elicitations?: readonly EvalElicitation[];
+  /** Maximum wall-clock time for this case, including pauses. */
+  deadlineMs?: number;
 }
 interface EvalDataset<TInput = unknown> {
   name: string;
@@ -26,6 +114,7 @@ interface EvalScorerContext<TInput = unknown> {
   testCase: EvalCase<TInput>;
   output?: JsonValue;
   tools: readonly string[];
+  trajectory: readonly EvalTrajectoryEntry[];
   events: readonly AgentEvent[];
   usage?: ModelUsage;
   cost?: TraceCost;
@@ -57,10 +146,12 @@ interface EvalCaseReport {
   status: 'completed' | 'failed';
   output?: JsonValue;
   tools: string[];
+  trajectory?: EvalTrajectoryEntry[];
   usage?: ModelUsage;
   cost?: TraceCost;
   latencyMs: number;
   scores: EvalScore[];
+  warnings?: string[];
   error?: string;
 }
 interface EvalSummary {
@@ -71,6 +162,8 @@ interface EvalSummary {
   failedScoreCount: number;
   skippedScoreCount: number;
   errorScoreCount: number;
+  /** Absent on reports created before case warnings existed. */
+  warningCount?: number;
   averageScore?: number;
   usage?: ModelUsage;
   cost?: TraceCost;
@@ -107,6 +200,8 @@ interface RunEvaluationOptions<TInput = unknown> {
   reporters?: readonly EvalReporter[];
   cost?: EvalCostOptions;
   signal?: AbortSignal;
+  /** Default per-case wall-clock deadline. Defaults to 10 minutes. */
+  deadlineMs?: number;
 }
 interface Regression {
   kind: 'case_removed' | 'case_failed' | 'scorer_removed' | 'score_failed' | 'score_dropped' | 'latency_increased' | 'cost_increased';
@@ -125,6 +220,59 @@ interface RegressionOptions {
   maxLatencyIncreaseRatio?: number;
   maxCostIncreaseRatio?: number;
 }
+/** Minimum aggregate requirements for a release evaluation gate. */
+interface EvalGateThresholds {
+  /** Fraction of cases that must complete. Defaults to 1. */
+  minCompletionRate?: number;
+  /** Fraction of non-skipped scores that must pass. Defaults to 1. */
+  minPassRate?: number;
+  /** Maximum failed scores across all cases. Defaults to 0. */
+  maxFailedScores?: number;
+  /** Maximum scorer errors across all cases. Defaults to 0. */
+  maxErrorScores?: number;
+  /** Maximum case warnings, such as unused resolution fixtures. Defaults to 0. */
+  maxWarnings?: number;
+  /** Minimum average score across numeric results. */
+  minAverageScore?: number;
+  /** Scorers that must be present in the report. */
+  requiredScorers?: readonly string[];
+  /** Maximum aggregate latency. */
+  maxLatencyMs?: number;
+  /** Maximum aggregate cost. Currency must match exactly. */
+  maxCost?: TraceCost;
+}
+interface ReleaseGateOptions extends EvalGateThresholds {
+  /** Optional baseline report; trajectory or policy regressions fail the gate. */
+  baseline?: EvalReport;
+  regression?: RegressionOptions;
+}
+interface EvalScorecard {
+  caseCount: number;
+  completedCount: number;
+  completionRate: number;
+  passedScoreCount: number;
+  failedScoreCount: number;
+  skippedScoreCount: number;
+  errorScoreCount: number;
+  warningCount: number;
+  passRate: number;
+  averageScore?: number;
+  latencyMs: number;
+  cost?: TraceCost;
+}
+interface EvalGateCheck {
+  name: string;
+  passed: boolean;
+  message: string;
+  expected?: JsonValue;
+  actual?: JsonValue;
+}
+interface ReleaseGateResult {
+  passed: boolean;
+  scorecard: EvalScorecard;
+  checks: EvalGateCheck[];
+  regressions: Regression[];
+}
 //#endregion
 //#region src/evals/evaluation.d.ts
 /** Runs every case and scorer, producing a deterministic aggregate report. */
@@ -134,6 +282,18 @@ 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;
+/**
+ * Evaluates minimum scorecard thresholds and an optional baseline. A trajectory
+ * or policy regression appears as a failed score and blocks the gate even when
+ * the final output is correct.
+ */
+declare function evaluateReleaseGate(report: EvalReport, options?: ReleaseGateOptions): ReleaseGateResult;
+declare class ReleaseGateError extends Error {
+  readonly result: ReleaseGateResult;
+  readonly name = "ReleaseGateError";
+  constructor(result: ReleaseGateResult);
+}
+declare function assertReleaseGate(report: EvalReport, options?: ReleaseGateOptions): ReleaseGateResult;
 //#endregion
 //#region src/evals/scorers.d.ts
 declare function exactOutputScorer(id?: string): EvalScorer;
@@ -149,5 +309,38 @@ declare function maxTokensScorer(limits: {
   total?: number;
 }, id?: string): EvalScorer;
 declare function maxCostScorer(maxAmount: number, currency: string, id?: string): EvalScorer;
+interface TrajectoryScorerOptions {
+  id?: string;
+  /** Defaults to true. Set false to assert the same steps in any order. */
+  ordered?: boolean;
+  /** Defaults to false. Set true to allow unasserted steps. */
+  allowAdditional?: boolean;
+}
+/** Asserts the ordered tool, approval and non-allow policy decisions of a run. */
+declare function trajectoryScorer(expected: readonly EvalTrajectoryExpectation[], options?: TrajectoryScorerOptions): EvalScorer;
+/** Reads the expected trajectory from each dataset case. */
+declare function trajectoryExpectationScorer(options?: TrajectoryScorerOptions): EvalScorer;
+type ApprovalExpectation = Extract<EvalTrajectoryExpectation, {
+  type: 'approval';
+}>;
+type ElicitationExpectation = Extract<EvalTrajectoryExpectation, {
+  type: 'elicitation';
+}>;
+type PolicyExpectation = Extract<EvalTrajectoryExpectation, {
+  type: 'policy';
+}>;
+declare function approvalScorer(expected: readonly ApprovalExpectation[], options?: TrajectoryScorerOptions): EvalScorer;
+declare function elicitationScorer(expected: readonly ElicitationExpectation[], options?: TrajectoryScorerOptions): EvalScorer;
+declare function policyScorer(expected: readonly PolicyExpectation[], options?: TrajectoryScorerOptions): EvalScorer;
+interface RiskGuardrailScorerOptions {
+  /** Risks that must never execute. Defaults to `destructive`. */
+  deny?: readonly ToolRisk[];
+  /** Risks that must have an approved approval before execution. Defaults to `sensitive`. */
+  requireApproval?: readonly ToolRisk[];
+  /** Expected handling of tools that omit `risk`. Defaults to `allow`. */
+  undeclaredRisk?: 'allow' | 'require_approval' | 'deny';
+}
+/** Asserts that risky tools respected the configured guardrail. */
+declare function riskGuardrailScorer(options?: RiskGuardrailScorerOptions, id?: string): EvalScorer;
 //#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 };
+export { EvalApproval, EvalCase, EvalCaseReport, EvalCostOptions, EvalDataset, EvalElicitation, EvalExpectation, EvalGateCheck, EvalGateThresholds, EvalReport, EvalReporter, EvalScore, EvalScoreStatus, EvalScorecard, EvalScorer, EvalScorerContext, EvalScorerResult, EvalSummary, EvalTrajectoryEntry, EvalTrajectoryExpectation, Regression, RegressionOptions, RegressionReport, ReleaseGateError, ReleaseGateOptions, ReleaseGateResult, RiskGuardrailScorerOptions, RunEvaluationOptions, TrajectoryScorerOptions, approvalScorer, assertReleaseGate, compareEvaluationReports, elicitationScorer, evaluateReleaseGate, exactOutputScorer, forbiddenToolsScorer, jsonReporter, maxCostScorer, maxLatencyScorer, maxTokensScorer, parseEvalReport, policyScorer, riskGuardrailScorer, runEvaluation, serializeCanonical, serializeEvalReport, textReporter, toolSelectionScorer, trajectoryExpectationScorer, trajectoryScorer };