Struct DelegationOrigin 

pub struct DelegationOrigin<'a> {
    pub context_id: String,
    pub launched: Option<Arc<dyn Fn(DelegationLaunch) + Send + Sync + 'a>>,
    pub stop: Option<Arc<dyn Fn() -> bool + Send + Sync + 'a>>,
}

The parent’s side of one delegation, beyond the three strings its agent supplied.

Per call rather than per plane: a launch that mints one context id per task has no launch-scoped conversation to name, so the id is only knowable once a task is running.

Fields

context_id: String

The conversation the delegation was made from. Empty when the caller has none, which injects no handle at all rather than one naming a conversation that does not exist.

launched: Option<Arc<dyn Fn(DelegationLaunch) + Send + Sync + 'a>>

What to do with the launch notice, or None for a caller that records no delegation_start. Called on the delegating thread, before the delegation has ended.

A callback rather than a channel because the two callers are not the same shape: DelegationPlane::start runs on a blocking tokio worker with a task free to drain a receiver, while plan::execute calls DelegationPlane::delegate directly on a scheduler thread with no runtime to await on and nothing else running to drain anything. Invoked in place, both surfaces get the record on disk while the child is still in flight, which is the whole reason it is a record of its own.

stop: Option<Arc<dyn Fn() -> bool + Send + Sync + 'a>>

Whether the task this delegation was made for has been cancelled, or None for a caller that cannot be. Polled, so it must be cheap and must never block.

Read only by DelegationPlane::delegate, which ends the child itself when it reports true. DelegationPlane::start ignores it: its caller races its own cancel against the launch, and holds the child’s handle from then on.

Trait Implementations

impl<'a> Clone for DelegationOrigin<'a>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DelegationOrigin<'_>

Hand-written because DelegationOrigin::launched and DelegationOrigin::stop are trait objects and cannot derive one. A callback has no readable identity, so what is printed of it is whether there is one.

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

Formats the value using the given formatter.

impl<'a> Default for DelegationOrigin<'a>

fn default() -> Self

Returns the “default value” for a type.