agnosai 1.1.0

Provider-agnostic AI orchestration framework
Documentation 
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

//! Hot-reload configuration via `tokio::sync::watch`.
//!
//! Provides a `ConfigHolder<T>` that allows runtime configuration updates
//! without restart. Readers get a snapshot via `borrow()`; writers push
//! updates via `update()`.

use std::sync::Arc;

use serde::{Deserialize, Serialize};
use tokio::sync::watch;

/// Runtime-reloadable configuration holder.
///
/// Uses a `watch` channel internally: single writer, many readers.
/// Readers always see the latest value with zero contention.
pub struct ConfigHolder<T: Clone + Send + Sync + 'static> {
    tx: watch::Sender<Arc<T>>,
    rx: watch::Receiver<Arc<T>>,
}

impl<T: Clone + Send + Sync + 'static> ConfigHolder<T> {
    /// Create a new config holder with an initial value.
    pub fn new(initial: T) -> Self {
        let (tx, rx) = watch::channel(Arc::new(initial));
        Self { tx, rx }
    }

    /// Get a snapshot of the current configuration.
    #[must_use]
    pub fn get(&self) -> Arc<T> {
        Arc::clone(&self.rx.borrow())
    }

    /// Get a receiver that can be cloned to other tasks.
    #[must_use]
    pub fn receiver(&self) -> watch::Receiver<Arc<T>> {
        self.rx.clone()
    }

    /// Update the configuration. All readers see the new value immediately.
    pub fn update(&self, new_config: T) {
        let _ = self.tx.send(Arc::new(new_config));
    }
}

/// AgnosAI runtime configuration (hot-reloadable subset).
#[derive(Debug, Clone, Serialize, Deserialize)]
#[non_exhaustive]
pub struct RuntimeConfig {
    /// Maximum concurrent crew executions.
    pub max_concurrent_crews: usize,
    /// Default inference timeout in seconds.
    pub inference_timeout_secs: u64,
    /// Whether authentication is enabled.
    pub auth_enabled: bool,
    /// Log level filter string (e.g. "agnosai=info").
    pub log_level: String,
}

impl Default for RuntimeConfig {
    fn default() -> Self {
        Self {
            max_concurrent_crews: 10,
            inference_timeout_secs: 300,
            auth_enabled: false,
            log_level: "agnosai=info".into(),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn config_holder_initial_value() {
        let holder = ConfigHolder::new(42u32);
        assert_eq!(*holder.get(), 42);
    }

    #[test]
    fn config_holder_update() {
        let holder = ConfigHolder::new("old".to_string());
        assert_eq!(*holder.get(), "old");
        holder.update("new".to_string());
        assert_eq!(*holder.get(), "new");
    }

    #[test]
    fn config_holder_receiver_sees_updates() {
        let holder = ConfigHolder::new(1u64);
        let rx = holder.receiver();
        holder.update(2);
        assert_eq!(**rx.borrow(), 2);
    }

    #[test]
    fn runtime_config_defaults() {
        let cfg = RuntimeConfig::default();
        assert_eq!(cfg.max_concurrent_crews, 10);
        assert_eq!(cfg.inference_timeout_secs, 300);
        assert!(!cfg.auth_enabled);
    }

    #[test]
    fn runtime_config_serde_roundtrip() {
        let cfg = RuntimeConfig::default();
        let json = serde_json::to_string(&cfg).unwrap();
        let restored: RuntimeConfig = serde_json::from_str(&json).unwrap();
        assert_eq!(restored.max_concurrent_crews, cfg.max_concurrent_crews);
    }
}