muse_code_sdk/msp/view/item_content/
catch_all.rs1use super::{
4 CompactionOutcome, CompactionTrigger, HookRunStatus, ItemKind, ItemStatus,
5 OutputRefAvailability, SubagentControlStatus,
6};
7use serde::{Deserialize, Deserializer, Serialize, Serializer};
8
9impl OutputRefAvailability {
10 pub fn as_str(&self) -> &str {
12 match self {
13 Self::Available => "available",
14 Self::Missing => "missing",
15 Self::Unsupported => "unsupported",
16 Self::AccessFailed => "accessFailed",
17 Self::Unknown(word) => word,
18 }
19 }
20}
21
22impl Serialize for OutputRefAvailability {
23 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
24 serializer.serialize_str(self.as_str())
25 }
26}
27
28impl<'de> Deserialize<'de> for OutputRefAvailability {
29 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
30 let word = String::deserialize(deserializer)?;
31 Ok(match word.as_str() {
32 "available" => Self::Available,
33 "missing" => Self::Missing,
34 "unsupported" => Self::Unsupported,
35 "accessFailed" => Self::AccessFailed,
36 _ => Self::Unknown(word),
37 })
38 }
39}
40
41impl SubagentControlStatus {
42 pub fn as_str(&self) -> &str {
44 match self {
45 Self::Accepted => "accepted",
46 Self::Starting => "starting",
47 Self::Running => "running",
48 Self::ResultReady => "resultReady",
49 Self::Closing => "closing",
50 Self::Closed => "closed",
51 Self::RecoveryPending => "recoveryPending",
52 Self::ManualReconciliation => "manualReconciliation",
53 Self::Unknown(word) => word,
54 }
55 }
56}
57
58impl Serialize for SubagentControlStatus {
59 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
60 serializer.serialize_str(self.as_str())
61 }
62}
63
64impl<'de> Deserialize<'de> for SubagentControlStatus {
65 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
66 let word = String::deserialize(deserializer)?;
67 Ok(match word.as_str() {
68 "accepted" => Self::Accepted,
69 "starting" => Self::Starting,
70 "running" => Self::Running,
71 "resultReady" => Self::ResultReady,
72 "closing" => Self::Closing,
73 "closed" => Self::Closed,
74 "recoveryPending" => Self::RecoveryPending,
75 "manualReconciliation" => Self::ManualReconciliation,
76 _ => Self::Unknown(word),
77 })
78 }
79}
80
81impl CompactionOutcome {
82 pub fn as_str(&self) -> &str {
84 match self {
85 Self::Compacted => "compacted",
86 Self::Noop => "noop",
87 Self::Failed => "failed",
88 Self::Cancelled => "cancelled",
89 Self::Unknown(word) => word,
90 }
91 }
92}
93
94impl Serialize for CompactionOutcome {
95 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
96 serializer.serialize_str(self.as_str())
97 }
98}
99
100impl<'de> Deserialize<'de> for CompactionOutcome {
101 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
102 let word = String::deserialize(deserializer)?;
103 Ok(match word.as_str() {
104 "compacted" => Self::Compacted,
105 "noop" => Self::Noop,
106 "failed" => Self::Failed,
107 "cancelled" => Self::Cancelled,
108 _ => Self::Unknown(word),
109 })
110 }
111}
112
113impl CompactionTrigger {
114 pub fn as_str(&self) -> &str {
116 match self {
117 Self::Manual => "manual",
118 Self::Auto => "auto",
119 Self::Unknown(word) => word,
120 }
121 }
122}
123
124impl Serialize for CompactionTrigger {
125 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
126 serializer.serialize_str(self.as_str())
127 }
128}
129
130impl<'de> Deserialize<'de> for CompactionTrigger {
131 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
132 let word = String::deserialize(deserializer)?;
133 Ok(match word.as_str() {
134 "manual" => Self::Manual,
135 "auto" => Self::Auto,
136 _ => Self::Unknown(word),
137 })
138 }
139}
140
141impl ItemKind {
142 pub fn as_str(&self) -> &str {
144 match self {
145 Self::UserMessage => "userMessage",
146 Self::AgentMessage => "agentMessage",
147 Self::Reasoning => "reasoning",
148 Self::ToolCall => "toolCall",
149 Self::UserShell => "userShell",
150 Self::Subagent => "subagent",
151 Self::Workflow => "workflow",
152 Self::ReminderChild => "reminderChild",
153 Self::Compaction => "compaction",
154 Self::HookRun => "hookRun",
155 Self::SideChat => "sideChat",
156 Self::SkillRead => "skillRead",
157 Self::WebSearch => "webSearch",
158 Self::MonitorFeed => "monitorFeed",
159 Self::DamagedRange => "damagedRange",
160 Self::ScheduledFire => "scheduledFire",
161 Self::BackgroundTerminalCompletion => "backgroundTerminalCompletion",
162 Self::OverdueNotice => "overdueNotice",
163 Self::Unknown(word) => word,
164 }
165 }
166}
167
168impl Serialize for ItemKind {
169 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
170 serializer.serialize_str(self.as_str())
171 }
172}
173
174impl<'de> Deserialize<'de> for ItemKind {
175 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
176 let word = String::deserialize(deserializer)?;
177 Ok(match word.as_str() {
178 "userMessage" => Self::UserMessage,
179 "agentMessage" => Self::AgentMessage,
180 "reasoning" => Self::Reasoning,
181 "toolCall" => Self::ToolCall,
182 "userShell" => Self::UserShell,
183 "subagent" => Self::Subagent,
184 "workflow" => Self::Workflow,
185 "reminderChild" => Self::ReminderChild,
186 "compaction" => Self::Compaction,
187 "hookRun" => Self::HookRun,
188 "sideChat" => Self::SideChat,
189 "skillRead" => Self::SkillRead,
190 "webSearch" => Self::WebSearch,
191 "monitorFeed" => Self::MonitorFeed,
192 "damagedRange" => Self::DamagedRange,
193 "scheduledFire" => Self::ScheduledFire,
194 "backgroundTerminalCompletion" => Self::BackgroundTerminalCompletion,
195 "overdueNotice" => Self::OverdueNotice,
196 _ => Self::Unknown(word),
197 })
198 }
199}
200
201impl ItemStatus {
202 pub fn as_str(&self) -> &str {
204 match self {
205 Self::InProgress => "inProgress",
206 Self::Completed => "completed",
207 Self::Failed => "failed",
208 Self::Cancelled => "cancelled",
209 Self::Rejected => "rejected",
210 Self::TimedOut => "timedOut",
211 Self::Unknown(word) => word,
212 }
213 }
214}
215
216impl Serialize for ItemStatus {
217 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
218 serializer.serialize_str(self.as_str())
219 }
220}
221
222impl<'de> Deserialize<'de> for ItemStatus {
223 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
224 let word = String::deserialize(deserializer)?;
225 Ok(match word.as_str() {
226 "inProgress" => Self::InProgress,
227 "completed" => Self::Completed,
228 "failed" => Self::Failed,
229 "cancelled" => Self::Cancelled,
230 "rejected" => Self::Rejected,
231 "timedOut" => Self::TimedOut,
232 _ => Self::Unknown(word),
233 })
234 }
235}
236
237impl HookRunStatus {
238 pub fn as_str(&self) -> &str {
240 match self {
241 Self::Completed => "completed",
242 Self::Blocked => "blocked",
243 Self::Failed => "failed",
244 Self::TimedOut => "timedOut",
245 Self::Cancelled => "cancelled",
246 Self::Unknown(word) => word,
247 }
248 }
249}
250
251impl Serialize for HookRunStatus {
252 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
253 serializer.serialize_str(self.as_str())
254 }
255}
256
257impl<'de> Deserialize<'de> for HookRunStatus {
258 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
259 let word = String::deserialize(deserializer)?;
260 Ok(match word.as_str() {
261 "completed" => Self::Completed,
262 "blocked" => Self::Blocked,
263 "failed" => Self::Failed,
264 "timedOut" => Self::TimedOut,
265 "cancelled" => Self::Cancelled,
266 _ => Self::Unknown(word),
267 })
268 }
269}