codewhale-tui 0.9.2

Terminal UI for open-source and open-weight coding models
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

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum OperationClass {
    ModelRequest,
    ModelStream,
    ToolTransport,
    ToolExecution,
    ContextCompaction,
    Verification,
    ChildRun,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Idempotency {
    ReadOnly,
    IdempotentWrite,
    NonIdempotentWrite,
    Unknown,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct RetryAttempt {
    pub operation: OperationClass,
    pub idempotency: Idempotency,
    pub attempt: u32,
    pub max_attempts: u32,
    pub content_observed: bool,
    pub side_effect_observed: bool,
    pub canceled: bool,
    pub reason: String,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum RetryDecision {
    Retry,
    Stop { reason: String },
}

#[must_use]
pub fn decide_retry(attempt: &RetryAttempt) -> RetryDecision {
    if attempt.canceled {
        return RetryDecision::Stop {
            reason: "operation was canceled".to_string(),
        };
    }
    if attempt.attempt >= attempt.max_attempts {
        return RetryDecision::Stop {
            reason: "retry budget exhausted".to_string(),
        };
    }
    if attempt.side_effect_observed
        && matches!(
            attempt.idempotency,
            Idempotency::NonIdempotentWrite | Idempotency::Unknown
        )
    {
        return RetryDecision::Stop {
            reason: "uncertain write side effect prevents an automatic retry".to_string(),
        };
    }
    if attempt.content_observed && attempt.operation == OperationClass::ModelStream {
        return RetryDecision::Stop {
            reason: "model stream already emitted content".to_string(),
        };
    }
    RetryDecision::Retry
}

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

    fn attempt() -> RetryAttempt {
        RetryAttempt {
            operation: OperationClass::ModelStream,
            idempotency: Idempotency::ReadOnly,
            attempt: 0,
            max_attempts: 2,
            content_observed: false,
            side_effect_observed: false,
            canceled: false,
            reason: "network".to_string(),
        }
    }

    #[test]
    fn model_stream_retries_only_before_content() {
        assert_eq!(decide_retry(&attempt()), RetryDecision::Retry);
        let mut after_content = attempt();
        after_content.content_observed = true;
        assert!(matches!(
            decide_retry(&after_content),
            RetryDecision::Stop { .. }
        ));
    }

    #[test]
    fn uncertain_write_never_retries_after_side_effect() {
        let mut write = attempt();
        write.operation = OperationClass::ToolExecution;
        write.idempotency = Idempotency::Unknown;
        write.side_effect_observed = true;
        assert!(matches!(decide_retry(&write), RetryDecision::Stop { .. }));
    }
}