vex-api 1.7.0

Industry-grade HTTP API gateway for VEX Protocol
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

//! Application State
//!
//! Centralizes access to DB, Queue, and Auth/Monitoring services.

use crate::a2a::handler::A2aState;
use crate::auth::JwtAuth;
use crate::tenant_rate_limiter::TenantRateLimiter;
use std::sync::Arc;
use vex_chora::AuthorityBridge;
use vex_llm::{LlmProvider, Metrics};
use vex_persist::StorageBackend;
use vex_queue::{QueueBackend, WorkerPool};

/// Application state shared across handlers
#[derive(Clone)]
pub struct AppState {
    jwt_auth: JwtAuth,
    rate_limiter: Arc<TenantRateLimiter>,
    metrics: Arc<Metrics>,
    db: Arc<dyn StorageBackend>,
    evolution_store: Arc<dyn vex_persist::EvolutionStore>,
    queue: Arc<WorkerPool<dyn QueueBackend>>,
    a2a_state: Arc<A2aState>,
    llm: Arc<dyn LlmProvider>,
    router: Option<Arc<vex_router::Router>>,
    gate: Arc<dyn vex_runtime::Gate>,
    orchestrator: Arc<vex_runtime::Orchestrator<dyn vex_llm::LlmProvider>>,
    bridge: Arc<AuthorityBridge>,
}

impl AppState {
    /// Create new application state
    #[allow(clippy::too_many_arguments)]
    pub fn new(
        jwt_auth: JwtAuth,
        rate_limiter: Arc<TenantRateLimiter>,
        metrics: Arc<Metrics>,
        db: Arc<dyn StorageBackend>,
        evolution_store: Arc<dyn vex_persist::EvolutionStore>,
        queue: Arc<WorkerPool<dyn QueueBackend>>,
        a2a_state: Arc<A2aState>,
        llm: Arc<dyn LlmProvider>,
        router: Option<Arc<vex_router::Router>>,
        gate: Arc<dyn vex_runtime::Gate>,
        orchestrator: Arc<vex_runtime::Orchestrator<dyn vex_llm::LlmProvider>>,
        bridge: Arc<AuthorityBridge>,
    ) -> Self {
        Self {
            jwt_auth,
            rate_limiter,
            metrics,
            db,
            evolution_store,
            queue,
            a2a_state,
            llm,
            router,
            gate,
            orchestrator,
            bridge,
        }
    }

    /// Get JWT auth service
    pub fn jwt_auth(&self) -> &JwtAuth {
        &self.jwt_auth
    }

    /// Get rate limiter (cloned Arc for sharing)
    pub fn rate_limiter(&self) -> Arc<TenantRateLimiter> {
        self.rate_limiter.clone()
    }

    /// Get metrics collector (cloned Arc for sharing)
    pub fn metrics(&self) -> Arc<Metrics> {
        self.metrics.clone()
    }

    /// Get database backend (cloned Arc for sharing)
    pub fn db(&self) -> Arc<dyn StorageBackend> {
        self.db.clone()
    }

    /// Get evolution store (cloned Arc for sharing)
    pub fn evolution_store(&self) -> Arc<dyn vex_persist::EvolutionStore> {
        self.evolution_store.clone()
    }

    /// Get queue worker pool (cloned Arc for sharing)
    pub fn queue(&self) -> Arc<WorkerPool<dyn QueueBackend>> {
        self.queue.clone()
    }

    /// Get A2A state (cloned Arc for sharing)
    pub fn a2a_state(&self) -> Arc<A2aState> {
        self.a2a_state.clone()
    }

    /// Get LLM provider (cloned Arc for sharing)
    pub fn llm(&self) -> Arc<dyn LlmProvider> {
        self.llm.clone()
    }

    /// Get Router specifically (cloned Arc for sharing)
    pub fn router(&self) -> Option<Arc<vex_router::Router>> {
        self.router.clone()
    }

    /// Get Gate provider (cloned Arc for sharing)
    pub fn gate(&self) -> Arc<dyn vex_runtime::Gate> {
        self.gate.clone()
    }

    /// Get Orchestrator (cloned Arc for sharing)
    pub fn orchestrator(&self) -> Arc<vex_runtime::Orchestrator<dyn vex_llm::LlmProvider>> {
        self.orchestrator.clone()
    }

    /// Get Authority Bridge (cloned Arc for sharing)
    pub fn bridge(&self) -> Arc<AuthorityBridge> {
        self.bridge.clone()
    }
}