llm 1.3.8

A Rust library unifying multiple LLM backends.
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

use crate::conversation::ConversationId;
use crate::provider::ProviderCapabilities;
use crate::runtime::{
    ConfirmState, OverlayState, PickerItem, PickerState, SearchState, SlashCommandState,
};

use super::super::AppController;

pub fn confirm_exit(controller: &mut AppController) -> bool {
    controller.state.overlay = OverlayState::ConfirmExit(ConfirmState {
        message: "Quit the app?".to_string(),
    });
    true
}

pub fn open_provider_picker(controller: &mut AppController) -> bool {
    let items = controller
        .state
        .provider_registry
        .list()
        .map(|info| PickerItem {
            id: info.id.to_string(),
            label: info.display_name.clone(),
            meta: None,
            badges: provider_badges(info.capabilities),
        })
        .collect();
    controller.state.overlay = OverlayState::ProviderPicker(PickerState::new("Providers", items));
    true
}

pub fn open_model_picker(controller: &mut AppController) -> bool {
    let items = model_items(controller);
    controller.state.overlay = OverlayState::ModelPicker(PickerState::new("Models", items));
    true
}

pub fn open_conversation_picker(controller: &mut AppController) -> bool {
    let items = controller
        .state
        .conversations
        .list()
        .map(|conv| PickerItem {
            id: conv.id.to_string(),
            label: conv.title.clone(),
            meta: Some(conv.provider_id.to_string()),
            badges: Vec::new(),
        })
        .collect();
    controller.state.overlay =
        OverlayState::ConversationPicker(PickerState::new("Conversations", items));
    true
}

pub fn open_help(controller: &mut AppController) -> bool {
    controller.state.overlay = OverlayState::Help;
    true
}

pub fn open_search(controller: &mut AppController) -> bool {
    controller.state.overlay = OverlayState::Search(SearchState::new());
    true
}

pub fn open_slash_commands(controller: &mut AppController) -> bool {
    controller.state.overlay = OverlayState::SlashCommands(SlashCommandState::new());
    true
}

pub fn open_skill_picker(controller: &mut AppController) -> bool {
    let items = controller
        .state
        .skills
        .list()
        .iter()
        .map(|skill| PickerItem {
            id: skill.name.clone(),
            label: skill.name.clone(),
            meta: Some(skill.description.clone()),
            badges: skill.aliases.clone(),
        })
        .collect();
    controller.state.overlay = OverlayState::SkillPicker(PickerState::new("Skills", items));
    true
}

pub fn apply_picker_selection(controller: &mut AppController, item: &PickerItem) {
    if let Ok(uuid) = uuid::Uuid::parse_str(&item.id) {
        let id = ConversationId::from(uuid);
        controller.state.conversations.set_active(id);
        return;
    }
    controller.switch_provider(item.id.clone());
    open_model_picker(controller);
}

pub fn resolve_tool_approval(controller: &mut AppController, approved: bool) {
    if let Some(sender) = controller.pending_tool_approval.take() {
        let _ = sender.send(approved);
    }
    controller.state.overlay = OverlayState::None;
}

fn model_items(controller: &AppController) -> Vec<PickerItem> {
    let provider_id = controller
        .state
        .active_conversation()
        .map(|conv| conv.provider_id.to_string())
        .unwrap_or_default();
    let models = controller
        .state
        .config
        .providers
        .get(&provider_id)
        .map(|cfg| cfg.models.clone())
        .unwrap_or_default();
    models
        .into_iter()
        .map(|model| PickerItem {
            badges: model_badges(&model),
            id: model.id.clone(),
            label: model.id,
            meta: model.context_window.map(|v| format!("{v} ctx")),
        })
        .collect()
}

fn provider_badges(caps: ProviderCapabilities) -> Vec<String> {
    let mut badges = Vec::new();
    if caps.streaming {
        badges.push("stream".to_string());
    }
    if caps.tools {
        badges.push("tools".to_string());
    }
    if caps.tool_streaming {
        badges.push("tool-stream".to_string());
    }
    if caps.vision {
        badges.push("vision".to_string());
    }
    if caps.models_list {
        badges.push("models".to_string());
    }
    badges
}

fn model_badges(model: &crate::config::ModelConfig) -> Vec<String> {
    let mut badges = Vec::new();
    if model.supports_streaming.unwrap_or(false) {
        badges.push("stream".to_string());
    }
    if model.supports_tools.unwrap_or(false) {
        badges.push("tools".to_string());
    }
    if model.supports_vision.unwrap_or(false) {
        badges.push("vision".to_string());
    }
    badges
}