Struct Pending 

pub struct Pending {
    pub id: i64,
    pub run_id: i64,
    pub step: u32,
    pub act: String,
    pub target: String,
    pub content: Option<String>,
    pub resolved: Option<String>,
}

An action paused awaiting a human decision, persisted so it outlives the process that requested it.

use io_harness::Store;

let store = Store::memory()?;
let run_id = store.start_run("update the deploy config", "deploy/prod.yaml")?;

// The agent asked to write a production file, the policy said `Ask`, and the
// approver deferred. The payload is stored with it, because resuming has to
// replay exactly what was approved and not whatever the model would say now.
let request_id = store.put_pending(run_id, 2, "write", "deploy/prod.yaml", Some("replicas: 4"))?;

// This process may now exit. A reviewer — a web UI, a CLI, a person the next
// morning — reads the request back and decides.
let pending = store.pending(request_id)?.expect("just written");
assert_eq!((pending.act.as_str(), pending.target.as_str()), ("write", "deploy/prod.yaml"));
assert_eq!(pending.content.as_deref(), Some("replicas: 4"));
assert!(pending.resolved.is_none(), "nobody has decided yet");

store.resolve_pending(request_id, "approve")?;
assert_eq!(store.pending(request_id)?.unwrap().resolved.as_deref(), Some("approve"));
// `resume_with_decision` then continues the run from here.

Fields

id: i64

The request id, as returned by Store::put_pending.

run_id: i64

The run this action belongs to.

step: u32

The step it paused on.

act: String

"read", "write", or "exec".

target: String

The target path or binary.

content: Option<String>

The write payload, needed to replay exactly what was approved.

resolved: Option<String>

None while pending; otherwise "approve" or "deny".

Trait Implementations

impl Clone for Pending

fn clone(&self) -> Pending

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Pending

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

Formats the value using the given formatter.

impl Eq for Pending

impl PartialEq for Pending

fn eq(&self, other: &Pending) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Pending