1use serde::{Deserialize, Serialize};
2
3#[derive(Debug, Clone, Serialize, Deserialize)]
4#[serde(rename_all = "camelCase")]
5pub struct JsonRpcRequest {
6 pub jsonrpc: String,
7 pub id: u64,
8 pub method: String,
9 pub params: serde_json::Value,
10}
11
12#[derive(Debug, Clone, Serialize, Deserialize)]
13#[serde(rename_all = "camelCase")]
14pub struct JsonRpcResponse {
15 pub jsonrpc: String,
16 pub id: u64,
17 pub result: Option<serde_json::Value>,
18 pub error: Option<JsonRpcError>,
19}
20
21#[derive(Debug, Clone, Serialize, Deserialize)]
22#[serde(rename_all = "camelCase")]
23pub struct JsonRpcNotification {
24 pub jsonrpc: String,
25 pub method: String,
26 pub params: serde_json::Value,
27}
28
29#[derive(Debug, Clone, Serialize, Deserialize)]
30#[serde(rename_all = "camelCase")]
31pub struct JsonRpcError {
32 pub code: i32,
33 pub message: String,
34 pub data: Option<serde_json::Value>,
35}
36
37#[derive(Debug, Clone, Serialize, Deserialize)]
38#[serde(untagged)]
39pub enum JsonRpcMessage {
40 Response(JsonRpcResponse),
41 Notification(JsonRpcNotification),
42 Request(JsonRpcRequest),
43}
44
45#[derive(Debug, Clone, Serialize, Deserialize)]
46#[serde(rename_all = "camelCase")]
47pub struct InitializeRequest {
48 pub protocol_version: u32,
49 pub client_capabilities: ClientCapabilities,
50 pub client_info: Option<Implementation>,
51}
52
53#[derive(Debug, Clone, Serialize, Deserialize)]
54#[serde(rename_all = "camelCase")]
55pub struct InitializeResponse {
56 pub protocol_version: u32,
57 #[serde(default)]
58 pub agent_capabilities: AgentCapabilities,
59 pub agent_info: Option<Implementation>,
60 #[serde(default)]
61 pub auth_methods: Vec<AuthMethod>,
62}
63
64#[derive(Debug, Clone, Serialize, Deserialize)]
65#[serde(rename_all = "camelCase")]
66pub struct Implementation {
67 pub name: String,
68 pub title: Option<String>,
69 pub version: Option<String>,
70}
71
72#[derive(Debug, Clone, Serialize, Deserialize)]
73#[serde(rename_all = "camelCase")]
74pub struct ClientCapabilities {
75 pub fs: FsCapabilities,
76 pub terminal: bool,
77}
78
79#[derive(Debug, Clone, Serialize, Deserialize)]
80#[serde(rename_all = "camelCase")]
81pub struct FsCapabilities {
82 pub read_text_file: bool,
83 pub write_text_file: bool,
84}
85
86#[derive(Debug, Clone, Serialize, Deserialize, Default)]
87#[serde(rename_all = "camelCase", default)]
88pub struct AgentCapabilities {
89 pub load_session: bool,
90 pub prompt_capabilities: PromptCapabilities,
91 pub mcp_capabilities: McpCapabilities,
92 pub session_capabilities: serde_json::Value,
93}
94
95#[derive(Debug, Clone, Serialize, Deserialize, Default)]
96#[serde(rename_all = "camelCase", default)]
97pub struct PromptCapabilities {
98 pub image: bool,
99 pub audio: bool,
100 pub embedded_context: bool,
101}
102
103#[derive(Debug, Clone, Serialize, Deserialize, Default)]
104#[serde(rename_all = "camelCase", default)]
105pub struct McpCapabilities {
106 pub http: bool,
107 pub sse: bool,
108}
109
110#[derive(Debug, Clone, Serialize, Deserialize)]
111#[serde(rename_all = "camelCase")]
112pub struct AuthMethod {
113 pub id: String,
114 pub description: Option<String>,
115}
116
117#[derive(Debug, Clone, Serialize, Deserialize)]
118#[serde(rename_all = "camelCase")]
119pub struct AuthenticateRequest {
120 pub method_id: String,
121}
122
123#[derive(Debug, Clone, Serialize, Deserialize)]
124pub struct AuthenticateResponse {}
125
126pub type SessionId = String;
127
128#[derive(Debug, Clone, Serialize, Deserialize)]
129#[serde(rename_all = "camelCase")]
130pub struct NewSessionRequest {
131 pub cwd: String,
132 #[serde(default)]
133 pub mcp_servers: Vec<McpServer>,
134}
135
136#[derive(Debug, Clone, Serialize, Deserialize)]
137#[serde(rename_all = "camelCase")]
138pub struct NewSessionResponse {
139 pub session_id: SessionId,
140 pub modes: Option<SessionModeState>,
141 pub config_options: Option<Vec<SessionConfigOption>>,
142}
143
144#[derive(Debug, Clone, Serialize, Deserialize)]
145#[serde(rename_all = "camelCase")]
146pub struct LoadSessionRequest {
147 pub session_id: SessionId,
148 pub cwd: String,
149 #[serde(default)]
150 pub mcp_servers: Vec<McpServer>,
151}
152
153#[derive(Debug, Clone, Serialize, Deserialize)]
154#[serde(rename_all = "camelCase")]
155pub struct LoadSessionResponse {
156 pub modes: Option<SessionModeState>,
157 pub config_options: Option<Vec<SessionConfigOption>>,
158}
159
160#[derive(Debug, Clone, Serialize, Deserialize)]
161#[serde(tag = "type", rename_all = "lowercase")]
162pub enum McpServer {
163 Stdio {
164 name: String,
165 command: String,
166 #[serde(default)]
167 args: Vec<String>,
168 #[serde(default)]
169 env: Vec<EnvVariable>,
170 },
171 Http {
172 name: String,
173 url: String,
174 #[serde(default)]
175 headers: Vec<HttpHeader>,
176 },
177 Sse {
178 name: String,
179 url: String,
180 #[serde(default)]
181 headers: Vec<HttpHeader>,
182 },
183}
184
185#[derive(Debug, Clone, Serialize, Deserialize)]
186#[serde(rename_all = "camelCase")]
187pub struct EnvVariable {
188 pub name: String,
189 pub value: String,
190}
191
192#[derive(Debug, Clone, Serialize, Deserialize)]
193#[serde(rename_all = "camelCase")]
194pub struct HttpHeader {
195 pub name: String,
196 pub value: String,
197}
198
199#[derive(Debug, Clone, Serialize, Deserialize)]
200#[serde(rename_all = "camelCase")]
201pub struct PromptRequest {
202 pub session_id: SessionId,
203 pub prompt: Vec<ContentBlock>,
204}
205
206#[derive(Debug, Clone, Serialize, Deserialize)]
207#[serde(rename_all = "camelCase")]
208pub struct PromptResponse {
209 pub stop_reason: StopReason,
210}
211
212#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
213#[serde(rename_all = "snake_case")]
214pub enum StopReason {
215 EndTurn,
216 MaxTokens,
217 MaxTurnRequests,
218 Refusal,
219 Cancelled,
220}
221
222#[derive(Debug, Clone, Serialize, Deserialize)]
223#[serde(tag = "type", rename_all = "snake_case")]
224pub enum ContentBlock {
225 Text {
226 text: String,
227 },
228 Image {
229 mime_type: String,
230 data: String,
231 },
232 Audio {
233 mime_type: String,
234 data: String,
235 },
236 Resource {
237 resource: EmbeddedResource,
238 },
239 ResourceLink {
240 uri: String,
241 name: String,
242 mime_type: Option<String>,
243 title: Option<String>,
244 description: Option<String>,
245 size: Option<u64>,
246 },
247}
248
249#[derive(Debug, Clone, Serialize, Deserialize)]
250#[serde(rename_all = "camelCase")]
251pub struct EmbeddedResource {
252 pub uri: String,
253 pub mime_type: Option<String>,
254 pub text: Option<String>,
255 pub blob: Option<String>,
256}
257
258#[derive(Debug, Clone, Serialize, Deserialize)]
259#[serde(rename_all = "camelCase")]
260pub struct SessionNotification {
261 pub session_id: SessionId,
262 pub update: SessionUpdate,
263}
264
265#[derive(Debug, Clone, Serialize, Deserialize)]
266#[serde(tag = "sessionUpdate", rename_all = "snake_case")]
267pub enum SessionUpdate {
268 AgentMessageChunk {
269 content: ContentBlock,
270 },
271 UserMessageChunk {
272 content: ContentBlock,
273 },
274 ThoughtChunk {
275 content: ContentBlock,
276 },
277 ToolCall {
278 tool_call_id: String,
279 title: String,
280 kind: ToolKind,
281 status: ToolCallStatus,
282 #[serde(default)]
283 content: Option<Vec<ToolCallContent>>,
284 #[serde(default)]
285 locations: Option<Vec<ToolCallLocation>>,
286 raw_input: Option<serde_json::Value>,
287 raw_output: Option<serde_json::Value>,
288 },
289 ToolCallUpdate {
290 tool_call_id: String,
291 title: Option<String>,
292 status: Option<ToolCallStatus>,
293 #[serde(default)]
294 content: Option<Vec<ToolCallContent>>,
295 #[serde(default)]
296 locations: Option<Vec<ToolCallLocation>>,
297 },
298 Plan {
299 entries: Vec<PlanEntry>,
300 },
301 AvailableCommandsUpdate {
302 available_commands: Vec<AvailableCommand>,
303 },
304 CurrentModeUpdate {
305 mode_id: String,
306 },
307 ConfigOptionsUpdate {
308 config_options: Vec<SessionConfigOption>,
309 },
310}
311
312#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
313#[serde(rename_all = "snake_case")]
314pub enum ToolKind {
315 Read,
316 Edit,
317 Delete,
318 Move,
319 Search,
320 Execute,
321 Think,
322 Fetch,
323 Other,
324}
325
326#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
327#[serde(rename_all = "snake_case")]
328pub enum ToolCallStatus {
329 Pending,
330 InProgress,
331 Completed,
332 Failed,
333}
334
335#[derive(Debug, Clone, Serialize, Deserialize)]
336#[serde(rename_all = "camelCase")]
337pub struct ToolCallLocation {
338 pub path: String,
339 pub line: Option<u32>,
340}
341
342#[derive(Debug, Clone, Serialize, Deserialize)]
343#[serde(tag = "type", rename_all = "snake_case")]
344pub enum ToolCallContent {
345 Content {
346 content: ContentBlock,
347 },
348 Diff {
349 path: String,
350 old_text: Option<String>,
351 new_text: String,
352 },
353 Terminal {
354 terminal_id: String,
355 },
356}
357
358#[derive(Debug, Clone, Serialize, Deserialize)]
359#[serde(rename_all = "camelCase")]
360pub struct PlanEntry {
361 pub content: String,
362 pub priority: PlanEntryPriority,
363 pub status: PlanEntryStatus,
364}
365
366#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
367#[serde(rename_all = "snake_case")]
368pub enum PlanEntryPriority {
369 High,
370 Medium,
371 Low,
372}
373
374#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
375#[serde(rename_all = "snake_case")]
376pub enum PlanEntryStatus {
377 Pending,
378 InProgress,
379 Completed,
380}
381
382#[derive(Debug, Clone, Serialize, Deserialize)]
383#[serde(rename_all = "camelCase")]
384pub struct AvailableCommand {
385 pub name: String,
386 pub description: String,
387 pub input: Option<AvailableCommandInput>,
388}
389
390#[derive(Debug, Clone, Serialize, Deserialize)]
391#[serde(rename_all = "camelCase")]
392pub struct AvailableCommandInput {
393 pub hint: String,
394}
395
396#[derive(Debug, Clone, Serialize, Deserialize)]
397#[serde(rename_all = "camelCase")]
398pub struct RequestPermissionRequest {
399 pub session_id: SessionId,
400 pub tool_call: ToolCallForPermission,
401 #[serde(default)]
402 pub options: Vec<PermissionOption>,
403}
404
405#[derive(Debug, Clone, Serialize, Deserialize)]
406#[serde(rename_all = "camelCase")]
407pub struct ToolCallForPermission {
408 pub tool_call_id: String,
409 pub title: String,
410 pub kind: ToolKind,
411 pub status: ToolCallStatus,
412 #[serde(default)]
413 pub content: Option<Vec<ToolCallContent>>,
414}
415
416#[derive(Debug, Clone, Serialize, Deserialize)]
417#[serde(rename_all = "camelCase")]
418pub struct PermissionOption {
419 pub option_id: String,
420 pub name: String,
421 pub kind: PermissionOptionKind,
422}
423
424#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
425#[serde(rename_all = "snake_case")]
426pub enum PermissionOptionKind {
427 AllowOnce,
428 AllowAlways,
429 RejectOnce,
430 RejectAlways,
431}
432
433#[derive(Debug, Clone, Serialize, Deserialize)]
434#[serde(rename_all = "camelCase")]
435pub struct RequestPermissionResponse {
436 pub outcome: RequestPermissionOutcome,
437}
438
439#[derive(Debug, Clone, Serialize, Deserialize)]
440#[serde(tag = "outcome", rename_all = "snake_case")]
441pub enum RequestPermissionOutcome {
442 Cancelled,
443 Selected { option_id: String },
444}
445
446#[derive(Debug, Clone, Serialize, Deserialize)]
447#[serde(rename_all = "camelCase")]
448pub struct ReadTextFileRequest {
449 pub session_id: SessionId,
450 pub path: String,
451 pub line: Option<u32>,
452 pub limit: Option<u32>,
453}
454
455#[derive(Debug, Clone, Serialize, Deserialize)]
456#[serde(rename_all = "camelCase")]
457pub struct ReadTextFileResponse {
458 pub content: String,
459}
460
461#[derive(Debug, Clone, Serialize, Deserialize)]
462#[serde(rename_all = "camelCase")]
463pub struct WriteTextFileRequest {
464 pub session_id: SessionId,
465 pub path: String,
466 pub content: String,
467}
468
469#[derive(Debug, Clone, Serialize, Deserialize)]
470pub struct WriteTextFileResponse {}
471
472#[derive(Debug, Clone, Serialize, Deserialize)]
473#[serde(rename_all = "camelCase")]
474pub struct CreateTerminalRequest {
475 pub session_id: SessionId,
476 pub command: String,
477 #[serde(default)]
478 pub args: Vec<String>,
479 #[serde(default)]
480 pub env: Vec<EnvVariable>,
481 pub cwd: Option<String>,
482 pub output_byte_limit: Option<u64>,
483}
484
485#[derive(Debug, Clone, Serialize, Deserialize)]
486#[serde(rename_all = "camelCase")]
487pub struct CreateTerminalResponse {
488 pub terminal_id: String,
489}
490
491#[derive(Debug, Clone, Serialize, Deserialize)]
492#[serde(rename_all = "camelCase")]
493pub struct TerminalOutputRequest {
494 pub session_id: SessionId,
495 pub terminal_id: String,
496}
497
498#[derive(Debug, Clone, Serialize, Deserialize)]
499#[serde(rename_all = "camelCase")]
500pub struct TerminalOutputResponse {
501 pub output: String,
502 pub truncated: bool,
503 pub exit_status: Option<TerminalExitStatus>,
504}
505
506#[derive(Debug, Clone, Serialize, Deserialize)]
507#[serde(rename_all = "camelCase")]
508pub struct WaitForTerminalExitRequest {
509 pub session_id: SessionId,
510 pub terminal_id: String,
511}
512
513#[derive(Debug, Clone, Serialize, Deserialize)]
514#[serde(rename_all = "camelCase")]
515pub struct WaitForTerminalExitResponse {
516 pub exit_code: Option<i32>,
517 pub signal: Option<String>,
518}
519
520#[derive(Debug, Clone, Serialize, Deserialize)]
521#[serde(rename_all = "camelCase")]
522pub struct KillTerminalRequest {
523 pub session_id: SessionId,
524 pub terminal_id: String,
525}
526
527#[derive(Debug, Clone, Serialize, Deserialize)]
528pub struct KillTerminalResponse {}
529
530#[derive(Debug, Clone, Serialize, Deserialize)]
531#[serde(rename_all = "camelCase")]
532pub struct ReleaseTerminalRequest {
533 pub session_id: SessionId,
534 pub terminal_id: String,
535}
536
537#[derive(Debug, Clone, Serialize, Deserialize)]
538pub struct ReleaseTerminalResponse {}
539
540#[derive(Debug, Clone, Serialize, Deserialize)]
541#[serde(rename_all = "camelCase")]
542pub struct TerminalExitStatus {
543 pub exit_code: Option<i32>,
544 pub signal: Option<String>,
545}
546
547#[derive(Debug, Clone, Serialize, Deserialize)]
548#[serde(rename_all = "camelCase")]
549pub struct SessionModeState {
550 pub current_mode_id: String,
551 #[serde(default)]
552 pub available_modes: Vec<SessionMode>,
553}
554
555#[derive(Debug, Clone, Serialize, Deserialize)]
556#[serde(rename_all = "camelCase")]
557pub struct SessionMode {
558 pub id: String,
559 pub name: String,
560 pub description: Option<String>,
561}
562
563#[derive(Debug, Clone, Serialize, Deserialize)]
564#[serde(rename_all = "camelCase")]
565pub struct SetSessionModeRequest {
566 pub session_id: SessionId,
567 pub mode_id: String,
568}
569
570#[derive(Debug, Clone, Serialize, Deserialize)]
571pub struct SetSessionModeResponse {}
572
573pub type SessionConfigId = String;
574pub type SessionConfigValueId = String;
575
576#[derive(Debug, Clone, Serialize, Deserialize)]
577#[serde(rename_all = "camelCase")]
578pub struct SessionConfigOption {
579 pub id: SessionConfigId,
580 pub label: String,
581 #[serde(default)]
582 pub values: Vec<SessionConfigValue>,
583 pub current: SessionConfigValueId,
584}
585
586#[derive(Debug, Clone, Serialize, Deserialize)]
587#[serde(rename_all = "camelCase")]
588pub struct SessionConfigValue {
589 pub id: SessionConfigValueId,
590 pub label: String,
591}
592
593#[derive(Debug, Clone, Serialize, Deserialize)]
594#[serde(rename_all = "camelCase")]
595pub struct SetSessionConfigOptionRequest {
596 pub session_id: SessionId,
597 pub config_id: SessionConfigId,
598 pub value: SessionConfigValueId,
599}
600
601#[derive(Debug, Clone, Serialize, Deserialize)]
602#[serde(rename_all = "camelCase")]
603pub struct SetSessionConfigOptionResponse {
604 #[serde(default)]
605 pub config_options: Vec<SessionConfigOption>,
606}
607
608#[derive(Debug, Clone, Serialize, Deserialize)]
609#[serde(rename_all = "camelCase")]
610pub struct CancelNotification {
611 pub session_id: SessionId,
612}