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

use serde::{Deserialize, Serialize};
use serde_json::Value;

// ================  Data Structures For LLM  ================
//
#[derive(Deserialize, Serialize, Debug, Clone)]
pub struct Message {
    pub role: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub content: Option<String>,
    /// If using tool-calls / function calls
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tool_calls: Option<Vec<FunctionCall>>,
    /// If using tool-calls, track the function call ID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tool_call_id: Option<String>,
}

impl Message {
    pub fn new(role: &str, content: &str) -> Self {
        Self {
            role: role.to_string(),
            content: Some(content.to_string()),
            tool_calls: None,
            tool_call_id: None,
        }
    }
}

/// A structure representing a single function call from the LLM (tool usage).
#[derive(Deserialize, Serialize, Debug, Clone)]
pub struct FunctionCall {
    pub id: String,
    #[serde(rename = "type")]
    pub call_type: String,
    pub function: Function,
}

/// The function descriptor itself (like “weather_lookup”, {args…}).
#[derive(Deserialize, Serialize, Debug, Clone)]
pub struct Function {
    pub name: String,
    pub arguments: Value, // JSON of arguments
}

/// Represents a chunk of a streamed LLM response.
#[derive(Deserialize, Debug, Clone)]
pub struct LLMChunkResponse {
    pub id: String,
    pub object: String,
    pub created: u64,
    pub model: String,
    pub choices: Vec<ChunkChoice>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub system_fingerprint: Option<String>,
}

#[derive(Deserialize, Debug, Clone)]
pub struct ChunkChoice {
    pub index: u32,
    pub delta: Delta,
    pub finish_reason: Option<String>,
}

#[derive(Deserialize, Debug, Clone)]
pub struct Delta {
    pub role: Option<String>,
    pub content: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reasoning_content: Option<String>,
}

/// Represents a complete LLM response (non-streamed or after streaming finishes).
#[derive(Deserialize, Debug, Clone)]
pub struct LLMResponse {
    pub id: String,
    pub object: String,
    pub created: u64,
    pub model: String,
    pub choices: Vec<Choice>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub system_fingerprint: Option<String>,
}

/// Each choice in the response can contain a final `Message`.
#[derive(Deserialize, Debug, Clone)]
pub struct Choice {
    pub index: u32,
    pub message: Option<Message>,
    pub finish_reason: Option<String>,
}

/// HTTP method for calls
#[derive(Debug)]
pub enum Method {
    Get,
    Post,
}

/// Your endpoints for different LLM actions
#[derive(Debug)]
pub enum Endpoint {
    ChatCompletion,
    Responses,
    ListModels,
    PullModel,
    Embedding,
}

impl Endpoint {
    pub fn http_uri(&self) -> &str {
        match self {
            Endpoint::ChatCompletion => "v1/chat/completions",
            Endpoint::Responses => "v1/responses",
            Endpoint::ListModels => "api/tags",
            Endpoint::PullModel => "api/pull",
            Endpoint::Embedding => "api/v0/embeddings",
        }
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Mode {
    ChatCompletion,
    Responses,
}

#[derive(Clone, Debug)]
pub struct LLMConfig {
    pub mode: Mode,
}

impl Default for LLMConfig {
    fn default() -> Self {
        Self {
            mode: Mode::ChatCompletion,
        }
    }
}

//