Struct AppState 

pub struct AppState {

    pub agent_registry: AgentRegistry,
    pub audit_store: AuditStore,
    pub dependency_store: DependencyStore,
    pub message_store: MessageStore,
    pub event_bus: EventBus,
    pub delivery_tracker: DeliveryTracker,
    pub task_store: TaskStore,
    pub subscription_store: SubscriptionStore,
    pub project_config_store: ProjectConfigStore,
    pub circuit_breaker: CircuitBreaker,
    pub rate_limiter: HybridRateLimiter,
    pub nudge_config: Mutex<NudgeConfig>,
    pub start_time: DateTime<Utc>,
    pub atheneum_path: Option<String>,
    /* private fields */
}

Shared application state across all handlers.

Fields

agent_registry: AgentRegistry

audit_store: AuditStore

dependency_store: DependencyStore

message_store: MessageStore

event_bus: EventBus

delivery_tracker: DeliveryTracker

task_store: TaskStore

subscription_store: SubscriptionStore

project_config_store: ProjectConfigStore

circuit_breaker: CircuitBreaker

rate_limiter: HybridRateLimiter

nudge_config: Mutex<NudgeConfig>

start_time: DateTime<Utc>

atheneum_path: Option<String>

Implementations

impl AppState

pub fn new(engine: Engine) -> Result<Self>

pub fn with_atheneum(self, path: Option<String>) -> Self

pub fn require_atheneum_path(&self) -> Result<String>

pub async fn with_graph_async<F, T>(&self, f: F) -> Result<T>

where F: FnOnce(&SqliteGraph) -> T + Send + 'static, T: Send + 'static,

Async version of with_graph — offloads DB work to the blocking thread pool. Use this from all async handlers to avoid blocking tokio worker threads.

pub async fn with_engine_async<F, T>(&self, f: F) -> Result<T>

where F: FnOnce(&Engine) -> Result<T> + Send + 'static, T: Send + 'static,

Async version that provides the full Engine (not just graph).