1. 1//! Human-In-The-Loop (HIL) state machine with in-place command editing.
2. 2//!
3. 3//! A real `HilApprovalState` is populated from an `AgentEvent::ApprovalRequested`
4. 4//! that arrives over the SSE event stream, not from a hardcoded demo fixture.
5. 5//! When the operator approves or denies, the outcome is dispatched to the
6. 6//! server via `POST /sessions/{id}/approvals/{req_id}` — there is no local
7. 7//! state change that never reaches the server.
8. 8
9. 9use serde_json::Value;
10. 10
11. 11#[derive(Debug, Clone, PartialEq, Eq)]
12. 12pub enum HilOutcome {
13. 13 ApproveOnce { modified_command: Option<String> },
14. 14 AlwaysForSession,
15. 15 Deny,
16. 16 Cancel,
17. 17}
18. 18
19. 19/// Represents whether a "remember this decision" checkbox is active.
20. 20#[derive(Debug, Clone, Copy, PartialEq, Eq)]
21. 21pub enum RememberMode {
22. 22 No,
23. 23 Yes,
24. 24}
25. 25
26. 26/// A real approval request that arrived over the SSE event stream.
27. 27#[derive(Debug, Clone)]
28. 28pub struct HilApprovalState {
29. 29 pub request_id: String,
30. 30 pub session_id: String,
31. 31 pub tool_name: String,
32. 32 pub args_json: String,
33. 33 pub risk_reason: String,
34. 34 pub workspace_path: String,
35. 35 pub cost_estimate_usd: Option<f64>,
36. 36 /// The command/script the approval gates (if applicable, e.g. for `bash`).
37. 37 pub original_command: String,
38. 38 /// Mutable in-place-edited copy of the command.
39. 39 pub edited_command: String,
40. 40 pub is_editing: bool,
41. 41 pub edit_cursor: usize,
42. 42 pub remember: RememberMode,
43. 43}
44. 44
45. 45impl HilApprovalState {
46. 46 /// Build from a real `ApprovalRequested` agent event.
47. 47 pub fn from_approval_event(
48. 48 session_id: impl Into<String>,
49. 49 request_id: impl Into<String>,
50. 50 tool_name: impl Into<String>,
51. 51 args_json: impl Into<String>,
52. 52 reason: impl Into<String>,
53. 53 workspace_path: impl Into<String>,
54. 54 cost_estimate_usd: Option<f64>,
55. 55 ) -> Self {
56. 56 let tool_name = tool_name.into();
57. 57 let args_json = args_json.into();
58. 58 let cmd = Self::command_from_args(&tool_name, &args_json);
59. 59 let cmd_owned = cmd.clone();
60. 60 Self {
61. 61 request_id: request_id.into(),
62. 62 session_id: session_id.into(),
63. 63 tool_name,
64. 64 args_json,
65. 65 risk_reason: reason.into(),
66. 66 workspace_path: workspace_path.into(),
67. 67 cost_estimate_usd,
68. 68 original_command: cmd_owned.clone(),
69. 69 edited_command: cmd_owned,
70. 70 is_editing: false,
71. 71 edit_cursor: cmd.len(),
72. 72 remember: RememberMode::No,
73. 73 }
74. 74 }
75. 75
76. 76 /// Extract a human-readable command string from tool arguments.
77. 77 /// For `bash`-type tools this is the script; for others it is a
78. 78 /// rendered summary of the args JSON.
79. 79 fn command_from_args(tool_name: &str, args_json: &str) -> String {
80. 80 if tool_name == "bash" || tool_name == "shell" {
81. 81 if let Ok(val) = serde_json::from_str::<Value>(args_json)
82. 82 && let Some(code) = val.get("command").and_then(|v| v.as_str())
83. 83 {
84. 84 return code.to_string();
85. 85 }
86. 86 args_json.to_string()
87. 87 } else {
88. 88 // For non-bash tools, render the args as a compact summary.
89. 89 if let Ok(val) = serde_json::from_str::<Value>(args_json) {
90. 90 serde_json::to_string(&val).unwrap_or_else(|_| args_json.to_string())
91. 91 } else {
92. 92 args_json.to_string()
93. 93 }
94. 94 }
95. 95 }
96. 96
97. 97 pub fn start_editing(&mut self) {
98. 98 self.is_editing = true;
99. 99 self.edit_cursor = self.edited_command.len();
100. 100 }
101. 101
102. 102 pub fn cancel_editing(&mut self) {
103. 103 self.is_editing = false;
104. 104 self.edited_command = self.original_command.clone();
105. 105 }
106. 106
107. 107 pub fn toggle_remember(&mut self) {
108. 108 self.remember = match self.remember {
109. 109 RememberMode::No => RememberMode::Yes,
110. 110 RememberMode::Yes => RememberMode::No,
111. 111 };
112. 112 }
113. 113
114. 114 pub fn insert_char(&mut self, c: char) {
115. 115 if self.is_editing {
116. 116 if self.edit_cursor >= self.edited_command.len() {
117. 117 self.edited_command.push(c);
118. 118 } else {
119. 119 self.edited_command.insert(self.edit_cursor, c);
120. 120 }
121. 121 self.edit_cursor += c.len_utf8();
122. 122 }
123. 123 }
124. 124
125. 125 pub fn delete_backspace(&mut self) {
126. 126 if self.is_editing && self.edit_cursor > 0 && !self.edited_command.is_empty() {
127. 127 let mut prev = self.edit_cursor - 1;
128. 128 while prev > 0 && !self.edited_command.is_char_boundary(prev) {
129. 129 prev -= 1;
130. 130 }
131. 131 self.edited_command.remove(prev);
132. 132 self.edit_cursor = prev;
133. 133 }
134. 134 }
135. 135
136. 136 pub fn finish_approval(&self) -> HilOutcome {
137. 137 let modified = if self.edited_command != self.original_command {
138. 138 Some(self.edited_command.clone())
139. 139 } else {
140. 140 None
141. 141 };
142. 142 HilOutcome::ApproveOnce {
143. 143 modified_command: modified,
144. 144 }
145. 145 }
146. 146
147. 147 /// Whether the edited command differs from the original.
148. 148 pub fn has_modification(&self) -> bool {
149. 149 self.edited_command != self.original_command
150. 150 }
151. 151}
152. 152
153. 153/// Helper to extract an `ApprovalRequested` event from an `AgentEvent` JSON
154. 154/// value (as received over the SSE event stream). Returns `None` if the
155. 155/// event is not an approval request or is malformed.
156. 156pub fn extract_approval_request(event_json: &serde_json::Value) -> Option<RealApprovalRequest> {
157. 157 // The server emits AgentEvent::ApprovalRequested as:
158. 158 // {"ApprovalRequested": {"id": "...", "tool": "...", "args_json": "...", "reason": "..."}}
159. 159 let approval = event_json.get("ApprovalRequested")?;
160. 160 Some(RealApprovalRequest {
161. 161 request_id: approval
162. 162 .get("id")
163. 163 .and_then(|v| v.as_str())
164. 164 .map(String::from)?,
165. 165 tool: approval
166. 166 .get("tool")
167. 167 .and_then(|v| v.as_str())
168. 168 .map(String::from)?,
169. 169 args_json: approval
170. 170 .get("args_json")
171. 171 .and_then(|v| v.as_str())
172. 172 .map(String::from)
173. 173 .unwrap_or_default(),
174. 174 reason: approval
175. 175 .get("reason")
176. 176 .and_then(|v| v.as_str())
177. 177 .map(String::from)
178. 178 .unwrap_or_default(),
179. 179 })
180. 180}
181. 181
182. 182/// A real approval request extracted from the agent event stream.
183. 183#[derive(Debug, Clone)]
184. 184pub struct RealApprovalRequest {
185. 185 pub request_id: String,
186. 186 pub tool: String,
187. 187 pub args_json: String,
188. 188 pub reason: String,
189. 189}
190. 190