daimon 0.16.0

A Rust-native AI agent 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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use std::collections::HashMap;

/// A prompt template with `{variable}` interpolation.
///
/// Variables are replaced at render time. Unknown variables are left as-is.
#[derive(Debug, Clone)]
pub struct PromptTemplate {
    template: String,
    variables: HashMap<String, String>,
}

impl PromptTemplate {
    /// Creates a new template from a format string containing `{name}` placeholders.
    pub fn new(template: impl Into<String>) -> Self {
        Self {
            template: template.into(),
            variables: HashMap::new(),
        }
    }

    /// Sets a variable value. Chainable.
    pub fn var(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
        self.variables.insert(key.into(), value.into());
        self
    }

    /// Sets multiple variables from an iterator.
    pub fn vars<I, K, V>(mut self, vars: I) -> Self
    where
        I: IntoIterator<Item = (K, V)>,
        K: Into<String>,
        V: Into<String>,
    {
        for (k, v) in vars {
            self.variables.insert(k.into(), v.into());
        }
        self
    }

    /// Renders the template by replacing all `{name}` placeholders with their
    /// values. Unset variables remain as literal `{name}`.
    pub fn render_static(&self) -> String {
        let mut result = self.template.clone();
        for (key, value) in &self.variables {
            let placeholder = format!("{{{key}}}");
            result = result.replace(&placeholder, value);
        }
        result
    }

    /// Renders with additional runtime variables that override stored ones.
    pub fn render_with(&self, overrides: &HashMap<String, String>) -> String {
        let mut merged = self.variables.clone();
        for (k, v) in overrides {
            merged.insert(k.clone(), v.clone());
        }
        let mut result = self.template.clone();
        for (key, value) in &merged {
            let placeholder = format!("{{{key}}}");
            result = result.replace(&placeholder, value);
        }
        result
    }

    /// Renders the template, resolving [`DynamicContext`](super::DynamicContext) providers
    /// for any remaining `{variable}` placeholders.
    pub async fn render_dynamic(
        &self,
        contexts: &[&dyn super::ErasedDynamicContext],
    ) -> String {
        let mut overrides = HashMap::new();
        for ctx in contexts {
            let value = ctx.resolve_erased().await;
            overrides.insert(ctx.key().to_string(), value);
        }
        self.render_with(&overrides)
    }
}

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

    #[test]
    fn test_basic_interpolation() {
        let tpl = PromptTemplate::new("Hello {name}, you are a {role}.")
            .var("name", "Alice")
            .var("role", "developer");
        assert_eq!(tpl.render_static(), "Hello Alice, you are a developer.");
    }

    #[test]
    fn test_missing_variable_preserved() {
        let tpl = PromptTemplate::new("Hello {name}, {unknown}.")
            .var("name", "Bob");
        assert_eq!(tpl.render_static(), "Hello Bob, {unknown}.");
    }

    #[test]
    fn test_render_with_overrides() {
        let tpl = PromptTemplate::new("{greeting} {name}")
            .var("greeting", "Hello")
            .var("name", "Alice");

        let mut overrides = HashMap::new();
        overrides.insert("name".to_string(), "Bob".to_string());

        assert_eq!(tpl.render_with(&overrides), "Hello Bob");
    }

    #[test]
    fn test_empty_template() {
        let tpl = PromptTemplate::new("");
        assert_eq!(tpl.render_static(), "");
    }

    #[test]
    fn test_no_placeholders() {
        let tpl = PromptTemplate::new("Just plain text.");
        assert_eq!(tpl.render_static(), "Just plain text.");
    }

    #[test]
    fn test_vars_bulk() {
        let tpl = PromptTemplate::new("{a} {b}")
            .vars([("a", "1"), ("b", "2")]);
        assert_eq!(tpl.render_static(), "1 2");
    }
}