ai-agent 0.13.4

Idiomatic agent sdk inspired by the claude code source leak
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

use std::collections::HashMap;

#[derive(Debug, Clone)]
pub struct AwaySummaryConfig {
    pub enabled: bool,
    pub blur_delay_ms: u64,
    pub min_turns_since_last_user: usize,
}

impl Default for AwaySummaryConfig {
    fn default() -> Self {
        Self {
            enabled: true,
            blur_delay_ms: 5 * 60 * 1000,
            min_turns_since_last_user: 1,
        }
    }
}

pub struct AwaySummaryState {
    is_enabled: bool,
    is_generating: bool,
    pending_summary: Option<String>,
    last_summary_turn: usize,
}

impl AwaySummaryState {
    pub fn new() -> Self {
        Self {
            is_enabled: true,
            is_generating: false,
            pending_summary: None,
            last_summary_turn: 0,
        }
    }

    pub fn set_enabled(&mut self, enabled: bool) {
        self.is_enabled = enabled;
    }

    pub fn is_enabled(&self) -> bool {
        self.is_enabled
    }

    pub fn set_generating(&mut self, generating: bool) {
        self.is_generating = generating;
    }

    pub fn is_generating(&self) -> bool {
        self.is_generating
    }

    pub fn set_pending_summary(&mut self, summary: String) {
        self.pending_summary = Some(summary);
    }

    pub fn get_pending_summary(&self) -> Option<&String> {
        self.pending_summary.as_ref()
    }

    pub fn clear_pending_summary(&mut self) {
        self.pending_summary = None;
    }

    pub fn mark_summary_generated(&mut self, turn: usize) {
        self.last_summary_turn = turn;
        self.is_generating = false;
        self.pending_summary = None;
    }

    pub fn get_last_summary_turn(&self) -> usize {
        self.last_summary_turn
    }
}

impl Default for AwaySummaryState {
    fn default() -> Self {
        Self::new()
    }
}

pub fn should_show_away_summary(
    config: &AwaySummaryConfig,
    state: &AwaySummaryState,
    is_blurred: bool,
    current_turn: usize,
) -> bool {
    if !config.enabled || !state.is_enabled() {
        return false;
    }

    if !is_blurred {
        return false;
    }

    if state.is_generating() {
        return false;
    }

    let turns_since_summary = current_turn.saturating_sub(state.get_last_summary_turn());
    if turns_since_summary < config.min_turns_since_last_user {
        return false;
    }

    true
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_away_summary_state() {
        let mut state = AwaySummaryState::new();

        assert!(state.is_enabled());

        state.set_enabled(false);
        assert!(!state.is_enabled());
    }

    #[test]
    fn test_pending_summary() {
        let mut state = AwaySummaryState::new();

        state.set_pending_summary("Test summary".to_string());
        assert!(state.get_pending_summary().is_some());

        state.clear_pending_summary();
        assert!(state.get_pending_summary().is_none());
    }

    #[test]
    fn test_should_show_away_summary() {
        let config = AwaySummaryConfig::default();
        let state = AwaySummaryState::new();

        assert!(!should_show_away_summary(&config, &state, false, 1));
    }
}