1use serde::{Deserialize, Serialize};
2
3use super::content::UserInput;
4
5#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
11pub struct InitializeParams {
12 pub protocol_version: String,
14 #[serde(skip_serializing_if = "Option::is_none")]
16 pub client: Option<ClientInfo>,
17 #[serde(skip_serializing_if = "Option::is_none")]
19 pub external_tools: Option<Vec<ExternalTool>>,
20 #[serde(skip_serializing_if = "Option::is_none")]
22 pub capabilities: Option<ClientCapabilities>,
23 #[serde(skip_serializing_if = "Option::is_none")]
25 pub hooks: Option<Vec<WireHookSubscription>>,
26}
27
28impl InitializeParams {
29 pub fn new(protocol_version: impl Into<String>) -> Self {
31 Self {
32 protocol_version: protocol_version.into(),
33 client: None,
34 external_tools: None,
35 capabilities: None,
36 hooks: None,
37 }
38 }
39
40 pub fn with_client(mut self, client: ClientInfo) -> Self {
42 self.client = Some(client);
43 self
44 }
45
46 pub fn with_external_tools(mut self, tools: Vec<ExternalTool>) -> Self {
48 self.external_tools = Some(tools);
49 self
50 }
51
52 pub fn with_capabilities(mut self, caps: ClientCapabilities) -> Self {
54 self.capabilities = Some(caps);
55 self
56 }
57
58 pub fn with_hooks(mut self, hooks: Vec<WireHookSubscription>) -> Self {
60 self.hooks = Some(hooks);
61 self
62 }
63}
64
65#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
67pub struct ClientInfo {
68 pub name: String,
70 #[serde(skip_serializing_if = "Option::is_none")]
72 pub version: Option<String>,
73}
74
75#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
77pub struct ClientCapabilities {
78 #[serde(skip_serializing_if = "Option::is_none")]
80 pub supports_question: Option<bool>,
81 #[serde(skip_serializing_if = "Option::is_none")]
83 pub supports_plan_mode: Option<bool>,
84}
85
86#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
88pub struct WireHookSubscription {
89 pub id: String,
91 pub event: String,
93 #[serde(skip_serializing_if = "Option::is_none")]
95 pub matcher: Option<String>,
96 #[serde(skip_serializing_if = "Option::is_none")]
98 pub timeout: Option<u32>,
99}
100
101#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
103pub struct ExternalTool {
104 pub name: String,
106 pub description: String,
108 pub parameters: serde_json::Value,
110}
111
112#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
114pub struct InitializeResult {
115 pub protocol_version: String,
117 pub server: ServerInfo,
119 pub slash_commands: Vec<SlashCommandInfo>,
121 #[serde(skip_serializing_if = "Option::is_none")]
123 pub external_tools: Option<ExternalToolsResult>,
124 #[serde(skip_serializing_if = "Option::is_none")]
126 pub capabilities: Option<ServerCapabilities>,
127 #[serde(skip_serializing_if = "Option::is_none")]
129 pub hooks: Option<HooksInfo>,
130}
131
132#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
134pub struct ServerInfo {
135 pub name: String,
137 pub version: String,
139}
140
141#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
143pub struct SlashCommandInfo {
144 pub name: String,
146 pub description: String,
148 pub aliases: Vec<String>,
150}
151
152#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
154pub struct ExternalToolsResult {
155 pub accepted: Vec<String>,
157 pub rejected: Vec<RejectedExternalTool>,
159}
160
161#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
163pub struct RejectedExternalTool {
164 pub name: String,
166 pub reason: String,
168}
169
170#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
172pub struct ServerCapabilities {
173 #[serde(skip_serializing_if = "Option::is_none")]
175 pub supports_question: Option<bool>,
176}
177
178#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
180pub struct HooksInfo {
181 pub supported_events: Vec<String>,
183 pub configured: std::collections::HashMap<String, u32>,
185}
186
187#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
193pub struct PromptParams {
194 pub user_input: UserInput,
196}
197
198#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
200pub struct PromptResult {
201 pub status: PromptStatus,
203 #[serde(skip_serializing_if = "Option::is_none")]
205 pub steps: Option<u64>,
206}
207
208#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
210#[serde(rename_all = "snake_case")]
211#[non_exhaustive]
212pub enum PromptStatus {
213 Finished,
215 Cancelled,
217 MaxStepsReached,
219 Pending,
228 UnexpectedEof,
236}
237
238#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
244pub struct ReplayParams {}
245
246#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
248pub struct ReplayResult {
249 pub status: ReplayStatus,
251 pub events: u64,
253 pub requests: u64,
255}
256
257#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
259#[serde(rename_all = "snake_case")]
260#[non_exhaustive]
261pub enum ReplayStatus {
262 Finished,
264 Cancelled,
266}
267
268#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
274pub struct SteerParams {
275 pub user_input: UserInput,
277}
278
279#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
281pub struct SteerResult {
282 pub status: SteerStatus,
284}
285
286#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
288#[serde(rename_all = "snake_case")]
289#[non_exhaustive]
290pub enum SteerStatus {
291 Steered,
293}
294
295#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
301pub struct SetPlanModeParams {
302 pub enabled: bool,
304}
305
306#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
308pub struct SetPlanModeResult {
309 pub status: SetPlanModeStatus,
311 pub plan_mode: bool,
313}
314
315#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
317#[serde(rename_all = "snake_case")]
318#[non_exhaustive]
319pub enum SetPlanModeStatus {
320 Ok,
322}
323
324#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
330pub struct CancelParams {}
331
332#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
334pub struct CancelResult {}