Struct TursoStorage 

pub struct TursoStorage { /* private fields */ }

Turso storage backend for durable persistence

Implementations

impl TursoStorage

pub async fn add_relationship( &self, from_episode_id: Uuid, to_episode_id: Uuid, relationship_type: RelationshipType, metadata: RelationshipMetadata, ) -> Result<Uuid>

Add a relationship between two episodes

pub async fn store_relationship( &self, relationship: &EpisodeRelationship, ) -> Result<()>

Store a relationship between two episodes

This is the StorageBackend trait implementation that takes a pre-built EpisodeRelationship.

pub async fn remove_relationship(&self, relationship_id: Uuid) -> Result<()>

Remove a relationship by ID

pub async fn get_relationships( &self, episode_id: Uuid, direction: Direction, ) -> Result<Vec<EpisodeRelationship>>

Get relationships for an episode

pub async fn get_relationships_by_type( &self, episode_id: Uuid, relationship_type: RelationshipType, direction: Direction, ) -> Result<Vec<EpisodeRelationship>>

Get relationships by type

pub async fn relationship_exists( &self, from_episode_id: Uuid, to_episode_id: Uuid, relationship_type: RelationshipType, ) -> Result<bool>

Check if a relationship exists

pub async fn get_dependent_episodes( &self, episode_id: Uuid, ) -> Result<Vec<Uuid>>

Get all episodes that depend on the given episode (blocking it)

pub async fn get_dependencies(&self, episode_id: Uuid) -> Result<Vec<Uuid>>

Get all episodes that the given episode depends on

impl TursoStorage

pub async fn store_episodes_with_patterns_batch( &self, episodes: Vec<Episode>, patterns: Vec<Pattern>, ) -> Result<()>

Store episodes with their associated patterns in a single transaction

This is more efficient than storing episodes and patterns separately when they are related, as it ensures atomicity and reduces round-trips.

Arguments

• episodes - Episodes to store
• patterns - Patterns to store (may be associated with episodes)

Example

let storage = TursoStorage::new("file:test.db", "").await?;

let episodes = vec![/* ... */];
let patterns = vec![/* ... */];

storage.store_episodes_with_patterns_batch(episodes, patterns).await?;

impl TursoStorage

pub async fn store_episodes_batch(&self, episodes: Vec<Episode>) -> Result<()>

Store multiple episodes in a single transaction

Uses prepared statements and transactions for 4-6x throughput improvement.

Arguments

• episodes - Vector of episodes to store

Returns

Result indicating success or failure

Example

let storage = TursoStorage::new("file:test.db", "").await?;

let episodes = vec![
    Episode::new("Task 1".to_string(), TaskContext::default(), TaskType::CodeGeneration),
    Episode::new("Task 2".to_string(), TaskContext::default(), TaskType::Debugging),
];

storage.store_episodes_batch(episodes).await?;

impl TursoStorage

pub async fn get_episodes_batch( &self, ids: &[Uuid], ) -> Result<Vec<Option<Episode>>>

Retrieve multiple episodes by IDs efficiently

Uses a single query with IN clause for efficient batch retrieval.

Arguments

• ids - Slice of episode UUIDs to retrieve

Returns

Vector of optional episodes (None if episode not found)

Example

let storage = TursoStorage::new("file:test.db", "").await?;

let ids = vec![Uuid::new_v4(), Uuid::new_v4()];
let episodes = storage.get_episodes_batch(&ids).await?;

for episode in episodes {
    if let Some(ep) = episode {
        println!("Found episode: {}", ep.episode_id);
    }
}

pub async fn get_patterns_batch( &self, ids: &[PatternId], ) -> Result<Vec<Option<Pattern>>>

Retrieve multiple patterns by IDs efficiently

Uses a single query with IN clause for efficient batch retrieval.

Arguments

• ids - Slice of pattern IDs to retrieve

Returns

Vector of optional patterns (None if pattern not found)

Example

let storage = TursoStorage::new("file:test.db", "").await?;

let ids = vec![PatternId::new_v4(), PatternId::new_v4()];
let patterns = storage.get_patterns_batch(&ids).await?;

for pattern in patterns {
    if let Some(p) = pattern {
        println!("Found pattern: {:?}", p.id());
    }
}

pub async fn get_heuristics_batch( &self, ids: &[Uuid], ) -> Result<Vec<Option<Heuristic>>>

Retrieve multiple heuristics by IDs efficiently

Uses a single query with IN clause for efficient batch retrieval.

Arguments

• ids - Slice of heuristic UUIDs to retrieve

Returns

Vector of optional heuristics (None if heuristic not found)

Example

let storage = TursoStorage::new("file:test.db", "").await?;

let ids = vec![Uuid::new_v4(), Uuid::new_v4()];
let heuristics = storage.get_heuristics_batch(&ids).await?;

for heuristic in heuristics {
    if let Some(h) = heuristic {
        println!("Found heuristic: {}", h.heuristic_id);
    }
}

impl TursoStorage

pub async fn store_patterns_batch(&self, patterns: Vec<Pattern>) -> Result<()>

Store multiple patterns in a single transaction

Uses prepared statements and transactions for 4-6x throughput improvement. All patterns are stored atomically - if any fails, all are rolled back.

pub async fn update_patterns_batch(&self, patterns: Vec<Pattern>) -> Result<()>

Update multiple patterns in a single transaction

pub async fn store_patterns_batch_with_progress( &self, patterns: Vec<Pattern>, batch_size: usize, ) -> Result<BatchResult>

Store patterns in batches with progress tracking

pub async fn get_patterns_batch_by_ids( &self, pattern_ids: Vec<PatternId>, ) -> Result<Vec<Pattern>>

Retrieve multiple patterns by IDs in a single query

Uses a single IN query for efficient bulk retrieval (4-6x improvement over individual queries).

Arguments

• pattern_ids - Vector of pattern IDs to retrieve

Returns

Vector of patterns (only patterns that exist are returned)

Example

let storage = TursoStorage::new("file:test.db", "").await?;

let ids = vec![
    PatternId::new_v4(),
    PatternId::new_v4(),
];

let patterns = storage.get_patterns_batch(&ids).await?;

pub async fn delete_patterns_batch( &self, pattern_ids: Vec<PatternId>, ) -> Result<usize>

Delete multiple patterns in a single transaction

All deletions are atomic - if any fails, all are rolled back.

Arguments

• pattern_ids - Vector of pattern IDs to delete

Returns

Number of patterns actually deleted

Example

let storage = TursoStorage::new("file:test.db", "").await?;

let ids = vec![
    PatternId::new_v4(),
    PatternId::new_v4(),
];

let deleted = storage.delete_patterns_batch(ids).await?;
println!("Deleted {} patterns", deleted);

impl TursoStorage

pub async fn store_heuristics_batch( &self, heuristics: Vec<Heuristic>, ) -> Result<()>

Store multiple heuristics in a single transaction

Uses prepared statements and transactions for 4-6x throughput improvement. All heuristics are stored atomically - if any fails, all are rolled back.

pub async fn update_heuristics_batch( &self, heuristics: Vec<Heuristic>, ) -> Result<()>

Update multiple heuristics in a single transaction

pub async fn store_heuristics_batch_with_progress( &self, heuristics: Vec<Heuristic>, batch_size: usize, ) -> Result<HeuristicBatchResult>

Store heuristics in batches with progress tracking

pub async fn update_heuristics_batch_with_progress( &self, heuristics: Vec<Heuristic>, batch_size: usize, ) -> Result<HeuristicBatchResult>

Update heuristics in batches with progress tracking

pub async fn delete_heuristics_batch(&self, ids: Vec<Uuid>) -> Result<()>

Delete multiple heuristics in a single transaction

Uses transactions for atomic deletion - if any fails, all are rolled back.

Arguments

• ids - Vector of heuristic IDs to delete

Returns

Result indicating success or failure

Example

let storage = TursoStorage::new("file:test.db", "").await?;

let ids = vec![Uuid::new_v4(), Uuid::new_v4()];
storage.delete_heuristics_batch(ids).await?;

pub async fn delete_heuristics_batch_with_progress( &self, ids: Vec<Uuid>, batch_size: usize, ) -> Result<HeuristicBatchResult>

Delete heuristics in batches with progress tracking

impl TursoStorage

pub async fn store_episode_with_capacity( &self, episode: &Episode, max_episodes: usize, ) -> Result<()>

Store an episode with capacity management

When the episode limit is reached, the least relevant episodes are evicted based on the configured eviction policy.

pub async fn get_capacity_statistics(&self) -> Result<CapacityStatistics>

Get storage statistics including capacity info

impl TursoStorage

pub fn get_embedding_table_for_dimension( &self, dimension: usize, ) -> &'static str

pub fn get_vector_index_for_dimension( &self, dimension: usize, ) -> Option<&'static str>

impl TursoStorage

pub async fn store_episode(&self, episode: &Episode) -> Result<()>

Store an episode

Uses INSERT OR REPLACE for upsert semantics. When compression is enabled, large payloads are compressed to reduce bandwidth.

pub async fn get_episode(&self, episode_id: Uuid) -> Result<Option<Episode>>

Retrieve an episode by ID

When adaptive-ttl feature is enabled and caching is configured, this method will first check the cache before querying the database. Cache hits record access for TTL adaptation.

pub async fn delete_episode(&self, episode_id: Uuid) -> Result<()>

Delete an episode by ID

pub async fn store_episode_summary( &self, summary: &EpisodeSummary, ) -> Result<()>

Store an episode summary

pub async fn get_episode_summary( &self, episode_id: Uuid, ) -> Result<Option<EpisodeSummary>>

Retrieve an episode summary by episode ID

pub async fn get_episode_by_task_desc( &self, task_desc: &str, ) -> Result<Option<Episode>>

Retrieve an episode by task description

impl TursoStorage

pub async fn query_episodes(&self, query: &EpisodeQuery) -> Result<Vec<Episode>>

Query episodes with filters

pub async fn query_episodes_since( &self, since: DateTime<Utc>, limit: Option<usize>, ) -> Result<Vec<Episode>>

Query episodes modified since a given timestamp

Arguments

• since - Timestamp to query from
• limit - Maximum number of episodes to return (default: 100, max: 1000)

pub async fn query_episodes_by_metadata( &self, key: &str, value: &str, limit: Option<usize>, ) -> Result<Vec<Episode>>

Query episodes by metadata key-value pair

Uses json_extract for efficient querying of JSON metadata fields. Falls back to LIKE pattern matching if json_extract is not available.

Arguments

• key - Metadata key to search for
• value - Metadata value to match
• limit - Maximum number of episodes to return (default: 100, max: 1000)

impl TursoStorage

pub async fn query_episodes_raw(&self, sql: &str) -> Result<Vec<Episode>>

Execute a raw SQL query for episodes

Convenience method for cache integration. See RawEpisodeQuery for details.

pub async fn query_episodes_raw_with_params<P: IntoParams>( &self, sql: &str, params: P, ) -> Result<Vec<Episode>>

Execute a parameterized SQL query for episodes

Convenience method for cache integration with safe parameters.

impl TursoStorage

pub async fn store_heuristic(&self, heuristic: &Heuristic) -> Result<()>

Store a heuristic

pub async fn get_heuristic(&self, id: Uuid) -> Result<Option<Heuristic>>

Retrieve a heuristic by ID

pub async fn get_heuristics(&self) -> Result<Vec<Heuristic>>

Get all heuristics

pub async fn delete_heuristic(&self, id: Uuid) -> Result<()>

Delete a heuristic by ID

impl TursoStorage

pub async fn store_execution_record( &self, record: &ExecutionRecord, ) -> Result<()>

Store an execution record

pub async fn store_agent_metrics(&self, metrics: &AgentMetrics) -> Result<()>

Store agent metrics

pub async fn store_task_metrics(&self, metrics: &TaskMetrics) -> Result<()>

Store task metrics

pub async fn load_agent_metrics( &self, agent_name: &str, ) -> Result<Option<AgentMetrics>>

Load agent metrics

pub async fn load_execution_records( &self, agent_name: Option<&str>, limit: usize, ) -> Result<Vec<ExecutionRecord>>

Load execution records

pub async fn load_task_metrics( &self, task_type: &str, ) -> Result<Option<TaskMetrics>>

Load task metrics

impl TursoStorage

pub async fn store_pattern(&self, pattern: &CorePattern) -> Result<()>

Store a pattern

pub async fn get_pattern( &self, pattern_id: PatternId, ) -> Result<Option<CorePattern>>

Retrieve a pattern by ID

pub async fn query_patterns( &self, query: &PatternQuery, ) -> Result<Vec<CorePattern>>

Query patterns with filters

impl TursoStorage

pub async fn query_patterns_raw(&self, sql: &str) -> Result<Vec<Pattern>>

Execute a raw SQL query for patterns

Convenience method for cache integration. See RawPatternQuery for details.

pub async fn query_patterns_raw_with_params<P: IntoParams>( &self, sql: &str, params: P, ) -> Result<Vec<Pattern>>

Execute a parameterized SQL query for patterns

Convenience method for cache integration with safe parameters.

impl TursoStorage

pub async fn store_recommendation_session( &self, session: &RecommendationSession, ) -> Result<()>

pub async fn get_recommendation_session( &self, session_id: Uuid, ) -> Result<Option<RecommendationSession>>

pub async fn get_recommendation_session_for_episode( &self, episode_id: Uuid, ) -> Result<Option<RecommendationSession>>

pub async fn store_recommendation_feedback( &self, feedback: &RecommendationFeedback, ) -> Result<()>

pub async fn get_recommendation_feedback( &self, session_id: Uuid, ) -> Result<Option<RecommendationFeedback>>

pub async fn get_recommendation_stats(&self) -> Result<RecommendationStats>

impl TursoStorage

pub async fn _store_embedding_internal( &self, item_id: &str, item_type: &str, embedding: &[f32], ) -> Result<()>

Store an embedding (internal implementation)

When compression is enabled, embeddings are compressed using the configured algorithm (LZ4, Zstd, or Gzip) to reduce network bandwidth.

When turso_multi_dimension feature is enabled, routes to dimension-specific tables.

pub async fn _get_embedding_internal( &self, item_id: &str, item_type: &str, ) -> Result<Option<Vec<f32>>>

Get an embedding (internal implementation)

Automatically decompresses embeddings if they were stored compressed.

pub async fn _delete_embedding_internal(&self, item_id: &str) -> Result<bool>

Delete an embedding (internal implementation)

pub async fn _store_embeddings_batch_internal( &self, embeddings: Vec<(String, Vec<f32>)>, ) -> Result<()>

Store embeddings in batch (internal implementation)

pub async fn _get_embeddings_batch_internal( &self, item_ids: &[String], ) -> Result<Vec<Option<Vec<f32>>>>

Get embeddings in batch (internal implementation)

pub async fn migrate_embeddings_to_vector_format(&self) -> Result<usize>

Migrate existing embeddings to populate embedding_vector column

This migration populates the embedding_vector F32_BLOB column for embeddings that were stored before native vector support was added. The vector column enables DiskANN-accelerated vector_top_k search.

Returns the number of embeddings migrated.

pub async fn has_vector_embeddings(&self) -> Result<bool>

Check if embedding vector column is populated for vector_top_k search

Returns true if at least one embedding has the vector column populated.

pub async fn store_embedding_backend( &self, id: &str, embedding: Vec<f32>, ) -> Result<()>

Store an embedding (backend API)

pub async fn get_embedding_backend(&self, id: &str) -> Result<Option<Vec<f32>>>

Get an embedding (backend API)

pub async fn delete_embedding_backend(&self, id: &str) -> Result<bool>

Delete an embedding (backend API)

pub async fn store_embeddings_batch_backend( &self, embeddings: Vec<(String, Vec<f32>)>, ) -> Result<()>

Store embeddings in batch (backend API)

pub async fn get_embeddings_batch_backend( &self, ids: &[String], ) -> Result<Vec<Option<Vec<f32>>>>

Get embeddings in batch (backend API)

impl TursoStorage

pub async fn initialize_schema(&self) -> Result<()>

Initialize the database schema

Creates tables and indexes if they don’t exist. Safe to call multiple times.

impl TursoStorage

pub async fn new_with_adaptive_pool( url: &str, token: &str, config: TursoConfig, adaptive_config: AdaptivePoolConfig, ) -> Result<Self>

Create a new Turso storage instance with adaptive connection pool

The adaptive pool automatically adjusts its size based on load:

• Scales up when utilization exceeds threshold (default: 70%)
• Scales down during low utilization (default: <30%)
• Provides 20% better performance under variable load

Arguments

• url - Database URL
• token - Authentication token
• config - Turso configuration
• adaptive_config - Adaptive pool configuration

Example

use do_memory_storage_turso::{TursoStorage, TursoConfig, AdaptivePoolConfig};
use std::time::Duration;

let config = TursoConfig::default();
let adaptive_config = AdaptivePoolConfig {
    min_connections: 5,
    max_connections: 50,
    scale_up_threshold: 0.7,
    scale_down_threshold: 0.3,
    scale_up_cooldown: Duration::from_secs(10),
    scale_down_cooldown: Duration::from_secs(30),
    scale_up_increment: 5,
    scale_down_decrement: 5,
    check_interval: Duration::from_secs(5),
};

let storage = TursoStorage::new_with_adaptive_pool(
    "libsql://localhost:8080",
    "token",
    config,
    adaptive_config
).await?;

impl TursoStorage

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

Create a new Turso storage instance

Arguments

• url - Database URL (only libsql://, file:, or :memory: protocols allowed)
• token - Authentication token (required for libsql://, empty for local files)

Security

This method enforces secure connections:

• Remote connections must use libsql:// protocol with a valid token
• HTTP/HTTPS protocols are rejected to prevent insecure connections
• Local file: and :memory: databases are allowed without tokens

Example

// Remote connection with authentication
let storage = TursoStorage::new("libsql://localhost:8080", "my-token").await?;

// Local file database
let local = TursoStorage::new("file:local.db", "").await?;

pub fn from_database(db: Database) -> Result<Self>

Create a Turso storage instance from an existing Database

This is useful for testing with local file-based databases.

Arguments

• db - libSQL Database instance

Example

let db = Builder::new_local("test.db").build().await?;
let storage = TursoStorage::from_database(db)?;

pub async fn with_config( url: &str, token: &str, config: TursoConfig, ) -> Result<Self>

Create a new Turso storage instance with custom configuration

Security

This method enforces the following security requirements:

• Only libsql://, file:, and :memory: protocols are allowed
• Remote connections (libsql://) require a non-empty authentication token
• Local file and memory databases do not require tokens

These checks prevent accidental use of insecure protocols and ensure proper authentication for remote Turso databases.

impl TursoStorage

pub async fn get_connection(&self) -> Result<Connection>

Get a database connection

If connection pooling is enabled, this will use a pooled connection. If keep-alive pool is enabled, it will be used for reduced overhead. If adaptive pool is enabled, it will be used for variable load optimization. Otherwise, it creates a new connection each time.

pub async fn get_connection_with_id(&self) -> Result<(Connection, ConnectionId)>

Get a database connection with its cache ID

This method returns both the connection and a unique connection ID for use with the prepared statement cache. The ID should be passed to prepare_cached and clear_prepared_cache for proper cache management.

Returns

A tuple of (Connection, ConnectionId)

Example

let (conn, conn_id) = storage.get_connection_with_id().await?;
// Use conn and conn_id with prepare_cached

pub async fn get_count(&self, conn: &Connection, table: &str) -> Result<usize>

Get count of records in a table

Safety

The table parameter should be a validated table name from a fixed whitelist. This function does not sanitize the table name, so callers must ensure it comes from a trusted source (e.g., the fixed list in capacity.rs). CodeQL may flag this as a potential SQL injection, but it is safe when used with the predefined table names from the whitelist.

pub async fn execute_pragmas(&self, conn: &Connection) -> Result<()>

Execute PRAGMA statements for database configuration

PRAGMA statements may return rows, so we need to consume them before continuing.

pub async fn execute_with_retry( &self, conn: &Connection, sql: &str, ) -> Result<()>

Execute a SQL statement with retry logic

pub async fn health_check(&self) -> Result<bool>

Health check - verify database connectivity

pub fn with_cache_default(self) -> CachedTursoStorage

Wrap this storage with a cache layer using default cache configuration

This provides transparent caching for episodes, patterns, and heuristics with adaptive TTL based on access patterns.

Example

let storage = TursoStorage::new("file:test.db", "").await?;
let cached = storage.with_cache_default();

pub fn with_cache(self, cache_config: CacheConfig) -> CachedTursoStorage

Wrap this storage with a cache layer using custom cache configuration

Arguments

• config - Cache configuration to use

Returns

A new CachedTursoStorage wrapping this storage

Example

let storage = TursoStorage::new("file:test.db", "").await?;
let config = CacheConfig {
    max_episodes: 1000,
    episode_ttl: Duration::from_secs(3600),
    ..Default::default()
};
let cached = storage.with_cache(config);

pub fn cache_config(&self) -> Option<&CacheConfig>

Get the cache configuration if set

pub fn prepared_cache_stats(&self) -> PreparedCacheStats

Get prepared statement cache statistics

pub fn prepared_cache(&self) -> &PreparedStatementCache

Get a reference to the prepared statement cache

pub async fn get_statistics(&self) -> Result<StorageStatistics>

Get database statistics

pub async fn pool_statistics(&self) -> Option<PoolStatistics>

Get pool statistics if pooling is enabled

pub async fn pool_utilization(&self) -> Option<f32>

Get pool utilization if pooling is enabled

pub fn adaptive_pool_metrics(&self) -> Option<AdaptivePoolMetrics>

Get adaptive pool metrics if enabled

pub fn adaptive_pool_size(&self) -> Option<(u32, u32)>

Get current adaptive pool size

pub async fn check_adaptive_pool_scale(&self)

Manually trigger adaptive pool scaling check

pub async fn prepare_cached( &self, conn_id: ConnectionId, conn: &Connection, sql: &str, ) -> Result<Statement>

Prepare a SQL statement with cache tracking

This method prepares a SQL statement and tracks cache statistics. If the statement is already cached for this connection, it’s a cache hit. Otherwise, it’s a cache miss and the statement is prepared and tracked.

Arguments

• conn_id - Connection identifier for cache tracking
• conn - Database connection to prepare on
• sql - SQL statement to prepare

Returns

The prepared statement

Errors

Returns error if statement preparation fails

pub fn clear_prepared_cache(&self, conn_id: ConnectionId) -> usize

Clear the prepared statement cache for a connection

This should be called when a connection is returned to the pool to prevent memory leaks and ensure proper cache management.

Arguments

• conn_id - Connection identifier to clear

Returns

Number of statements cleared from the cache

Trait Implementations

impl EmbeddingStorageBackend for TursoStorage

fn store_episode_embedding<'life0, 'async_trait>( &'life0 self, episode_id: Uuid, embedding: Vec<f32>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Store an episode embedding

fn store_pattern_embedding<'life0, 'async_trait>( &'life0 self, pattern_id: PatternId, embedding: Vec<f32>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Store a pattern embedding

fn get_episode_embedding<'life0, 'async_trait>( &'life0 self, episode_id: Uuid, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<f32>>>> + Send + 'async_trait>>

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

Get an episode embedding

fn get_pattern_embedding<'life0, 'async_trait>( &'life0 self, pattern_id: PatternId, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<f32>>>> + Send + 'async_trait>>

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

Get a pattern embedding

fn find_similar_episodes<'life0, 'async_trait>( &'life0 self, query_embedding: Vec<f32>, limit: usize, threshold: f32, ) -> Pin<Box<dyn Future<Output = Result<Vec<SimilaritySearchResult<Episode>>>> + Send + 'async_trait>>

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

Find similar episodes using vector similarity

fn find_similar_patterns<'life0, 'async_trait>( &'life0 self, query_embedding: Vec<f32>, limit: usize, threshold: f32, ) -> Pin<Box<dyn Future<Output = Result<Vec<SimilaritySearchResult<Pattern>>>> + Send + 'async_trait>>

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

Find similar patterns using vector similarity

impl MonitoringStorageBackend for TursoStorage

Implement the MonitoringStorageBackend trait for TursoStorage

fn store_execution_record<'life0, 'life1, 'async_trait>( &'life0 self, record: &'life1 ExecutionRecord, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

fn store_agent_metrics<'life0, 'life1, 'async_trait>( &'life0 self, metrics: &'life1 AgentMetrics, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

fn store_task_metrics<'life0, 'life1, 'async_trait>( &'life0 self, metrics: &'life1 TaskMetrics, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

fn load_agent_metrics<'life0, 'life1, 'async_trait>( &'life0 self, agent_name: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<AgentMetrics>>> + Send + 'async_trait>>

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

fn load_execution_records<'life0, 'life1, 'async_trait>( &'life0 self, agent_name: Option<&'life1 str>, limit: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<ExecutionRecord>>> + Send + 'async_trait>>

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

fn load_task_metrics<'life0, 'life1, 'async_trait>( &'life0 self, task_type: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<TaskMetrics>>> + Send + 'async_trait>>

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

impl StorageBackend for TursoStorage

Implement the unified StorageBackend trait for TursoStorage

fn store_episode<'life0, 'life1, 'async_trait>( &'life0 self, episode: &'life1 Episode, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Store an episode

fn get_episode<'life0, 'async_trait>( &'life0 self, id: Uuid, ) -> Pin<Box<dyn Future<Output = Result<Option<Episode>>> + Send + 'async_trait>>

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

Retrieve an episode by ID

fn delete_episode<'life0, 'async_trait>( &'life0 self, id: Uuid, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Delete an episode by ID

fn store_pattern<'life0, 'life1, 'async_trait>( &'life0 self, pattern: &'life1 Pattern, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Store a pattern

fn get_pattern<'life0, 'async_trait>( &'life0 self, id: PatternId, ) -> Pin<Box<dyn Future<Output = Result<Option<Pattern>>> + Send + 'async_trait>>

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

Retrieve a pattern by ID

fn store_heuristic<'life0, 'life1, 'async_trait>( &'life0 self, heuristic: &'life1 Heuristic, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Store a heuristic

fn get_heuristic<'life0, 'async_trait>( &'life0 self, id: Uuid, ) -> Pin<Box<dyn Future<Output = Result<Option<Heuristic>>> + Send + 'async_trait>>

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

Retrieve a heuristic by ID

fn query_episodes_since<'life0, 'async_trait>( &'life0 self, since: DateTime<Utc>, limit: Option<usize>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Episode>>> + Send + 'async_trait>>

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

Query episodes modified since a given timestamp

fn query_episodes_by_metadata<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, key: &'life1 str, value: &'life2 str, limit: Option<usize>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Episode>>> + Send + 'async_trait>>

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

Query episodes by metadata key-value pair

fn store_embedding<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, embedding: Vec<f32>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Store embedding for an episode or pattern

fn get_embedding<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<f32>>>> + Send + 'async_trait>>

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

Retrieve embedding by ID

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

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

Delete embedding by ID

fn store_embeddings_batch<'life0, 'async_trait>( &'life0 self, embeddings: Vec<(String, Vec<f32>)>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Store multiple embeddings in batch

fn get_embeddings_batch<'life0, 'life1, 'async_trait>( &'life0 self, ids: &'life1 [String], ) -> Pin<Box<dyn Future<Output = Result<Vec<Option<Vec<f32>>>>> + Send + 'async_trait>>

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

Get embeddings for multiple IDs

fn store_relationship<'life0, 'life1, 'async_trait>( &'life0 self, relationship: &'life1 EpisodeRelationship, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Store a relationship between two episodes

fn remove_relationship<'life0, 'async_trait>( &'life0 self, relationship_id: Uuid, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Remove a relationship by ID

fn get_relationships<'life0, 'async_trait>( &'life0 self, episode_id: Uuid, direction: Direction, ) -> Pin<Box<dyn Future<Output = Result<Vec<EpisodeRelationship>>> + Send + 'async_trait>>

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

Get relationships for an episode

fn relationship_exists<'life0, 'async_trait>( &'life0 self, from_episode_id: Uuid, to_episode_id: Uuid, relationship_type: RelationshipType, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>

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

Check if a relationship exists

fn store_recommendation_session<'life0, 'life1, 'async_trait>( &'life0 self, session: &'life1 RecommendationSession, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Persist a recommendation session for durability and analytics.

fn get_recommendation_session<'life0, 'async_trait>( &'life0 self, session_id: Uuid, ) -> Pin<Box<dyn Future<Output = Result<Option<RecommendationSession>>> + Send + 'async_trait>>

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

Retrieve a recommendation session by ID.

fn get_recommendation_session_for_episode<'life0, 'async_trait>( &'life0 self, episode_id: Uuid, ) -> Pin<Box<dyn Future<Output = Result<Option<RecommendationSession>>> + Send + 'async_trait>>

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

Retrieve the most recent recommendation session for an episode.

fn store_recommendation_feedback<'life0, 'life1, 'async_trait>( &'life0 self, feedback: &'life1 RecommendationFeedback, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

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

Persist feedback associated with a recommendation session.

fn get_recommendation_feedback<'life0, 'async_trait>( &'life0 self, session_id: Uuid, ) -> Pin<Box<dyn Future<Output = Result<Option<RecommendationFeedback>>> + Send + 'async_trait>>

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

Retrieve feedback for a recommendation session.

fn get_recommendation_stats<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<RecommendationStats>> + Send + 'async_trait>>

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

Compute global recommendation statistics.

fn cleanup_episodes<'life0, 'life1, 'async_trait>( &'life0 self, policy: &'life1 EpisodeRetentionPolicy, ) -> Pin<Box<dyn Future<Output = Result<CleanupResult, Error>> + Send + 'async_trait>>

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

Clean up expired episodes based on retention policy

fn count_cleanup_candidates<'life0, 'life1, 'async_trait>( &'life0 self, policy: &'life1 EpisodeRetentionPolicy, ) -> Pin<Box<dyn Future<Output = Result<usize, Error>> + Send + 'async_trait>>

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

Get count of episodes that would be cleaned up (dry run)