muse_code_sdk/msp/method/
session_wire_words.rs1use super::session::RunningElsewhereOrigin;
4use super::session::SessionKind;
5use super::session_events::SessionClosedReason;
6use super::session_events::SessionStatus;
7use serde::Deserialize;
8use serde::Deserializer;
9use serde::Serialize;
10use serde::Serializer;
11
12impl SessionKind {
13 #[must_use]
15 pub fn as_str(&self) -> &str {
16 match self {
17 Self::Root => "root",
18 Self::Subagent => "subagent",
19 Self::Unknown(value) => value,
20 }
21 }
22}
23
24impl Serialize for SessionKind {
25 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
26 where
27 S: Serializer,
28 {
29 serializer.serialize_str(self.as_str())
30 }
31}
32
33impl<'de> Deserialize<'de> for SessionKind {
34 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
35 where
36 D: Deserializer<'de>,
37 {
38 let value = String::deserialize(deserializer)?;
39 Ok(match value.as_str() {
40 "root" => Self::Root,
41 "subagent" => Self::Subagent,
42 _ => Self::Unknown(value),
43 })
44 }
45}
46
47impl SessionStatus {
48 #[must_use]
50 pub fn as_str(&self) -> &str {
51 match self {
52 Self::NotLoaded => "notLoaded",
53 Self::Idle => "idle",
54 Self::Running => "running",
55 Self::Unknown(value) => value,
56 }
57 }
58}
59
60impl Serialize for SessionStatus {
61 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
62 where
63 S: Serializer,
64 {
65 serializer.serialize_str(self.as_str())
66 }
67}
68
69impl<'de> Deserialize<'de> for SessionStatus {
70 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
71 where
72 D: Deserializer<'de>,
73 {
74 let value = String::deserialize(deserializer)?;
75 Ok(match value.as_str() {
76 "notLoaded" => Self::NotLoaded,
77 "idle" => Self::Idle,
78 "running" => Self::Running,
79 _ => Self::Unknown(value),
80 })
81 }
82}
83
84impl SessionClosedReason {
85 #[must_use]
87 pub fn as_str(&self) -> &str {
88 match self {
89 Self::Idle => "idle",
90 Self::HostShutdown => "hostShutdown",
91 Self::Leave => "leave",
92 Self::Vacated => "vacated",
93 Self::Unknown(value) => value,
94 }
95 }
96}
97
98impl Serialize for SessionClosedReason {
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 SessionClosedReason {
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 "idle" => Self::Idle,
115 "hostShutdown" => Self::HostShutdown,
116 "leave" => Self::Leave,
117 "vacated" => Self::Vacated,
118 _ => Self::Unknown(value),
119 })
120 }
121}
122
123impl RunningElsewhereOrigin {
124 #[must_use]
126 pub fn as_str(&self) -> &str {
127 match self {
128 Self::Tui => "tui",
129 Self::Exec => "exec",
130 Self::Serve => "serve",
131 Self::Unknown(value) => value,
132 }
133 }
134}
135
136impl Serialize for RunningElsewhereOrigin {
137 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
138 where
139 S: Serializer,
140 {
141 serializer.serialize_str(self.as_str())
142 }
143}
144
145impl<'de> Deserialize<'de> for RunningElsewhereOrigin {
146 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
147 where
148 D: Deserializer<'de>,
149 {
150 let value = String::deserialize(deserializer)?;
151 Ok(match value.as_str() {
152 "tui" => Self::Tui,
153 "exec" => Self::Exec,
154 "serve" => Self::Serve,
155 _ => Self::Unknown(value),
156 })
157 }
158}