rho-coding-agent 2.3.0

A fast Rust agent harness with a small footprint and opinionated defaults
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};
use std::time::Duration;

#[derive(Clone, Debug)]
pub struct ProcessLimits {
    pub max_live: usize,
    pub max_records: usize,
    pub max_bytes: usize,
    pub max_chunks: usize,
    pub retention: Duration,
}
impl Default for ProcessLimits {
    fn default() -> Self {
        Self {
            max_live: 16,
            max_records: 64,
            max_bytes: 1024 * 1024,
            max_chunks: 8192,
            retention: Duration::from_secs(30 * 60),
        }
    }
}
#[derive(Clone, Copy, Debug, Deserialize, Serialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum State {
    Starting,
    Running,
    Exited,
    Terminated,
    TimedOut,
    FailedToStart,
}

impl State {
    pub(crate) const fn is_live(self) -> bool {
        matches!(self, Self::Starting | Self::Running)
    }

    pub(crate) const fn as_wire_str(self) -> &'static str {
        match self {
            Self::Starting => "starting",
            Self::Running => "running",
            Self::Exited => "exited",
            Self::Terminated => "terminated",
            Self::TimedOut => "timed_out",
            Self::FailedToStart => "failed_to_start",
        }
    }
}
#[derive(Clone, Copy, Debug, Deserialize, Serialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum Stream {
    Stdout,
    Stderr,
}
#[derive(Clone, Debug, Deserialize, Serialize, PartialEq)]
pub struct Chunk {
    pub cursor: u64,
    pub stream: Stream,
    pub text: String,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct Snapshot {
    pub process_id: String,
    pub command: String,
    pub state: State,
    pub runtime_seconds: f64,
    pub first_cursor: u64,
    pub next_cursor: u64,
    pub available_cursor: u64,
    pub truncated: bool,
    pub output_pending: bool,
    pub chunks: Vec<Chunk>,
    pub exit_code: Option<i32>,
    pub terminal_detail: Option<String>,
}
pub(super) fn terminal(s: State) -> bool {
    matches!(
        s,
        State::Exited | State::Terminated | State::TimedOut | State::FailedToStart
    )
}

/// Host-UI-only retained output for one process. Not a tool action.
///
/// Does not mark the process observed or advance any agent-visible poll cursor.
#[derive(Clone, Debug)]
pub(crate) struct HostProcessView {
    pub(crate) snapshot: Snapshot,
    pub(crate) elapsed_seconds: u64,
    /// Seconds since the most recent output chunk. None when the process has
    /// produced no output yet, and None for terminal-state rows.
    pub(crate) quiet_seconds: Option<u64>,
}

/// Host-side view of one live process for UI rails. Not a tool action.
#[derive(Clone, Debug, PartialEq, Eq)]
pub(crate) struct LiveProcessSummary {
    pub(crate) process_id: String,
    pub(crate) command: String,
    pub(crate) state: State,
    pub(crate) elapsed_seconds: u64,
    /// Seconds since the most recent output chunk. None when the process has
    /// produced no output yet, and None for terminal-state rows (the UI shows
    /// a verdict instead).
    pub(crate) quiet_seconds: Option<u64>,
    /// Populated for terminal rows from the process exit code. None for live rows.
    pub(crate) exit_code: Option<i32>,
}