behest 0.5.9

A Rust-native cloud agent runtime with typed tools, pluggable memory, queues, and observability.
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
141

//! Runtime configuration section.

use std::time::Duration;

use serde::{Deserialize, Serialize};

use crate::runtime::RuntimePolicy;

/// Runtime configuration covering policy, context limits, and event channel.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RuntimeConfig {
    /// Execution policy (max iterations, timeouts, retries).
    #[serde(default)]
    pub policy: RuntimePolicyConfig,

    /// Maximum number of history messages before trimming. Default: 50.
    #[serde(default = "default_max_history_messages")]
    pub max_history_messages: usize,

    /// Internal broadcast channel capacity for local event subscribers. Default: 256.
    #[serde(default = "default_event_channel_capacity")]
    pub event_channel_capacity: usize,

    /// Directory for storing run recovery snapshots. `None` disables snapshotting.
    #[serde(default)]
    pub snapshot_dir: Option<String>,
}

/// Per-run execution limits and constraints.
///
/// All fields have sensible defaults; only non-default values need to be
/// set explicitly.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RuntimePolicyConfig {
    /// Maximum model call iterations per run. Default: 10.
    #[serde(default = "default_max_iterations")]
    pub max_iterations: usize,

    /// Maximum total tokens per run. `None` means unlimited.
    #[serde(default)]
    pub max_tokens: Option<usize>,

    /// Maximum concurrent tool executions. Default: 4.
    #[serde(default = "default_max_tool_concurrency")]
    pub max_tool_concurrency: usize,

    /// Timeout for individual tool execution, in seconds. Default: 30.
    #[serde(default = "default_tool_timeout_secs")]
    pub tool_timeout_secs: u64,

    /// Timeout for provider calls, in seconds. Default: 60.
    #[serde(default = "default_provider_timeout_secs")]
    pub provider_timeout_secs: u64,

    /// Continue the run when a tool fails. Default: `true`.
    #[serde(default = "default_continue_on_tool_failure")]
    pub continue_on_tool_failure: bool,

    /// Retry on retryable provider errors. Default: `true`.
    #[serde(default = "default_retry_on_provider_error")]
    pub retry_on_provider_error: bool,

    /// Maximum retries for provider calls per attempt. Default: 2.
    #[serde(default = "default_max_retries")]
    pub max_retries: usize,
}

impl Default for RuntimeConfig {
    fn default() -> Self {
        Self {
            policy: RuntimePolicyConfig::default(),
            max_history_messages: default_max_history_messages(),
            event_channel_capacity: default_event_channel_capacity(),
            snapshot_dir: None,
        }
    }
}

impl Default for RuntimePolicyConfig {
    fn default() -> Self {
        Self {
            max_iterations: default_max_iterations(),
            max_tokens: None,
            max_tool_concurrency: default_max_tool_concurrency(),
            tool_timeout_secs: default_tool_timeout_secs(),
            provider_timeout_secs: default_provider_timeout_secs(),
            continue_on_tool_failure: default_continue_on_tool_failure(),
            retry_on_provider_error: default_retry_on_provider_error(),
            max_retries: default_max_retries(),
        }
    }
}

impl From<RuntimePolicyConfig> for RuntimePolicy {
    fn from(config: RuntimePolicyConfig) -> Self {
        RuntimePolicy::new()
            .with_max_iterations(config.max_iterations)
            .with_tool_timeout(Duration::from_secs(config.tool_timeout_secs))
            .with_provider_timeout(Duration::from_secs(config.provider_timeout_secs))
            .with_continue_on_tool_failure(config.continue_on_tool_failure)
            .with_retry_on_provider_error(config.retry_on_provider_error)
            .with_max_retries(config.max_retries)
            .with_max_output_recovery_attempts(3)
    }
}

const fn default_max_iterations() -> usize {
    10
}

const fn default_max_tool_concurrency() -> usize {
    4
}

const fn default_tool_timeout_secs() -> u64 {
    30
}

const fn default_provider_timeout_secs() -> u64 {
    60
}

const fn default_continue_on_tool_failure() -> bool {
    true
}

const fn default_retry_on_provider_error() -> bool {
    true
}

const fn default_max_retries() -> usize {
    2
}

const fn default_max_history_messages() -> usize {
    50
}

const fn default_event_channel_capacity() -> usize {
    256
}