stynx-code-compact 3.6.1

Context compaction and conversation summarization
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

use stynx_code_errors::AppResult;
use stynx_code_types::{ContentBlock, Conversation, Message, Provider, Role, StreamEvent};
use futures::StreamExt;

use crate::prompt;

pub struct FullCompactor;

impl Default for FullCompactor {
    fn default() -> Self {
        Self
    }
}

impl FullCompactor {
    pub fn new() -> Self {
        Self
    }

    pub async fn compact(
        &self,
        conversation: &Conversation,
        provider: &dyn Provider,
    ) -> AppResult<Conversation> {

        let conversation_text = self.build_conversation_text(conversation);

        let conversation_text = if conversation_text.len() > 50_000 {
            format!("{}...\n(truncated)", &conversation_text[..50_000])
        } else {
            conversation_text
        };

        let mut summary_conv = Conversation {
            system: Some(prompt::compaction_system_prompt()),
            ..Default::default()
        };
        summary_conv.push(Message::user(prompt::compaction_user_prompt(
            &conversation_text,
        )));

        let tools: Vec<serde_json::Value> = vec![];
        let mut summary_text = String::new();

        match provider.stream(&summary_conv, &tools).await {
            Ok(mut stream) => {
                while let Some(event) = stream.next().await {
                    if let StreamEvent::ContentDelta { text } = event {
                        summary_text.push_str(&text);
                    }
                }
            }
            Err(e) => {
                tracing::error!("Full compaction failed: {e}");

                return Ok(self.fallback_compact(conversation));
            }
        }

        if summary_text.is_empty() {
            summary_text = "Previous conversation context was compacted.".into();
        }

        let mut compacted = Conversation {
            system: conversation.system.clone(),
            ..Default::default()
        };

        compacted.push(Message::user(format!(
            "[Context from previous conversation]\n{summary_text}"
        )));
        compacted.push(Message::assistant(vec![ContentBlock::Text {
            text: "I understand. I have the context from our previous conversation. How can I help you next?".into(),
        }]));

        let keep = conversation.messages.len().min(2);
        let start = conversation.messages.len() - keep;
        for msg in &conversation.messages[start..] {
            compacted.push(msg.clone());
        }

        Ok(compacted)
    }

    fn build_conversation_text(&self, conversation: &Conversation) -> String {
        let mut parts = Vec::new();

        for msg in &conversation.messages {
            let role = match msg.role {
                Role::User => "User",
                Role::Assistant => "Assistant",
            };
            for block in &msg.content {
                match block {
                    ContentBlock::Text { text } => {
                        parts.push(format!("{role}: {text}"));
                    }
                    ContentBlock::ToolUse { name, .. } => {
                        parts.push(format!("{role}: [used tool: {name}]"));
                    }
                    ContentBlock::ToolResult { content, .. } => {
                        let preview = if content.len() > 200 {
                            format!("{}...", &content[..200])
                        } else {
                            content.clone()
                        };
                        parts.push(format!("{role}: [tool result: {preview}]"));
                    }
                    ContentBlock::Thinking { thinking } => {
                        let preview = if thinking.len() > 200 {
                            format!("{}...", &thinking[..200])
                        } else {
                            thinking.clone()
                        };
                        parts.push(format!("{role}: [thinking: {preview}]"));
                    }
                    ContentBlock::Image { .. } => {
                        parts.push(format!("{role}: [image]"));
                    }
                }
            }
        }

        parts.join("\n")
    }

    fn fallback_compact(&self, conversation: &Conversation) -> Conversation {
        let mut compacted = Conversation {
            system: conversation.system.clone(),
            ..Default::default()
        };
        let keep = conversation.messages.len().min(4);
        let start = conversation.messages.len() - keep;
        for msg in &conversation.messages[start..] {
            compacted.push(msg.clone());
        }
        compacted
    }
}