rhine 0.1.8

code core of Rhine Lab
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use crate::chat::chat_single::SingleChat;
use crate::config::Config;
use crate::config::ModelCapability::{Think, ToolUse};
use crate::schema::json_schema::JsonSchema;
use crate::tests::format_test_block;
use rhine_schema_derive::{JsonSchema, tool_schema_derive};
use serde::Deserialize;

pub async fn test_chat() {
    Config::add_api_source(
        "pumpkin",
        "https://api.pumpkinaigc.online/v1/chat/completions",
        20,
    );
    Config::add_api_info(
        "pumpkin-ds-r1",
        "deepseek-r1",
        Think,
        "pumpkin",
        "sk-cPdegaWl8YFcKZYs8a108b5f741844D9A1E0B90e724bBe23",
    );
    Config::add_api_info(
        "pumpkin-gpt-4o",
        "gpt-4o",
        ToolUse,
        "pumpkin",
        "sk-cPdegaWl8YFcKZYs8a108b5f741844D9A1E0B90e724bBe23",
    );

    test_single_chat().await;
    // test_single_chat_get_json().await;
    // test_single_chat_get_tool().await;
}

async fn test_single_chat() {
    let mut chat = SingleChat::new_with_api_name("pumpkin-gpt-4o", "", true);

    let resp_1 = chat.get_req_body("深度思考strawberry有几个r").await.unwrap();
    let message_1 = chat.base.session.clone();
    let answer_1 = chat.get_content_from_req_body(resp_1).await.unwrap();
    format_test_block("chat_single_round", || {
        format!("message: {:?}\nanswer: {}", message_1, answer_1)
    });

    let resp_2 = chat.get_req_body("你确定吗?").await.unwrap();
    let message_2 = chat.base.session.clone();
    let answer_2 = chat.get_content_from_req_body(resp_2).await.unwrap();
    format_test_block("chat_single_round", || {
        format!("message: {:?}\nanswer: {}", message_2, answer_2)
    });

    let resp_3 = chat.get_req_body_again([0].as_ref()).await.unwrap();
    let message_3 = chat.base.session.clone();
    let answer_3 = chat.get_content_from_req_body(resp_3).await.unwrap();
    format_test_block("chat_single_round", || {
        format!("message: {:?}\nanswer: {}", message_3, answer_3)
    });

    let resp_4 = chat
        .get_req_body_with_new_question(
            [].as_ref(),
            "straw中有一个r, berry中有两个r, 深度思考strawberry有几个r?",
        )
        .await
        .unwrap();
    let message_4 = chat.base.session.clone();
    let answer_4 = chat.get_content_from_req_body(resp_4).await.unwrap();
    format_test_block("chat_single_round", || {
        format!("message: {:?}\nanswer: {}", message_4, answer_4)
    });
}

async fn test_single_chat_get_json() {
    let mut chat = SingleChat::new_with_api_name("pumpkin-ds-r1", "", true);
    let answer = chat
        .get_json_answer::<StudentInfo>("编造一个学生信息")
        .await
        .unwrap();
    format_test_block("structured_answer", || format!("StudentInfo: {:?}", answer));
}

async fn test_single_chat_get_tool() {
    let mut chat = SingleChat::new_with_api_name("pumpkin-ds-r1", "", true);
    chat.set_tools(vec![send_email_tool_schema()]);
    let answer = chat
        .get_tool_answer("随意编造信息发送一封邮件")
        .await
        .unwrap();
    format_test_block("structured_answer", || {
        format!(
            "ToolUseResult:\n Answer: {}\nResponse: {:?}",
            answer.0, answer.1
        )
    });
}

#[derive(Debug, Deserialize, JsonSchema)]
#[schema(name = "student_info", description = "用于记录学生信息", strict = true)]
pub struct StudentInfo {
    #[schema(desc = "学生的姓名", required = true)]
    name: String,

    #[schema(desc = "学生的年龄", required = true)]
    age: i32,

    #[schema(
        desc = "学生的年级",
        enum = "freshman, sophomore, junior, senior",
        required = true
    )]
    grade: Option<String>,

    #[schema(desc = "是否参加考试")]
    had_exam: bool,
}

#[derive(Deserialize, JsonSchema)]
#[schema(
    name = "SendEmailParams",
    description = "Parameters for sending email",
    inner = true,
    strict = true
)]
pub struct SendEmailParameters {
    #[schema(desc = "The recipient email address.")]
    pub to: String,
    #[schema(desc = "Email subject line.")]
    pub subject: String,
    #[schema(desc = "Body of the email message.")]
    pub body: String,
}

#[tool_schema_derive(
    description = "Send an email to a given recipient with a subject and message.",
    parameters = "SendEmailParameters",
    module_path = crate::tests::chat,
    strict = true
)]
pub fn send_email(params: SendEmailParameters) {
    println!(
        "To: {} Subject: {} Body: {}",
        params.to, params.subject, params.body
    );
}