alith-client 0.4.3

The Easiest Rust Interface for Local LLMs, and an Interface for Deterministic Signals from Probabilistic LLM Vibes
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

use alith_prompt::{PromptMessage, PromptMessageType, TextConcatenator, TextConcatenatorTrait};
use anyhow::{Result, anyhow};

#[derive(Clone)]
pub struct InstructPrompt {
    pub instructions: Option<PromptMessage>,
    pub supporting_material: Option<PromptMessage>,
    pub concatenator: TextConcatenator,
}

impl Default for InstructPrompt {
    fn default() -> Self {
        Self::new()
    }
}

impl InstructPrompt {
    pub fn new() -> Self {
        Self {
            instructions: None,
            supporting_material: None,
            concatenator: TextConcatenator::default(),
        }
    }

    pub fn reset_instruct_prompt(&mut self) {
        self.instructions = None;
        self.supporting_material = None;
    }

    pub fn build_instructions(&self) -> Option<String> {
        if let Some(instructions) = &self.instructions {
            instructions.get_built_prompt_message().ok()
        } else {
            None
        }
    }

    pub fn build_supporting_material(&self) -> Option<String> {
        if let Some(supporting_material) = &self.supporting_material {
            supporting_material.get_built_prompt_message().ok()
        } else {
            None
        }
    }

    pub fn build_instruct_prompt(&mut self, supporting_material_first: bool) -> Result<String> {
        Ok(
            match (self.build_instructions(), self.build_supporting_material()) {
                (Some(instructions), Some(supporting_material)) => {
                    if supporting_material_first {
                        format!(
                            "{}{}{}",
                            supporting_material,
                            self.concatenator.as_str(),
                            instructions
                        )
                    } else {
                        format!(
                            "{}{}{}",
                            instructions,
                            self.concatenator.as_str(),
                            supporting_material
                        )
                    }
                }
                (Some(instructions), None) => instructions,
                (None, Some(supporting_material)) => supporting_material,

                (None, None) => {
                    return Err(anyhow!("No instructions or supporting material found"));
                }
            },
        )
    }
}

impl TextConcatenatorTrait for InstructPrompt {
    fn concatenator_mut(&mut self) -> &mut TextConcatenator {
        &mut self.concatenator
    }

    fn clear_built(&self) {}
}

pub trait InstructPromptTrait {
    fn instruct_prompt_mut(&mut self) -> &mut InstructPrompt;

    fn set_instructions<T: AsRef<str>>(&mut self, instructions: T) -> &mut Self {
        self.instructions().set_content(instructions);
        self
    }

    fn instructions(&mut self) -> &mut PromptMessage {
        if self.instruct_prompt_mut().instructions.is_none() {
            self.instruct_prompt_mut().instructions = Some(PromptMessage::new(
                PromptMessageType::User,
                &self.instruct_prompt_mut().concatenator,
            ));
        }
        self.instruct_prompt_mut().instructions.as_mut().unwrap()
    }

    fn set_supporting_material<T: AsRef<str>>(&mut self, supporting_material: T) -> &mut Self {
        self.supporting_material().set_content(supporting_material);
        self
    }

    fn supporting_material(&mut self) -> &mut PromptMessage {
        if self.instruct_prompt_mut().supporting_material.is_none() {
            self.instruct_prompt_mut().supporting_material = Some(PromptMessage::new(
                PromptMessageType::User,
                &self.instruct_prompt_mut().concatenator,
            ));
        }

        self.instruct_prompt_mut()
            .supporting_material
            .as_mut()
            .unwrap()
    }
}