Skip to main content

ScopedPersistence

Struct ScopedPersistence 

Source
pub struct ScopedPersistence { /* private fields */ }

Implementations§

Source§

impl ScopedPersistence

Source

pub fn new(inner: Arc<dyn PersistenceLayer>, scope: ResourceScope) -> Self

Source

pub async fn close(&self) -> CloseReport

Source

pub fn scope(&self) -> ResourceScope

Trait Implementations§

Source§

impl Debug for ScopedPersistence

Source§

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

Formats the value using the given formatter. Read more
Source§

impl PersistenceLayer for ScopedPersistence

Source§

fn supports_durable_client_tools(&self) -> bool

Source§

fn create_client_tool_continuation<'life0, 'life1, 'async_trait>( &'life0 self, row: &'life1 ClientToolContinuation, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Persist before exposing a caller-tool handoff. Existing batches are never overwritten.
Source§

fn load_client_tool_continuation<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, owner: &'life1 str, tenant: Option<&'life2 str>, agent: &'life3 str, batch: &'life4 str, ) -> Pin<Box<dyn Future<Output = Result<Option<ClientToolContinuation>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Source§

fn load_client_tool_continuation_for_run<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, owner: &'life1 str, tenant: Option<&'life2 str>, agent: &'life3 str, run: &'life4 str, ) -> Pin<Box<dyn Future<Output = Result<Option<ClientToolContinuation>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Source§

fn load_client_tool_continuation_for_session<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, owner: &'life1 str, tenant: Option<&'life2 str>, session: &'life3 str, batch: &'life4 str, ) -> Pin<Box<dyn Future<Output = Result<Option<ClientToolContinuation>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Recover a protocol session’s trusted selected agent without a caller-supplied agent override.
Source§

fn compare_and_swap_client_tool_continuation<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, before: &'life1 ClientToolContinuation, after: &'life2 ClientToolContinuation, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Atomic full-batch claim/completion. A miss must not authorize host effects.
Source§

fn supports_durable_mcp_elicitations(&self) -> bool

Source§

fn create_mcp_elicitation<'life0, 'life1, 'async_trait>( &'life0 self, _row: &'life1 McpElicitationRecord, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Source§

fn list_mcp_elicitations<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _owner: &'life1 str, _run: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<McpElicitationRecord>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Source§

fn compare_and_swap_mcp_elicitation<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _before: &'life1 McpElicitationRecord, _after: &'life2 McpElicitationRecord, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Source§

fn supports_durable_tool_receipts(&self) -> bool

Source§

fn supports_durable_a2ui_actions(&self) -> bool

Source§

fn create_a2ui_action<'life0, 'life1, 'async_trait>( &'life0 self, row: &'life1 A2uiActionReceipt, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Create once, before host dispatch. An unknown write outcome never authorizes retry.
Source§

fn load_a2ui_action<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, owner: &'life1 str, agent: &'life2 str, thread: &'life3 str, interaction: &'life4 str, ) -> Pin<Box<dyn Future<Output = Result<Option<A2uiActionReceipt>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Source§

fn list_conversation_run_history<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, owner: &'life1 str, conversation: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<RunHistoryRecord>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Bounded owner/conversation snapshot. A full 65 rows signals incomplete authority.
Source§

fn supports_durable_agui_runs(&self) -> bool

Source§

fn create_agui_run<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _row: &'life1 AguiRunBinding, _previous: Option<&'life2 AguiRunBinding>, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Source§

fn load_agui_run<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, _owner: &'life1 str, _agent: &'life2 str, _thread: &'life3 str, _run: &'life4 str, ) -> Pin<Box<dyn Future<Output = Result<Option<AguiRunBinding>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Source§

fn list_agui_runs<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _owner: &'life1 str, _agent: &'life2 str, _thread: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<AguiRunBinding>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Source§

fn compare_and_swap_agui_run<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _before: &'life1 AguiRunBinding, _after: &'life2 AguiRunBinding, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Source§

fn reconcile_a2a_cancellation<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, _owner: &'life1 str, _user: &'life2 str, _agent: &'life3 str, _task: &'life4 str, ) -> Pin<Box<dyn Future<Output = Result<Option<A2aBinding>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Host reconciliation only: excluded producer plus resolved effects, never elapsed time or an absent actor. Unsupported stores retain cancellation.
Source§

fn supports_durable_a2a_bindings(&self) -> bool

Source§

fn create_a2a_binding<'life0, 'life1, 'async_trait>( &'life0 self, _record: &'life1 A2aBinding, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Source§

fn load_a2a_binding<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _owner: &'life1 str, _agent: &'life2 str, _task: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<Option<A2aBinding>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Source§

fn compare_and_swap_a2a_binding<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _before: &'life1 A2aBinding, _after: &'life2 A2aBinding, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Source§

fn list_a2a_bindings<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _owner: &'life1 str, _agent: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<A2aBinding>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Source§

fn supports_durable_run_history(&self) -> bool

Restart-durable public run history. Every published event is written through; a terminal-only snapshot does not satisfy the contract.
Source§

fn upsert_run_history_record<'life0, 'life1, 'async_trait>( &'life0 self, _record: &'life1 RunHistoryRecord, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Source§

fn load_run_history_record<'life0, 'life1, 'async_trait>( &'life0 self, _run_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<RunHistoryRecord>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Source§

fn append_run_history_event<'life0, 'life1, 'async_trait>( &'life0 self, _event: &'life1 RunHistoryEvent, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Source§

fn load_run_history_events<'life0, 'life1, 'async_trait>( &'life0 self, _run_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<RunHistoryEvent>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Source§

fn bind_accounting_delegation<'life0, 'life1, 'async_trait>( &'life0 self, _link: &'life1 AccountingDelegation, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Source§

fn get_accounting_delegation<'life0, 'life1, 'async_trait>( &'life0 self, _digest: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<AccountingCall>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Source§

fn supports_durable_accounting(&self) -> bool

Durable accounting is a host capability, not an in-memory fallback.
Source§

fn durable_store_eligibility(&self) -> DurableStoreEligibility

Captured backing-store eligibility for admission and durable-work gates.
Source§

fn admit_remote_grant<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _owner: &'life1 str, _accounting_id: &'life2 str, _grant: &'life3 UarUsageGrant, _activity: RemoteGrantActivity, ) -> Pin<Box<dyn Future<Output = Result<RemoteGrantState>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Source§

fn ensure_accounting_scope<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _id: &'life1 ScopeIdentity, _limits: &'life2 ScopeLimits, ) -> Pin<Box<dyn Future<Output = Result<AccountingScope>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Source§

fn get_accounting_scope<'life0, 'life1, 'async_trait>( &'life0 self, _id: &'life1 ScopeIdentity, ) -> Pin<Box<dyn Future<Output = Result<Option<AccountingScope>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Source§

fn update_accounting_scope<'life0, 'life1, 'async_trait>( &'life0 self, _change: &'life1 ScopeUpdate, ) -> Pin<Box<dyn Future<Output = Result<AccountingScope>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Source§

fn admit_accounting_call<'life0, 'life1, 'async_trait>( &'life0 self, _admission: &'life1 CallAdmission, ) -> Pin<Box<dyn Future<Output = Result<AccountingCall>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Source§

fn record_accounting_usage<'life0, 'life1, 'async_trait>( &'life0 self, _usage: &'life1 CallUsage, ) -> Pin<Box<dyn Future<Output = Result<AccountingCall>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Source§

fn list_accounting_calls<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _owner: &'life1 str, _run: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<AccountingCall>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Source§

fn supports_durable_ingestion(&self) -> bool

Acceptance is unavailable unless bytes, job, and document commit atomically.
Source§

fn accept_ingestion<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _document: &'life1 KnowledgeDocument, _source: &'life2 [u8], ) -> Pin<Box<dyn Future<Output = Result<IngestionJob>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Source§

fn discover_ingestion<'life0, 'async_trait>( &'life0 self, _limit: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<IngestionJob>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Source§

fn next_ingestion_due_at<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Option<i64>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

The next durable ingestion deadline, if accepted work remains. Read more
Source§

fn get_ingestion_job<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _owner: &'life1 str, _document: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Option<IngestionJob>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Source§

fn get_ingestion_source<'life0, 'life1, 'async_trait>( &'life0 self, _job: &'life1 IngestionJob, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Source§

fn transition_ingestion<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _before: &'life1 IngestionJob, _after: &'life2 IngestionJob, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Source§

fn publish_ingestion<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _job: &'life1 IngestionJob, _publication: &'life2 IngestionPublication, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Commits the complete chunk generation, embedding identity and Indexed state together.
Source§

fn reconcile_ingestion<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Legacy accepted metadata without recoverable bytes must require reupload.
Source§

fn supports_channel_observers(&self) -> bool

Channel-source observations are a separate, explicitly negotiated profile.
Source§

fn channel_observer_unavailable_reason(&self) -> &'static str

Source§

fn create_channel_subscription<'life0, 'life1, 'async_trait>( &'life0 self, _record: &'life1 ChannelSubscription, ) -> Pin<Box<dyn Future<Output = Result<ChannelSubscription>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Source§

fn load_channel_subscription<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _owner: &'life1 str, _workspace: &'life2 str, _id: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<Option<ChannelSubscription>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Source§

fn list_channel_subscriptions<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _owner: &'life1 str, _workspace: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<ChannelSubscription>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Source§

fn compare_and_swap_channel_subscription<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _before: &'life1 ChannelSubscription, _after: &'life2 ChannelSubscription, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Source§

fn create_channel_inbox_entry<'life0, 'life1, 'async_trait>( &'life0 self, _record: &'life1 ChannelInboxEntry, ) -> Pin<Box<dyn Future<Output = Result<ChannelInboxEntry>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Source§

fn load_channel_inbox_entry<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, _owner: &'life1 str, _workspace: &'life2 str, _subscription: &'life3 str, _delivery: &'life4 str, ) -> Pin<Box<dyn Future<Output = Result<Option<ChannelInboxEntry>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Source§

fn list_channel_inbox_entries<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _owner: &'life1 str, _workspace: &'life2 str, _subscription: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<ChannelInboxEntry>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Read the exact owner’s subscription inbox without changing its cursor or state.
Source§

fn compare_and_swap_channel_inbox_entry<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _before: &'life1 ChannelInboxEntry, _after: &'life2 ChannelInboxEntry, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Source§

fn supports_durable_observers(&self) -> bool

True only for a provider with a transactional instance outbox and durable observer inbox.
Source§

fn create_observer_subscription<'life0, 'life1, 'async_trait>( &'life0 self, _subscription: &'life1 ObserverSubscription, ) -> Pin<Box<dyn Future<Output = Result<ObserverSubscription>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Source§

fn load_observer_subscription<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _owner_id: &'life1 str, _workspace_id: &'life2 str, _subscription_id: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<Option<ObserverSubscription>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Source§

fn list_observer_subscriptions<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _owner_id: &'life1 str, _workspace_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<ObserverSubscription>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Source§

fn list_all_observer_subscriptions<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<ObserverSubscription>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Trusted runtime restart scan; API handlers must use scoped listing instead.
Source§

fn compare_and_swap_observer_subscription<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _owner_id: &'life1 str, _workspace_id: &'life2 str, _expected_revision: u64, _next: &'life3 ObserverSubscription, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Source§

fn list_instance_occurrences<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _owner_id: &'life1 str, _workspace_id: &'life2 str, _source_instance_id: &'life3 str, _after_sequence: Option<u64>, _limit: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<ObserverOccurrence>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Source§

fn instance_occurrence_bounds<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _owner_id: &'life1 str, _workspace_id: &'life2 str, _source_instance_id: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<ObserverOccurrenceBounds>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Source§

fn supports_durable_agent_instances(&self) -> bool

True only when this provider persists logical instances across restarts.
Source§

fn create_agent_instance<'life0, 'life1, 'async_trait>( &'life0 self, _record: &'life1 AgentInstanceRecord, ) -> Pin<Box<dyn Future<Output = Result<AgentInstanceRecord>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Create an exact owner/workspace-scoped logical instance, never upserting.
Source§

fn load_agent_instance<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _owner_id: &'life1 str, _workspace_id: &'life2 str, _instance_id: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<Option<AgentInstanceRecord>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Read one exact logical instance without owner/workspace fallback.
Source§

fn list_agent_instances<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _owner_id: &'life1 str, _workspace_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<AgentInstanceRecord>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

List one authorized workspace’s logical instances.
Source§

fn compare_and_swap_agent_instance<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _owner_id: &'life1 str, _workspace_id: &'life2 str, _expected_revision: u64, _expected_epoch: u64, _next: &'life3 AgentInstanceRecord, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Atomically replace bounded state only while revision and epoch match. False means a caller must reload and reconcile before retrying.
Source§

fn create_presentation<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, owner_id: &'life1 str, draft: &'life2 PresentationDraft, ) -> Pin<Box<dyn Future<Output = Result<Presentation>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Create a validated template in the verified owner’s partition.
Source§

fn get_presentation<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, owner_id: &'life1 str, id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Option<Presentation>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Read one template without exposing records belonging to another owner.
Source§

fn list_presentations<'life0, 'life1, 'async_trait>( &'life0 self, owner_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<Presentation>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List the owner’s templates, including disabled records for management.
Source§

fn update_presentation<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, owner_id: &'life1 str, id: &'life2 str, expected_revision: u64, draft: &'life3 PresentationDraft, ) -> Pin<Box<dyn Future<Output = Result<Presentation>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Atomically replace editable content only at the expected revision.
Source§

fn delete_presentation<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, owner_id: &'life1 str, id: &'life2 str, expected_revision: u64, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Atomically delete only the requested owner’s expected record revision.
Source§

fn save_session<'life0, 'life1, 'async_trait>( &'life0 self, session: &'life1 Session, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Source§

fn load_session<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, owner_id: &'life1 str, id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Option<Session>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Source§

fn list_sessions<'life0, 'life1, 'async_trait>( &'life0 self, owner_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<Session>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List every session whose serialized owner matches owner_id. Read more
Source§

fn delete_session<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, owner_id: &'life1 str, id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Delete a session and all owned downstream data (conversation policy, checkpoints, cost ledger entries, tool admission evidence) for the verified owner. Returns true when a session row existed.
Source§

fn list_expired_sessions<'life0, 'async_trait>( &'life0 self, _cutoff: DateTime<Utc>, ) -> Pin<Box<dyn Future<Output = Result<Vec<(String, String)>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

List sessions whose last activity predates the cutoff. Default returns an empty vec; providers that persist sessions override this for TTL sweeps.
Source§

fn subscribe_persisted_session_changes(&self) -> Option<Receiver<u64>>

Subscribe to successful local durable session commits. This is a wakeup, not a state transfer: receivers reread the authoritative expiry after a generation change. None means this provider has no durable signal.
Source§

fn next_persisted_session_expiry<'life0, 'async_trait>( &'life0 self, _idle_timeout: Duration, ) -> Pin<Box<dyn Future<Output = Result<Option<DateTime<Utc>>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Return the earliest future persisted idle deadline under the supplied policy. The deadline schedules a one-shot wakeup; it does not prove a session is removable until the deletion transaction rechecks it.
Source§

fn save_conversation_policy<'life0, 'life1, 'async_trait>( &'life0 self, record: &'life1 ConversationPolicyRecord, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Save or replace a conversation-scoped chat policy.
Source§

fn load_conversation_policy<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, owner_id: &'life1 str, conversation_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Option<ConversationPolicyRecord>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Load a conversation-scoped chat policy.
Source§

fn save_principal_conversation_policy<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, record: &'life1 ConversationPolicyRecord, expected: Option<&'life2 RunPolicy>, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Conditionally write in the principal namespace. None expects no record; an existing policy must still equal the complete supplied baseline.
Source§

fn load_principal_conversation_policy<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, owner_id: &'life1 str, conversation_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Option<ConversationPolicyRecord>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Read only the verified principal namespace, without legacy fallback.
Source§

fn delete_conversation_policy<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, owner_id: &'life1 str, conversation_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Delete a conversation-scoped chat policy.
Source§

fn save_user_prompt_caching_settings<'life0, 'life1, 'async_trait>( &'life0 self, settings: &'life1 UserPromptCachingSettings, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Save or replace one verified user’s prompt-caching preferences.
Source§

fn load_user_prompt_caching_settings<'life0, 'life1, 'async_trait>( &'life0 self, principal_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<UserPromptCachingSettings>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Load prompt-caching preferences by the collision-safe verified principal key.
Source§

fn save_skill<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, skill: &'life1 Skill, embedding: &'life2 [f32], ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Source§

fn create_skill_if_absent<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _skill: &'life1 Skill, _embedding: &'life2 [f32], ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Insert one skill only when its ID is not already durable. Read more
Source§

fn update_skill_selection<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, skill_id: &'life1 str, enabled: bool, scoped_config: &'life2 [ScopedSkillConfig], ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Change only existing skill selection fields; preserve every other stored field. Returns false when no durable skill row exists.
Source§

fn search_skills<'life0, 'life1, 'async_trait>( &'life0 self, query_vec: &'life1 [f32], limit: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<SkillMatch>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Source§

fn save_skill_in_space<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, skill: &'life1 Skill, embedding: &'life2 [f32], space: &'life3 EmbeddingFingerprint, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Persist a skill together with the embedding space its vector belongs to. Providers whose store enforces space identity override this; the default ignores the space.
Source§

fn create_skill_if_absent_in_space<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, skill: &'life1 Skill, embedding: &'life2 [f32], space: &'life3 EmbeddingFingerprint, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Self::create_skill_if_absent recording the vector’s embedding space.
Source§

fn search_skills_in_space<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, query_vec: &'life1 [f32], limit: usize, space: &'life2 EmbeddingFingerprint, ) -> Pin<Box<dyn Future<Output = Result<Vec<SkillMatch>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Search only vectors produced in space. Rows embedded in another space are never compared. The default ignores the space.
Source§

fn skill_ids_outside_space<'life0, 'life1, 'async_trait>( &'life0 self, space: &'life1 EmbeddingFingerprint, ) -> Pin<Box<dyn Future<Output = Result<Vec<String>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

IDs of skills holding an embedding that was not produced in space (another space, or one never recorded) and so need re-embedding. Providers that do not fence embedding spaces report none.
Source§

fn set_skill_embedding<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, skill_id: &'life1 str, embedding: &'life2 [f32], space: &'life3 EmbeddingFingerprint, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Replace only a skill’s embedding and its recorded space, leaving every other stored field untouched. Returns false when no durable row exists.
Source§

fn list_skills<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<Skill>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

List all persisted skills.
Source§

fn delete_skill<'life0, 'life1, 'async_trait>( &'life0 self, _id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete a skill by ID.
Source§

fn save_knowledge_base<'life0, 'life1, 'async_trait>( &'life0 self, kb: &'life1 KnowledgeBase, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Save or update a knowledge base definition. The host supplies a verified principal storage key, or anonymous at the explicit anonymous boundary. Authenticated rows live in storage disjoint from all legacy subjects.
Source§

fn begin_knowledge_regeneration<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, owner: &'life1 str, kb: &'life2 str, target: &'life3 EmbeddingFingerprint, ) -> Pin<Box<dyn Future<Output = Result<KnowledgeRegeneration>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Atomically freeze a KB’s retained sources and revoke/requeue every member.
Source§

fn search_knowledge_scoped_in_space<'life0, 'life1, 'life2, 'life3, 'life4, 'life5, 'async_trait>( &'life0 self, owner_id: &'life1 str, kb_ids: &'life2 [&'life3 str], query_vec: &'life4 [f32], limit: usize, min_score: f32, space: &'life5 EmbeddingFingerprint, ) -> Pin<Box<dyn Future<Output = Result<Vec<KnowledgeMatch>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait, 'life5: 'async_trait,

Identity-aware retrieval; concrete durable stores fence one read snapshot.
Source§

fn get_knowledge_base<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, owner_id: &'life1 str, id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Option<KnowledgeBase>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Get a knowledge base by ID.
Source§

fn get_knowledge_base_by_name<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, owner_id: &'life1 str, name: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Option<KnowledgeBase>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Get a knowledge base by name.
Source§

fn list_knowledge_bases<'life0, 'life1, 'async_trait>( &'life0 self, owner_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<KnowledgeBase>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List all knowledge bases.
Source§

fn delete_knowledge_base<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, owner_id: &'life1 str, id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Delete a knowledge base and all its chunks/documents.
Source§

fn save_chunk<'life0, 'life1, 'async_trait>( &'life0 self, chunk: &'life1 KnowledgeChunk, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Save a knowledge chunk.
Source§

fn search_knowledge<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, owner_id: &'life1 str, query_vec: &'life2 [f32], limit: usize, min_score: f32, ) -> Pin<Box<dyn Future<Output = Result<Vec<KnowledgeMatch>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Search knowledge across ALL knowledge bases (original behavior).
Source§

fn search_knowledge_scoped<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, owner_id: &'life1 str, kb_ids: &'life2 [&'life3 str], query_vec: &'life4 [f32], limit: usize, min_score: f32, ) -> Pin<Box<dyn Future<Output = Result<Vec<KnowledgeMatch>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Search knowledge scoped to specific knowledge base IDs.
Source§

fn save_document<'life0, 'life1, 'async_trait>( &'life0 self, doc: &'life1 KnowledgeDocument, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Save a document record.
Source§

fn get_document<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, owner_id: &'life1 str, id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Option<KnowledgeDocument>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Get a document by ID.
Source§

fn list_documents<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, owner_id: &'life1 str, kb_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<KnowledgeDocument>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

List documents in a knowledge base.
Source§

fn count_documents<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, owner_id: &'life1 str, kb_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<usize>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Count documents in a knowledge base. Default impl uses list_documents; providers should override with a backend-native COUNT query for efficiency.
Source§

fn update_document_status<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, owner_id: &'life1 str, doc_id: &'life2 str, status: &'life3 DocumentStatus, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Update document processing status.
Source§

fn delete_document<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, owner_id: &'life1 str, doc_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Delete a document and all its associated chunks.
Source§

fn create_agent_root<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, owner_id: &'life1 str, thread: &'life2 AgentThread, ) -> Pin<Box<dyn Future<Output = Result<PersistedAgentThread>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Insert a fresh root. Existing IDs/paths are errors, never upserts. The owner argument must come from the verified host context.
Source§

fn create_agent_child<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, owner_id: &'life1 str, thread: &'life2 AgentThread, edge: &'life3 AgentEdge, ) -> Pin<Box<dyn Future<Output = Result<PersistedAgentThread>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Atomically insert a pending child and its immutable edge. Both persisted parent and root must belong to the owner/tree and still have a live turn. An interrupted/error response is not proof that nothing committed: the caller must reconcile the exact child ID before releasing its reservation.
Source§

fn load_agent_thread<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, owner_id: &'life1 str, thread_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Option<PersistedAgentThread>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Load only from this owner’s namespace. Missing records return None; corrupt records or backend failures return errors, never empty success.
Source§

fn update_agent_thread<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, owner_id: &'life1 str, expected_revision: u64, thread: &'life2 AgentThread, ) -> Pin<Box<dyn Future<Output = Result<PersistedAgentThread>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Update mutable turn state with compare-and-swap on the storage revision. Lineage, artifact, creation time, and terminal outcomes cannot be rewritten. A new authorized turn may replace a terminal outcome with a new run ID.
Source§

fn list_agent_threads<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, owner_id: &'life1 str, root_run_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<PersistedAgentThread>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

List one owner’s root-run tree, ordered by canonical path then thread ID using Rust string ordering (independent of database locale/collation).
Source§

fn list_agent_edges<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, owner_id: &'life1 str, root_run_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<AgentEdge>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

List immutable edges in canonical path/child-ID order. No deletion API is exposed: lineage remains available for recovery and lifetime accounting.
Source§

fn save_canonical_tool_receipt<'life0, 'life1, 'async_trait>( &'life0 self, receipt: &'life1 CanonicalToolReceipt, ) -> Pin<Box<dyn Future<Output = Result<CanonicalToolReceipt>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Append one immutable pre-format tool result. A repeated call ID is idempotent only when its canonical payload identity is unchanged.
Source§

fn list_canonical_tool_receipts<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, owner_id: &'life1 str, run_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<CanonicalToolReceipt>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

List one owner’s canonical receipts for a run in stable execution order.
Source§

fn supports_durable_approvals(&self) -> bool

Whether approval history survives a process restart on this provider.
Source§

fn create_approval_record<'life0, 'life1, 'async_trait>( &'life0 self, _record: &'life1 ApprovalRecord, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Source§

fn transition_approval_record<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _before: &'life1 ApprovalRecord, _after: &'life2 ApprovalRecord, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

CAS one pending challenge. Human resolution checks the original deadline at the storage serialization point; a late intent commits Expired and returns false rather than authorizing Approved or replacing it with Denied.
Source§

fn list_approval_records<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _owner: &'life1 str, _run: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<ApprovalRecord>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Source§

fn save_tool_admission_evidence<'life0, 'life1, 'async_trait>( &'life0 self, _evidence: &'life1 ToolAdmissionEvidence, ) -> Pin<Box<dyn Future<Output = Result<ToolAdmissionEvidence>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Append one sanitized lifecycle fact for an exact tool invocation. Implementations must be idempotent for an identical state and reject a conflicting duplicate. This history never reconstructs authority.
Source§

fn list_tool_admission_evidence<'life0, 'life1, 'async_trait>( &'life0 self, _owner_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<ToolAdmissionEvidence>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List one owner’s admission evidence in persisted time order.
Source§

fn save_agent<'life0, 'life1, 'async_trait>( &'life0 self, agent: &'life1 AgentArtifact, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Source§

fn save_agent_if_unchanged<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, expected: &'life1 AgentArtifact, updated: &'life2 AgentArtifact, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Persist a merged agent only while the stored artifact matches the read baseline. A conflict returns false without overwriting another editor.
Source§

fn load_agent<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<AgentArtifact>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Source§

fn load_agent_by_name<'life0, 'life1, 'async_trait>( &'life0 self, name: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<AgentArtifact>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Source§

fn list_agents<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<AgentArtifact>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Source§

fn delete_agent<'life0, 'life1, 'async_trait>( &'life0 self, _id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete an agent by ID.
Source§

fn save_memory<'life0, 'life1, 'async_trait>( &'life0 self, memory: &'life1 Memory, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Source§

fn search_memory<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, agent_id: Option<&'life1 str>, query_vec: &'life2 [f32], limit: usize, min_score: f32, ) -> Pin<Box<dyn Future<Output = Result<Vec<MemoryMatch>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Source§

fn upsert_settings_type<'life0, 'life1, 'async_trait>( &'life0 self, _st: &'life1 SettingsType, ) -> Pin<Box<dyn Future<Output = Result<Uuid>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Upsert a settings type definition (core UAR namespace or plugin-provided). Callers pass in the full struct including JSON Schema — idempotent on key. Returns the actual id stored in the database: on a first insert this matches st.id, but on a conflict-update the original row’s id is kept, so callers must use the returned value when constructing FK references.
Source§

fn list_settings_types<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<SettingsType>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

List all registered settings types.
Source§

fn get_settings_type<'life0, 'life1, 'async_trait>( &'life0 self, _key: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<SettingsType>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get a settings type by key slug (e.g. “server”).
Source§

fn upsert_setting<'life0, 'life1, 'async_trait>( &'life0 self, _setting: &'life1 Settings, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Upsert a single setting value. Read more
Source§

fn get_setting<'life0, 'life1, 'async_trait>( &'life0 self, _key: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<Settings>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get one setting by its unique dotted key (e.g. “server.port”).
Source§

fn compare_and_swap_global_presentation_policy<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, expected: &'life1 Value, selection: &'life2 ResourceSelection, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Change only global Presentation intent if the full saved policy still matches the supplied baseline. Missing or changed records return false.
Source§

fn list_settings<'life0, 'life1, 'async_trait>( &'life0 self, _type_key: Option<&'life1 str>, _parent_id: Option<Uuid>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Settings>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List settings, optionally scoped to a type key and/or parent_id.
Source§

fn delete_setting<'life0, 'life1, 'async_trait>( &'life0 self, _key: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete a setting by key (reset-to-default workflow).
Source§

fn insert_attachment<'life0, 'life1, 'async_trait>( &'life0 self, _meta: &'life1 AttachmentMeta, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Persist attachment metadata after a file has been written to disk.
Source§

fn get_attachment<'life0, 'life1, 'async_trait>( &'life0 self, _id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<AttachmentMeta>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Retrieve attachment metadata by ID.
Source§

fn list_attachments_for_session<'life0, 'life1, 'async_trait>( &'life0 self, _session_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<AttachmentMeta>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List all attachments uploaded during a given chat session.
Source§

fn register_supervisor_domain<'life0, 'life1, 'async_trait>( &'life0 self, _registration: &'life1 SupervisorRegistration, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Trusted containment registrations never imply exclusion by themselves.
Source§

fn load_supervisor_domain<'life0, 'life1, 'async_trait>( &'life0 self, _epoch: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<SupervisorRegistration>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Source§

fn create_supervisor_challenge<'life0, 'life1, 'async_trait>( &'life0 self, _challenge: &'life1 SupervisorChallenge, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Source§

fn load_supervisor_challenge<'life0, 'life1, 'async_trait>( &'life0 self, _id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<SupervisorChallenge>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Source§

fn commit_supervisor_checkpoint_exclusion<'life0, 'life1, 'async_trait>( &'life0 self, _proof: &'life1 VerifiedSupervisorExclusion, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Source§

fn supports_durable_checkpoint_resume(&self) -> bool

True only for an atomic protected envelope, durable claim and exclusion store.
Source§

fn save_resumable_checkpoint<'life0, 'life1, 'async_trait>( &'life0 self, _envelope: &'life1 CheckpointResumeEnvelope, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Atomically create immutable checkpoint bytes and complete owner metadata.
Source§

fn load_checkpoint_resume<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _owner_key: &'life1 str, _run_id: &'life2 str, _checkpoint_id: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<Option<CheckpointResumeEnvelope>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Load exact principal-scoped resume evidence before any live-run lookup.
Source§

fn list_checkpoint_resumes<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _owner_key: &'life1 str, _run_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<CheckpointResumeEnvelope>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

List protected checkpoint envelopes for one complete verified principal.
Source§

fn claim_checkpoint_resume<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _envelope: &'life1 CheckpointResumeEnvelope, _claim: &'life2 CheckpointContinuationClaim, ) -> Pin<Box<dyn Future<Output = Result<CheckpointClaimOutcome>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Claim one source run and exact revision only after trusted predecessor exclusion.
Source§

fn exclude_checkpoint_runtime_epoch<'life0, 'life1, 'async_trait>( &'life0 self, _runtime_epoch: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Trusted shutdown commits this only after actual producer/descendant joins and effect reconciliation. No timeout or lost connection proves exclusion.
Source§

fn save_checkpoint<'life0, 'life1, 'async_trait>( &'life0 self, _checkpoint: &'life1 Checkpoint, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Persist a graph execution checkpoint.
Source§

fn load_checkpoint<'life0, 'life1, 'async_trait>( &'life0 self, _id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<Checkpoint>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Load a single checkpoint by its unique ID.
Source§

fn list_checkpoints<'life0, 'life1, 'async_trait>( &'life0 self, _run_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<Checkpoint>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List all checkpoints recorded for a given run, ordered by creation time.
Source§

fn record_cost_entry<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _scope: &'life1 str, _scope_id: &'life2 str, _cost_usd: f64, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Durably record one cost-budget spend event. CostBudgetTracker (src/uar/runtime/cost_budget.rs) is intentionally in-memory-only for the hot path; this is the durable roll-up layer its own doc comment anticipated subscribing to. Default no-op so this remains additive for any future PersistenceLayer implementer that doesn’t need history.
Source§

fn list_cost_history<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _scope: &'life1 str, _scope_id: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<CostEntry>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

List durable cost-history entries for a (scope, scope_id), ordered by recorded_at ascending.
Source§

fn capability_matrix(&self) -> Value

Every durable capability flag of this store, keyed by its supports_* method name. Hosts serve this so clients can see what a store refuses before they ask it to do the work.

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
§

impl<T> ArchivePointee for T

§

type ArchivedMetadata = ()

The archived version of the pointer metadata for this type.
§

fn pointer_metadata( _: &<T as ArchivePointee>::ArchivedMetadata, ) -> <T as Pointee>::Metadata

Converts some archived metadata to the pointer metadata for itself.
§

impl<T> AsyncFriendly for T
where T: Send + Sync + 'static,

Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for DT
where ST: ?Sized, DT: ?Sized,

§

impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DT
where ST: ?Sized, DT: ?Sized,

§

impl<T> Conv for T

§

fn conv<T>(self) -> T
where Self: Into<T>,

Converts self into T using Into<T>. Read more
§

impl<T> ErasedDestructor for T
where T: 'static,

§

impl<T> FmtForward for T

§

fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,

Causes self to use its Binary implementation when Debug-formatted.
§

fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,

Causes self to use its Display implementation when Debug-formatted.
§

fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp,

Causes self to use its LowerExp implementation when Debug-formatted.
§

fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex,

Causes self to use its LowerHex implementation when Debug-formatted.
§

fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,

Causes self to use its Octal implementation when Debug-formatted.
§

fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,

Causes self to use its Pointer implementation when Debug-formatted.
§

fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,

Causes self to use its UpperExp implementation when Debug-formatted.
§

fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex,

Causes self to use its UpperHex implementation when Debug-formatted.
§

fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator,

Formats each item in a sequence. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<T> FutureExt for T

§

fn with_context(self, otel_cx: Context) -> WithContext<Self>

Attaches the provided Context to this type, returning a WithContext wrapper. Read more
§

fn with_current_context(self) -> WithContext<Self>

Attaches the current Context to this type, returning a WithContext wrapper. Read more
§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
§

impl<T> IntoRequest<T> for T

§

fn into_request(self) -> Request<T>

Wrap the input message T in a tonic::Request
§

impl<Unshared, Shared> IntoShared<Shared> for Unshared
where Shared: FromUnshared<Unshared>,

§

fn into_shared(self) -> Shared

Creates a shared type from an unshared type.
§

impl<L> LayerExt<L> for L

§

fn named_layer<S>(&self, service: S) -> Layered<<L as Layer<S>>::Service, S>
where L: Layer<S>,

Applies the layer to a service and wraps it in [Layered].
§

impl<T> LayoutRaw for T

§

fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError>

Returns the layout of the type.
§

impl<T> MaybeSend for T
where T: Send,

§

impl<T> MaybeSend for T
where T: Send,

§

impl<T> Message for T
where T: Any + Send + 'static,

§

fn from_boxed(m: BoxedMessage) -> Result<Self, BoxedDowncastErr>

Convert a [BoxedMessage] to this concrete type
§

fn box_message(self, pid: &ActorId) -> Result<BoxedMessage, BoxedDowncastErr>

Convert this message to a [BoxedMessage]
§

impl<T, N1, N2> Niching<NichedOption<T, N1>> for N2
where T: SharedNiching<N1, N2>, N1: Niching<T>, N2: Niching<T>,

§

unsafe fn is_niched(niched: *const NichedOption<T, N1>) -> bool

Returns whether the given value has been niched. Read more
§

fn resolve_niched(out: Place<NichedOption<T, N1>>)

Writes data to out indicating that a T is niched.
§

impl<T> Pipe for T
where T: ?Sized,

§

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

Pipes by value. This is generally the method you want to use. Read more
§

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

Borrows self and passes that borrow into the pipe function. Read more
§

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,

Mutably borrows self and passes that borrow into the pipe function. Read more
§

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

Borrows self, then passes self.borrow() into the pipe function. Read more
§

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more
§

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

Borrows self, then passes self.as_ref() into the pipe function.
§

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.as_mut() into the pipe function.
§

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

Borrows self, then passes self.deref() into the pipe function.
§

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R, ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.deref_mut() into the pipe function.
§

impl<T> Pointable for T

§

const ALIGN: usize

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
§

impl<T> Pointee for T

§

type Metadata = ()

The metadata type for pointers and references to this type.
§

impl<T> Pointee for T

§

type Pointer = u32

§

fn debug( pointer: <T as Pointee>::Pointer, f: &mut Formatter<'_>, ) -> Result<(), Error>

§

impl<T> PolicyExt for T
where T: ?Sized,

§

fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Sized + Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns [Action::Follow] only if self and other return Action::Follow. Read more
§

fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Sized + Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns [Action::Follow] if either self or other returns Action::Follow. Read more
§

impl<T> PolicyExt for T
where T: ?Sized,

§

fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Sized + Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns [Action::Follow] only if self and other return Action::Follow. Read more
§

fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Sized + Policy<B, E>, P: Policy<B, E>,

Create a new Policy that returns [Action::Follow] if either self or other returns Action::Follow. Read more
§

impl<T> Read<Exclusive, BecauseExclusive> for T
where T: ?Sized,

Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
§

impl<T, S> SimdFrom<T, S> for T
where S: Simd,

§

fn simd_from(_simd: S, value: T) -> T

§

impl<F, T, S> SimdInto<T, S> for F
where T: SimdFrom<F, S>, S: Simd,

§

fn simd_into(self, simd: S) -> T

§

impl<T> State for T
where T: Any + Send + 'static,

§

impl<T> Tap for T

§

fn tap(self, func: impl FnOnce(&Self)) -> Self

Immutable access to a value. Read more
§

fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self

Mutable access to a value. Read more
§

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Immutable access to the Borrow<B> of a value. Read more
§

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Mutable access to the BorrowMut<B> of a value. Read more
§

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Immutable access to the AsRef<R> view of a value. Read more
§

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Mutable access to the AsMut<R> view of a value. Read more
§

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Immutable access to the Deref::Target of a value. Read more
§

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Mutable access to the Deref::Target of a value. Read more
§

fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self

Calls .tap() only in debug builds, and is erased in release builds.
§

fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self

Calls .tap_mut() only in debug builds, and is erased in release builds.
§

fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Calls .tap_borrow() only in debug builds, and is erased in release builds.
§

fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds.
§

fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Calls .tap_ref() only in debug builds, and is erased in release builds.
§

fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Calls .tap_ref_mut() only in debug builds, and is erased in release builds.
§

fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Calls .tap_deref() only in debug builds, and is erased in release builds.
§

fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Calls .tap_deref_mut() only in debug builds, and is erased in release builds.
§

impl<T> TryConv for T

§

fn try_conv<T>(self) -> Result<T, Self::Error>
where Self: TryInto<T>,

Attempts to convert self into T using TryInto<T>. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

impl<G1, G2> Within<G2> for G1
where G2: Contains<G1>,

§

fn is_within(&self, b: &G2) -> bool