tandem-core 0.6.0

Core types and helpers for the Tandem engine
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

pub(super) fn max_tool_iterations() -> usize {
    let default_iterations = 25usize;
    std::env::var("TANDEM_MAX_TOOL_ITERATIONS")
        .ok()
        .and_then(|raw| raw.trim().parse::<usize>().ok())
        .filter(|value| *value > 0)
        .unwrap_or(default_iterations)
}

pub(super) fn strict_write_retry_max_attempts() -> usize {
    std::env::var("TANDEM_STRICT_WRITE_RETRY_MAX_ATTEMPTS")
        .ok()
        .and_then(|raw| raw.trim().parse::<usize>().ok())
        .filter(|value| *value > 0)
        .unwrap_or(3)
}

pub(super) fn provider_stream_connect_timeout_ms() -> usize {
    std::env::var("TANDEM_PROVIDER_STREAM_CONNECT_TIMEOUT_MS")
        .ok()
        .and_then(|raw| raw.trim().parse::<usize>().ok())
        .filter(|value| *value > 0)
        .unwrap_or(90_000)
}

pub(super) fn provider_stream_idle_timeout_ms() -> usize {
    std::env::var("TANDEM_PROVIDER_STREAM_IDLE_TIMEOUT_MS")
        .ok()
        .and_then(|raw| raw.trim().parse::<usize>().ok())
        .filter(|value| *value > 0)
        .unwrap_or(90_000)
}

pub(super) fn provider_stream_decode_retry_attempts() -> usize {
    std::env::var("TANDEM_PROVIDER_STREAM_DECODE_RETRY_ATTEMPTS")
        .ok()
        .and_then(|raw| raw.trim().parse::<usize>().ok())
        .unwrap_or(2)
}

pub(super) fn prompt_context_hook_timeout_ms() -> usize {
    std::env::var("TANDEM_PROMPT_CONTEXT_HOOK_TIMEOUT_MS")
        .ok()
        .and_then(|raw| raw.trim().parse::<usize>().ok())
        .filter(|value| *value > 0)
        .unwrap_or(5_000)
}

pub(super) fn permission_wait_timeout_ms() -> usize {
    std::env::var("TANDEM_PERMISSION_WAIT_TIMEOUT_MS")
        .ok()
        .and_then(|raw| raw.trim().parse::<usize>().ok())
        .filter(|value| *value > 0)
        .unwrap_or(15_000)
}

/// Soft char budget for Full context mode prompts. Crossing it emits a
/// warning event with the top contributors but does not block the send.
/// Roughly 60k tokens at the shared 4-chars-per-token fallback estimate.
pub(super) fn full_context_soft_budget_chars() -> usize {
    std::env::var("TANDEM_FULL_CONTEXT_SOFT_BUDGET_CHARS")
        .ok()
        .and_then(|raw| raw.trim().parse::<usize>().ok())
        .filter(|value| *value > 0)
        .unwrap_or(240_000)
}

/// Hard char budget for Full context mode prompts. Crossing it fails the run
/// closed before provider send unless the override env is set.
/// Roughly 120k tokens at the shared 4-chars-per-token fallback estimate.
pub(super) fn full_context_hard_budget_chars() -> usize {
    std::env::var("TANDEM_FULL_CONTEXT_HARD_BUDGET_CHARS")
        .ok()
        .and_then(|raw| raw.trim().parse::<usize>().ok())
        .filter(|value| *value > 0)
        .unwrap_or(480_000)
}

pub(super) fn full_context_hard_budget_override() -> bool {
    std::env::var("TANDEM_FULL_CONTEXT_HARD_BUDGET_OVERRIDE")
        .map(|raw| {
            let value = raw.trim().to_ascii_lowercase();
            value == "1" || value == "true" || value == "yes"
        })
        .unwrap_or(false)
}

pub(super) fn tool_exec_timeout_ms() -> usize {
    std::env::var("TANDEM_TOOL_EXEC_TIMEOUT_MS")
        .ok()
        .and_then(|raw| raw.trim().parse::<usize>().ok())
        .filter(|value| *value > 0)
        .unwrap_or(45_000)
}