Struct InMemoryTaskStorage 

pub struct InMemoryTaskStorage { /* private fields */ }

Simple in-memory task storage for testing and example purposes.

Persistence-only: streaming fan-out lives in InMemoryStreamingHandler and push-webhook delivery behind the AsyncPushNotifier port (this struct hands out its registry via push_notifier). The store still owns push-config CRUD (AsyncNotificationManager) because that is config persistence.

Implementations

impl InMemoryTaskStorage

pub fn new() -> Self

Create a new empty task storage

pub fn with_push_sender( push_sender: impl PushNotificationSender + 'static, ) -> Self

Create a new task storage with a custom push notification sender

pub fn with_read_refresh(self, read_refresh: ReadRefresh) -> Self

Let a read of a principal’s user: bag count as keeping it alive.

Off by default. See ReadRefresh for what it costs and why the window is not a bool; pair it with the RetentionPolicy a sweep will run under, which ReadRefresh::halfway_through does from the policy itself.

pub fn push_notifier(&self) -> Arc<dyn AsyncPushNotifier>

Hand out this store’s push-notification registry as an AsyncPushNotifier.

The returned notifier shares the same config registry the store writes to via AsyncNotificationManager::set_config, so a config registered on the store is immediately visible to the notifier at the composition edge.

Trait Implementations

impl AsyncContextStateStore for InMemoryTaskStorage

fn load_state<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, context_id: &'life1 ContextId, caller: Option<&'life2 str>, ) -> Pin<Box<dyn Future<Output = Result<ContextState, A2AError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Everything visible from this context: its own keys, plus the caller’s user: keys.

fn remember<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, context_id: &'life1 ContextId, caller: Option<&'life2 str>, key: &'life3 StateKey, value: &'life4 str, ) -> Pin<Box<dyn Future<Output = Result<Remembered, A2AError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Record value under key, reporting what the key held before.

fn forget<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, context_id: &'life1 ContextId, caller: Option<&'life2 str>, key: &'life3 StateKey, ) -> Pin<Box<dyn Future<Output = Result<bool, A2AError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Drop key, reporting whether it held anything.

impl AsyncConversationStore for InMemoryTaskStorage

fn load<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, context_id: &'life1 ContextId, caller: Option<&'life2 str>, limit: Option<u32>, ) -> Pin<Box<dyn Future<Output = Result<Conversation, A2AError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Load the newest digest and the messages recorded after its watermark.

fn compact<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, context_id: &'life1 ContextId, caller: Option<&'life2 str>, digest: Digest, ) -> Pin<Box<dyn Future<Output = Result<(), A2AError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Append a digest covering everything through Digest::covers_through, claiming the context for caller if it is new.

impl AsyncNotificationManager for InMemoryTaskStorage

fn set_config<'life0, 'life1, 'async_trait>( &'life0 self, config: &'life1 TaskPushNotificationConfig, ) -> Pin<Box<dyn Future<Output = Result<TaskPushNotificationConfig, A2AError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Create or replace a push-notification config, returning it with any server-assigned ID populated.

fn get_config<'life0, 'life1, 'async_trait>( &'life0 self, params: &'life1 GetTaskPushNotificationConfigParams, ) -> Pin<Box<dyn Future<Output = Result<TaskPushNotificationConfig, A2AError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get a push-notification config for a task.

fn list_configs<'life0, 'life1, 'async_trait>( &'life0 self, params: &'life1 ListTaskPushNotificationConfigsParams, ) -> Pin<Box<dyn Future<Output = Result<Vec<TaskPushNotificationConfig>, A2AError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List all push-notification configs for a task.

fn delete_config<'life0, 'life1, 'async_trait>( &'life0 self, params: &'life1 DeleteTaskPushNotificationConfigParams, ) -> Pin<Box<dyn Future<Output = Result<(), A2AError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Delete a push-notification config. Idempotent per the v1.0.0 spec.

impl AsyncRetention for InMemoryTaskStorage

fn sweep<'life0, 'life1, 'async_trait>( &'life0 self, policy: &'life1 RetentionPolicy, now: DateTime<Utc>, ) -> Pin<Box<dyn Future<Output = Result<Swept, A2AError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Sweep under one set of guards.

Every map is locked for the whole sweep, in the order documented on conversations. Phasing it — pick the ids, release, then delete — would let a turn arrive on a context between the two and leave that context with its tasks deleted and its conversation intact. A sweep runs once a night against contexts nothing has touched for days, so holding the store still for it costs nothing anyone will notice.

impl AsyncTaskLifecycle for InMemoryTaskStorage

fn create<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, id: &'life1 TaskId, context_id: &'life2 ContextId, ) -> Pin<Box<dyn Future<Output = Result<Task, A2AError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Create a new task in the given context.

fn update_status<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 TaskId, state: TaskState, message: Option<Message>, ) -> Pin<Box<dyn Future<Output = Result<Task, A2AError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Update task status, optionally appending a message to history.

fn exists<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 TaskId, ) -> Pin<Box<dyn Future<Output = Result<bool, A2AError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Check whether a task exists.

fn get<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 TaskId, history_length: Option<u32>, ) -> Pin<Box<dyn Future<Output = Result<Task, A2AError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get a task by ID with optional history length limit.

fn cancel<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 TaskId, ) -> Pin<Box<dyn Future<Output = Result<Task, A2AError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Cancel a task.

impl AsyncTaskQuery for InMemoryTaskStorage

fn list<'life0, 'life1, 'async_trait>( &'life0 self, params: &'life1 ListTasksParams, ) -> Pin<Box<dyn Future<Output = Result<ListTasksResult, A2AError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List tasks with filtering and pagination (A2A v1.0.0 tasks/list).

impl AsyncTaskVersioning for InMemoryTaskStorage

fn version<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 TaskId, ) -> Pin<Box<dyn Future<Output = Result<u64, A2AError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Current stored version of a task. Bumped on every successful mutation.

fn get_versioned<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 TaskId, history_length: Option<u32>, ) -> Pin<Box<dyn Future<Output = Result<VersionedTask, A2AError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Fetch a task together with its current version (history-limited as in AsyncTaskLifecycle::get).

fn update_status_checked<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 TaskId, expected: u64, state: TaskState, message: Option<Message>, ) -> Pin<Box<dyn Future<Output = Result<VersionedTask, A2AError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Update status only if the stored version equals expected.

impl Clone for InMemoryTaskStorage

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for InMemoryTaskStorage

fn default() -> Self

Returns the “default value” for a type.