1use crate::services::oauth::replay_key::ReplayKey;
4use ed25519_dalek::{SigningKey, VerifyingKey};
5use hyprstream_rpc_std::model_client::{LoadModelRequest, ModelClient};
6use hyprstream_rpc_std::policy_client::PolicyClient;
7use hyprstream_rpc_std::registry_client::RegistryClient;
8use hyprstream_util::TtlCache;
9use std::collections::HashMap;
10use std::sync::Arc;
11use tokio::sync::RwLock;
12
13const DPOP_JTI_MAX_ENTRIES: usize = 360_000;
18const DPOP_JTI_REAP_BUDGET: usize = 64;
19
20pub use crate::config::{CorsConfig, SamplingParamDefaults, ServerConfig};
22
23#[cfg(feature = "metrics")]
25pub use hyprstream_metrics::storage::context::{ContextRecord, ContextStore, SearchResult};
26
27#[derive(Clone)]
29pub struct ServerState {
30 pub model_client: ModelClient,
32
33 pub policy_client: PolicyClient,
35
36 pub registry: RegistryClient,
38
39 pub config: Arc<ServerConfig>,
41
42 pub metrics: Arc<Metrics>,
44
45 pub signing_key: Arc<SigningKey>,
47
48 pub verifying_key: Arc<VerifyingKey>,
54
55 pub published_jwt_verifying_keys: crate::auth::key_rotation::PublishedEd25519Keys,
62
63 #[cfg(feature = "metrics")]
65 pub context_store:
66 Option<Arc<ContextStore<hyprstream_metrics::storage::duckdb::DuckDbBackend>>>,
67
68 pub resource_url: String,
70
71 pub oauth_issuer_url: String,
73
74 pub federation_resolver: Arc<crate::auth::FederationKeyResolver>,
77
78 pub dpop_jti_seen: Arc<TtlCache<ReplayKey, ()>>,
82
83 pub rate_limiter: Arc<crate::server::middleware::RateLimiter>,
85
86 pub browser_provisioning_rate_limiter: Arc<crate::server::middleware::RateLimiter>,
89
90 pub public_route_rate_limiter: Arc<crate::server::middleware::RateLimiter>,
95
96 pub ninep_decider: Arc<dyn hyprstream_9p::AccessDecider>,
98
99 pub ninep_vfs_pep: Option<Arc<hyprstream_vfs::NamespacePep>>,
101}
102
103#[derive(Clone)]
109pub struct ResourceAuthState {
110 pub verifying_key: Arc<VerifyingKey>,
111 pub published_jwt_verifying_keys: crate::auth::key_rotation::PublishedEd25519Keys,
112 pub composite_key_set: Arc<hyprstream_rpc::auth::CompositeKeySet>,
113 pub resource_url: String,
114 pub oauth_issuer_url: String,
115 pub federation_resolver: Arc<dyn hyprstream_rpc::auth::FederationKeySource>,
116 pub dpop_jti_seen: Arc<TtlCache<ReplayKey, ()>>,
117 pub rate_limiter: Arc<crate::server::middleware::RateLimiter>,
118}
119
120impl ResourceAuthState {
121 pub fn new(
122 verifying_key: VerifyingKey,
123 resource_url: String,
124 oauth_issuer_url: String,
125 federation_resolver: Arc<dyn hyprstream_rpc::auth::FederationKeySource>,
126 ) -> Self {
127 Self {
128 verifying_key: Arc::new(verifying_key),
129 published_jwt_verifying_keys: crate::auth::key_rotation::global_ed25519_verifying_keys(
130 ),
131 composite_key_set: hyprstream_rpc::auth::global_composite_key_set(),
132 resource_url,
133 oauth_issuer_url,
134 federation_resolver,
135 dpop_jti_seen: Arc::new(TtlCache::new(DPOP_JTI_MAX_ENTRIES, DPOP_JTI_REAP_BUDGET)),
136 rate_limiter: Arc::new(crate::server::middleware::RateLimiter::new(300, 60)),
137 }
138 }
139}
140
141pub struct Metrics {
143 pub total_requests: Arc<std::sync::atomic::AtomicU64>,
145
146 pub total_tokens: Arc<std::sync::atomic::AtomicU64>,
148
149 pub avg_latency_ms: Arc<RwLock<f64>>,
151
152 pub active_requests: Arc<std::sync::atomic::AtomicU32>,
154}
155
156impl Default for Metrics {
157 fn default() -> Self {
158 Self {
159 total_requests: Arc::new(std::sync::atomic::AtomicU64::new(0)),
160 total_tokens: Arc::new(std::sync::atomic::AtomicU64::new(0)),
161 avg_latency_ms: Arc::new(RwLock::new(0.0)),
162 active_requests: Arc::new(std::sync::atomic::AtomicU32::new(0)),
163 }
164 }
165}
166
167impl ServerState {
168 pub fn resource_auth_state(&self) -> ResourceAuthState {
170 ResourceAuthState {
171 verifying_key: Arc::clone(&self.verifying_key),
172 published_jwt_verifying_keys: Arc::clone(&self.published_jwt_verifying_keys),
173 composite_key_set: hyprstream_rpc::auth::global_composite_key_set(),
174 resource_url: self.resource_url.clone(),
175 oauth_issuer_url: self.oauth_issuer_url.clone(),
176 federation_resolver: self.federation_resolver.clone(),
177 dpop_jti_seen: Arc::clone(&self.dpop_jti_seen),
178 rate_limiter: Arc::clone(&self.rate_limiter),
179 }
180 }
181
182 pub async fn new(
188 config: ServerConfig,
189 model_client: ModelClient,
190 policy_client: PolicyClient,
191 registry: RegistryClient,
192 signing_key: SigningKey,
193 jwt_verifying_key: VerifyingKey,
194 resource_url: String,
195 oauth_issuer_url: String,
196 trusted_issuers: &HashMap<String, crate::config::TrustedIssuerConfig>,
197 ninep_decider: Arc<dyn hyprstream_9p::AccessDecider>,
198 ninep_vfs_pep: Option<Arc<hyprstream_vfs::NamespacePep>>,
199 ) -> Result<Self, anyhow::Error> {
200 if let Some(export) = &config.ninep_canonical_read {
201 export.validate()?;
202 anyhow::ensure!(
203 ninep_vfs_pep.is_some(),
204 "canonical 9P export needs armed VFS PEP"
205 );
206 }
207 let signing_key = Arc::new(signing_key);
208 let verifying_key = Arc::new(jwt_verifying_key);
211
212 let published_jwt_verifying_keys =
216 crate::auth::key_rotation::global_ed25519_verifying_keys();
217
218 if !config.preload_models.is_empty() {
220 tracing::info!("Preloading {} models", config.preload_models.len());
221 for model_name in &config.preload_models {
222 tracing::info!("Preloading model: {}", model_name);
223 match model_client
224 .load(&LoadModelRequest {
225 model_ref: model_name.to_owned(),
226 max_context: None,
227 kv_quant: None,
228 })
229 .await
230 {
231 Ok(_) => tracing::info!("Preloaded: {}", model_name),
232 Err(e) => tracing::warn!("Failed to preload model '{}': {}", model_name, e),
233 }
234 }
235 }
236
237 let metrics = Arc::new(Metrics::default());
239
240 let federation_resolver = Arc::new(
244 crate::auth::FederationKeyResolver::new(trusted_issuers)
245 .with_policy_client(Arc::new(policy_client.clone())),
246 );
247
248 Ok(Self {
249 model_client,
250 policy_client,
251 registry,
252 config: Arc::new(config),
253 metrics,
254 signing_key,
255 verifying_key,
256 published_jwt_verifying_keys,
257 #[cfg(feature = "metrics")]
258 context_store: None, resource_url,
260 oauth_issuer_url,
261 federation_resolver,
262 dpop_jti_seen: Arc::new(TtlCache::new(DPOP_JTI_MAX_ENTRIES, DPOP_JTI_REAP_BUDGET)),
263 rate_limiter: Arc::new(crate::server::middleware::RateLimiter::new(300, 60)),
264 browser_provisioning_rate_limiter: Arc::new(
265 crate::server::middleware::RateLimiter::new(60, 60),
266 ),
267 public_route_rate_limiter: Arc::new(crate::server::middleware::RateLimiter::new(
268 3_000, 60,
269 )),
270 ninep_decider,
271 ninep_vfs_pep,
272 })
273 }
274
275 pub async fn get_metrics(&self) -> serde_json::Value {
277 serde_json::json!({
278 "total_requests": self.metrics.total_requests.load(std::sync::atomic::Ordering::Relaxed),
279 "total_tokens": self.metrics.total_tokens.load(std::sync::atomic::Ordering::Relaxed),
280 "avg_latency_ms": *self.metrics.avg_latency_ms.read().await,
281 "active_requests": self.metrics.active_requests.load(std::sync::atomic::Ordering::Relaxed),
282 })
283 }
284
285 #[cfg(feature = "metrics")]
297 pub async fn enable_context_store(
298 &mut self,
299 db_path: &str,
300 embedding_dim: i32,
301 ) -> Result<(), anyhow::Error> {
302 use hyprstream_metrics::storage::context::{context_schema, ContextStore};
303 use hyprstream_metrics::storage::duckdb::DuckDbBackend;
304 use hyprstream_metrics::StorageBackend;
305
306 let backend = Arc::new(DuckDbBackend::new(
307 db_path.to_owned(),
308 std::collections::HashMap::new(),
309 None,
310 )?);
311 backend
312 .init()
313 .await
314 .map_err(|e| anyhow::anyhow!("Failed to init DuckDB: {}", e))?;
315 backend
316 .create_table("context", &context_schema(embedding_dim))
317 .await
318 .map_err(|e| anyhow::anyhow!("Failed to create context table: {}", e))?;
319
320 let store = ContextStore::new(backend, "context", embedding_dim);
321 self.context_store = Some(Arc::new(store));
322
323 tracing::info!(
324 "Context store enabled with embedding_dim={} at {}",
325 embedding_dim,
326 db_path
327 );
328
329 Ok(())
330 }
331
332 #[cfg(feature = "metrics")]
334 pub fn get_context_store(
335 &self,
336 ) -> Option<&Arc<ContextStore<hyprstream_metrics::storage::duckdb::DuckDbBackend>>> {
337 self.context_store.as_ref()
338 }
339}
340
341