@noetaris/harness 0.12.0 → 0.13.0

package/README.md

@@ -29,13 +29,15 @@ interface Ctx {
 }
 
 // 2. Create the harness — fixes Ctx and infers State from the field schema
-const h = createHarness<Ctx>()({
+const base = createHarness<Ctx>()({
   messages:  field<string[]>({ default: () => [],  reduce: (a, b) => [...a, ...b] }),
   toolCalls: field<any[]>   ({ default: () => [] }),
+  toolResults: field<any[]>({ default: () => [] }),
 })
 
-// 3. Define the loop — validated immediately at call time
-h.loop(l =>
+// 3. Define the loop — validated immediately at call time.
+//    Each builder call returns a new harness: keep the result.
+const withLoop = base.loop(l =>
   l.start()
    .step('think', {
      run: async (state, ctx) => {
@@ -57,9 +59,10 @@ h.loop(l =>
 )
 
 // 4. Declare providers
-h.provide('tools',   { search: new MySearchTool() }) // hard-coded
-h.provide('prompts', required())                     // must be supplied at createAgent()
-h.provide('model',   runtime())                      // must be supplied at agent.run()
+const h = withLoop
+  .provide('tools',   { search: new MySearchTool() }) // hard-coded
+  .provide('prompts', required())                     // must be supplied at createAgent()
+  .provide('model',   runtime())                      // must be supplied at agent.run()
 
 // 5. Create an agent — assigns an ID and fills required() slots
 const agent = createAgent('my-agent', h, {
@@ -166,6 +169,7 @@ does depends on the session's latest run:
 | completed | a new turn | returns its outcome, runs nothing |
 | paused on an interrupt | resolves `$error` with `SessionPendingInterruptError` | returns its outcome (`signal: '$interrupt'`), runs nothing |
 | paused by a stop or an unhandled error | merges the input and continues from where it paused | continues from where it paused, **without** merging the input again |
+| a checkpoint (`'running'`: its instance died mid-run, see [Checkpoints](#checkpoints)) | merges the input and continues from the last finished step | continues after the last finished step, **without** merging the input again |
 
 A retry of an earlier request (not the latest) is found with the store's optional
 `findRequest` and its outcome is returned; it never runs again, since later turns have
@@ -187,6 +191,106 @@ Notes:
 - `sessionId` and `requestId` must be non-empty strings when given; otherwise `agent.run()`
   throws `InvalidRunResourceError`.
 
+### Checkpoints
+
+By default a session is saved only when a run settles. If the instance dies in the middle of a
+long turn, the next run starts the whole turn again, and the side effects of the steps that
+already finished happen again. With `checkpoint: 'step'`, the session is also saved after every
+finished top-level step:
+
+```ts
+const agent = createAgent('agent', h, {}, { checkpoint: 'step' })   // every run of this agent
+agent.run(input, { sessionId, requestId, checkpoint: 'off' })        // or per call: 'off' | 'step'
+```
+
+```
+ turn ── a ── save ── b ── save ── c ──✕ crash
+                         ↑
+       next run ─────────┘ continues from c; a and b do not run again
+```
+
+- Each checkpoint is a new stored run with `phase: 'running'`, `step` = the next step to run,
+  and the state after the finished step. `agent.status()` reports it as
+  `{ phase: 'running', step, instanceId?, checkpointedAt }`.
+- Running the session again continues from that step, like a stopped run (see the table above):
+  a retry with the same `requestId` does not merge its input again. With a store that supports
+  claims, another instance gets `SessionBusyError` while the owner's claim is alive, and can take
+  over once it expires.
+- Steps run **at least once**: only the step that was running when the instance died runs
+  again, so only that step needs to be idempotent.
+- A fork is saved as a whole: there is a checkpoint before it and after it, none inside. A crash
+  inside a fork runs the whole fork again.
+- After each checkpoint the claim is extended. A single step that runs longer than the claim TTL
+  still needs `ctx.keepAlive()`.
+- `onCheckpoint(ctx, { step, version, durationMs })` on an [observer](#observers) reports each
+  saved checkpoint. A checkpoint that is skipped (its state can't be copied with
+  `structuredClone`, or the store failed) is reported to `events.onStoreError` with phase
+  `'checkpoint'`, and the run goes on.
+- When the store reports that another writer saved the session first, or that this instance's
+  claim was taken over, the run stops at once with `LeaseExpiredError` (reported with phase
+  `'claim'`) and saves nothing more. Detecting a taken-over claim needs a store that checks
+  `SaveOptions.lease` on `save()` (see [Fencing](#fencing)).
+- Without a session store the option does nothing. Each checkpoint is one store write per step.
+
+Limits:
+- Nothing in core looks for runs whose instance died. The session continues only when something
+  runs it again: a retry with the same `requestId`, a queue that redelivers the request, or your
+  own sweep over sessions whose `agent.status()` is `'running'`.
+- Every checkpoint is a stored run, and none are removed: `loadHistory()` grows by one run per
+  finished step. Filter by `phase` when you read it.
+- `branch()` starts from the last stored run of a `runId`. It can't start from an earlier
+  checkpoint of that run.
+- It is all top-level steps or none; you can't pick which steps save.
+- A step has no fencing token to pass to other systems. A stale instance is stopped at its next
+  save to the session store, but what its step already wrote elsewhere stays written.
+- If a save reached the store but the call still failed (a timeout, a dropped connection), the
+  next checkpoint conflicts with it and the run stops with `LeaseExpiredError`. The next run
+  continues from that save; steps still run at least once.
+
+> **Upgrading.**
+> - `StoredRun.phase` and `SessionPhase` have a new value, `'running'`. A `switch` that handles
+>   every phase needs a case for it.
+> - `checkpoint` is now a reserved run resource. A `runtime()` slot named `checkpoint` no longer
+>   reaches `ctx`, and the value passed under that key must be `'off'` or `'step'`. Rename the slot.
+> - `SessionStore.save` takes an optional fourth argument, `SaveOptions`. Existing stores keep
+>   working, without [fencing](#fencing).
+> - With a store that fences, a run whose final save is rejected because it lost its claim now
+>   settles `$error` with `LeaseExpiredError`. Before, it returned its result although the store
+>   did not keep it.
+
+### Fencing
+
+With a store that supports claims, a run holds a lease on its session. A lease can be lost while
+the run still works: the claim expires (a step ran longer than the claim TTL without
+`ctx.keepAlive()`), and another instance claims the session and runs it. The first instance is
+now stale. Without fencing, its next save would overwrite the new owner's progress.
+
+Core already stops a run at the next step boundary once its lease has expired by the local clock.
+Fencing covers what that check can't see: a save made before that boundary, and clocks that differ
+between instances.
+
+So every save a run makes while it holds a claim (each checkpoint, the final save, and writing an
+interrupt answer on `resume()`) passes the lease as `SaveOptions.lease`. A store that fences
+checks, in the same atomic step as the version check, that the session's claim is still that
+lease. If not, it writes nothing and throws an error named `LeaseLostError`.
+
+```
+ A (stale): save {lease A} ──► store: claim is now B's → LeaseLostError → A stops, $error
+ B (owner): save {lease B} ──► store: claim ok, version ok             → saved
+```
+
+What the caller of the stale run sees:
+- The run settles `signal: '$error'` with `LeaseExpiredError` in `state.$error`. Its `cause` is the
+  store's `LeaseLostError`. `events.onStoreError` gets the same `LeaseExpiredError` with phase
+  `'claim'`.
+- Nothing more is saved for that run.
+- Any other error from the final save is still only reported (phase `'persist'`), and the run
+  keeps its signal.
+
+`PostgresSessionStore` and `RedisSessionStore` fence. `InMemorySessionStore` and
+`LocalFileSessionStore` have no claims, so there is nothing to fence. A custom store that ignores
+`SaveOptions` keeps only the version check.
+
 ### Interrupts
 
 A run can be stopped or resumed:
@@ -404,6 +508,7 @@ call uses it once. Hook errors go to the per-call `onObserverError`, else the ag
 | `onStepSettled(ctx, event)` | once per step, when its outcome and destination are final |
 | `wrap(ctx, scope, fn)` | around a step's `run`, and around calls made with `ctx.within` |
 | `carry(ctx)` | once per top-level run, right after `onRunStart`; returns a string map to keep on the run's record (see [Linking runs](#linking-runs)) |
+| `onCheckpoint(ctx, { step, version, durationMs })` | after a checkpoint was saved, before `step` starts; top-level runs with `checkpoint: 'step'` only (see [Checkpoints](#checkpoints)) |
 
 Step hooks receive a `StepContext`: `agentId`, `sessionId`, `runId`, `stepName` and, inside a
 fork branch, `branchPath`. `runId` is the same value as `RunContext.runId`. Steps inside a branch
@@ -547,29 +652,33 @@ The harness never trusts a wrapper. `fn` always runs exactly once, and the calle
 | Export | Description |
 |---|---|
 | `createHarness<Ctx>()(schema)` | Creates a harness. Fixes `Ctx`, infers `State` from schema. |
-| `createAgent(id, h, slots, options?)` | Assigns the agent an ID and fills `required()` slots. `options` (`AgentOptions`) takes `instanceId`, `stores` (for `required()` store slots), `claimOptions` (this agent's default claim TTL; per-call `claimOptions` wins, then `HARNESS_CLAIM_TTL_MS`, then 30 000 ms), `observer` (for every run of the agent; see [Observers](#observers)) and `onObserverError` (the default sink for hook errors). Returns an `Agent`. |
+| `createAgent(id, h, slots, options?)` | Assigns the agent an ID and fills `required()` slots. `options` (`AgentOptions`) takes `instanceId`, `stores` (for `required()` store slots), `claimOptions` (this agent's default claim TTL; per-call `claimOptions` wins, then `HARNESS_CLAIM_TTL_MS`, then 30 000 ms), `observer` (for every run of the agent; see [Observers](#observers)), `onObserverError` (the default sink for hook errors) and `checkpoint` (`'off'` or `'step'`; see [Checkpoints](#checkpoints)). Returns an `Agent`. |
 | `field<T>(opts)` | Declares a state field with a default and optional reduce function. |
 | `required()` | Marks a provider slot as required at `createAgent()`. |
 | `runtime()` | Marks a provider slot as required at `agent.run()`. |
 | `composeObservers([a, b], onObserverError?)` | Merges multiple `Observer` instances into one fan-out observer; a throwing observer is isolated and reported to `onObserverError`. |
 | `SessionStore` | Interface for session persistence backends. Optional extensions: `loadHistory`, `branch`, `claim` / `release` / `extendClaim`, and `findRequest` (the newest run of a request, for retries of earlier requests). |
-| `StoredRun` | Type for a persisted run snapshot. Includes `agentId`, `runId`, `sessionId`, `phase`, state, and optionally `requestId` (the run's turn), `carrier` (the run's `carry` result) and `branchedFrom` (on a branch seed). |
+| `SaveOptions` | Last argument of `SessionStore.save`: `{ lease? }`, the lease the caller holds. A store that supports claims rejects a save whose lease is no longer the session's claim with an error named `LeaseLostError`. |
+| `CheckpointMode` | `'off' \| 'step'` — the `checkpoint` option and resource. |
+| `StoredRun` | Type for a persisted run snapshot. Includes `agentId`, `runId`, `sessionId`, `phase` (`'paused'`, `'completed'` or `'running'` for a checkpoint), state, and optionally `requestId` (the run's turn), `carrier` (the run's `carry` result) and `branchedFrom` (on a branch seed). |
 | `RunRef` | `{ runId, carrier? }` — points at an earlier run; used by `RunContext.resumedFrom`, `continuedFrom` and `branchedFrom` (which adds `sessionId`). |
 | `RunCarrier` | `Readonly<Record<string, string>>` — the opaque map an observer's `carry` returns. |
 | `Observer` | Interface for telemetry hooks on run and step lifecycle events (see [Observers](#observers)). |
 | `StepSettledEvent` | Payload of `Observer.onStepSettled` — outcome, duration, update, signal, next, error, interrupt, fork. |
+| `CheckpointEvent` | Payload of `Observer.onCheckpoint` — `step`, `version`, `durationMs`. |
 | `StepSettledNext` | Where the run goes after a step settles: `step`, `end`, `pause`, or `throw`. |
 | `ObserverAware` | Interface for provider objects that want per-step telemetry: the harness calls `withTelemetry(telemetry)` once per step and installs the returned view on `ctx`. |
 | `TelemetryContext` | What `withTelemetry` receives: `observer` (the run's observer, fault-isolated), `stepContext`, and `within(type, payload, fn)` bound to that step. |
 | `WrapScope` | What `Observer.wrap` is asked to enclose: `{ kind: 'step' }` or `{ kind: 'event', type, payload }`. |
 | `RunContext` | Context passed to run-level observer hooks — `agentId`, `sessionId`, `runId`, `parentRunId?`, `instanceId?`, `branchPath?`, `resumedFrom?`, `branchedFrom?`, `continuedFrom?`, `requestId?` (see [Linking runs](#linking-runs)). |
 | `StepContext` | Context passed to step-level observer hooks — `agentId`, `sessionId`, `runId`, `stepName`, `branchPath?`. |
-| `InvalidRunResourceError` | Thrown by `agent.run()` when `sessionId` or `requestId` is given but is not a non-empty string; `key` and `value` name it. |
+| `InvalidRunResourceError` | Thrown by `agent.run()` when `sessionId` or `requestId` is given but is not a non-empty string, and by `run()`, `debug()` and `resume()` when `checkpoint` is not `'off'` or `'step'`; `key` and `value` name it. |
 | `NoInterruptError` | Thrown when `resume()` is called but the session is not paused on a matching interrupt. |
 | `SessionInFlightError` | Thrown when a session is already running. |
 | `SessionPendingInterruptError` | `agent.run()` on a session paused on a pending interrupt — use `agent.resume()` instead. With a session store, the run resolves with `signal: '$error'` and this error in `state.$error`; without one, `agent.run()` throws it. |
 | `StoreLoadError` | Thrown when the session store fails to load state. |
-| `InvalidAgentOptionError` | Thrown by `createAgent()` when `observer` is not an object or `onObserverError` is not a function; `key` and `value` name it. |
+| `LeaseExpiredError` | In `state.$error` when a run lost its claim: the lease expired, or the store rejected a save because the session's claim is no longer this run's lease (see [Fencing](#fencing)). `sessionId`; `cause` holds the store's error when there is one. |
+| `InvalidAgentOptionError` | Thrown by `createAgent()` when `observer` is not an object, `onObserverError` is not a function, or `checkpoint` is not `'off'` or `'step'`; `key` and `value` name it. |
 | `InvalidClaimOptionsError` | Thrown by `createAgent()` when `claimOptions.ttlMs` is not a finite number greater than 0. |
 | `DebugSession` | Returned by `agent.debug()`: a run driven step by step (see [Debugging a run](#debugging-a-run)). |
 | `DebugStop` | Where a debug session stopped: `step`, `interrupt` or `end`. |

package/dist/index.d.ts

@@ -339,6 +339,22 @@ interface Observer {
      * `onObserverError` (hook name `'carry'`) and counts as `undefined`.
      */
     carry?: (ctx: RunContext) => Record<string, string> | undefined;
+    /**
+     * Called after a checkpoint was saved (`checkpoint: 'step'`): the session can now continue
+     * from `event.step` if this instance dies. Not called when a checkpoint was skipped or failed —
+     * those go to `onStoreError` with phase `'checkpoint'` (or `'claim'` when the run lost the
+     * session). Top-level runs only.
+     */
+    onCheckpoint?: (ctx: RunContext, event: CheckpointEvent) => void;
+}
+/** What {@link Observer.onCheckpoint} gets. */
+interface CheckpointEvent {
+    /** The step the session continues from. */
+    readonly step: string;
+    /** The version of the saved row. */
+    readonly version: number;
+    /** Time spent on the checkpoint: snapshot, save and lease extension. */
+    readonly durationMs: number;
 }
 /**
  * The telemetry a resource needs to attribute an `invoke()` call to the correct
@@ -485,6 +501,24 @@ interface Lease {
      */
     readonly token: unknown;
 }
+/**
+ * `'step'`: save the session after every finished top-level step, so a run whose instance dies
+ * continues from its last finished step. `'off'`: save only when a run settles.
+ */
+type CheckpointMode = 'off' | 'step';
+/** Options passed to {@link SessionStore.save}. */
+interface SaveOptions {
+    /**
+     * The lease the caller holds on the session. When given, a store that supports claims
+     * must check — atomically with the version check — that the session's current claim is
+     * the one this lease was issued for (by the store's own claim identity, e.g. the nonce in
+     * `lease.token`; never by comparing times). If it is not, write nothing and throw an
+     * `Error` whose `name` is `'LeaseLostError'`, whatever the version: this check takes
+     * precedence over the version check, because the framework treats a version conflict on a
+     * run's last save as a failed write and carries on.
+     */
+    readonly lease?: Lease;
+}
 /**
  * Operational metadata written by the framework into every {@link StoredRun}.
  *
@@ -534,8 +568,15 @@ interface SessionStore {
      *   record and `run.version === 0`), the write succeeds.
      * - Otherwise, another writer committed a newer version concurrently — the
      *   implementation must throw `ConcurrentModificationError`.
+     *
+     * The framework passes `options.lease` on every save it makes while holding a claim, and
+     * no `options` otherwise. A store that supports claims fences the write with it (see
+     * {@link SaveOptions.lease}), so an instance whose lease was taken over cannot overwrite
+     * the new owner's progress; the framework stops that run with `LeaseExpiredError`. A store
+     * without claims, or one that ignores `options`, keeps the version check only and gives no
+     * protection against such a stale owner.
      */
-    save(agentId: string, sessionId: string, run: StoredRun): Promise<void>;
+    save(agentId: string, sessionId: string, run: StoredRun, options?: SaveOptions): Promise<void>;
     /**
      * Return the full ordered run history for a session, oldest first.
      * Optional — omit if your store does not support history.
@@ -543,7 +584,8 @@ interface SessionStore {
     loadHistory?(agentId: string, sessionId: string): Promise<StoredRun[]>;
     /**
      * Fork the session at the state captured by `runId`, returning a new session ID
-     * whose initial state equals the forked run's `finalState`.
+     * whose initial state equals the forked run's `finalState`. When a run has several records,
+     * use its last one.
      * Optional — omit if your store does not support branching.
      *
      * Save the new session's version-0 record as a seed the next run continues: `phase: 'paused'`,
@@ -610,6 +652,9 @@ interface SessionStore {
  *   existed is still a valid `Cursor`, so old rows load and resume unchanged.
  * - `phase: 'completed'` — the loop exited normally; `signal` holds the exit
  *   signal (or is absent when the loop ended without emitting a signal).
+ * - `phase: 'running'` — a checkpoint, written after a finished step when checkpoints are on
+ *   (`checkpoint: 'step'`); `step` is the step to run next, always a plain step name, and there
+ *   is no `signal`. The run has not settled since: it is still running, or its instance died.
  */
 interface StoredRun {
     readonly agentId: string;
@@ -618,7 +663,7 @@ interface StoredRun {
     readonly version: number;
     readonly startedAt: string;
     readonly settledAt: string;
-    readonly phase: 'paused' | 'completed';
+    readonly phase: 'paused' | 'completed' | 'running';
     readonly initialState: Record<string, unknown>;
     readonly finalState: Record<string, unknown>;
     readonly signal?: string;
@@ -661,6 +706,9 @@ interface StoredRun {
  *   step that issued the interrupt. When the run paused inside a fork, `step` is
  *   the fork's own name (not the richer per-branch detail — see `pendingInterrupts`).
  * - `'completed'` — the last run exited the loop; `signal` is the exit signal.
+ * - `'running'` — the last run saved a checkpoint and has not settled since: it is still
+ *   running, or its instance died. Running the session again continues it from `step`
+ *   (another instance gets `SessionBusyError` while the owner's claim is alive).
  */
 type SessionPhase = {
     readonly phase: 'fresh';
@@ -681,6 +729,14 @@ type SessionPhase = {
 } | {
     readonly phase: 'completed';
     readonly signal?: string;
+} | {
+    readonly phase: 'running';
+    /** The step the session continues from. */
+    readonly step: string;
+    /** The `instanceId` of the instance that saved the checkpoint, when it had one. */
+    readonly instanceId?: string;
+    /** When the checkpoint was saved (ISO 8601). */
+    readonly checkpointedAt: string;
 };
 /** One outstanding `ctx.interrupt()` call awaiting a response. See {@link SessionPhase}. */
 interface PendingInterrupt$1 {
@@ -1256,6 +1312,13 @@ interface AgentOptions {
      * Must be a function; otherwise `createAgent` throws `InvalidAgentOptionError`.
      */
     readonly onObserverError?: ObserverErrorSink;
+    /**
+     * Save the session after every finished top-level step, so a run whose instance dies continues
+     * from its last finished step instead of re-running the turn: `'step'`. `'off'` (the default)
+     * saves only when a run settles. Ignored without a session store. A per-call `checkpoint`
+     * resource overrides it. Any other value makes `createAgent` throw `InvalidAgentOptionError`.
+     */
+    readonly checkpoint?: CheckpointMode;
 }
 interface Agent {
     /** The agent's unique identifier, as provided to createAgent(). */
@@ -1308,21 +1371,32 @@ declare class InvalidClaimOptionsError extends Error {
     readonly ttlMs: unknown;
     constructor(ttlMs: unknown);
 }
-/** Thrown by {@link createAgent} when `agentOptions.observer` is not an object or `agentOptions.onObserverError` is not a function. */
+declare const AGENT_OPTION_EXPECTED: {
+    readonly observer: "an object";
+    readonly onObserverError: "a function";
+    readonly checkpoint: "'off' or 'step'";
+};
+/**
+ * Thrown by {@link createAgent} when `agentOptions.observer` is not an object, `agentOptions.onObserverError`
+ * is not a function, or `agentOptions.checkpoint` is not `'off'` or `'step'`.
+ */
 declare class InvalidAgentOptionError extends Error {
     /** The option that was rejected. */
-    readonly key: 'observer' | 'onObserverError';
+    readonly key: keyof typeof AGENT_OPTION_EXPECTED;
     /** The rejected value, as given. */
     readonly value: unknown;
-    constructor(key: 'observer' | 'onObserverError', value: unknown);
+    constructor(key: keyof typeof AGENT_OPTION_EXPECTED, value: unknown);
 }
-/** Thrown by `agent.run()` when `sessionId` or `requestId` is given but is not a non-empty string. */
+/**
+ * Thrown by `agent.run()` when `sessionId` or `requestId` is given but is not a non-empty string, and by
+ * `agent.run()`, `agent.debug()` and `agent.resume()` when `checkpoint` is given but is not `'off'` or `'step'`.
+ */
 declare class InvalidRunResourceError extends Error {
     /** The resource key that was rejected. */
-    readonly key: 'sessionId' | 'requestId';
+    readonly key: 'sessionId' | 'requestId' | 'checkpoint';
     /** The rejected value, as given. */
     readonly value: unknown;
-    constructor(key: 'sessionId' | 'requestId', value: unknown);
+    constructor(key: 'sessionId' | 'requestId' | 'checkpoint', value: unknown);
 }
 /**
  * Instantiate an agent from a fully-configured {@link Harness}.
@@ -1417,7 +1491,13 @@ declare class SessionBusyError extends Error {
 declare class LeaseExpiredError extends Error {
     /** The session whose lease expired. */
     readonly sessionId: string;
-    constructor(sessionId: string);
+    /**
+     * The store's error when the store rejected a save: its `LeaseLostError` (the session's
+     * claim is no longer this run's lease), or, on a checkpoint, its `ConcurrentModificationError`
+     * (another writer saved first). Absent when the expiry was seen on the local clock.
+     */
+    readonly cause?: unknown;
+    constructor(sessionId: string, cause?: unknown);
 }
 
 /**
@@ -1431,4 +1511,4 @@ declare class NoInterruptError extends Error {
     constructor();
 }
 
-export { type Agent, type AgentOptions, type BranchCursor, type BranchDef, type ClaimOptions, type Cursor, type DebugBreakpoint, DebugCommandError, type DebugFrame, type DebugSession, type DebugStop, type DeepWithMarkers, type EndedFrame, type FieldDefinition, type ForkCursor, type ForkDef, type FrameworkState, type Harness, InvalidAgentOptionError, InvalidClaimOptionsError, InvalidRunResourceError, type Lease, LeaseExpiredError, type LoopDefinition, type LoopNode, LoopNotDefinedError, NoInterruptError, type Observer, type ObserverAware, type ObserverErrorContext, type ObserverErrorSink, type PendingInterrupt, REQUIRED_TAG, RUNTIME_TAG, type RequiredMarker, type RouteFn, type RunCarrier, type RunContext, type RunFn, type RunRef, type RuntimeMarker, SessionBusyError, SessionInDebugError, SessionInFlightError, SessionPendingInterruptError, type SessionStore, type SettledStep, type SignalTransition, type Snapshot, type StateFromSchema, type StepContext, type StepDef, type StepSettledEvent, type StepSettledNext, type StepState, StoreLoadError, type StoredRun, type StoredRunMetadata, type TelemetryContext, type TransitionTarget, type WrapScope, composeObservers, createAgent, createHarness, field, isForkCursor, isForkDef, isRequiredMarker, isRuntimeMarker, required, runtime };
+export { type Agent, type AgentOptions, type BranchCursor, type BranchDef, type CheckpointEvent, type CheckpointMode, type ClaimOptions, type Cursor, type DebugBreakpoint, DebugCommandError, type DebugFrame, type DebugSession, type DebugStop, type DeepWithMarkers, type EndedFrame, type FieldDefinition, type ForkCursor, type ForkDef, type FrameworkState, type Harness, InvalidAgentOptionError, InvalidClaimOptionsError, InvalidRunResourceError, type Lease, LeaseExpiredError, type LoopDefinition, type LoopNode, LoopNotDefinedError, NoInterruptError, type Observer, type ObserverAware, type ObserverErrorContext, type ObserverErrorSink, type PendingInterrupt, REQUIRED_TAG, RUNTIME_TAG, type RequiredMarker, type RouteFn, type RunCarrier, type RunContext, type RunFn, type RunRef, type RuntimeMarker, type SaveOptions, SessionBusyError, SessionInDebugError, SessionInFlightError, SessionPendingInterruptError, type SessionStore, type SettledStep, type SignalTransition, type Snapshot, type StateFromSchema, type StepContext, type StepDef, type StepSettledEvent, type StepSettledNext, type StepState, StoreLoadError, type StoredRun, type StoredRunMetadata, type TelemetryContext, type TransitionTarget, type WrapScope, composeObservers, createAgent, createHarness, field, isForkCursor, isForkDef, isRequiredMarker, isRuntimeMarker, required, runtime };