aboutsummaryrefslogtreecommitdiff
path: root/src/app/init.rs
blob: f2b1ee342b4db111c3e566b3b7cc9383e59b7429 (plain)
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
use crate::app::llm::{Message, MessageType, LLM};
use crate::app::modules::{wikipedia, resume, chat, code};
use crate::helper::init::warn;
use uuid::Uuid;
use tokio::runtime::Builder;

pub struct App {
    pub messages: Vec<Message>, // History of recorded message
    pub conv_id: Uuid, // ID for retrieving and saving the history of messag
    categorize_llm: LLM,
}

impl App {
    pub fn new() -> App {

        App {
            messages: Vec::new(),
            conv_id: Uuid::new_v4(),
            categorize_llm: LLM::new("config/categorize-LLM.json"),
        }
    }

    fn append_message(&mut self, msg: String, role: MessageType) {
        let message = Message::new(role, msg);

        let err = message.save_message(self.conv_id.to_string());
        //warn(err.is_err().to_string()); 

        self.messages.push(message);
    }

    fn categorize_ask(&mut self) {
        let runtime = Builder::new_current_thread().enable_all().build().unwrap();

        let result = runtime.block_on(async {
            // Ask the LLM to categorise the request between (chat, code, wikipedia)
            self.categorize_llm.ask_tools(&self.messages).await
        });

        match result {
            Ok(msg) => {
                let categorie = msg[0]["function"]["arguments"]["category_choice"].clone();
                self.ask(&categorie.to_string().replace("\"", ""));
            },
            Err(e) => self.append_message(e.to_string(), MessageType::ASSISTANT),
        }
    }

    fn ask(&mut self, mode: &str) {
        warn(format!("Categorie: {}", mode));
        let runtime = Builder::new_current_thread()
            .enable_all()
            .build().unwrap();

        let result = runtime.block_on(async {
            if mode == "resume" {
                resume::resume_conv(self.messages.clone()).await
            } else if mode == "wikipedia" {
                wikipedia::ask_wiki(&self.messages).await
            } else {
                chat::ask_chat(self.messages.clone()).await
            }
        });

        match result {
            Ok(msg) => self.append_message(msg.to_string(), MessageType::ASSISTANT),
            Err(e) => self.append_message(e.to_string(), MessageType::ASSISTANT),
        }
    }

    pub fn send_message(&mut self, content: String) {
        self.append_message(content, MessageType::USER);
        self.categorize_ask();
    }

    pub fn resume_conv(&mut self) {
        self.ask("resume"); 
    }
}
ArKa projects. All rights to me, and your next child right arm.