Struct CapabilityScope 

pub struct CapabilityScope<K: ScopeKind> { /* private fields */ }

Typed immutable catalog and monotonic governance scope.

The value is deliberately not Clone: its owner must close it explicitly. Borrowed CapabilityLease values carry the marker type and cannot outlive this owner. Dropping the owner synchronously cancels and aborts supervised tasks; it never starts asynchronous cleanup.

Implementations

impl CapabilityScope<Session>

pub fn new_session( local_id: impl Into<String>, set: Arc<CapabilitySet>, ceiling: CapabilityCeiling, ) -> Result<Self, CapabilityScopeError>

pub fn new_session_with_close_policy( local_id: impl Into<String>, set: Arc<CapabilitySet>, ceiling: CapabilityCeiling, close_policy: ScopeClosePolicy, ) -> Result<Self, CapabilityScopeError>

pub fn new_session_with_cancellation( local_id: impl Into<String>, set: Arc<CapabilitySet>, ceiling: CapabilityCeiling, cancellation: CancellationToken, ) -> Result<Self, CapabilityScopeError>

Create a Session scope rooted in a host-owned cancellation tree.

Every admitted descendant derives its token from this exact root, so a Run cannot remain active after its host invocation or Session lifetime has been cancelled.

pub fn new_session_with_close_policy_and_cancellation( local_id: impl Into<String>, set: Arc<CapabilitySet>, ceiling: CapabilityCeiling, close_policy: ScopeClosePolicy, cancellation: CancellationToken, ) -> Result<Self, CapabilityScopeError>

pub fn admit_run( &self, local_id: impl Into<String>, ceiling: CapabilityCeiling, ) -> Result<CapabilityScope<Run>, CapabilityScopeError>

Admit a Run for a catalog without an upstream A3S Use cursor.

pub fn admit_use_run<L>( &self, local_id: impl Into<String>, ceiling: CapabilityCeiling, lease: L, ) -> Result<CapabilityScope<Run>, CapabilityScopeError>

where L: RetainedUseGeneration,

Admit a Run while retaining the exact, non-clone A3S Use generation lease for the complete Run lifetime.

impl CapabilityScope<Run>

pub fn turn( &self, local_id: impl Into<String>, ceiling: CapabilityCeiling, ) -> Result<CapabilityScope<Turn>, CapabilityScopeError>

pub fn subtask( &self, local_id: impl Into<String>, ceiling: CapabilityCeiling, ) -> Result<CapabilityScope<Subtask>, CapabilityScopeError>

impl CapabilityScope<Turn>

pub fn subtask( &self, local_id: impl Into<String>, ceiling: CapabilityCeiling, ) -> Result<CapabilityScope<Subtask>, CapabilityScopeError>

impl CapabilityScope<Subtask>

pub fn turn( &self, local_id: impl Into<String>, ceiling: CapabilityCeiling, ) -> Result<CapabilityScope<Turn>, CapabilityScopeError>

Start one model/tool Turn inside a delegated execution scope.

This transition makes the hierarchy recursively composable: a child Agent can own Turns, whose tool calls can in turn create Subtasks.

pub fn subtask( &self, local_id: impl Into<String>, ceiling: CapabilityCeiling, ) -> Result<CapabilityScope<Subtask>, CapabilityScopeError>

impl<K: ScopeKind> CapabilityScope<K>

pub fn id(&self) -> &CapabilityScopeId

pub const fn kind(&self) -> CapabilityScopeKind

pub fn parent_id(&self) -> Option<&CapabilityScopeId>

pub fn catalog_digest(&self) -> &Sha256Digest

pub fn ceiling(&self) -> &CapabilityCeiling

pub fn use_generation(&self) -> Option<&UseCapabilityGeneration>

pub fn is_active(&self) -> bool

pub fn cancellation(&self) -> CancellationToken

pub fn handle(&self) -> CapabilityScopeHandle<K>

pub fn lease(&self) -> Result<CapabilityLease<'_, K>, CapabilityScopeError>

pub fn register_effect<E>(&self, effect: E) -> Result<(), CapabilityScopeError>

where E: CapabilityEffect,

pub fn spawn_task<F>( &self, name: impl Into<String>, task: F, ) -> Result<SupervisedTaskId, CapabilityScopeError>

where F: Future<Output = Result<(), CapabilityEffectError>> + Send + 'static,

pub fn cancel(&self)

pub async fn close(&self) -> Result<ScopeCloseReport, CapabilityScopeError>

Trait Implementations

impl<K: ScopeKind> Debug for CapabilityScope<K>

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

Formats the value using the given formatter.

impl<K: ScopeKind> Drop for CapabilityScope<K>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

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

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.