muse_code_sdk/msp/method/
session_wire_words.rs1use super::session::NeedsInputReason;
4use super::session::ProbeDegradedReason;
5use super::session::RunningElsewhereOrigin;
6use super::session::SessionKind;
7use super::session_events::SessionClosedReason;
8use super::session_events::SessionStatus;
9use serde::Deserialize;
10use serde::Deserializer;
11use serde::Serialize;
12use serde::Serializer;
13
14impl SessionKind {
15 #[must_use]
17 pub fn as_str(&self) -> &str {
18 match self {
19 Self::Root => "root",
20 Self::Subagent => "subagent",
21 Self::Unknown(value) => value,
22 }
23 }
24}
25
26impl Serialize for SessionKind {
27 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
28 where
29 S: Serializer,
30 {
31 serializer.serialize_str(self.as_str())
32 }
33}
34
35impl<'de> Deserialize<'de> for SessionKind {
36 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
37 where
38 D: Deserializer<'de>,
39 {
40 let value = String::deserialize(deserializer)?;
41 Ok(match value.as_str() {
42 "root" => Self::Root,
43 "subagent" => Self::Subagent,
44 _ => Self::Unknown(value),
45 })
46 }
47}
48
49impl SessionStatus {
50 #[must_use]
52 pub fn as_str(&self) -> &str {
53 match self {
54 Self::NotLoaded => "notLoaded",
55 Self::Idle => "idle",
56 Self::Running => "running",
57 Self::NeedsInput => "needsInput",
58 Self::Unknown(value) => value,
59 }
60 }
61}
62
63impl NeedsInputReason {
64 #[must_use]
66 pub fn as_str(&self) -> &str {
67 match self {
68 Self::ApprovalPending => "approvalPending",
69 Self::InputPending => "inputPending",
70 Self::Unknown(value) => value,
71 }
72 }
73}
74
75impl Serialize for NeedsInputReason {
76 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
77 where
78 S: Serializer,
79 {
80 serializer.serialize_str(self.as_str())
81 }
82}
83
84impl<'de> Deserialize<'de> for NeedsInputReason {
85 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
86 where
87 D: Deserializer<'de>,
88 {
89 let value = String::deserialize(deserializer)?;
90 Ok(match value.as_str() {
91 "approvalPending" => Self::ApprovalPending,
92 "inputPending" => Self::InputPending,
93 _ => Self::Unknown(value),
94 })
95 }
96}
97
98impl Serialize for SessionStatus {
99 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
100 where
101 S: Serializer,
102 {
103 serializer.serialize_str(self.as_str())
104 }
105}
106
107impl<'de> Deserialize<'de> for SessionStatus {
108 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
109 where
110 D: Deserializer<'de>,
111 {
112 let value = String::deserialize(deserializer)?;
113 Ok(match value.as_str() {
114 "notLoaded" => Self::NotLoaded,
115 "idle" => Self::Idle,
116 "running" => Self::Running,
117 "needsInput" => Self::NeedsInput,
118 _ => Self::Unknown(value),
119 })
120 }
121}
122
123impl SessionClosedReason {
124 #[must_use]
126 pub fn as_str(&self) -> &str {
127 match self {
128 Self::Idle => "idle",
129 Self::HostShutdown => "hostShutdown",
130 Self::Leave => "leave",
131 Self::Vacated => "vacated",
132 Self::Unknown(value) => value,
133 }
134 }
135}
136
137impl Serialize for SessionClosedReason {
138 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
139 where
140 S: Serializer,
141 {
142 serializer.serialize_str(self.as_str())
143 }
144}
145
146impl<'de> Deserialize<'de> for SessionClosedReason {
147 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
148 where
149 D: Deserializer<'de>,
150 {
151 let value = String::deserialize(deserializer)?;
152 Ok(match value.as_str() {
153 "idle" => Self::Idle,
154 "hostShutdown" => Self::HostShutdown,
155 "leave" => Self::Leave,
156 "vacated" => Self::Vacated,
157 _ => Self::Unknown(value),
158 })
159 }
160}
161
162impl RunningElsewhereOrigin {
163 #[must_use]
165 pub fn as_str(&self) -> &str {
166 match self {
167 Self::Tui => "tui",
168 Self::Exec => "exec",
169 Self::Serve => "serve",
170 Self::Unknown(value) => value,
171 }
172 }
173}
174
175impl Serialize for RunningElsewhereOrigin {
176 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
177 where
178 S: Serializer,
179 {
180 serializer.serialize_str(self.as_str())
181 }
182}
183
184impl<'de> Deserialize<'de> for RunningElsewhereOrigin {
185 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
186 where
187 D: Deserializer<'de>,
188 {
189 let value = String::deserialize(deserializer)?;
190 Ok(match value.as_str() {
191 "tui" => Self::Tui,
192 "exec" => Self::Exec,
193 "serve" => Self::Serve,
194 _ => Self::Unknown(value),
195 })
196 }
197}
198
199impl ProbeDegradedReason {
200 #[must_use]
202 pub fn as_str(&self) -> &str {
203 match self {
204 Self::SkippedUntrusted => "skippedUntrusted",
205 Self::SkippedSandboxUnavailable => "skippedSandboxUnavailable",
206 Self::ProbeFailed => "probeFailed",
207 Self::Unknown(value) => value,
208 }
209 }
210
211 #[must_use]
216 pub fn from_wire(word: &str) -> Self {
217 match word {
218 "skippedUntrusted" => Self::SkippedUntrusted,
219 "skippedSandboxUnavailable" => Self::SkippedSandboxUnavailable,
220 "probeFailed" => Self::ProbeFailed,
221 _ => Self::Unknown(word.to_owned()),
222 }
223 }
224}
225
226impl Serialize for ProbeDegradedReason {
227 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
228 where
229 S: Serializer,
230 {
231 serializer.serialize_str(self.as_str())
232 }
233}
234
235impl<'de> Deserialize<'de> for ProbeDegradedReason {
236 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
237 where
238 D: Deserializer<'de>,
239 {
240 let value = String::deserialize(deserializer)?;
241 Ok(Self::from_wire(&value))
242 }
243}