Struct ActionContract 

pub struct ActionContract {
    pub name: String,
    pub input_schema: Value,
    pub output_schema: Value,
    pub node: Option<String>,
    pub timeout: Option<Duration>,
    pub retry: Option<RetryContract>,
    pub advisory: bool,
    pub agent: bool,
    pub body: Option<ActionBodyContract>,
}

One typed activity declaration.

Fields

name: String

Activity type.

input_schema: Value

Object schema over the activity parameters.

output_schema: Value

Activity result schema.

node: Option<String>

Declared node selector.

timeout: Option<Duration>

Declared schedule-to-close timeout.

retry: Option<RetryContract>

Declaration-owned retry envelope.

advisory: bool

Whether the declaration classes this activity as ADVISORY: a side channel whose failure warns on the run and never faults the calling step (RUNTIME-OPERATIONS.md R5). Identity-bound — flipping it changes what the package promises a caller.

agent: bool

Whether the declaration classes this activity as an AGENT seam: its one String parameter carries a prompt and its String result carries the reply, so a worker hands the call to an agent harness rather than to a typed handler. The checker enforces that shape, so a worker reading this flag may rely on it.

Identity-bound for the same reason advisory is — an action that becomes an agent seam promises a caller something different — and skipped when false, so a document with no agent action hashes exactly as it did before the marker existed.

body: Option<ActionBodyContract>

The declarative body the action carries, when it declares one.

None is a requirement on an out-of-band worker: the action’s name and schemas are the whole promise, and something must connect to serve it. Some means the package itself says what the action DOES, so the host can execute it with no worker connected.

Identity-bound deliberately: the body is executable authority, and an authority that did not participate in the package hash could be rewritten in storage without changing what the deployment claims to be. A body edit is a new package, always.

Implementations

impl ActionContract

pub fn worker_owed(&self) -> bool

Whether serving this action is a WORKER’s job.

true when the action carries no declared body: the declaration is a requirement on an out-of-band worker, and nothing runs until one connects and advertises the action. false when the action carries a declared body: the package itself says what the action does, the host executes it, and no worker is needed or admitted for it.

This is the one place the body-exemption rule lives. Every surface that splits a queue’s actions into worker-owed and server-run — admission diffs, availability, scaffolding, codegen — must call this rather than restate body.is_none().

Trait Implementations

impl Clone for ActionContract

fn clone(&self) -> ActionContract

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ActionContract

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ActionContract

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ActionContract

impl PartialEq for ActionContract

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for ActionContract

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ActionContract