Enum RuntimeError 

pub enum RuntimeError {
    Replay(ReplayError),
    Store(StoreError),
    Model(Error),
    RequestEncode(Error),
    RecordedResponseDecode(Error),
    RunAlreadyStarted {
        run_id: RunId,
    },
    UnknownRun {
        run_id: RunId,
    },
    NotParked {
        run_id: RunId,
        status: String,
    },
    ResumeInputRejected(String),
    InvalidLabels(String),
    NotReconcilable {
        run_id: RunId,
        status: String,
    },
    CallInFlight {
        tool: String,
        idempotency_key: String,
        holder: RunId,
        holder_seq: u64,
    },
    IdempotencyKeyCollision {
        tool: String,
        idempotency_key: String,
        origin: RunId,
        origin_seq: u64,
    },
    CommitmentUnreadable {
        tool: String,
        idempotency_key: String,
        origin: RunId,
        origin_seq: u64,
    },
    AlreadyTerminal {
        run_id: RunId,
        status: String,
    },
}

What can go wrong while driving a run.

Replay, Store, and Model each spell out their inner error’s Display directly in their own message ("replay: {0}" and so on) rather than leaning on thiserror’s #[source]/#[from] chaining for that text. A field that is both interpolated into the message AND wired as the Error::source() gets printed twice by anything that walks the source chain on top of Display (anyhow’s {:#}, {:?}, and the like): once embedded in this variant’s own message, once again as the chain’s next link. Plain From impls below give ? the same conversion #[from] would without also handing these three a chained source, so the detail appears exactly once no matter how the caller prints the error.

Variants

Replay(ReplayError)

The replay layer refused to continue: divergence, a malformed log, or a dangling write intent that needs human reconciliation.

Store(StoreError)

The event store failed to persist or read an event.

Model(Error)

A live model call failed after the client’s own retries. The run’s log is intact (the intent, if any, is recorded), so the run can be recovered later; the model intent will be re-issued safely.

RequestEncode(Error)

A model request could not be serialized to JSON for hashing.

RecordedResponseDecode(Error)

A recorded model response could not be decoded back into a typed response. This means the log holds something this build cannot read, which is a storage or versioning fault, not orchestration divergence.

RunAlreadyStarted

start was called for a run id that already has recorded history.

Fields

run_id: RunId

The run that already exists.

UnknownRun

The named run has no recorded history at all.

Fields

run_id: RunId

The run that was not found.

NotParked

resume was called on a run whose log does not end at a suspension or budget crossing.

Fields

run_id: RunId

The run that was not parked.

status: String

A short description of the status the run was actually in.

ResumeInputRejected(String)

The resume input did not satisfy the recorded suspension schema (or, for a budget crossing, the budget-extension shape).

InvalidLabels(String)

The labels a run is about to be created with violate the sanity bounds (too many, or a key/value over its length cap). See crate::validate_labels. Surfaces only on a genuinely fresh begin; a replayed run never re-checks the labels it already recorded.

NotReconcilable

resolve was called on a run that is not awaiting reconciliation. The hand-recorded completion is only ever appended to a run whose log ends at a dangling write intent; every other state is a caller mistake.

Fields

run_id: RunId

The run that was not awaiting reconciliation.

status: String

A short description of the status the run was actually in.

CallInFlight

A keyed call could not proceed because another run holds the same (tool, idempotency key) identity and has not finished with it.

The holder is either running right now or died mid-call. Either way the effect may or may not have happened, and this run has no way to find out and no right to try: proceeding would be exactly the second execution the key exists to prevent. So the call refuses, and it refuses before recording anything, which leaves this run’s log untouched and the run re-runnable once the holder is finished or reconciled.

The resolution lives in the holding run, never here. Finish it, or reconcile its dangling write with salvor resolve, and then run this one again.

Fields

tool: String

The tool whose identity is held.

idempotency_key: String

The idempotency key naming the effect.

holder: RunId

The run holding the identity.

holder_seq: u64

The position of the holder’s intent for this call.

IdempotencyKeyCollision

Two different calls presented the same (tool, idempotency key) identity with different inputs.

The key is a promise that two calls are the same call. Different inputs under one key break that promise, and there is no safe reading of it: deduplicating would hand this call an output computed from somebody else’s arguments, and executing would perform an effect the key says has already been performed. So neither happens and the key’s author is told.

The fix is in the key, not here. A key must be specific enough to name one effect: "pay_claim:wreck-9931", not "pay_claim".

Fields

tool: String

The tool whose key collided.

idempotency_key: String

The key that named two different calls.

origin: RunId

The run holding the committed call.

origin_seq: u64

The position of the committed call’s intent.

CommitmentUnreadable

A commitment pointed at a completion that its run’s log does not hold.

The store said an identity was settled at a position, and reading that run’s log (chain verification included) did not produce the completion there. That is a damaged store, not a race: a settlement and its completion are written as one unit, so one cannot exist without the other. Reported rather than worked around, because the alternative would be executing an effect the store believes already happened.

Fields

tool: String

The tool named by the commitment.

idempotency_key: String

The key named by the commitment.

origin: RunId

The run the commitment pointed at.

origin_seq: u64

The position the commitment pointed at.

AlreadyTerminal

abandon was called on a run that already reached a terminal event (completed, failed, or previously abandoned). A terminal run is already at rest; there is nothing left to retire, so the operator action is refused rather than appending a second terminal.

Fields

run_id: RunId

The run that had already finished.

status: String

A short description of the terminal status the run was in.

Trait Implementations

impl Debug for RuntimeError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for RuntimeError

fn fmt(&self, __formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Error for RuntimeError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<Error> for RuntimeError

fn from(error: Error) -> Self

Converts to this type from the input type.

impl From<ReplayError> for RuntimeError

fn from(error: ReplayError) -> Self

Converts to this type from the input type.

impl From<StoreError> for RuntimeError

fn from(error: StoreError) -> Self

Converts to this type from the input type.