plainllm 1.2.0

A plain & simple LLM client
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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

use super::{types::Message, LLMOptions};
use serde::{Deserialize, Serialize};
use serde_json::Value;

// ================  ChatCompletionRequest  ================
//

/// The top-level request you send to your LLM server.
#[derive(Serialize, Debug, Clone)]
pub struct ChatCompletionRequest {
    pub model: String,
    pub messages: Vec<Message>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub tool_choice: Option<String>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub temperature: Option<f32>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub top_p: Option<f32>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_tokens: Option<u32>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub stop: Option<Vec<String>>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub presence_penalty: Option<f32>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub frequency_penalty: Option<f32>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub repeat_penalty: Option<f32>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub context_overflow_policy: Option<String>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub top_k: Option<u32>,

    // This indicates whether we want streaming or not.
    pub stream: bool,

    // If you have a "response format" (like a JSON Schema request),
    // attach it here:
    #[serde(skip_serializing_if = "Option::is_none")]
    pub response_format: Option<ResponseFormat>,

    /// If you have "options" or "tools" in your server's schema:
    #[serde(skip_serializing_if = "Option::is_none")]
    pub options: Option<Options>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub tools: Option<Vec<Tool>>,
}

/// Minimal “Options” struct for advanced stuff
#[derive(Serialize, Debug, Clone)]
pub struct Options {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub response_format: Option<String>,
}

/// A “Tool” definition that can be passed to your LLM so it knows which function calls exist.
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct Tool {
    #[serde(rename = "type")]
    pub tool_type: String,
    pub function: FunctionDefinition,
}

/// Similar to the original snippet
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct FunctionDefinition {
    pub name: String,
    pub description: String,
    pub parameters: Parameters,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct Parameters {
    #[serde(rename = "type")]
    pub param_type: String,
    pub properties: serde_json::Value,
    pub required: Vec<String>,
    pub additional_properties: bool,
}

/// For JSON schema style requests
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct JsonSchemaFormat {
    pub name: String,
    pub strict: bool,
    pub schema: Value,
}

#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct ResponseFormat {
    pub r#type: String,
    pub json_schema: JsonSchemaFormat,
}

impl ChatCompletionRequest {
    /// A helper constructor with defaults.
    pub fn new(model: String, messages: Vec<Message>) -> Self {
        Self {
            model,
            messages,
            temperature: None,
            top_p: None,
            max_tokens: None,
            stop: None,
            presence_penalty: None,
            frequency_penalty: None,
            stream: false,
            response_format: None,
            options: None,
            tools: None,
            tool_choice: None,
            context_overflow_policy: None,
            repeat_penalty: None,
            top_k: None,
        }
    }

    pub fn from_llm_options(&mut self, opts: &LLMOptions) -> &mut Self {
        self.stream = opts.streaming;
        if let Some(t) = opts.temperature {
            self.temperature = Some(t);
        }
        if let Some(p) = opts.top_p {
            self.top_p = Some(p);
        }
        if let Some(max) = opts.max_tokens {
            self.max_tokens = Some(max);
        }
        if let Some(ref stop) = opts.stop {
            self.stop = Some(stop.clone());
        }
        if let Some(p) = opts.presence_penalty {
            self.presence_penalty = Some(p);
        }
        if let Some(p) = opts.frequency_penalty {
            self.frequency_penalty = Some(p);
        }
        self
    }

    /// If you want to specify an advanced "response format", do so here.
    pub fn with_response_format(&mut self, format: ResponseFormat) -> &mut Self {
        self.response_format = Some(format);
        self
    }

    pub fn with_temperature(&mut self, temperature: f32) -> &mut Self {
        self.temperature = Some(temperature);
        self
    }
}