Struct TenantAwareInMemoryTaskStore 

pub struct TenantAwareInMemoryTaskStore { /* private fields */ }

Tenant-isolated in-memory TaskStore.

Maintains a separate InMemoryTaskStore per tenant, providing full data isolation between tenants. The current tenant is determined from TenantContext.

Usage

use a2a_protocol_server::store::tenant::{TenantAwareInMemoryTaskStore, TenantContext};
use a2a_protocol_server::store::TaskStore;

let store = TenantAwareInMemoryTaskStore::new();

// Tenant A saves a task
TenantContext::scope("tenant-a", async {
    let task = Task {
        id: TaskId::new("task-1"),
        context_id: ContextId::new("ctx-1"),
        status: TaskStatus::with_timestamp(TaskState::Submitted),
        history: None,
        artifacts: None,
        metadata: None,
    };
    store.save(&task).await.unwrap();
}).await;

// Tenant B cannot see tenant A's task
TenantContext::scope("tenant-b", async {
    let result = store.get(&TaskId::new("task-1")).await.unwrap();
    assert!(result.is_none());
}).await;

Implementations

impl TenantAwareInMemoryTaskStore

pub fn new() -> Self

Creates a new tenant-aware store with default configuration.

pub fn with_config(config: TenantStoreConfig) -> Self

Creates a new tenant-aware store with custom configuration.

pub fn with_tenant_override( self, tenant: impl Into<String>, config: TaskStoreConfig, ) -> Self

Gives tenant its own TaskStoreConfig, overriding TenantStoreConfig::per_tenant for that tenant alone.

This is the per-tenant store bound that TenantLimits::max_stored_tasks claimed to be and could not: that field sits on PerTenantConfig, which the handler holds and a store never sees. Here the store owns the map and reads it as it creates the partition.

Every field of TaskStoreConfig is overridden, not just capacity — a tenant can be given its own TTL, eviction interval and page cap too. The override replaces the whole config rather than merging, so build it from per_tenant with .. if you mean to change one field:

use a2a_protocol_server::{TaskStoreConfig, TenantAwareInMemoryTaskStore};

let store = TenantAwareInMemoryTaskStore::new().with_tenant_override(
    "small-fry",
    TaskStoreConfig {
        max_capacity: Some(100),
        ..TaskStoreConfig::default()
    },
);

A partition is created on a tenant’s first use, so an override for a tenant that already has one applies only to a store built afterwards.

pub async fn tenant_count(&self) -> usize

Returns the number of active tenant partitions.

pub async fn run_eviction_all(&self)

Runs eviction on all tenant stores.

Call periodically to clean up terminal tasks in idle tenants.

pub async fn prune_empty_tenants(&self)

Removes empty tenant partitions to reclaim memory.

A partition is considered empty when its task count is zero, so this reclaims a slot only once every task in that partition is gone — evicted by TTL, by capacity, or deleted. It is the only way a max_tenants slot is ever given back, and nothing calls it for you: schedule it alongside run_eviction_all, which is what makes partitions empty in the first place.

Calling it will not relieve a store that is at its cap because of live tasks; see max_tenants for why that matters.

Trait Implementations

impl Debug for TenantAwareInMemoryTaskStore

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

Formats the value using the given formatter.

impl Default for TenantAwareInMemoryTaskStore

fn default() -> Self

Returns the “default value” for a type.

impl TaskStore for TenantAwareInMemoryTaskStore

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

Saves (creates or updates) a task.

fn get<'a>( &'a self, id: &'a TaskId, ) -> Pin<Box<dyn Future<Output = A2aResult<Option<Task>>> + 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 = A2aResult<TaskListResponse>> + Send + 'a>>

Lists tasks matching the given filter parameters.

fn insert_if_absent<'a>( &'a self, task: &'a Task, ) -> Pin<Box<dyn Future<Output = A2aResult<bool>> + 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 = A2aResult<()>> + Send + 'a>>

Deletes a task by its ID.

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

Returns the total number of tasks in the store.

fn save_artifact_delta<'a>( &'a self, task: &'a Task, delta: ArtifactDelta, ) -> Pin<Box<dyn Future<Output = A2aResult<()>> + Send + 'a>>

Persists an artifact change that has already been applied to task.