Skip to main content

muse_code_sdk/msp/method/
session_wire_words.rs

1// @generated from the MSP stable schema and protocol sources; do not edit by hand.
2
3use 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    /// The exact wire spelling, including a value from a newer host.
16    #[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    /// The exact wire spelling, including a value from a newer host.
51    #[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    /// The exact wire spelling, including a value from a newer host.
65    #[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    /// The exact wire spelling, including a value from a newer host.
125    #[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    /// The exact wire spelling, including a value from a newer host.
164    #[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    /// The exact wire spelling, including a value from a newer host.
201    #[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    /// Parse one wire word without a serde round-trip: the picker renders every
212    /// row through this instead of `serde_json::from_value`, so an unknown word
213    /// costs a match, not a parse. Total — an unknown word becomes `Unknown`,
214    /// like the `Deserialize` impl below, which delegates here.
215    #[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}