meerkat 0.8.10

Modular, high-performance agent harness for LLM-powered applications
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

//! SDK-facing configuration store helpers.

use std::path::PathBuf;
use std::sync::Arc;

use meerkat_core::config::ConfigError;
use meerkat_core::{Config, ConfigDelta, ConfigStore, FileConfigStore, MemoryConfigStore};

/// SDK config store wrapper.
///
/// Defaults to an in-memory store. Use `with_path` for explicit persistence.
#[derive(Clone)]
pub struct SdkConfigStore {
    store: Arc<dyn ConfigStore>,
}

impl SdkConfigStore {
    /// Create a default in-memory config store.
    pub fn new() -> Self {
        let mut config = Config::default();
        let _ = config.apply_env_overrides();
        Self {
            store: Arc::new(MemoryConfigStore::new(config, meerkat_models::canonical())),
        }
    }

    /// Create an in-memory store with a specific config.
    pub fn with_config(config: Config) -> Self {
        let mut config = config;
        let _ = config.apply_env_overrides();
        Self {
            store: Arc::new(MemoryConfigStore::new(config, meerkat_models::canonical())),
        }
    }

    /// Create a file-backed store for explicit persistence.
    pub fn with_path(path: impl Into<PathBuf>) -> Self {
        Self {
            store: Arc::new(FileConfigStore::new(
                path.into(),
                meerkat_models::canonical(),
            )),
        }
    }

    /// Fetch the current config.
    pub async fn get(&self) -> Result<Config, ConfigError> {
        let mut config = self.store.get().await?;
        let _ = config.apply_env_overrides();
        Ok(config)
    }

    /// Persist the provided config.
    pub async fn set(&self, config: Config) -> Result<(), ConfigError> {
        self.store.set(config).await
    }

    /// Apply a config patch and return the updated config.
    pub async fn patch(&self, delta: ConfigDelta) -> Result<Config, ConfigError> {
        self.store.patch(delta).await
    }

    /// Return the inner store (for advanced integration).
    pub fn inner(&self) -> Arc<dyn ConfigStore> {
        Arc::clone(&self.store)
    }
}

impl Default for SdkConfigStore {
    fn default() -> Self {
        Self::new()
    }
}