agentfootprint 6.43.0 → 6.45.0

package/dist/esm/recorders/observability/trace.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Trace — a UI-free, JSON-lossless snapshot of a run for OFFLINE REPLAY.
+ *
+ * `localObservability()` (Tier-3 / Debug) retains a live model during a run.
+ * `serializeTrace()` freezes that model into a `Trace` — plain JSON you can
+ * persist (file, Redis, a bug report) and later rehydrate WITHOUT re-running
+ * the agent. `agentfootprint-lens`'s `<Replay trace={…} />` consumes it and
+ * rebuilds the flowchart via the existing translators.
+ *
+ * A `Trace` stores ONLY the domain-event log (the single source of truth the
+ * Lens already reads). The step graph is ALWAYS a derived projection of those
+ * events (footprint.js's "graph is derived, never post-processed" principle) —
+ * it is rebuilt at render time, never stored. Storing a derived graph would be
+ * redundant AND a redaction hazard: a second content surface a per-event
+ * `redact` could never reach.
+ *
+ * PII / trust boundary: the event log carries real content — `llm.end.content`,
+ * `tool.start.args`, `tool.end.result`, `context.injected.contentSummary`,
+ * `run`/`subflow` `payload`, `decision.branch.rationale`. A live, in-process
+ * model is fine, but **serializing is a trust-boundary crossing** (the trace
+ * can travel). So redaction is applied HERE, at serialize time, via a
+ * consumer `redact` function — PII never enters the `Trace`. `redactContent`
+ * is a ready-made redactor covering every content field. The result is
+ * self-describing: `trace.redaction`. See
+ * `docs/design/local-observability-and-pii.md`.
+ *
+ * Because `getEvents()` is FLAT (parent + every subflow), one `redact` pass
+ * covers the whole tree — no per-subflow inheritance needed here. (The engine's
+ * `RedactionPolicy` separately propagates to subflows for the OBSERVER mirror.)
+ */
+import type { DomainEvent } from './BoundaryRecorder.js';
+import { type StepGraph } from './FlowchartRecorder.js';
+/**
+ * How a `Trace` was redacted before serialization.
+ * - `'none'`   — raw content (no `redact`). A `<Replay>` UI may warn.
+ * - `'pii'`    — a consumer `redact` ran (the default label when one is given).
+ * - `'policy'` — produced from a declarative `RedactionPolicy` (future).
+ */
+export type TraceRedaction = 'none' | 'pii' | 'policy';
+/** Cheap headline rollup, so a consumer can show totals without folding `events`. */
+export interface TraceSummary {
+    readonly tokens: {
+        readonly input: number;
+        readonly output: number;
+    };
+    readonly llmCalls: number;
+    readonly toolCalls: number;
+    readonly durationMs?: number;
+}
+/**
+ * A JSON-lossless, UI-free snapshot of one run. Persist it, ship it, replay it.
+ * `events` ARE the run (the graph is a derived projection, rebuilt at render).
+ */
+export interface Trace {
+    /** Schema version. Bump on a breaking shape change. */
+    readonly version: 1;
+    /** The domain-event log — the whole timeline. Already redacted if `redact` ran. */
+    readonly events: readonly DomainEvent[];
+    /**
+     * The serialized STATIC chart structure (footprint.js `buildTimeStructure`).
+     * Design-time data (stage ids/names/types/edges) — UI-free. `<Replay>` rebuilds
+     * the flowchart from this and overlays `events`, so an offline replay matches
+     * the live `<Lens>` exactly. NOT runtime-redacted (it carries no user data; the
+     * `redact` function targets runtime events).
+     */
+    readonly structure?: unknown;
+    /** Optional headline totals. */
+    readonly summary?: TraceSummary;
+    /** Self-describing redaction state — travels with the trace. */
+    readonly redaction: TraceRedaction;
+    /** Wall-clock capture time, stamped by the caller (the engine has no clock here). */
+    readonly capturedAtMs?: number;
+}
+export interface SerializeTraceOptions {
+    /**
+     * Consumer redaction — runs once per domain event at the serialize boundary,
+     * so PII never enters the `Trace`. Return a scrubbed COPY (do not mutate the
+     * input — the live model still references it). Use `redactContent` for a
+     * ready-made redactor. When omitted, content is raw.
+     */
+    readonly redact?: (event: DomainEvent) => DomainEvent;
+    /** Override the `redaction` label. Defaults to `'pii'` when `redact` is given, else `'none'`. */
+    readonly redactionLabel?: TraceRedaction;
+    /** The serialized static chart (`getSpec().buildTimeStructure`) — for `<Replay>` to rebuild the flowchart. */
+    readonly structure?: unknown;
+    /** Optional precomputed headline rollup. */
+    readonly summary?: TraceSummary;
+    /** Wall-clock capture time. Pass `Date.now()` from the call site. */
+    readonly capturedAtMs?: number;
+}
+/**
+ * Ready-made redactor: replaces every content-bearing field with a marker,
+ * keeping structure/counts for a useful replay. Covers ALL `DomainEvent`
+ * content surfaces — pass it to `getTrace({ redact: redactContent })`.
+ *
+ * Returns a copy only when it changes something, so unaffected events stay
+ * referentially identical (cheap) and the caller's live model is never mutated.
+ */
+export declare function redactContent(event: DomainEvent): DomainEvent;
+/**
+ * Freeze a live run model into a `Trace`. Pure: pass the `BoundaryRecorder`'s
+ * `getEvents()` output.
+ *
+ *   const trace = serializeTrace(handle.boundary.getEvents(), {
+ *     redact: redactContent,         // PII stripped before it enters the trace
+ *     capturedAtMs: Date.now(),
+ *   });
+ *   fs.writeFileSync('run.trace.json', JSON.stringify(trace));
+ */
+export declare function serializeTrace(events: readonly DomainEvent[], options?: SerializeTraceOptions): Trace;
+/**
+ * Rebuild the step graph from a `Trace` — the offline half of replay. The graph
+ * is ALWAYS a derived projection of `trace.events`; because those events were
+ * already redacted at serialize time, the rebuilt graph is clean too (no extra
+ * redaction needed — that's exactly why the graph is never stored). UI-free:
+ * `agentfootprint-lens`'s `<Replay>` translates this `StepGraph` into its
+ * xyflow render model.
+ */
+export declare function traceToStepGraph(trace: Trace): StepGraph;

package/dist/esm/recorders/observability/trace.js

@@ -0,0 +1,99 @@
+/**
+ * Trace — a UI-free, JSON-lossless snapshot of a run for OFFLINE REPLAY.
+ *
+ * `localObservability()` (Tier-3 / Debug) retains a live model during a run.
+ * `serializeTrace()` freezes that model into a `Trace` — plain JSON you can
+ * persist (file, Redis, a bug report) and later rehydrate WITHOUT re-running
+ * the agent. `agentfootprint-lens`'s `<Replay trace={…} />` consumes it and
+ * rebuilds the flowchart via the existing translators.
+ *
+ * A `Trace` stores ONLY the domain-event log (the single source of truth the
+ * Lens already reads). The step graph is ALWAYS a derived projection of those
+ * events (footprint.js's "graph is derived, never post-processed" principle) —
+ * it is rebuilt at render time, never stored. Storing a derived graph would be
+ * redundant AND a redaction hazard: a second content surface a per-event
+ * `redact` could never reach.
+ *
+ * PII / trust boundary: the event log carries real content — `llm.end.content`,
+ * `tool.start.args`, `tool.end.result`, `context.injected.contentSummary`,
+ * `run`/`subflow` `payload`, `decision.branch.rationale`. A live, in-process
+ * model is fine, but **serializing is a trust-boundary crossing** (the trace
+ * can travel). So redaction is applied HERE, at serialize time, via a
+ * consumer `redact` function — PII never enters the `Trace`. `redactContent`
+ * is a ready-made redactor covering every content field. The result is
+ * self-describing: `trace.redaction`. See
+ * `docs/design/local-observability-and-pii.md`.
+ *
+ * Because `getEvents()` is FLAT (parent + every subflow), one `redact` pass
+ * covers the whole tree — no per-subflow inheritance needed here. (The engine's
+ * `RedactionPolicy` separately propagates to subflows for the OBSERVER mirror.)
+ */
+import { buildStepGraphFromEvents } from './FlowchartRecorder.js';
+/**
+ * Ready-made redactor: replaces every content-bearing field with a marker,
+ * keeping structure/counts for a useful replay. Covers ALL `DomainEvent`
+ * content surfaces — pass it to `getTrace({ redact: redactContent })`.
+ *
+ * Returns a copy only when it changes something, so unaffected events stay
+ * referentially identical (cheap) and the caller's live model is never mutated.
+ */
+export function redactContent(event) {
+    switch (event.type) {
+        case 'llm.end':
+            return { ...event, content: `[${event.content.length} chars]` };
+        case 'tool.start':
+            return event.args !== undefined ? { ...event, args: '[redacted]' } : event;
+        case 'tool.end':
+            return event.result !== undefined ? { ...event, result: '[redacted]' } : event;
+        case 'context.injected':
+            return event.contentSummary !== undefined
+                ? { ...event, contentSummary: '[redacted]' }
+                : event;
+        case 'run.entry':
+        case 'run.exit':
+            return event.payload !== undefined ? { ...event, payload: '[redacted]' } : event;
+        case 'subflow.entry':
+        case 'subflow.exit':
+            return event.payload !== undefined ? { ...event, payload: '[redacted]' } : event;
+        case 'decision.branch':
+            return event.rationale !== undefined ? { ...event, rationale: '[redacted]' } : event;
+        default:
+            return event;
+    }
+}
+/**
+ * Freeze a live run model into a `Trace`. Pure: pass the `BoundaryRecorder`'s
+ * `getEvents()` output.
+ *
+ *   const trace = serializeTrace(handle.boundary.getEvents(), {
+ *     redact: redactContent,         // PII stripped before it enters the trace
+ *     capturedAtMs: Date.now(),
+ *   });
+ *   fs.writeFileSync('run.trace.json', JSON.stringify(trace));
+ */
+export function serializeTrace(events, options = {}) {
+    const { redact, redactionLabel, structure, summary, capturedAtMs } = options;
+    // A fresh array either way, so a held Trace is detached from the live store.
+    const safeEvents = redact ? events.map((e) => redact(e)) : events.slice();
+    const redaction = redactionLabel ?? (redact ? 'pii' : 'none');
+    return {
+        version: 1,
+        events: safeEvents,
+        ...(structure !== undefined && { structure }),
+        ...(summary !== undefined && { summary }),
+        redaction,
+        ...(capturedAtMs !== undefined && { capturedAtMs }),
+    };
+}
+/**
+ * Rebuild the step graph from a `Trace` — the offline half of replay. The graph
+ * is ALWAYS a derived projection of `trace.events`; because those events were
+ * already redacted at serialize time, the rebuilt graph is clean too (no extra
+ * redaction needed — that's exactly why the graph is never stored). UI-free:
+ * `agentfootprint-lens`'s `<Replay>` translates this `StepGraph` into its
+ * xyflow render model.
+ */
+export function traceToStepGraph(trace) {
+    return buildStepGraphFromEvents(trace.events);
+}
+//# sourceMappingURL=trace.js.map

package/dist/esm/recorders/observability/trace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace.js","sourceRoot":"","sources":["../../../../src/recorders/observability/trace.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAGH,OAAO,EAAE,wBAAwB,EAAkB,MAAM,wBAAwB,CAAC;AA6DlF;;;;;;;GAOG;AACH,MAAM,UAAU,aAAa,CAAC,KAAkB;IAC9C,QAAQ,KAAK,CAAC,IAAI,EAAE,CAAC;QACnB,KAAK,SAAS;YACZ,OAAO,EAAE,GAAG,KAAK,EAAE,OAAO,EAAE,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,SAAS,EAAE,CAAC;QAClE,KAAK,YAAY;YACf,OAAO,KAAK,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,GAAG,KAAK,EAAE,IAAI,EAAE,YAAY,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC;QAC7E,KAAK,UAAU;YACb,OAAO,KAAK,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,GAAG,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC;QACjF,KAAK,kBAAkB;YACrB,OAAO,KAAK,CAAC,cAAc,KAAK,SAAS;gBACvC,CAAC,CAAC,EAAE,GAAG,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE;gBAC5C,CAAC,CAAC,KAAK,CAAC;QACZ,KAAK,WAAW,CAAC;QACjB,KAAK,UAAU;YACb,OAAO,KAAK,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,GAAG,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC;QACnF,KAAK,eAAe,CAAC;QACrB,KAAK,cAAc;YACjB,OAAO,KAAK,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,GAAG,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC;QACnF,KAAK,iBAAiB;YACpB,OAAO,KAAK,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,GAAG,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC;QACvF;YACE,OAAO,KAAK,CAAC;IACjB,CAAC;AACH,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,cAAc,CAC5B,MAA8B,EAC9B,UAAiC,EAAE;IAEnC,MAAM,EAAE,MAAM,EAAE,cAAc,EAAE,SAAS,EAAE,OAAO,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC;IAC7E,6EAA6E;IAC7E,MAAM,UAAU,GAAG,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;IAC1E,MAAM,SAAS,GAAmB,cAAc,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;IAC9E,OAAO;QACL,OAAO,EAAE,CAAC;QACV,MAAM,EAAE,UAAU;QAClB,GAAG,CAAC,SAAS,KAAK,SAAS,IAAI,EAAE,SAAS,EAAE,CAAC;QAC7C,GAAG,CAAC,OAAO,KAAK,SAAS,IAAI,EAAE,OAAO,EAAE,CAAC;QACzC,SAAS;QACT,GAAG,CAAC,YAAY,KAAK,SAAS,IAAI,EAAE,YAAY,EAAE,CAAC;KACpD,CAAC;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAY;IAC3C,OAAO,wBAAwB,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;AAChD,CAAC"}

package/dist/esm/reliability/CircuitBreaker.d.ts

@@ -0,0 +1,75 @@
+/**
+ * CircuitBreaker — pure state-machine functions for the Nygard breaker
+ * pattern.
+ *
+ * Refactored from a class-with-instance-state to PURE FUNCTIONS that
+ * take a state record and return a new one. Reasons:
+ *
+ *   1. **No hidden runtime state.** Breaker state lives in scope where
+ *      it's visible to commitLog, narrative, and rules — the footprintjs
+ *      "everything in scope" principle. The closure used to be the
+ *      source of truth and scope held only a projection; now scope IS
+ *      the source of truth.
+ *
+ *   2. **Round-trippable across gate invocations.** Because state is a
+ *      plain record, gate's outputMapper writes it back to agent scope;
+ *      agent scope persists across the ReAct loop's many LLM-call gate
+ *      invocations; gate's inputMapper reads it back in for the next
+ *      call. Per-process persistence comes from the agent scope, not
+ *      from a closure that hides between runs.
+ *
+ *   3. **Distributable later.** A future v2.12 `BreakerStateStore`
+ *      adapter (Redis/DynamoDB) just needs to serialize/deserialize the
+ *      state record. No class instances to reconstruct.
+ *
+ *   4. **Testable in isolation.** Pure functions; no instance setup.
+ *
+ * Pattern: Nygard *Release It!* — three states (CLOSED → OPEN →
+ *          HALF-OPEN) with cooldown and probe-success thresholds.
+ */
+import type { CircuitBreakerConfig } from './types.js';
+export type CircuitState = 'closed' | 'open' | 'half-open';
+/** Plain serializable record holding one breaker's full state. */
+export interface BreakerState {
+    state: CircuitState;
+    consecutiveFailures: number;
+    consecutiveSuccesses: number;
+    openedAt: number;
+    lastErrorMessage?: string;
+}
+/**
+ * Thrown by `assertAdmit()` when the breaker is OPEN and the cooldown
+ * window has not elapsed. The reliability gate stage catches this,
+ * classifies via `classifyError` → `'circuit-open'`, and lets the
+ * post-decide rules route on it.
+ */
+export declare class CircuitOpenError extends Error {
+    readonly code: "ERR_CIRCUIT_OPEN";
+    readonly cause: unknown;
+    readonly retryAfter: number;
+    constructor(providerName: string, lastErrorMessage: string | undefined, retryAfter: number);
+}
+/** Initial state for a freshly-CLOSED breaker. */
+export declare function initialBreakerState(): BreakerState;
+/**
+ * Decide whether to admit a call. Returns the (possibly-updated) state
+ * AND whether to admit. If OPEN and cooldown elapsed, transitions to
+ * HALF-OPEN and admits. Pure: caller must use the returned state.
+ *
+ * Usage in the gate stage:
+ * ```ts
+ * const { admitted, nextState } = admitCall(scope.breakerStates[name], config);
+ * scope.breakerStates[name] = nextState;
+ * if (!admitted) throw new CircuitOpenError(name, nextState.lastErrorMessage, ...);
+ * ```
+ */
+export declare function admitCall(state: BreakerState, config: CircuitBreakerConfig | undefined): {
+    admitted: boolean;
+    nextState: BreakerState;
+};
+/** Record a successful call. Returns the (possibly-updated) state. */
+export declare function recordSuccess(state: BreakerState, config: CircuitBreakerConfig | undefined): BreakerState;
+/** Record a failed call. Returns the (possibly-updated) state. */
+export declare function recordFailure(state: BreakerState, err: unknown, config: CircuitBreakerConfig | undefined): BreakerState;
+/** Compute the next probe time given a state + config. */
+export declare function nextProbeTime(state: BreakerState, config: CircuitBreakerConfig | undefined): number;

package/dist/esm/reliability/buildReliabilityGateChart.d.ts

@@ -0,0 +1,53 @@
+/**
+ * buildReliabilityGateChart — produces a footprintjs FlowChart that wraps
+ * an LLM call with rules-based reliability semantics, using the native
+ * `decide()` DSL via `addDeciderFunction` decider stages.
+ *
+ * The returned chart is mounted as a subflow in the agent's chart at
+ * Agent.build() time (only when reliability is configured). Inside the
+ * subflow:
+ *
+ *   PreCheck (decider) → CallProvider (function) → PostDecide (decider)
+ *                                                       │
+ *                                       ┌───────────────┘
+ *                                       ▼ loopTo('pre-check')
+ *
+ * Branch outcomes (escape via $break() to stop the gate's loop;
+ * fall-through via no-$break to trigger loopTo back to PreCheck):
+ *
+ *   PreCheck:
+ *     'continue'   → no-op   → falls through to CallProvider
+ *     'fail-fast'  → set failKind, $emit, $break(reason)
+ *
+ *   PostDecide:
+ *     'ok'          → $break() (subflow exits normally; agent continues)
+ *     'retry'       → bump attempt; falls through to loopTo
+ *     'retry-other' → bump providerIdx; falls through to loopTo
+ *     'fallback'    → call config.fallback(); $break() on success
+ *     'fail-fast'   → set failKind, $emit, $break(reason)
+ *
+ * The subflow is mounted WITHOUT `propagateBreak: true`. Subflow $break is
+ * local — agent.ts adds a `TranslateFailFast` agent-level stage AFTER the
+ * subflow that reads scope.reliabilityFailKind and converts it into an
+ * agent-level `$break(reason)`. This split lets normal subflow exits
+ * (`ok`/`fallback`) leave the agent running while fail-fast stops it.
+ *
+ * Three-channel discipline preserved:
+ *   • SCOPE STATE  — failKind/failPayload/failReason mapped to parent via
+ *                    outputMapper; consumed by agent's TranslateFailFast.
+ *   • $emit        — passive observability for external consumers.
+ *   • $break(reason)— control flow + human reason for narrative.
+ */
+import type { FlowChart } from 'footprintjs';
+import type { ReliabilityConfig } from './types.js';
+/**
+ * Build the reliability gate FlowChart from a config. Mount via
+ * `addSubFlowChartNext` in the agent's chart — see `Agent.build()`.
+ *
+ * Closure state captured by stage functions:
+ *   • `breakers` — Map<providerName, CircuitBreaker>; per-instance state
+ *     persists across gate invocations within ONE agent process.
+ *   • `preRules` / `postRules` — frozen rule arrays.
+ *   • `fallbackFn` — consumer's fallback function, if configured.
+ */
+export declare function buildReliabilityGateChart(config: ReliabilityConfig): FlowChart;

package/dist/esm/reliability/classifyError.d.ts

@@ -0,0 +1,28 @@
+/**
+ * classifyError — pure function mapping a thrown error to one of the
+ * coarse `ReliabilityScope.errorKind` categories used by reliability rules.
+ *
+ * Centralized so rules read structured `errorKind` instead of doing
+ * regex on `error.message` themselves. Add new categories ONLY when a
+ * new rule needs to discriminate them — keep the taxonomy small.
+ *
+ * Categories:
+ *   • 'ok'             — no error (caller should pass `undefined` or omit)
+ *   • 'circuit-open'   — `CircuitOpenError` from the breaker layer
+ *   • 'rate-limit'     — HTTP 429 or vendor rate-limit signal
+ *   • '5xx-transient'  — HTTP 5xx, ETIMEDOUT, ECONNRESET, ECONNREFUSED
+ *   • 'schema-fail'    — `OutputSchemaError` from the schema validator
+ *   • 'unknown'        — anything else (default; still routable but
+ *                        consumers usually `'fail-fast'` on this)
+ */
+import type { ReliabilityScope } from './types.js';
+type ErrorKind = ReliabilityScope['errorKind'];
+/**
+ * Classify an error into a `ReliabilityScope['errorKind']` category.
+ *
+ * @param err - The thrown value. May be an Error, a vendor SDK error
+ *   shape with `.status`/`.code`, or anything else (`unknown` defaults).
+ * @returns the matching coarse category string.
+ */
+export declare function classifyError(err: unknown): ErrorKind;
+export {};

package/dist/esm/reliability/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Reliability — public surface for the v2.11.1 rules-based reliability
+ * subsystem. Internal-only helpers (CircuitBreaker class, classifyError,
+ * buildReliabilityGate) live in their own files; this barrel exports
+ * the consumer-facing types and the typed error.
+ *
+ * Consumer use:
+ * ```ts
+ * import { Agent } from 'agentfootprint';
+ * import type { ReliabilityRule, ReliabilityScope } from 'agentfootprint/reliability';
+ * import { ReliabilityFailFastError } from 'agentfootprint/reliability';
+ *
+ * const agent = Agent.create({...}).reliability({
+ *   postDecide: [
+ *     { when: (s) => s.errorKind === '5xx-transient' && s.attempt < 3,
+ *       then: 'retry', kind: 'transient-retry' },
+ *     { when: (s) => s.error !== undefined,
+ *       then: 'fail-fast', kind: 'unrecoverable' },
+ *   ],
+ * }).build();
+ *
+ * try {
+ *   await agent.run({ message: '...' });
+ * } catch (e) {
+ *   if (e instanceof ReliabilityFailFastError) {
+ *     console.log(e.kind, e.reason);
+ *   }
+ * }
+ * ```
+ */
+export type { CircuitBreakerConfig, ReliabilityConfig, ReliabilityDecision, ReliabilityFallbackFn, ReliabilityProvider, ReliabilityRule, ReliabilityScope, } from './types.js';
+export { ReliabilityFailFastError } from './types.js';
+export { CircuitOpenError, initialBreakerState, type BreakerState, type CircuitState, } from './CircuitBreaker.js';
+export { ValidationFailure, lastNValidationErrorsMatch, defaultStuckLoopRule, } from '../core/agent/stages/reliabilityExecution.js';
+export type { OutputSchemaValidator } from '../core/agent/stages/reliabilityExecution.js';