icebreaker 2026.2.0

A local AI chat app powered by 🦀Rust, 🧊iced, 🤗Hugging Face, and 🦙llama.cpp 
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

use crate::core::assistant;
use crate::ui::markdown;
use crate::ui::{Markdown, Reasoning};

use iced::widget::column;
use iced::{Element, Theme};

#[derive(Debug, Default)]
pub struct Reply {
    reasoning: Option<Reasoning>,
    content: String,
    markdown: Markdown,
}

impl Reply {
    pub fn from_data(reply: assistant::Reply) -> Self {
        Self {
            reasoning: reply.reasoning.map(Reasoning::from_data),
            markdown: Markdown::parse(&reply.content),
            content: reply.content,
        }
    }

    pub fn to_data(&self) -> assistant::Reply {
        assistant::Reply {
            reasoning: self.reasoning.as_ref().map(Reasoning::to_data),
            content: self.content.as_str().to_owned(),
            last_token: None,
        }
    }

    pub fn to_text(&self) -> String {
        match &self.reasoning {
            Some(reasoning) if reasoning.show => {
                format!(
                    "{reasoning}\n\n{content}",
                    reasoning = reasoning
                        .thoughts
                        .iter()
                        .map(|thought| format!("> {thought}"))
                        .collect::<Vec<_>>()
                        .join("\n>\n"),
                    content = self.content.as_str()
                )
            }
            _ => self.content.as_str().to_owned(),
        }
    }

    pub fn update(&mut self, new_reply: assistant::Reply) {
        self.reasoning = new_reply.reasoning.map(Reasoning::from_data);
        self.content = new_reply.content;

        if let Some(reasoning) = &mut self.reasoning {
            reasoning.show = new_reply.last_token.is_none();
        }

        if let Some(token) = new_reply.last_token {
            self.markdown.push_str(&token);
        }
    }

    pub fn toggle_reasoning(&mut self, show: bool) {
        if let Some(reasoning) = &mut self.reasoning {
            reasoning.show = show;
        }
    }

    pub fn view<Message>(
        &self,
        theme: &Theme,
        on_reasoning_toggle: impl Fn(bool) -> Message,
        on_markdown_interaction: impl Fn(markdown::Interaction) -> Message + 'static,
    ) -> Element<'_, Message>
    where
        Message: Clone + 'static,
    {
        let message = self.markdown.view(theme).map(on_markdown_interaction);

        if let Some(reasoning) = &self.reasoning {
            column![reasoning.quote(on_reasoning_toggle), message]
                .spacing(20)
                .into()
        } else {
            message
        }
    }
}