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

use std::collections::HashMap;

use crate::config::AppConfig;
use crate::conversation::{Conversation, ConversationId, ConversationManager, MessageId};
use crate::dialogue::DialogueController;
use crate::history::BacktrackState;
use crate::input::{InputBuffer, InputHistory};
use crate::persistence::JsonConversationStore;
use crate::provider::{ProviderHandle, ProviderOverrides, ProviderRegistry};
use crate::skills::SkillCatalog;
use crate::terminal::TerminalCapabilities;

use super::overlay::OverlayState;
use super::scroll::ScrollState;
use super::status::AppStatus;
use super::PasteDetector;
use super::{AnimationState, CollapsibleState, StatusMetrics};

pub struct AppState {
    pub config: AppConfig,
    pub provider_registry: ProviderRegistry,
    pub store: JsonConversationStore,
    pub conversations: ConversationManager,
    pub skills: SkillCatalog,
    pub input: InputBuffer,
    pub history: InputHistory,
    pub status: AppStatus,
    pub status_metrics: StatusMetrics,
    pub collapsible: CollapsibleState,
    pub backtrack: BacktrackState,
    pub overlay: OverlayState,
    pub scroll: ScrollState,
    pub provider_cache: HashMap<ConversationId, ProviderHandle>,
    pub selected_message: Option<MessageId>,
    pub input_mode: InputMode,
    pub focus: Focus,
    pub terminal_size: (u16, u16),
    pub terminal_caps: TerminalCapabilities,
    pub animation: AnimationState,
    pub paste_detector: PasteDetector,
    pub should_quit: bool,
    pub session_overrides: ProviderOverrides,
    /// Active dialogue controller for multi-LLM conversations.
    pub dialogue_controller: Option<DialogueController>,
}

impl AppState {
    pub fn new(
        config: AppConfig,
        registry: ProviderRegistry,
        store: JsonConversationStore,
        terminal_caps: TerminalCapabilities,
    ) -> Self {
        Self {
            config,
            provider_registry: registry,
            store,
            conversations: ConversationManager::new(),
            skills: SkillCatalog::default(),
            input: InputBuffer::default(),
            history: InputHistory::default(),
            status: AppStatus::Idle,
            status_metrics: StatusMetrics::default(),
            collapsible: CollapsibleState::default(),
            backtrack: BacktrackState::default(),
            overlay: OverlayState::None,
            scroll: ScrollState::default(),
            provider_cache: HashMap::new(),
            selected_message: None,
            input_mode: InputMode::Insert,
            focus: Focus::Input,
            terminal_size: (0, 0),
            terminal_caps,
            animation: AnimationState::default(),
            paste_detector: PasteDetector::default(),
            should_quit: false,
            session_overrides: ProviderOverrides::default(),
            dialogue_controller: None,
        }
    }

    pub fn active_conversation(&self) -> Option<&Conversation> {
        self.conversations.active()
    }

    pub fn active_conversation_mut(&mut self) -> Option<&mut Conversation> {
        self.conversations.active_mut()
    }

    pub fn active_conversation_id(&self) -> Option<ConversationId> {
        self.conversations.active_id()
    }

    pub fn mark_dirty(&mut self) {
        if let Some(conv) = self.active_conversation_mut() {
            conv.dirty = true;
        }
    }
}

#[derive(Debug, Clone, Copy, Eq, PartialEq)]
pub enum InputMode {
    Insert,
    Normal,
}

#[derive(Debug, Clone, Copy, Eq, PartialEq)]
pub enum Focus {
    Input,
    Messages,
}