chatty-rs 0.0.1-alpha1

A terminal-based chat client for OpenAI's GPT models.
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

use super::*;
use crate::backend::mcp::{MockMcpClient, ToolInputSchema};

#[tokio::test]
async fn test_add_server() {
    let mut mock_mcp = MockMcpClient::new();
    mock_mcp.expect_list_tools().returning(|| {
        Box::pin(async {
            Ok(vec![
                fake_tool("test_tool", "test tool"),
                fake_tool("another_tool", "another tool"),
                fake_tool("yet_another_tool", "yet another tool"),
            ])
        })
    });

    let tmp = Arc::new(MockMcpClient::new());

    let mut manager = Manager::default();
    manager
        .tools
        .insert(fake_tool("another_tool", "replace"), tmp.clone());

    manager.tools.insert(
        fake_tool("yet_another_tool", "this tool will be not replace"),
        tmp.clone(),
    );
    let arc = Arc::new(mock_mcp);
    manager.add_server(arc.clone()).await.expect("add server");

    assert_eq!(
        manager.tools.len(),
        3,
        "Expected 3 tools after adding server"
    );

    let tools = manager.tools.keys().clone().collect::<Vec<_>>();
    let test_tool = tools.iter().find(|t| t.name == "test_tool").unwrap();
    assert_eq!(test_tool.name, "test_tool", "Expected test_tool");
    assert_eq!(
        test_tool.description.as_deref(),
        Some("test tool"),
        "Expected description to be 'test tool'"
    );

    let another_tool = tools.iter().find(|t| t.name == "another_tool").unwrap();
    assert_eq!(another_tool.name, "another_tool", "Expected another_tool");
    assert_eq!(
        another_tool.description.as_deref(),
        Some("another tool"),
        "Expected description to be 'another tool'"
    );

    let yet_another_tool = tools.iter().find(|t| t.name == "yet_another_tool").unwrap();
    assert_eq!(
        yet_another_tool.name, "yet_another_tool",
        "Expected yet_another_tool"
    );
    assert_eq!(
        yet_another_tool.description.as_deref(),
        Some("this tool will be not replace"),
        "Expected description to be 'yet another tool'"
    );
}

fn fake_tool(name: &str, desc: &str) -> Tool {
    Tool {
        provider: "test".to_string(),
        name: name.to_string(),
        description: Some(desc.to_string()),
        input_schema: ToolInputSchema::default(),
    }
}