rig-core 0.44.0

An opinionated library for building 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
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

use super::*;

#[derive(Serialize, Deserialize, Debug, PartialEq)]
struct Num(u32);
impl ContextValue for Num {
    const KEY: &'static str = "test.num";
}

#[derive(Serialize, Deserialize, Debug, PartialEq)]
struct Greeting(String);
impl ContextValue for Greeting {
    const KEY: &'static str = "test.greeting";
}

#[test]
fn different_types_are_independent() {
    let mut c = ToolContext::new();
    c.insert(Num(42)).unwrap();
    c.insert(Greeting("hello".to_string())).unwrap();
    assert_eq!(c.get::<Num>().unwrap(), Some(Num(42)));
    assert_eq!(
        c.get::<Greeting>().unwrap(),
        Some(Greeting("hello".to_string()))
    );
}
#[test]
fn empty_context_is_default_and_serializes_empty() {
    let c = ToolContext::default();
    assert!(!c.contains::<Num>());
    assert!(c.is_empty());
    assert_eq!(serde_json::to_value(&c).unwrap(), serde_json::json!({}));
}
#[test]
fn remove_missing_type_returns_none() {
    assert_eq!(ToolContext::new().remove::<Num>().unwrap(), None);
}
#[test]
fn require_missing_names_key() {
    let e = ToolContext::new().require::<Num>().unwrap_err();
    assert!(matches!(e, ToolContextError::Missing(Num::KEY)));
    assert!(e.to_string().contains("`test.num`"));
}
#[test]
fn result_metadata_round_trips_and_requires() {
    #[derive(Serialize, Deserialize, Debug, PartialEq)]
    struct Id(u32);
    impl ContextValue for Id {
        const KEY: &'static str = "test.id";
    }
    let mut c = ToolContext::new();
    c.insert_result(Id(7)).unwrap();
    assert_eq!(c.result::<Id>().unwrap(), Some(Id(7)));
    assert_eq!(c.require_result::<Id>().unwrap(), Id(7));
    assert_eq!(c.get::<Id>().unwrap(), None);
}
#[test]
fn dispatch_snapshot_isolates_inbound_and_publishes_only_result_metadata() {
    let mut c = ToolContext::new();
    c.insert(Num(7)).unwrap();
    c.insert_result(Greeting("old".to_string())).unwrap();
    let mut d = c.for_dispatch();
    assert_eq!(d.get::<Num>().unwrap(), Some(Num(7)));
    assert_eq!(d.result::<Greeting>().unwrap(), None);
    d.insert(Num(8)).unwrap();
    d.insert_result(Greeting("new".to_string())).unwrap();

    c.accept_dispatch_result(d);
    assert_eq!(c.get::<Num>().unwrap(), Some(Num(7)));
    assert_eq!(
        c.result::<Greeting>().unwrap(),
        Some(Greeting("new".to_string()))
    );
}
#[test]
fn many_distinct_types_round_trip() {
    #[derive(Serialize, Deserialize, PartialEq, Debug)]
    struct A(u8);
    impl ContextValue for A {
        const KEY: &'static str = "test.a";
    }
    #[derive(Serialize, Deserialize, PartialEq, Debug)]
    struct B(u16);
    impl ContextValue for B {
        const KEY: &'static str = "test.b";
    }
    let mut c = ToolContext::new();
    c.insert(A(1)).unwrap();
    c.insert(B(2)).unwrap();
    c.insert(Num(3)).unwrap();
    c.insert(Greeting("four".to_string())).unwrap();
    assert_eq!(c.get::<A>().unwrap(), Some(A(1)));
    assert_eq!(c.get::<B>().unwrap(), Some(B(2)));
    assert_eq!(c.get::<Num>().unwrap(), Some(Num(3)));
    assert_eq!(
        c.get::<Greeting>().unwrap(),
        Some(Greeting("four".to_string()))
    );
}
#[test]
fn unencodable_value_is_an_error_not_a_panic() {
    // A map with non-string keys has no JSON form.
    #[derive(Serialize, Deserialize, Debug)]
    struct TupleKeyed(std::collections::HashMap<(u8, u8), u8>);
    impl ContextValue for TupleKeyed {
        const KEY: &'static str = "test.tuple_keyed";
    }
    let mut c = ToolContext::new();
    let value = TupleKeyed([((1, 2), 3)].into_iter().collect());
    let err = c.insert(value).unwrap_err();
    assert!(matches!(
        err,
        ToolContextError::Encode {
            key: TupleKeyed::KEY,
            ..
        }
    ));
    assert!(!c.contains::<TupleKeyed>());
}