Struct InMemoryTaskStore 

pub struct InMemoryTaskStore { /* private fields */ }

In-memory TaskStore backed by a pre-allocated HashMap with secondary indexes under a single RwLock.

Suitable for testing and single-process deployments. Data is lost when the process exits.

The internal HashMap is pre-allocated to the configured max_capacity (default 10,000) to prevent latency spikes from table resizing. Without pre-allocation, HashMap doubles its capacity when load factor exceeds ~87.5%, triggering a full rehash of every stored entry. Pre-allocation eliminates these unpredictable latency cliffs entirely.

Indexing strategy

Index	Structure	Purpose
Primary	HashMap<TaskId, TaskEntry>	O(1) get/save
Sorted	BTreeSet<TaskId>	O(log n + page_size) pagination
Context	HashMap<String, BTreeSet<TaskId>>	O(log m + page_size) filtered list

The sorted index eliminates the O(n log n) sort in list() that previously caused 20-70× regressions at 10K+ tasks. The context index avoids full-scan filtering by pre-partitioning task IDs by context.

Eviction behavior

Eviction runs as a background task every N writes (configurable via TaskStoreConfig::eviction_interval) and whenever the store exceeds max_capacity. The eviction sweep is decoupled from the save() write lock so that writers are not blocked during the O(n) cleanup. However, if the system goes idle (no save() calls), completed tasks may persist in memory longer than their TTL.

Operators should call run_eviction() periodically (e.g. every 60 seconds via tokio::time::interval) to ensure timely cleanup of terminal tasks during idle periods.

Concurrency

For high-concurrency production deployments, consider SqliteTaskStore which uses a connection pool and row-level locking. The in-memory store uses a single RwLock and is optimized for testing and moderate load.

Implementations

impl InMemoryTaskStore

pub async fn run_eviction(&self)

Runs background eviction of expired and over-capacity entries.

Call this periodically (e.g. every 60 seconds) to clean up terminal tasks that would otherwise persist until the next save() call.

impl InMemoryTaskStore

pub fn new() -> InMemoryTaskStore

Creates a new empty in-memory task store with default configuration.

Default: max 10,000 tasks, 1-hour TTL for terminal tasks. The internal HashMap is pre-allocated to the configured max_capacity to prevent resize-induced latency spikes during operation.

pub fn with_config(config: TaskStoreConfig) -> InMemoryTaskStore

Creates a new in-memory task store with custom configuration.

The internal HashMap is pre-allocated to config.max_capacity (or a sensible default if None) to prevent resize-induced latency spikes.

Trait Implementations

impl Debug for InMemoryTaskStore

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

Formats the value using the given formatter.

impl Default for InMemoryTaskStore

fn default() -> InMemoryTaskStore

Returns the “default value” for a type.

impl TaskStore for InMemoryTaskStore

fn save<'a>( &'a self, task: &'a Task, ) -> Pin<Box<dyn Future<Output = Result<(), A2aError>> + Send + 'a>>

Saves (creates or updates) a task.

fn get<'a>( &'a self, id: &'a TaskId, ) -> Pin<Box<dyn Future<Output = Result<Option<Task>, A2aError>> + Send + 'a>>

Retrieves a task by its ID, returning None if not found.

fn list<'a>( &'a self, params: &'a ListTasksParams, ) -> Pin<Box<dyn Future<Output = Result<TaskListResponse, A2aError>> + Send + 'a>>

Lists tasks matching the given filter parameters.

fn insert_if_absent<'a>( &'a self, task: &'a Task, ) -> Pin<Box<dyn Future<Output = Result<bool, A2aError>> + Send + 'a>>

Atomically inserts a task only if no task with the same ID exists.

fn delete<'a>( &'a self, id: &'a TaskId, ) -> Pin<Box<dyn Future<Output = Result<(), A2aError>> + Send + 'a>>

Deletes a task by its ID.

fn count<'a>( &'a self, ) -> Pin<Box<dyn Future<Output = Result<u64, A2aError>> + Send + 'a>>

Returns the total number of tasks in the store.