llm-toolkit 0.63.1

A low-level, unopinionated Rust toolkit for the LLM last mile problem.
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

#[cfg(feature = "derive")]
mod tests {
    use llm_toolkit::ToPrompt;

    // Custom formatting function in the crate root (needed for macro to find it)
    pub fn format_temperature(temp: &f32) -> String {
        format!("{:.1}°C", temp)
    }

    pub fn format_percentage(value: &f32) -> String {
        format!("{:.0}%", value * 100.0)
    }

    pub fn format_list(items: &[String]) -> String {
        items.join(", ")
    }

    pub fn uppercase_format(s: &str) -> String {
        s.to_uppercase()
    }

    #[test]
    fn test_format_with_attribute() {
        #[derive(ToPrompt)]
        #[allow(dead_code)]
        struct WeatherReport {
            /// Current temperature
            #[prompt(format_with = "super::tests::format_temperature")]
            temperature: f32,

            /// Humidity level
            #[prompt(format_with = "super::tests::format_percentage")]
            humidity: f32,

            /// Weather conditions
            #[prompt(rename = "conditions", format_with = "super::tests::format_list")]
            weather_conditions: Vec<String>,

            // Normal field without custom formatting
            location: String,

            #[prompt(skip)]
            internal_id: u32,
        }

        let report = WeatherReport {
            temperature: 23.456,
            humidity: 0.65,
            weather_conditions: vec!["Partly cloudy".to_string(), "Light wind".to_string()],
            location: "Tokyo".to_string(),
            internal_id: 12345,
        };

        let prompt = report.to_prompt();

        // Check that custom formatters were applied
        assert!(
            prompt.contains("Current temperature: 23.5°C"),
            "Temperature should be formatted with format_temperature: {}",
            prompt
        );
        assert!(
            prompt.contains("Humidity level: 65%"),
            "Humidity should be formatted with format_percentage: {}",
            prompt
        );
        assert!(
            prompt.contains("conditions: Partly cloudy, Light wind"),
            "Weather conditions should use renamed key and custom formatter: {}",
            prompt
        );
        assert!(
            prompt.contains("location: Tokyo"),
            "Location should use default to_prompt: {}",
            prompt
        );
        assert!(
            !prompt.contains("internal_id"),
            "internal_id should be skipped: {}",
            prompt
        );
    }

    #[test]
    fn test_all_attributes_together() {
        // This test ensures that skip, rename, and format_with work together
        #[derive(ToPrompt)]
        #[allow(dead_code)]
        struct TestStruct {
            #[prompt(skip)]
            ignored: String,

            #[prompt(rename = "custom_name")]
            renamed_field: String,

            #[prompt(format_with = "super::tests::uppercase_format")]
            formatted_field: String,

            #[prompt(rename = "special", format_with = "super::tests::uppercase_format")]
            both_rename_and_format: String,
        }

        let test = TestStruct {
            ignored: "should not appear".to_string(),
            renamed_field: "renamed value".to_string(),
            formatted_field: "hello".to_string(),
            both_rename_and_format: "world".to_string(),
        };

        let prompt = test.to_prompt();

        assert!(!prompt.contains("should not appear"));
        assert!(!prompt.contains("ignored"));
        assert!(prompt.contains("custom_name: renamed value"));
        assert!(prompt.contains("formatted_field: HELLO"));
        assert!(prompt.contains("special: WORLD"));
    }
}