Skip to main content

SurrealDbProvider

Struct SurrealDbProvider 

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

Implementations§

Source§

impl SurrealDbProvider

Source

pub async fn from_existing_client( db: Surreal<Any>, backend: HostSurrealBackend, ) -> Result<Self>

Reuse the host’s already selected namespace/database and engine handle. The caller owns its lifecycle; this never reconnects, changes its selection, or substitutes another storage engine for existing user data.

Source§

impl SurrealDbProvider

Source

pub async fn new( connection_string: &str, surreal_user: Option<&str>, surreal_pass: Option<&str>, surreal_ns: Option<&str>, surreal_db: Option<&str>, ) -> Result<Self>

Connect to SurrealDB.

For server endpoints (ws://, wss://, http://, https://) the caller may supply optional credentials. HTTP endpoints are normalized to the equivalent WebSocket endpoint so remote storage retains live-query support. When credentials are absent the defaults root / root are used, which matches a freshly-started SurrealDB server. For embedded endpoints (SurrealKV, in-memory) authentication is not performed.

Source

pub async fn new_with_auth( connection_string: &str, surreal_user: Option<&str>, surreal_pass: Option<&str>, surreal_auth_level: Option<&str>, surreal_ns: Option<&str>, surreal_db: Option<&str>, ) -> Result<Self>

Connect using an explicit server-user authentication scope.

Source

pub fn catalog_storage_backend(&self) -> &'static str

Backend of the successfully initialized connection, without its endpoint.

Source

pub fn client(&self) -> Surreal<Any>

Source

pub fn subscribe_transport_state(&self) -> Result<Receiver<TransportState>>

Observe retained transport loss for this provider’s current SDK client. A loss asks the lifecycle supervisor to decide whether to reconnect; it never certifies the outcome of an interrupted remote mutation.

Source

pub fn endpoint(&self) -> &SurrealEndpoint

The normalized endpoint selected for this provider.

Source

pub fn ownership(&self) -> PersistenceOwnership

The lifecycle authority for the database client.

Source

pub fn is_owned(&self) -> bool

Source

pub async fn close_scope(&self) -> PersistenceCloseReport

Release this provider’s scope after all registered UAR users have drained. Borrowed clients remain open for their host.

The pinned SDK patch supplies Surreal::shutdown, which closes admission across all SDK clones and resolves only after local engine cleanup has completed. Server composition owns the ordering of dependent workers.

Trait Implementations§

Source§

impl Debug for SurrealDbProvider

Source§

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

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

impl PersistenceLayer for SurrealDbProvider

Source§

fn supports_durable_tool_receipts(&self) -> bool

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_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 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 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 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 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 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_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 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: &'life1 str, ids: &'life2 [&'life3 str], query: &'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 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 channel_observer_unavailable_reason(&self) -> &'static str

Source§

fn supports_channel_observers(&self) -> bool

Channel-source observations are a separate, explicitly negotiated profile.
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 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 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 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_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 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 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_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 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 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 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 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 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 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_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 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 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 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: &'life1 str, run: &'life2 str, checkpoint: &'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: &'life1 str, run: &'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, 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.
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.

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