pub struct ScopedPersistence { /* private fields */ }Implementations§
Source§impl ScopedPersistence
impl ScopedPersistence
pub fn new(inner: Arc<dyn PersistenceLayer>, scope: ResourceScope) -> Self
pub async fn close(&self) -> CloseReport
pub fn scope(&self) -> ResourceScope
Trait Implementations§
Source§impl Debug for ScopedPersistence
impl Debug for ScopedPersistence
Source§impl PersistenceLayer for ScopedPersistence
impl PersistenceLayer for ScopedPersistence
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,
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.
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,
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,
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,
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.
fn supports_durable_mcp_elicitations(&self) -> bool
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,
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,
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,
fn supports_durable_tool_receipts(&self) -> bool
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,
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.
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,
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.
fn supports_durable_agui_runs(&self) -> bool
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,
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,
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,
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,
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.
fn supports_durable_a2a_bindings(&self) -> bool
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,
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,
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,
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
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.
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,
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,
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,
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,
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,
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
fn supports_durable_accounting(&self) -> bool
Durable accounting is a host capability, not an in-memory fallback.
Source§fn durable_store_eligibility(&self) -> DurableStoreEligibility
fn durable_store_eligibility(&self) -> DurableStoreEligibility
Captured backing-store eligibility for admission and durable-work gates.
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,
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,
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,
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,
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,
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,
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
fn supports_durable_ingestion(&self) -> bool
Acceptance is unavailable unless bytes, job, and document commit atomically.
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,
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,
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
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,
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,
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,
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,
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
fn supports_channel_observers(&self) -> bool
Channel-source observations are a separate, explicitly negotiated profile.
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,
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,
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,
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,
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,
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,
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.
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
fn supports_durable_observers(&self) -> bool
True only for a provider with a transactional instance outbox and durable observer inbox.
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,
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,
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,
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.
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,
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,
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
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,
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,
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,
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,
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,
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,
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,
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,
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,
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.
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,
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,
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 moreSource§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,
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,
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>>
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,
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,
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,
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,
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,
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,
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,
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,
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.
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,
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,
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.
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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
fn supports_durable_approvals(&self) -> bool
Whether approval history survives a process restart on this provider.
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,
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.
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,
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,
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.
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,
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.
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,
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,
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,
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.
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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.
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,
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,
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,
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
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,
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,
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,
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,
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,
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,
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,
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,
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,
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,
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
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§
impl !RefUnwindSafe for ScopedPersistence
impl !UnwindSafe for ScopedPersistence
impl Freeze for ScopedPersistence
impl Send for ScopedPersistence
impl Sync for ScopedPersistence
impl Unpin for ScopedPersistence
impl UnsafeUnpin for ScopedPersistence
Blanket Implementations§
§impl<T> ArchivePointee for T
impl<T> ArchivePointee for T
§type ArchivedMetadata = ()
type ArchivedMetadata = ()
The archived version of the pointer metadata for this type.
§fn pointer_metadata(
_: &<T as ArchivePointee>::ArchivedMetadata,
) -> <T as Pointee>::Metadata
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
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
impl<ST, DT> CastableFrom<ST, Initialized, Initialized> for DT
impl<ST, DT> CastableFrom<ST, Uninit, Uninit> for DT
§impl<T> Conv for T
impl<T> Conv for T
impl<T> ErasedDestructor for Twhere
T: 'static,
§impl<T> FmtForward for T
impl<T> FmtForward for T
§fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
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,
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,
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,
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,
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,
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,
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,
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,
fn fmt_list(self) -> FmtList<Self>where
&'a Self: for<'a> IntoIterator,
Formats each item in a sequence. Read more
§impl<T> FutureExt for T
impl<T> FutureExt for T
§fn with_context(self, otel_cx: Context) -> WithContext<Self>
fn with_context(self, otel_cx: Context) -> WithContext<Self>
§fn with_current_context(self) -> WithContext<Self>
fn with_current_context(self) -> WithContext<Self>
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
Source§impl<T> IntoEither for T
impl<T> IntoEither for T
Source§fn into_either(self, into_left: bool) -> Either<Self, Self>
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 moreSource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
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
impl<T> IntoRequest<T> for T
§fn into_request(self) -> Request<T>
fn into_request(self) -> Request<T>
Wrap the input message
T in a tonic::RequestCreates a shared type from an unshared type.
§impl<L> LayerExt<L> for L
impl<L> LayerExt<L> for L
§fn named_layer<S>(&self, service: S) -> Layered<<L as Layer<S>>::Service, S>where
L: Layer<S>,
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
impl<T> LayoutRaw for T
§fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError>
fn layout_raw(_: <T as Pointee>::Metadata) -> Result<Layout, LayoutError>
Returns the layout of the type.
impl<T> MaybeSend for Twhere
T: Send,
impl<T> MaybeSend for Twhere
T: Send,
§impl<T> Message for T
impl<T> Message for T
§fn from_boxed(m: BoxedMessage) -> Result<Self, BoxedDowncastErr>
fn from_boxed(m: BoxedMessage) -> Result<Self, BoxedDowncastErr>
Convert a [BoxedMessage] to this concrete type
§fn box_message(self, pid: &ActorId) -> Result<BoxedMessage, BoxedDowncastErr>
fn box_message(self, pid: &ActorId) -> Result<BoxedMessage, BoxedDowncastErr>
Convert this message to a [BoxedMessage]
§impl<T, N1, N2> Niching<NichedOption<T, N1>> for N2where
T: SharedNiching<N1, N2>,
N1: Niching<T>,
N2: Niching<T>,
impl<T, N1, N2> Niching<NichedOption<T, N1>> for N2where
T: SharedNiching<N1, N2>,
N1: Niching<T>,
N2: Niching<T>,
§impl<T> Pipe for Twhere
T: ?Sized,
impl<T> Pipe for Twhere
T: ?Sized,
§fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
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) -> Rwhere
R: 'a,
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
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) -> Rwhere
R: 'a,
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
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
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
§fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R,
) -> R
fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
§fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
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
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
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
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
Borrows
self, then passes self.deref() into the pipe function.§impl<T> Pointable for T
impl<T> Pointable for T
§impl<T> Pointee for T
impl<T> Pointee for T
§impl<T> Pointee for T
impl<T> Pointee for T
§impl<T> PolicyExt for Twhere
T: ?Sized,
impl<T> PolicyExt for Twhere
T: ?Sized,
§impl<T> PolicyExt for Twhere
T: ?Sized,
impl<T> PolicyExt for Twhere
T: ?Sized,
impl<T> Read<Exclusive, BecauseExclusive> for Twhere
T: ?Sized,
§impl<F, T, S> SimdInto<T, S> for Fwhere
T: SimdFrom<F, S>,
S: Simd,
impl<F, T, S> SimdInto<T, S> for Fwhere
T: SimdFrom<F, S>,
S: Simd,
impl<T> State for T
§impl<T> Tap for T
impl<T> Tap for T
§fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
Immutable access to the
Borrow<B> of a value. Read more§fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
Mutable access to the
BorrowMut<B> of a value. Read more§fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
Immutable access to the
AsRef<R> view of a value. Read more§fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
Mutable access to the
AsMut<R> view of a value. Read more§fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
Immutable access to the
Deref::Target of a value. Read more§fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
Mutable access to the
Deref::Target of a value. Read more§fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
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
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
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
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
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
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
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
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
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
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
fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
Calls
.tap_deref() only in debug builds, and is erased in release
builds.