sacp/schema/agent_to_client/
requests.rs1use serde::Serialize;
2
3use crate::jsonrpc::{JrMessage, JrRequest, JrResponsePayload};
4use crate::schema::{
5 CreateTerminalRequest, CreateTerminalResponse, KillTerminalCommandRequest,
6 KillTerminalCommandResponse, ReadTextFileRequest, ReadTextFileResponse, ReleaseTerminalRequest,
7 ReleaseTerminalResponse, RequestPermissionRequest, RequestPermissionResponse,
8 TerminalOutputRequest, TerminalOutputResponse, WaitForTerminalExitRequest,
9 WaitForTerminalExitResponse, WriteTextFileRequest, WriteTextFileResponse,
10};
11use crate::util::json_cast;
12
13impl JrMessage for RequestPermissionRequest {
21 fn method(&self) -> &str {
22 "session/request_permission"
23 }
24
25 fn to_untyped_message(&self) -> Result<crate::UntypedMessage, crate::Error> {
26 crate::UntypedMessage::new(self.method(), self)
27 }
28
29 fn parse_message(method: &str, params: &impl Serialize) -> Option<Result<Self, crate::Error>> {
30 if method != "session/request_permission" {
31 return None;
32 }
33 Some(json_cast(params))
34 }
35}
36
37impl JrRequest for RequestPermissionRequest {
38 type Response = RequestPermissionResponse;
39}
40
41impl JrResponsePayload for RequestPermissionResponse {
42 fn into_json(self, _method: &str) -> Result<serde_json::Value, crate::Error> {
43 serde_json::to_value(self).map_err(crate::Error::into_internal_error)
44 }
45
46 fn from_value(_method: &str, value: serde_json::Value) -> Result<Self, crate::Error> {
47 json_cast(&value)
48 }
49}
50
51impl JrMessage for WriteTextFileRequest {
56 fn method(&self) -> &str {
57 "fs/write_text_file"
58 }
59
60 fn to_untyped_message(&self) -> Result<crate::UntypedMessage, crate::Error> {
61 crate::UntypedMessage::new(self.method(), self)
62 }
63
64 fn parse_message(method: &str, params: &impl Serialize) -> Option<Result<Self, crate::Error>> {
65 if method != "fs/write_text_file" {
66 return None;
67 }
68 Some(json_cast(params))
69 }
70}
71
72impl JrRequest for WriteTextFileRequest {
73 type Response = WriteTextFileResponse;
74}
75
76impl JrResponsePayload for WriteTextFileResponse {
77 fn into_json(self, _method: &str) -> Result<serde_json::Value, crate::Error> {
78 serde_json::to_value(self).map_err(crate::Error::into_internal_error)
79 }
80
81 fn from_value(_method: &str, value: serde_json::Value) -> Result<Self, crate::Error> {
82 json_cast(&value)
83 }
84}
85
86impl JrMessage for ReadTextFileRequest {
91 fn method(&self) -> &str {
92 "fs/read_text_file"
93 }
94
95 fn to_untyped_message(&self) -> Result<crate::UntypedMessage, crate::Error> {
96 crate::UntypedMessage::new(self.method(), self)
97 }
98
99 fn parse_message(method: &str, params: &impl Serialize) -> Option<Result<Self, crate::Error>> {
100 if method != "fs/read_text_file" {
101 return None;
102 }
103 Some(json_cast(params))
104 }
105}
106
107impl JrRequest for ReadTextFileRequest {
108 type Response = ReadTextFileResponse;
109}
110
111impl JrResponsePayload for ReadTextFileResponse {
112 fn into_json(self, _method: &str) -> Result<serde_json::Value, crate::Error> {
113 serde_json::to_value(self).map_err(crate::Error::into_internal_error)
114 }
115
116 fn from_value(_method: &str, value: serde_json::Value) -> Result<Self, crate::Error> {
117 json_cast(&value)
118 }
119}
120
121impl JrMessage for CreateTerminalRequest {
126 fn method(&self) -> &str {
127 "terminal/create"
128 }
129
130 fn to_untyped_message(&self) -> Result<crate::UntypedMessage, crate::Error> {
131 crate::UntypedMessage::new(self.method(), self)
132 }
133
134 fn parse_message(method: &str, params: &impl Serialize) -> Option<Result<Self, crate::Error>> {
135 if method != "terminal/create" {
136 return None;
137 }
138 Some(json_cast(params))
139 }
140}
141
142impl JrRequest for CreateTerminalRequest {
143 type Response = CreateTerminalResponse;
144}
145
146impl JrResponsePayload for CreateTerminalResponse {
147 fn into_json(self, _method: &str) -> Result<serde_json::Value, crate::Error> {
148 serde_json::to_value(self).map_err(crate::Error::into_internal_error)
149 }
150
151 fn from_value(_method: &str, value: serde_json::Value) -> Result<Self, crate::Error> {
152 json_cast(&value)
153 }
154}
155
156impl JrMessage for TerminalOutputRequest {
161 fn method(&self) -> &str {
162 "terminal/output"
163 }
164
165 fn to_untyped_message(&self) -> Result<crate::UntypedMessage, crate::Error> {
166 crate::UntypedMessage::new(self.method(), self)
167 }
168
169 fn parse_message(method: &str, params: &impl Serialize) -> Option<Result<Self, crate::Error>> {
170 if method != "terminal/output" {
171 return None;
172 }
173 Some(json_cast(params))
174 }
175}
176
177impl JrRequest for TerminalOutputRequest {
178 type Response = TerminalOutputResponse;
179}
180
181impl JrResponsePayload for TerminalOutputResponse {
182 fn into_json(self, _method: &str) -> Result<serde_json::Value, crate::Error> {
183 serde_json::to_value(self).map_err(crate::Error::into_internal_error)
184 }
185
186 fn from_value(_method: &str, value: serde_json::Value) -> Result<Self, crate::Error> {
187 json_cast(&value)
188 }
189}
190
191impl JrMessage for ReleaseTerminalRequest {
196 fn method(&self) -> &str {
197 "terminal/release"
198 }
199
200 fn to_untyped_message(&self) -> Result<crate::UntypedMessage, crate::Error> {
201 crate::UntypedMessage::new(self.method(), self)
202 }
203
204 fn parse_message(method: &str, params: &impl Serialize) -> Option<Result<Self, crate::Error>> {
205 if method != "terminal/release" {
206 return None;
207 }
208 Some(json_cast(params))
209 }
210}
211
212impl JrRequest for ReleaseTerminalRequest {
213 type Response = ReleaseTerminalResponse;
214}
215
216impl JrResponsePayload for ReleaseTerminalResponse {
217 fn into_json(self, _method: &str) -> Result<serde_json::Value, crate::Error> {
218 serde_json::to_value(self).map_err(crate::Error::into_internal_error)
219 }
220
221 fn from_value(_method: &str, value: serde_json::Value) -> Result<Self, crate::Error> {
222 json_cast(&value)
223 }
224}
225
226impl JrMessage for WaitForTerminalExitRequest {
231 fn method(&self) -> &str {
232 "terminal/wait_for_exit"
233 }
234
235 fn to_untyped_message(&self) -> Result<crate::UntypedMessage, crate::Error> {
236 crate::UntypedMessage::new(self.method(), self)
237 }
238
239 fn parse_message(method: &str, params: &impl Serialize) -> Option<Result<Self, crate::Error>> {
240 if method != "terminal/wait_for_exit" {
241 return None;
242 }
243 Some(json_cast(params))
244 }
245}
246
247impl JrRequest for WaitForTerminalExitRequest {
248 type Response = WaitForTerminalExitResponse;
249}
250
251impl JrResponsePayload for WaitForTerminalExitResponse {
252 fn into_json(self, _method: &str) -> Result<serde_json::Value, crate::Error> {
253 serde_json::to_value(self).map_err(crate::Error::into_internal_error)
254 }
255
256 fn from_value(_method: &str, value: serde_json::Value) -> Result<Self, crate::Error> {
257 json_cast(&value)
258 }
259}
260
261impl JrMessage for KillTerminalCommandRequest {
266 fn method(&self) -> &str {
267 "terminal/kill"
268 }
269
270 fn to_untyped_message(&self) -> Result<crate::UntypedMessage, crate::Error> {
271 crate::UntypedMessage::new(self.method(), self)
272 }
273
274 fn parse_message(method: &str, params: &impl Serialize) -> Option<Result<Self, crate::Error>> {
275 if method != "terminal/kill" {
276 return None;
277 }
278 Some(json_cast(params))
279 }
280}
281
282impl JrRequest for KillTerminalCommandRequest {
283 type Response = KillTerminalCommandResponse;
284}
285
286impl JrResponsePayload for KillTerminalCommandResponse {
287 fn into_json(self, _method: &str) -> Result<serde_json::Value, crate::Error> {
288 serde_json::to_value(self).map_err(crate::Error::into_internal_error)
289 }
290
291 fn from_value(_method: &str, value: serde_json::Value) -> Result<Self, crate::Error> {
292 json_cast(&value)
293 }
294}