claude-agent 0.2.25

Rust SDK for building AI agents with Anthropic's Claude - Direct API, no CLI dependency
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

//! Output style provider implementations using common infrastructure.

use super::{OutputStyle, OutputStyleLoader};
use crate::common::{
    FileProvider, InMemoryProvider as GenericInMemoryProvider, OutputStyleLookupStrategy,
};

pub type InMemoryOutputStyleProvider = GenericInMemoryProvider<OutputStyle>;

pub type FileOutputStyleProvider =
    FileProvider<OutputStyle, OutputStyleLoader, OutputStyleLookupStrategy>;

pub type ChainOutputStyleProvider = crate::common::ChainProvider<OutputStyle>;

pub fn file_output_style_provider() -> FileOutputStyleProvider {
    FileOutputStyleProvider::new(OutputStyleLoader::new(), OutputStyleLookupStrategy)
}

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

    #[tokio::test]
    async fn test_in_memory_provider() {
        let style = OutputStyle::new("test", "Test style", "Do something");
        let provider = InMemoryOutputStyleProvider::new().item(style);

        let names = provider.list().await.unwrap();
        assert_eq!(names, vec!["test"]);

        let loaded = provider.get("test").await.unwrap();
        assert!(loaded.is_some());
        assert_eq!(loaded.unwrap().name, "test");
    }

    #[tokio::test]
    async fn test_chain_provider() {
        let low = InMemoryOutputStyleProvider::new()
            .item(OutputStyle::new("shared", "Low", "Low content"))
            .priority(0);

        let high = InMemoryOutputStyleProvider::new()
            .item(OutputStyle::new("shared", "High", "High content"))
            .priority(10);

        let chain = ChainOutputStyleProvider::new().provider(low).provider(high);

        let style = chain.get("shared").await.unwrap().unwrap();
        assert_eq!(style.description, "High");
    }

    #[tokio::test]
    async fn test_file_provider() {
        use crate::common::{Provider, SourceType};

        let temp = tempfile::tempdir().unwrap();
        let provider = file_output_style_provider()
            .path(temp.path())
            .priority(5)
            .source_type(SourceType::Project);

        assert_eq!(Provider::priority(&provider), 5);
        assert_eq!(provider.paths().len(), 1);
    }

    #[tokio::test]
    async fn test_file_provider_load_style() {
        let temp = tempfile::tempdir().unwrap();
        let style_file = temp.path().join("custom.md");
        tokio::fs::write(
            &style_file,
            r#"---
name: custom-style
description: A custom style
---

Custom content here.
"#,
        )
        .await
        .unwrap();

        let provider = file_output_style_provider().path(temp.path());

        let style = provider.get("custom").await.unwrap();
        assert!(style.is_some());
        assert_eq!(style.unwrap().name, "custom-style");
    }
}