Struct SqliteTaskStore 

pub struct SqliteTaskStore { /* private fields */ }

SQLite-backed TaskStore.

Stores tasks as JSON blobs in a tasks table. Suitable for single-node production deployments that need persistence across restarts.

Schema

The store auto-creates the following table on first use:

CREATE TABLE IF NOT EXISTS tasks (
    id         TEXT PRIMARY KEY,
    context_id TEXT NOT NULL,
    state      TEXT NOT NULL,
    data       TEXT NOT NULL,
    updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%d %H:%M:%f','now'))
);

list() returns tasks most-recently-updated first (spec §3.1.4), ordered by (updated_at DESC, id DESC) with a composite row-value cursor. updated_at is written at millisecond precision in a fixed-width format so TEXT comparison matches chronological order.

Implementations

impl SqliteTaskStore

pub async fn new(url: &str) -> Result<Self, Error>

Opens (or creates) a SQLite database and initializes the schema.

Errors

Returns an error if the database cannot be opened or the schema migration fails.

pub async fn with_migrations(url: &str) -> Result<Self, Error>

Opens a SQLite database with automatic schema migration.

Runs all pending migrations before returning the store. This is the recommended constructor for production deployments because it ensures the schema is always up to date without duplicating DDL statements.

Errors

Returns an error if the database cannot be opened or any migration fails.

pub async fn from_pool(pool: SqlitePool) -> Result<Self, Error>

Creates a store from an existing connection pool.

Errors

Returns an error if the schema migration fails.

Trait Implementations

impl Clone for SqliteTaskStore

fn clone(&self) -> SqliteTaskStore

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SqliteTaskStore

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

Formats the value using the given formatter.

impl TaskStore for SqliteTaskStore

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

Appends into the stored JSON document instead of rewriting it.

save serializes the whole task in Rust and ships it as a bind parameter, so a streaming agent pays for every artifact it has already persisted on every subsequent event. This sends only what changed and lets SQLite splice it into the document with json_set.

What this does and does not remove

Removed: the Rust-side serde_json::to_string of the whole task, and the transfer of the whole document as a parameter. Both scale with the stream so far.

Not removed: SQLite still parses and rewrites the row internally, so the statement remains linear in document size. A blob-per-task schema cannot avoid that; only a normalized artifacts table could, and the measurement in benches/benches/backpressure.rs says that is not where this store’s time goes — the per-event round trip dominates by roughly 3:1 at 502 events. Doing the larger surgery for the smaller term would be the wrong trade, and it is recorded here rather than left implied.

updated_at is deliberately untouched: it carries the status timestamp that orders list (§3.1.4), and appending an artifact does not change a task’s status. This matches InMemoryTaskStore, which keeps the task’s list position across an append.

Falls back to save whenever the delta cannot be applied exactly. The refused cases, and why each one is refused, are documented on the private statement builder this calls.

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.