1use serde::{Deserialize, Deserializer, Serialize, Serializer};
2use serde_json::Value;
3use std::fmt;
4use uuid::Uuid;
5
6use super::claude_output::ClaudeOutput;
7use super::content_blocks::{deserialize_content_blocks, ContentBlock};
8use super::rate_limit::RateLimitInfo;
9
10#[derive(Debug, Clone, PartialEq, Eq, Hash)]
16pub enum SystemSubtype {
17 Init,
18 Status,
19 CompactBoundary,
20 ThinkingTokens,
21 TaskStarted,
22 TaskProgress,
23 TaskUpdated,
24 TaskNotification,
25 ApiRetry,
26 ControlRequestProgress,
27 ModelRefusalFallback,
28 ModelRefusalNoFallback,
29 LocalCommandOutput,
30 HookStarted,
31 HookProgress,
32 HookResponse,
33 PluginInstall,
34 BackgroundTasksChanged,
35 SessionStateChanged,
36 WorkerShuttingDown,
37 CommandsChanged,
38 Notification,
39 FilesPersisted,
40 MemoryRecall,
41 ElicitationComplete,
42 PermissionDenied,
43 MirrorError,
44 Informational,
45 CodeChangePublished,
46 VcsStateChanged,
47 FeedbackDraftQueued,
48 CloudSessionDelta,
49 DevIntent,
50 TurnHandoffAvailable,
51 TurnPreempted,
52 PeerMessageHold,
53 PerTurnEffortChanged,
54 SessionTitleChanged,
55 SessionWritesLost,
56 InstructionSizeWarning,
57 FileAttachmentsMissing,
58 PermissionCheckStatus,
59 InheritedAsksSettled,
60 UiFocus,
61 UiInvalidate,
62 UiLog,
63 UiNotify,
64 UiNotifyCancel,
65 UiPanes,
66 UiPlaced,
67 UiScroll,
68 UiStatus,
69 UiToast,
70 Unknown(String),
72}
73
74impl SystemSubtype {
75 pub fn as_str(&self) -> &str {
76 match self {
77 Self::Init => "init",
78 Self::Status => "status",
79 Self::CompactBoundary => "compact_boundary",
80 Self::ThinkingTokens => "thinking_tokens",
81 Self::TaskStarted => "task_started",
82 Self::TaskProgress => "task_progress",
83 Self::TaskUpdated => "task_updated",
84 Self::TaskNotification => "task_notification",
85 Self::ApiRetry => "api_retry",
86 Self::ControlRequestProgress => "control_request_progress",
87 Self::ModelRefusalFallback => "model_refusal_fallback",
88 Self::ModelRefusalNoFallback => "model_refusal_no_fallback",
89 Self::LocalCommandOutput => "local_command_output",
90 Self::HookStarted => "hook_started",
91 Self::HookProgress => "hook_progress",
92 Self::HookResponse => "hook_response",
93 Self::PluginInstall => "plugin_install",
94 Self::BackgroundTasksChanged => "background_tasks_changed",
95 Self::SessionStateChanged => "session_state_changed",
96 Self::WorkerShuttingDown => "worker_shutting_down",
97 Self::CommandsChanged => "commands_changed",
98 Self::Notification => "notification",
99 Self::FilesPersisted => "files_persisted",
100 Self::MemoryRecall => "memory_recall",
101 Self::ElicitationComplete => "elicitation_complete",
102 Self::PermissionDenied => "permission_denied",
103 Self::MirrorError => "mirror_error",
104 Self::Informational => "informational",
105 Self::CodeChangePublished => "code_change_published",
106 Self::VcsStateChanged => "vcs_state_changed",
107 Self::FeedbackDraftQueued => "feedback_draft_queued",
108 Self::CloudSessionDelta => "cloud_session_delta",
109 Self::DevIntent => "dev_intent",
110 Self::TurnHandoffAvailable => "turn_handoff_available",
111 Self::TurnPreempted => "turn_preempted",
112 Self::PeerMessageHold => "peer_message_hold",
113 Self::PerTurnEffortChanged => "per_turn_effort_changed",
114 Self::SessionTitleChanged => "session_title_changed",
115 Self::SessionWritesLost => "session_writes_lost",
116 Self::InstructionSizeWarning => "instruction_size_warning",
117 Self::FileAttachmentsMissing => "file_attachments_missing",
118 Self::PermissionCheckStatus => "permission_check_status",
119 Self::InheritedAsksSettled => "inherited_asks_settled",
120 Self::UiFocus => "ui_focus",
121 Self::UiInvalidate => "ui_invalidate",
122 Self::UiLog => "ui_log",
123 Self::UiNotify => "ui_notify",
124 Self::UiNotifyCancel => "ui_notify_cancel",
125 Self::UiPanes => "ui_panes",
126 Self::UiPlaced => "ui_placed",
127 Self::UiScroll => "ui_scroll",
128 Self::UiStatus => "ui_status",
129 Self::UiToast => "ui_toast",
130 Self::Unknown(s) => s.as_str(),
131 }
132 }
133}
134
135impl fmt::Display for SystemSubtype {
136 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
137 f.write_str(self.as_str())
138 }
139}
140
141impl From<&str> for SystemSubtype {
142 fn from(s: &str) -> Self {
143 match s {
144 "init" => Self::Init,
145 "status" => Self::Status,
146 "compact_boundary" => Self::CompactBoundary,
147 "thinking_tokens" => Self::ThinkingTokens,
148 "task_started" => Self::TaskStarted,
149 "task_progress" => Self::TaskProgress,
150 "task_updated" => Self::TaskUpdated,
151 "task_notification" => Self::TaskNotification,
152 "api_retry" => Self::ApiRetry,
153 "control_request_progress" => Self::ControlRequestProgress,
154 "model_refusal_fallback" => Self::ModelRefusalFallback,
155 "model_refusal_no_fallback" => Self::ModelRefusalNoFallback,
156 "local_command_output" => Self::LocalCommandOutput,
157 "hook_started" => Self::HookStarted,
158 "hook_progress" => Self::HookProgress,
159 "hook_response" => Self::HookResponse,
160 "plugin_install" => Self::PluginInstall,
161 "background_tasks_changed" => Self::BackgroundTasksChanged,
162 "session_state_changed" => Self::SessionStateChanged,
163 "worker_shutting_down" => Self::WorkerShuttingDown,
164 "commands_changed" => Self::CommandsChanged,
165 "notification" => Self::Notification,
166 "files_persisted" => Self::FilesPersisted,
167 "memory_recall" => Self::MemoryRecall,
168 "elicitation_complete" => Self::ElicitationComplete,
169 "permission_denied" => Self::PermissionDenied,
170 "mirror_error" => Self::MirrorError,
171 "informational" => Self::Informational,
172 "code_change_published" => Self::CodeChangePublished,
173 "vcs_state_changed" => Self::VcsStateChanged,
174 "feedback_draft_queued" => Self::FeedbackDraftQueued,
175 "cloud_session_delta" => Self::CloudSessionDelta,
176 "dev_intent" => Self::DevIntent,
177 "turn_handoff_available" => Self::TurnHandoffAvailable,
178 "turn_preempted" => Self::TurnPreempted,
179 "peer_message_hold" => Self::PeerMessageHold,
180 "per_turn_effort_changed" => Self::PerTurnEffortChanged,
181 "session_title_changed" => Self::SessionTitleChanged,
182 "session_writes_lost" => Self::SessionWritesLost,
183 "instruction_size_warning" => Self::InstructionSizeWarning,
184 "file_attachments_missing" => Self::FileAttachmentsMissing,
185 "permission_check_status" => Self::PermissionCheckStatus,
186 "inherited_asks_settled" => Self::InheritedAsksSettled,
187 "ui_focus" => Self::UiFocus,
188 "ui_invalidate" => Self::UiInvalidate,
189 "ui_log" => Self::UiLog,
190 "ui_notify" => Self::UiNotify,
191 "ui_notify_cancel" => Self::UiNotifyCancel,
192 "ui_panes" => Self::UiPanes,
193 "ui_placed" => Self::UiPlaced,
194 "ui_scroll" => Self::UiScroll,
195 "ui_status" => Self::UiStatus,
196 "ui_toast" => Self::UiToast,
197 other => Self::Unknown(other.to_string()),
198 }
199 }
200}
201
202impl Serialize for SystemSubtype {
203 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
204 serializer.serialize_str(self.as_str())
205 }
206}
207
208impl<'de> Deserialize<'de> for SystemSubtype {
209 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
210 let s = String::deserialize(deserializer)?;
211 Ok(Self::from(s.as_str()))
212 }
213}
214
215#[derive(Debug, Clone, PartialEq, Eq, Hash)]
220pub enum MessageRole {
221 User,
222 Assistant,
223 Unknown(String),
225}
226
227impl MessageRole {
228 pub fn as_str(&self) -> &str {
229 match self {
230 Self::User => "user",
231 Self::Assistant => "assistant",
232 Self::Unknown(s) => s.as_str(),
233 }
234 }
235}
236
237impl fmt::Display for MessageRole {
238 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
239 f.write_str(self.as_str())
240 }
241}
242
243impl From<&str> for MessageRole {
244 fn from(s: &str) -> Self {
245 match s {
246 "user" => Self::User,
247 "assistant" => Self::Assistant,
248 other => Self::Unknown(other.to_string()),
249 }
250 }
251}
252
253impl Serialize for MessageRole {
254 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
255 serializer.serialize_str(self.as_str())
256 }
257}
258
259impl<'de> Deserialize<'de> for MessageRole {
260 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
261 let s = String::deserialize(deserializer)?;
262 Ok(Self::from(s.as_str()))
263 }
264}
265
266#[derive(Debug, Clone, PartialEq, Eq, Hash)]
268pub enum CompactionTrigger {
269 Auto,
271 Manual,
273 Unknown(String),
275}
276
277impl CompactionTrigger {
278 pub fn as_str(&self) -> &str {
279 match self {
280 Self::Auto => "auto",
281 Self::Manual => "manual",
282 Self::Unknown(s) => s.as_str(),
283 }
284 }
285}
286
287impl fmt::Display for CompactionTrigger {
288 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
289 f.write_str(self.as_str())
290 }
291}
292
293impl From<&str> for CompactionTrigger {
294 fn from(s: &str) -> Self {
295 match s {
296 "auto" => Self::Auto,
297 "manual" => Self::Manual,
298 other => Self::Unknown(other.to_string()),
299 }
300 }
301}
302
303impl Serialize for CompactionTrigger {
304 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
305 serializer.serialize_str(self.as_str())
306 }
307}
308
309impl<'de> Deserialize<'de> for CompactionTrigger {
310 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
311 let s = String::deserialize(deserializer)?;
312 Ok(Self::from(s.as_str()))
313 }
314}
315
316#[derive(Debug, Clone, PartialEq, Eq, Hash)]
318pub enum StopReason {
319 EndTurn,
321 MaxTokens,
323 ToolUse,
325 Unknown(String),
327}
328
329impl StopReason {
330 pub fn as_str(&self) -> &str {
331 match self {
332 Self::EndTurn => "end_turn",
333 Self::MaxTokens => "max_tokens",
334 Self::ToolUse => "tool_use",
335 Self::Unknown(s) => s.as_str(),
336 }
337 }
338}
339
340impl fmt::Display for StopReason {
341 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
342 f.write_str(self.as_str())
343 }
344}
345
346impl From<&str> for StopReason {
347 fn from(s: &str) -> Self {
348 match s {
349 "end_turn" => Self::EndTurn,
350 "max_tokens" => Self::MaxTokens,
351 "tool_use" => Self::ToolUse,
352 other => Self::Unknown(other.to_string()),
353 }
354 }
355}
356
357impl Serialize for StopReason {
358 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
359 serializer.serialize_str(self.as_str())
360 }
361}
362
363impl<'de> Deserialize<'de> for StopReason {
364 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
365 let s = String::deserialize(deserializer)?;
366 Ok(Self::from(s.as_str()))
367 }
368}
369
370#[derive(Debug, Clone, PartialEq, Eq, Hash)]
372pub enum ApiKeySource {
373 None,
375 User,
376 Project,
377 Org,
378 Temporary,
379 Oauth,
380 Unknown(String),
382}
383
384impl ApiKeySource {
385 pub fn as_str(&self) -> &str {
386 match self {
387 Self::None => "none",
388 Self::User => "user",
389 Self::Project => "project",
390 Self::Org => "org",
391 Self::Temporary => "temporary",
392 Self::Oauth => "oauth",
393 Self::Unknown(s) => s.as_str(),
394 }
395 }
396}
397
398impl fmt::Display for ApiKeySource {
399 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
400 f.write_str(self.as_str())
401 }
402}
403
404impl From<&str> for ApiKeySource {
405 fn from(s: &str) -> Self {
406 match s {
407 "none" => Self::None,
408 "user" => Self::User,
409 "project" => Self::Project,
410 "org" => Self::Org,
411 "temporary" => Self::Temporary,
412 "oauth" => Self::Oauth,
413 other => Self::Unknown(other.to_string()),
414 }
415 }
416}
417
418impl Serialize for ApiKeySource {
419 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
420 serializer.serialize_str(self.as_str())
421 }
422}
423
424impl<'de> Deserialize<'de> for ApiKeySource {
425 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
426 let s = String::deserialize(deserializer)?;
427 Ok(Self::from(s.as_str()))
428 }
429}
430
431#[derive(Debug, Clone, PartialEq, Eq, Hash)]
433pub enum OutputStyle {
434 Default,
436 Unknown(String),
438}
439
440impl OutputStyle {
441 pub fn as_str(&self) -> &str {
442 match self {
443 Self::Default => "default",
444 Self::Unknown(s) => s.as_str(),
445 }
446 }
447}
448
449impl fmt::Display for OutputStyle {
450 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
451 f.write_str(self.as_str())
452 }
453}
454
455impl From<&str> for OutputStyle {
456 fn from(s: &str) -> Self {
457 match s {
458 "default" => Self::Default,
459 other => Self::Unknown(other.to_string()),
460 }
461 }
462}
463
464impl Serialize for OutputStyle {
465 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
466 serializer.serialize_str(self.as_str())
467 }
468}
469
470impl<'de> Deserialize<'de> for OutputStyle {
471 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
472 let s = String::deserialize(deserializer)?;
473 Ok(Self::from(s.as_str()))
474 }
475}
476
477#[derive(Debug, Clone, PartialEq, Eq, Hash)]
479pub enum InitPermissionMode {
480 Default,
482 AcceptEdits,
483 BypassPermissions,
484 Plan,
485 DontAsk,
486 Auto,
487 Unknown(String),
489}
490
491impl InitPermissionMode {
492 pub fn as_str(&self) -> &str {
493 match self {
494 Self::Default => "default",
495 Self::AcceptEdits => "acceptEdits",
496 Self::BypassPermissions => "bypassPermissions",
497 Self::Plan => "plan",
498 Self::DontAsk => "dontAsk",
499 Self::Auto => "auto",
500 Self::Unknown(s) => s.as_str(),
501 }
502 }
503}
504
505impl fmt::Display for InitPermissionMode {
506 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
507 f.write_str(self.as_str())
508 }
509}
510
511impl From<&str> for InitPermissionMode {
512 fn from(s: &str) -> Self {
513 match s {
514 "default" => Self::Default,
515 "acceptEdits" => Self::AcceptEdits,
516 "bypassPermissions" => Self::BypassPermissions,
517 "plan" => Self::Plan,
518 "dontAsk" => Self::DontAsk,
519 "auto" => Self::Auto,
520 other => Self::Unknown(other.to_string()),
521 }
522 }
523}
524
525impl Serialize for InitPermissionMode {
526 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
527 serializer.serialize_str(self.as_str())
528 }
529}
530
531impl<'de> Deserialize<'de> for InitPermissionMode {
532 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
533 let s = String::deserialize(deserializer)?;
534 Ok(Self::from(s.as_str()))
535 }
536}
537
538#[derive(Debug, Clone, PartialEq, Eq, Hash)]
540pub enum StatusMessageStatus {
541 Compacting,
543 Requesting,
545 Unknown(String),
547}
548
549impl StatusMessageStatus {
550 pub fn as_str(&self) -> &str {
551 match self {
552 Self::Compacting => "compacting",
553 Self::Requesting => "requesting",
554 Self::Unknown(s) => s.as_str(),
555 }
556 }
557}
558
559impl fmt::Display for StatusMessageStatus {
560 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
561 f.write_str(self.as_str())
562 }
563}
564
565impl From<&str> for StatusMessageStatus {
566 fn from(s: &str) -> Self {
567 match s {
568 "compacting" => Self::Compacting,
569 "requesting" => Self::Requesting,
570 other => Self::Unknown(other.to_string()),
571 }
572 }
573}
574
575impl Serialize for StatusMessageStatus {
576 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
577 serializer.serialize_str(self.as_str())
578 }
579}
580
581impl<'de> Deserialize<'de> for StatusMessageStatus {
582 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
583 let s = String::deserialize(deserializer)?;
584 Ok(Self::from(s.as_str()))
585 }
586}
587
588pub(crate) fn serialize_optional_uuid<S>(
590 uuid: &Option<Uuid>,
591 serializer: S,
592) -> Result<S::Ok, S::Error>
593where
594 S: Serializer,
595{
596 match uuid {
597 Some(id) => serializer.serialize_str(&id.to_string()),
598 None => serializer.serialize_none(),
599 }
600}
601
602pub(crate) fn deserialize_optional_uuid<'de, D>(deserializer: D) -> Result<Option<Uuid>, D::Error>
604where
605 D: Deserializer<'de>,
606{
607 let opt_str: Option<String> = Option::deserialize(deserializer)?;
608 match opt_str {
609 Some(s) => Uuid::parse_str(&s)
610 .map(Some)
611 .map_err(serde::de::Error::custom),
612 None => Ok(None),
613 }
614}
615
616#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
619pub struct MessageOrigin {
620 pub kind: String,
621 #[serde(flatten)]
622 pub extra: serde_json::Map<String, Value>,
623}
624
625#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
627pub struct SummarizeMetadata {
628 pub messages_summarized: u64,
629 #[serde(default, skip_serializing_if = "Option::is_none")]
630 pub user_context: Option<String>,
631 #[serde(default, skip_serializing_if = "Option::is_none")]
632 pub direction: Option<String>,
633}
634
635#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
637pub struct McpMeta {
638 #[serde(default, skip_serializing_if = "Option::is_none", rename = "_meta")]
639 pub meta: Option<Value>,
640 #[serde(default, skip_serializing_if = "Option::is_none")]
641 pub structured_content: Option<Value>,
642 #[serde(default, skip_serializing_if = "Vec::is_empty")]
647 pub resource_links: Vec<ResourceLink>,
648}
649
650#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
654pub struct ResourceLink {
655 pub uri: String,
656 pub name: String,
657 #[serde(default, skip_serializing_if = "Option::is_none")]
658 pub title: Option<String>,
659 #[serde(default, skip_serializing_if = "Option::is_none")]
660 pub description: Option<String>,
661 #[serde(default, skip_serializing_if = "Option::is_none", rename = "mimeType")]
662 pub mime_type: Option<String>,
663 #[serde(default, skip_serializing_if = "Option::is_none")]
664 pub size: Option<u64>,
665 #[serde(default, skip_serializing_if = "Option::is_none")]
666 pub annotations: Option<Value>,
667}
668
669#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
671pub struct ToolResultMeta {
672 pub id: String,
674 #[serde(default, skip_serializing_if = "Option::is_none")]
681 pub non_execution_kind: Option<String>,
682 #[serde(default, skip_serializing_if = "Option::is_none")]
684 pub user_feedback: Option<String>,
685 #[serde(default, skip_serializing_if = "Option::is_none")]
690 pub remedy: Option<ToolResultRemedy>,
691 #[serde(default, skip_serializing_if = "Option::is_none")]
698 pub permission_decision: Option<ToolPermissionDecision>,
699 #[serde(default, skip_serializing_if = "Option::is_none")]
706 pub built_in_tool: Option<String>,
707 #[serde(default, skip_serializing_if = "Option::is_none")]
714 pub run_input: Option<String>,
715}
716
717#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
721pub struct ToolPermissionDecision {
722 pub decision: PermissionDecisionOutcome,
724 pub source: String,
732 #[serde(default, skip_serializing_if = "Option::is_none")]
738 pub reason_type: Option<PermissionDecisionReasonType>,
739 #[serde(default, skip_serializing_if = "Option::is_none")]
745 pub auto_mode_rule: Option<AutoModeRule>,
746}
747
748#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
751pub struct AutoModeRule {
752 pub list: AutoModeRuleList,
754 pub name: String,
756}
757
758#[derive(Debug, Clone, PartialEq, Eq, Hash)]
760pub enum AutoModeRuleList {
761 Allow,
763 SoftDeny,
765 Unknown(String),
767}
768
769impl AutoModeRuleList {
770 pub fn as_str(&self) -> &str {
771 match self {
772 Self::Allow => "allow",
773 Self::SoftDeny => "soft_deny",
774 Self::Unknown(s) => s.as_str(),
775 }
776 }
777}
778
779impl fmt::Display for AutoModeRuleList {
780 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
781 f.write_str(self.as_str())
782 }
783}
784
785impl From<&str> for AutoModeRuleList {
786 fn from(s: &str) -> Self {
787 match s {
788 "allow" => Self::Allow,
789 "soft_deny" => Self::SoftDeny,
790 other => Self::Unknown(other.to_string()),
791 }
792 }
793}
794
795impl Serialize for AutoModeRuleList {
796 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
797 serializer.serialize_str(self.as_str())
798 }
799}
800
801impl<'de> Deserialize<'de> for AutoModeRuleList {
802 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
803 let s = String::deserialize(deserializer)?;
804 Ok(Self::from(s.as_str()))
805 }
806}
807
808#[derive(Debug, Clone, PartialEq, Eq, Hash)]
810pub enum PermissionDecisionOutcome {
811 Accept,
813 Reject,
815 Cancelled,
817 Unknown(String),
819}
820
821impl PermissionDecisionOutcome {
822 pub fn as_str(&self) -> &str {
823 match self {
824 Self::Accept => "accept",
825 Self::Reject => "reject",
826 Self::Cancelled => "cancelled",
827 Self::Unknown(s) => s.as_str(),
828 }
829 }
830}
831
832impl fmt::Display for PermissionDecisionOutcome {
833 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
834 f.write_str(self.as_str())
835 }
836}
837
838impl From<&str> for PermissionDecisionOutcome {
839 fn from(s: &str) -> Self {
840 match s {
841 "accept" => Self::Accept,
842 "reject" => Self::Reject,
843 "cancelled" => Self::Cancelled,
844 other => Self::Unknown(other.to_string()),
845 }
846 }
847}
848
849impl Serialize for PermissionDecisionOutcome {
850 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
851 serializer.serialize_str(self.as_str())
852 }
853}
854
855impl<'de> Deserialize<'de> for PermissionDecisionOutcome {
856 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
857 let s = String::deserialize(deserializer)?;
858 Ok(Self::from(s.as_str()))
859 }
860}
861
862#[derive(Debug, Clone, PartialEq, Eq, Hash)]
865pub enum PermissionDecisionReasonType {
866 Rule,
868 Mode,
870 SubcommandResults,
872 PermissionPromptTool,
874 Hook,
876 AsyncAgent,
878 SandboxOverride,
880 WorkingDir,
882 SafetyCheck,
884 Classifier,
886 Other,
888 Unknown(String),
890}
891
892impl PermissionDecisionReasonType {
893 pub fn as_str(&self) -> &str {
894 match self {
895 Self::Rule => "rule",
896 Self::Mode => "mode",
897 Self::SubcommandResults => "subcommandResults",
898 Self::PermissionPromptTool => "permissionPromptTool",
899 Self::Hook => "hook",
900 Self::AsyncAgent => "asyncAgent",
901 Self::SandboxOverride => "sandboxOverride",
902 Self::WorkingDir => "workingDir",
903 Self::SafetyCheck => "safetyCheck",
904 Self::Classifier => "classifier",
905 Self::Other => "other",
906 Self::Unknown(s) => s.as_str(),
907 }
908 }
909}
910
911impl fmt::Display for PermissionDecisionReasonType {
912 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
913 f.write_str(self.as_str())
914 }
915}
916
917impl From<&str> for PermissionDecisionReasonType {
918 fn from(s: &str) -> Self {
919 match s {
920 "rule" => Self::Rule,
921 "mode" => Self::Mode,
922 "subcommandResults" => Self::SubcommandResults,
923 "permissionPromptTool" => Self::PermissionPromptTool,
924 "hook" => Self::Hook,
925 "asyncAgent" => Self::AsyncAgent,
926 "sandboxOverride" => Self::SandboxOverride,
927 "workingDir" => Self::WorkingDir,
928 "safetyCheck" => Self::SafetyCheck,
929 "classifier" => Self::Classifier,
930 "other" => Self::Other,
931 other => Self::Unknown(other.to_string()),
932 }
933 }
934}
935
936impl Serialize for PermissionDecisionReasonType {
937 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
938 serializer.serialize_str(self.as_str())
939 }
940}
941
942impl<'de> Deserialize<'de> for PermissionDecisionReasonType {
943 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
944 let s = String::deserialize(deserializer)?;
945 Ok(Self::from(s.as_str()))
946 }
947}
948
949#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
954pub struct ToolResultRemedy {
955 pub kind: ToolResultRemedyKind,
958 #[serde(default, skip_serializing_if = "Option::is_none")]
962 pub servers: Option<Vec<String>>,
963 #[serde(default, skip_serializing_if = "Option::is_none")]
966 pub provider: Option<RemedyLoginProvider>,
967 #[serde(default, skip_serializing_if = "Option::is_none")]
971 pub path: Option<String>,
972 #[serde(default, skip_serializing_if = "Option::is_none")]
977 pub managed: Option<bool>,
978 #[serde(default, skip_serializing_if = "Option::is_none")]
980 pub feature: Option<RemedyFeature>,
981 #[serde(default, skip_serializing_if = "Option::is_none")]
983 pub cause: Option<RemedyFeatureCause>,
984 #[serde(default, skip_serializing_if = "Option::is_none")]
986 pub policy_kind: Option<RemedyPolicyKind>,
987}
988
989#[derive(Debug, Clone, PartialEq, Eq, Hash)]
991pub enum ToolResultRemedyKind {
992 McpNeedsAuth,
994 McpDisabled,
996 McpRequiredMissing,
998 AuthExpired,
1000 AuthOverridden,
1002 AuthMissingScope,
1004 DesignNeedsAuthorization,
1006 SandboxViolation,
1008 OutsideReadsBlocked,
1010 MemoryPaused,
1012 FeatureDisabled,
1014 PolicyDenied,
1017 SpawnArgLimit,
1019 StagedForReview,
1021 Unknown(String),
1023}
1024
1025impl ToolResultRemedyKind {
1026 pub fn as_str(&self) -> &str {
1027 match self {
1028 Self::McpNeedsAuth => "mcp_needs_auth",
1029 Self::McpDisabled => "mcp_disabled",
1030 Self::McpRequiredMissing => "mcp_required_missing",
1031 Self::AuthExpired => "auth_expired",
1032 Self::AuthOverridden => "auth_overridden",
1033 Self::AuthMissingScope => "auth_missing_scope",
1034 Self::DesignNeedsAuthorization => "design_needs_authorization",
1035 Self::SandboxViolation => "sandbox_violation",
1036 Self::OutsideReadsBlocked => "outside_reads_blocked",
1037 Self::MemoryPaused => "memory_paused",
1038 Self::FeatureDisabled => "feature_disabled",
1039 Self::PolicyDenied => "policy_denied",
1040 Self::SpawnArgLimit => "spawn_arg_limit",
1041 Self::StagedForReview => "staged_for_review",
1042 Self::Unknown(s) => s.as_str(),
1043 }
1044 }
1045}
1046
1047impl fmt::Display for ToolResultRemedyKind {
1048 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1049 f.write_str(self.as_str())
1050 }
1051}
1052
1053impl From<&str> for ToolResultRemedyKind {
1054 fn from(s: &str) -> Self {
1055 match s {
1056 "mcp_needs_auth" => Self::McpNeedsAuth,
1057 "mcp_disabled" => Self::McpDisabled,
1058 "mcp_required_missing" => Self::McpRequiredMissing,
1059 "auth_expired" => Self::AuthExpired,
1060 "auth_overridden" => Self::AuthOverridden,
1061 "auth_missing_scope" => Self::AuthMissingScope,
1062 "design_needs_authorization" => Self::DesignNeedsAuthorization,
1063 "sandbox_violation" => Self::SandboxViolation,
1064 "outside_reads_blocked" => Self::OutsideReadsBlocked,
1065 "memory_paused" => Self::MemoryPaused,
1066 "feature_disabled" => Self::FeatureDisabled,
1067 "policy_denied" => Self::PolicyDenied,
1068 "spawn_arg_limit" => Self::SpawnArgLimit,
1069 "staged_for_review" => Self::StagedForReview,
1070 other => Self::Unknown(other.to_string()),
1071 }
1072 }
1073}
1074
1075impl Serialize for ToolResultRemedyKind {
1076 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
1077 serializer.serialize_str(self.as_str())
1078 }
1079}
1080
1081impl<'de> Deserialize<'de> for ToolResultRemedyKind {
1082 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1083 let s = String::deserialize(deserializer)?;
1084 Ok(Self::from(s.as_str()))
1085 }
1086}
1087
1088#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1090pub enum RemedyLoginProvider {
1091 ClaudeAi,
1093 ClaudeDesign,
1095 Unknown(String),
1097}
1098
1099impl RemedyLoginProvider {
1100 pub fn as_str(&self) -> &str {
1101 match self {
1102 Self::ClaudeAi => "claude_ai",
1103 Self::ClaudeDesign => "claude_design",
1104 Self::Unknown(s) => s.as_str(),
1105 }
1106 }
1107}
1108
1109impl fmt::Display for RemedyLoginProvider {
1110 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1111 f.write_str(self.as_str())
1112 }
1113}
1114
1115impl From<&str> for RemedyLoginProvider {
1116 fn from(s: &str) -> Self {
1117 match s {
1118 "claude_ai" => Self::ClaudeAi,
1119 "claude_design" => Self::ClaudeDesign,
1120 other => Self::Unknown(other.to_string()),
1121 }
1122 }
1123}
1124
1125impl Serialize for RemedyLoginProvider {
1126 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
1127 serializer.serialize_str(self.as_str())
1128 }
1129}
1130
1131impl<'de> Deserialize<'de> for RemedyLoginProvider {
1132 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1133 let s = String::deserialize(deserializer)?;
1134 Ok(Self::from(s.as_str()))
1135 }
1136}
1137
1138#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1141pub enum RemedyFeature {
1142 Workflows,
1143 Artifacts,
1144 Unknown(String),
1146}
1147
1148impl RemedyFeature {
1149 pub fn as_str(&self) -> &str {
1150 match self {
1151 Self::Workflows => "workflows",
1152 Self::Artifacts => "artifacts",
1153 Self::Unknown(s) => s.as_str(),
1154 }
1155 }
1156}
1157
1158impl fmt::Display for RemedyFeature {
1159 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1160 f.write_str(self.as_str())
1161 }
1162}
1163
1164impl From<&str> for RemedyFeature {
1165 fn from(s: &str) -> Self {
1166 match s {
1167 "workflows" => Self::Workflows,
1168 "artifacts" => Self::Artifacts,
1169 other => Self::Unknown(other.to_string()),
1170 }
1171 }
1172}
1173
1174impl Serialize for RemedyFeature {
1175 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
1176 serializer.serialize_str(self.as_str())
1177 }
1178}
1179
1180impl<'de> Deserialize<'de> for RemedyFeature {
1181 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1182 let s = String::deserialize(deserializer)?;
1183 Ok(Self::from(s.as_str()))
1184 }
1185}
1186
1187#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1190pub enum RemedyFeatureCause {
1191 ManagedSettings,
1194 OrgPolicy,
1196 Unavailable,
1198 UserSetting,
1201 UnsupportedRuntime,
1205 Unknown(String),
1207}
1208
1209impl RemedyFeatureCause {
1210 pub fn as_str(&self) -> &str {
1211 match self {
1212 Self::ManagedSettings => "managed_settings",
1213 Self::OrgPolicy => "org_policy",
1214 Self::Unavailable => "unavailable",
1215 Self::UserSetting => "user_setting",
1216 Self::UnsupportedRuntime => "unsupported_runtime",
1217 Self::Unknown(s) => s.as_str(),
1218 }
1219 }
1220}
1221
1222impl fmt::Display for RemedyFeatureCause {
1223 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1224 f.write_str(self.as_str())
1225 }
1226}
1227
1228impl From<&str> for RemedyFeatureCause {
1229 fn from(s: &str) -> Self {
1230 match s {
1231 "managed_settings" => Self::ManagedSettings,
1232 "org_policy" => Self::OrgPolicy,
1233 "unavailable" => Self::Unavailable,
1234 "user_setting" => Self::UserSetting,
1235 "unsupported_runtime" => Self::UnsupportedRuntime,
1236 other => Self::Unknown(other.to_string()),
1237 }
1238 }
1239}
1240
1241impl Serialize for RemedyFeatureCause {
1242 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
1243 serializer.serialize_str(self.as_str())
1244 }
1245}
1246
1247impl<'de> Deserialize<'de> for RemedyFeatureCause {
1248 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1249 let s = String::deserialize(deserializer)?;
1250 Ok(Self::from(s.as_str()))
1251 }
1252}
1253
1254#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1257pub enum RemedyPolicyKind {
1258 OrgDenied,
1260 Latched,
1263 Unknown(String),
1265}
1266
1267impl RemedyPolicyKind {
1268 pub fn as_str(&self) -> &str {
1269 match self {
1270 Self::OrgDenied => "org_denied",
1271 Self::Latched => "latched",
1272 Self::Unknown(s) => s.as_str(),
1273 }
1274 }
1275}
1276
1277impl fmt::Display for RemedyPolicyKind {
1278 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1279 f.write_str(self.as_str())
1280 }
1281}
1282
1283impl From<&str> for RemedyPolicyKind {
1284 fn from(s: &str) -> Self {
1285 match s {
1286 "org_denied" => Self::OrgDenied,
1287 "latched" => Self::Latched,
1288 other => Self::Unknown(other.to_string()),
1289 }
1290 }
1291}
1292
1293impl Serialize for RemedyPolicyKind {
1294 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
1295 serializer.serialize_str(self.as_str())
1296 }
1297}
1298
1299impl<'de> Deserialize<'de> for RemedyPolicyKind {
1300 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
1301 let s = String::deserialize(deserializer)?;
1302 Ok(Self::from(s.as_str()))
1303 }
1304}
1305
1306#[derive(Debug, Clone, Serialize, Deserialize)]
1308pub struct UserMessage {
1309 pub message: MessageContent,
1310 #[serde(skip_serializing_if = "Option::is_none", alias = "sessionId")]
1311 #[serde(
1312 serialize_with = "serialize_optional_uuid",
1313 deserialize_with = "deserialize_optional_uuid"
1314 )]
1315 pub session_id: Option<Uuid>,
1316 #[serde(skip_serializing_if = "Option::is_none")]
1318 pub parent_tool_use_id: Option<String>,
1319 #[serde(skip_serializing_if = "Option::is_none")]
1321 pub uuid: Option<String>,
1322 #[serde(skip_serializing_if = "Option::is_none")]
1324 pub timestamp: Option<String>,
1325 #[serde(skip_serializing_if = "Option::is_none")]
1332 pub tool_use_result: Option<serde_json::Value>,
1333 #[serde(default, skip_serializing_if = "Option::is_none")]
1338 pub agent_id: Option<String>,
1339 #[serde(skip_serializing_if = "Option::is_none")]
1342 pub subagent_type: Option<String>,
1343 #[serde(skip_serializing_if = "Option::is_none")]
1345 pub task_description: Option<String>,
1346 #[serde(skip_serializing_if = "Option::is_none")]
1347 pub origin: Option<MessageOrigin>,
1348 #[serde(skip_serializing_if = "Option::is_none")]
1349 pub priority: Option<String>,
1350 #[serde(skip_serializing_if = "Option::is_none", rename = "isSynthetic")]
1351 pub is_synthetic: Option<bool>,
1352 #[serde(skip_serializing_if = "Option::is_none", rename = "shouldQuery")]
1353 pub should_query: Option<bool>,
1354 #[serde(default, skip_serializing_if = "Option::is_none")]
1355 pub is_meta: Option<bool>,
1356 #[serde(default, skip_serializing_if = "Option::is_none")]
1357 pub is_visible_in_transcript_only: Option<bool>,
1358 #[serde(default, skip_serializing_if = "Option::is_none")]
1359 pub is_virtual: Option<bool>,
1360 #[serde(default, skip_serializing_if = "Option::is_none")]
1361 pub is_compact_summary: Option<bool>,
1362 #[serde(skip_serializing_if = "Option::is_none")]
1363 pub summarize_metadata: Option<SummarizeMetadata>,
1364 #[serde(skip_serializing_if = "Option::is_none")]
1365 pub mcp_meta: Option<McpMeta>,
1366 #[serde(skip_serializing_if = "Option::is_none")]
1369 pub tool_result_meta: Option<Vec<ToolResultMeta>>,
1370 #[serde(skip_serializing_if = "Option::is_none")]
1371 pub source_tool_use_id: Option<String>,
1372 #[serde(skip_serializing_if = "Option::is_none")]
1373 pub source_tool_assistant_uuid: Option<String>,
1374 #[serde(skip_serializing_if = "Option::is_none")]
1375 pub image_paste_ids: Option<Vec<u64>>,
1376 #[serde(skip_serializing_if = "Option::is_none")]
1377 pub client_platform: Option<String>,
1378 #[serde(skip_serializing_if = "Option::is_none")]
1379 pub inbound_origin: Option<String>,
1380 #[serde(skip_serializing_if = "Option::is_none", rename = "isReplay")]
1381 pub is_replay: Option<bool>,
1382 #[serde(skip_serializing_if = "Option::is_none")]
1383 pub file_attachments: Option<Vec<Value>>,
1384 #[serde(default, skip_serializing_if = "Option::is_none")]
1386 pub seeded_summon: Option<bool>,
1387 #[serde(default, skip_serializing_if = "Option::is_none")]
1390 pub client_composed: Option<bool>,
1391 #[serde(default, skip_serializing_if = "Option::is_none")]
1400 pub text_not_typed: Option<bool>,
1401 #[serde(default, skip_serializing_if = "Option::is_none")]
1408 pub initiator: Option<String>,
1409 #[serde(default, skip_serializing_if = "Option::is_none")]
1415 pub pasted_content: Option<Vec<Value>>,
1416 #[serde(default, skip_serializing_if = "Option::is_none")]
1420 pub historical: Option<bool>,
1421 #[serde(default, skip_serializing_if = "Option::is_none")]
1427 pub server_received_wall_ms: Option<f64>,
1428 #[serde(default, skip_serializing_if = "Option::is_none")]
1432 pub refused_message_id: Option<String>,
1433 #[serde(default, skip_serializing_if = "Option::is_none")]
1440 pub requeue_if_interrupted_within_ms: Option<u64>,
1441 #[serde(default, skip_serializing_if = "Option::is_none")]
1450 pub ultrathink_typed: Option<bool>,
1451 #[serde(default, skip_serializing_if = "Option::is_none")]
1455 pub tool_states: Option<Vec<Value>>,
1456 #[serde(default, skip_serializing_if = "Option::is_none")]
1462 pub plugin_prompt: Option<PluginPrompt>,
1463 #[serde(default, skip_serializing_if = "Option::is_none")]
1474 pub retracted_message_uuids: Option<Vec<String>>,
1475}
1476
1477#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
1480pub struct PluginPrompt {
1481 pub name: String,
1484 pub text: String,
1490}
1491
1492impl UserMessage {
1493 pub fn tool_use_result_as<T: serde::de::DeserializeOwned>(
1501 &self,
1502 ) -> Option<Result<T, serde_json::Error>> {
1503 self.tool_use_result
1504 .as_ref()
1505 .map(|v| serde_json::from_value(v.clone()))
1506 }
1507
1508 pub fn subagent_result(&self) -> Option<SubagentResult> {
1519 self.tool_use_result
1520 .as_ref()
1521 .and_then(|v| serde_json::from_value(v.clone()).ok())
1522 }
1523}
1524
1525#[derive(Debug, Clone, Serialize, Deserialize)]
1536pub struct SubagentResult {
1537 #[serde(skip_serializing_if = "Option::is_none")]
1539 pub status: Option<String>,
1540 #[serde(skip_serializing_if = "Option::is_none")]
1542 pub prompt: Option<String>,
1543 #[serde(rename = "agentId", skip_serializing_if = "Option::is_none")]
1545 pub agent_id: Option<String>,
1546 #[serde(rename = "agentType", skip_serializing_if = "Option::is_none")]
1548 pub agent_type: Option<String>,
1549 #[serde(
1551 default,
1552 deserialize_with = "deserialize_content_blocks",
1553 skip_serializing_if = "Vec::is_empty"
1554 )]
1555 pub content: Vec<ContentBlock>,
1556 #[serde(rename = "resolvedModel", skip_serializing_if = "Option::is_none")]
1558 pub resolved_model: Option<String>,
1559 #[serde(rename = "totalDurationMs", skip_serializing_if = "Option::is_none")]
1561 pub total_duration_ms: Option<u64>,
1562 #[serde(rename = "totalTokens", skip_serializing_if = "Option::is_none")]
1564 pub total_tokens: Option<u64>,
1565 #[serde(rename = "totalToolUseCount", skip_serializing_if = "Option::is_none")]
1567 pub total_tool_use_count: Option<u64>,
1568 #[serde(skip_serializing_if = "Option::is_none")]
1570 pub usage: Option<super::result::UsageInfo>,
1571 #[serde(rename = "toolStats", skip_serializing_if = "Option::is_none")]
1573 pub tool_stats: Option<SubagentToolStats>,
1574}
1575
1576#[derive(Debug, Clone, Default, Serialize, Deserialize)]
1581#[serde(rename_all = "camelCase")]
1582pub struct SubagentToolStats {
1583 #[serde(default)]
1584 pub read_count: u64,
1585 #[serde(default)]
1586 pub search_count: u64,
1587 #[serde(default)]
1588 pub bash_count: u64,
1589 #[serde(default)]
1590 pub edit_file_count: u64,
1591 #[serde(default)]
1592 pub lines_added: u64,
1593 #[serde(default)]
1594 pub lines_removed: u64,
1595 #[serde(default)]
1596 pub other_tool_count: u64,
1597 #[serde(flatten)]
1598 pub extra: serde_json::Map<String, Value>,
1599}
1600
1601#[derive(Debug, Clone, Default, PartialEq, Eq)]
1628pub struct SubagentUsageRollup {
1629 pub subagent_tokens: u64,
1632 pub agent_count: u32,
1634 pub tool_uses: u64,
1636 pub duration_ms: u64,
1638 seen_agent_ids: std::collections::BTreeSet<String>,
1639}
1640
1641impl SubagentUsageRollup {
1642 pub fn observe(&mut self, output: &ClaudeOutput) -> bool {
1648 match output {
1649 ClaudeOutput::User(user) => self.observe_user(user),
1650 _ => false,
1651 }
1652 }
1653
1654 pub fn observe_user(&mut self, user: &UserMessage) -> bool {
1661 let Some(result) = user.subagent_result() else {
1662 return false;
1663 };
1664 if result.total_tokens.is_none() && result.agent_id.is_none() {
1665 return false;
1666 }
1667 if let Some(agent_id) = &result.agent_id {
1668 if !self.seen_agent_ids.insert(agent_id.clone()) {
1669 return false;
1670 }
1671 }
1672 self.agent_count += 1;
1673 self.subagent_tokens += result.total_tokens.unwrap_or(0);
1674 self.tool_uses += result.total_tool_use_count.unwrap_or(0);
1675 self.duration_ms += result.total_duration_ms.unwrap_or(0);
1676 true
1677 }
1678}
1679
1680#[derive(Debug, Clone, Serialize, Deserialize)]
1682pub struct MessageContent {
1683 pub role: MessageRole,
1684 #[serde(deserialize_with = "deserialize_content_blocks")]
1685 pub content: Vec<ContentBlock>,
1686}
1687
1688#[derive(Debug, Clone, Serialize, Deserialize)]
1690pub struct SystemMessage {
1691 pub subtype: SystemSubtype,
1692 #[serde(flatten)]
1693 pub data: Value, }
1695
1696impl SystemMessage {
1697 pub fn is_init(&self) -> bool {
1699 self.subtype == SystemSubtype::Init
1700 }
1701
1702 pub fn is_status(&self) -> bool {
1704 self.subtype == SystemSubtype::Status
1705 }
1706
1707 pub fn is_compact_boundary(&self) -> bool {
1709 self.subtype == SystemSubtype::CompactBoundary
1710 }
1711
1712 pub fn as_init(&self) -> Option<InitMessage> {
1714 if self.subtype != SystemSubtype::Init {
1715 return None;
1716 }
1717 serde_json::from_value(self.data.clone()).ok()
1718 }
1719
1720 pub fn as_status(&self) -> Option<StatusMessage> {
1722 if self.subtype != SystemSubtype::Status {
1723 return None;
1724 }
1725 serde_json::from_value(self.data.clone()).ok()
1726 }
1727
1728 pub fn as_compact_boundary(&self) -> Option<CompactBoundaryMessage> {
1730 if self.subtype != SystemSubtype::CompactBoundary {
1731 return None;
1732 }
1733 serde_json::from_value(self.data.clone()).ok()
1734 }
1735
1736 pub fn is_task_started(&self) -> bool {
1738 self.subtype == SystemSubtype::TaskStarted
1739 }
1740
1741 pub fn is_task_progress(&self) -> bool {
1743 self.subtype == SystemSubtype::TaskProgress
1744 }
1745
1746 pub fn is_task_notification(&self) -> bool {
1748 self.subtype == SystemSubtype::TaskNotification
1749 }
1750
1751 pub fn as_task_started(&self) -> Option<TaskStartedMessage> {
1753 if self.subtype != SystemSubtype::TaskStarted {
1754 return None;
1755 }
1756 serde_json::from_value(self.data.clone()).ok()
1757 }
1758
1759 pub fn as_task_progress(&self) -> Option<TaskProgressMessage> {
1761 if self.subtype != SystemSubtype::TaskProgress {
1762 return None;
1763 }
1764 serde_json::from_value(self.data.clone()).ok()
1765 }
1766
1767 pub fn as_task_notification(&self) -> Option<TaskNotificationMessage> {
1769 if self.subtype != SystemSubtype::TaskNotification {
1770 return None;
1771 }
1772 serde_json::from_value(self.data.clone()).ok()
1773 }
1774
1775 pub fn is_task_updated(&self) -> bool {
1777 self.subtype == SystemSubtype::TaskUpdated
1778 }
1779
1780 pub fn as_task_updated(&self) -> Option<TaskUpdatedMessage> {
1782 if self.subtype != SystemSubtype::TaskUpdated {
1783 return None;
1784 }
1785 serde_json::from_value(self.data.clone()).ok()
1786 }
1787
1788 pub fn is_thinking_tokens(&self) -> bool {
1790 self.subtype == SystemSubtype::ThinkingTokens
1791 }
1792
1793 pub fn as_thinking_tokens(&self) -> Option<ThinkingTokensMessage> {
1795 if self.subtype != SystemSubtype::ThinkingTokens {
1796 return None;
1797 }
1798 serde_json::from_value(self.data.clone()).ok()
1799 }
1800
1801 pub fn is_code_change_published(&self) -> bool {
1803 self.subtype == SystemSubtype::CodeChangePublished
1804 }
1805
1806 pub fn as_code_change_published(&self) -> Option<CodeChangePublishedMessage> {
1808 if self.subtype != SystemSubtype::CodeChangePublished {
1809 return None;
1810 }
1811 serde_json::from_value(self.data.clone()).ok()
1812 }
1813
1814 pub fn is_vcs_state_changed(&self) -> bool {
1816 self.subtype == SystemSubtype::VcsStateChanged
1817 }
1818
1819 pub fn as_vcs_state_changed(&self) -> Option<VcsStateChangedMessage> {
1821 if self.subtype != SystemSubtype::VcsStateChanged {
1822 return None;
1823 }
1824 serde_json::from_value(self.data.clone()).ok()
1825 }
1826
1827 pub fn is_feedback_draft_queued(&self) -> bool {
1829 self.subtype == SystemSubtype::FeedbackDraftQueued
1830 }
1831
1832 pub fn as_feedback_draft_queued(&self) -> Option<FeedbackDraftQueuedMessage> {
1834 if self.subtype != SystemSubtype::FeedbackDraftQueued {
1835 return None;
1836 }
1837 serde_json::from_value(self.data.clone()).ok()
1838 }
1839
1840 pub fn is_cloud_session_delta(&self) -> bool {
1842 self.subtype == SystemSubtype::CloudSessionDelta
1843 }
1844
1845 pub fn as_cloud_session_delta(&self) -> Option<CloudSessionDeltaMessage> {
1847 if self.subtype != SystemSubtype::CloudSessionDelta {
1848 return None;
1849 }
1850 serde_json::from_value(self.data.clone()).ok()
1851 }
1852
1853 pub fn is_dev_intent(&self) -> bool {
1855 self.subtype == SystemSubtype::DevIntent
1856 }
1857
1858 pub fn as_dev_intent(&self) -> Option<DevIntentMessage> {
1860 if self.subtype != SystemSubtype::DevIntent {
1861 return None;
1862 }
1863 serde_json::from_value(self.data.clone()).ok()
1864 }
1865
1866 pub fn is_turn_handoff_available(&self) -> bool {
1868 self.subtype == SystemSubtype::TurnHandoffAvailable
1869 }
1870
1871 pub fn as_turn_handoff_available(&self) -> Option<TurnHandoffAvailableMessage> {
1873 if self.subtype != SystemSubtype::TurnHandoffAvailable {
1874 return None;
1875 }
1876 serde_json::from_value(self.data.clone()).ok()
1877 }
1878
1879 pub fn is_turn_preempted(&self) -> bool {
1881 self.subtype == SystemSubtype::TurnPreempted
1882 }
1883
1884 pub fn as_turn_preempted(&self) -> Option<TurnPreemptedMessage> {
1886 if self.subtype != SystemSubtype::TurnPreempted {
1887 return None;
1888 }
1889 serde_json::from_value(self.data.clone()).ok()
1890 }
1891
1892 pub fn is_peer_message_hold(&self) -> bool {
1894 self.subtype == SystemSubtype::PeerMessageHold
1895 }
1896
1897 pub fn as_peer_message_hold(&self) -> Option<PeerMessageHoldMessage> {
1899 if self.subtype != SystemSubtype::PeerMessageHold {
1900 return None;
1901 }
1902 serde_json::from_value(self.data.clone()).ok()
1903 }
1904
1905 pub fn is_per_turn_effort_changed(&self) -> bool {
1907 self.subtype == SystemSubtype::PerTurnEffortChanged
1908 }
1909
1910 pub fn as_per_turn_effort_changed(&self) -> Option<PerTurnEffortChangedMessage> {
1912 if self.subtype != SystemSubtype::PerTurnEffortChanged {
1913 return None;
1914 }
1915 serde_json::from_value(self.data.clone()).ok()
1916 }
1917
1918 pub fn is_session_title_changed(&self) -> bool {
1920 self.subtype == SystemSubtype::SessionTitleChanged
1921 }
1922
1923 pub fn as_session_title_changed(&self) -> Option<SessionTitleChangedMessage> {
1925 if self.subtype != SystemSubtype::SessionTitleChanged {
1926 return None;
1927 }
1928 serde_json::from_value(self.data.clone()).ok()
1929 }
1930
1931 pub fn is_session_writes_lost(&self) -> bool {
1933 self.subtype == SystemSubtype::SessionWritesLost
1934 }
1935
1936 pub fn as_session_writes_lost(&self) -> Option<SessionWritesLostMessage> {
1938 if self.subtype != SystemSubtype::SessionWritesLost {
1939 return None;
1940 }
1941 serde_json::from_value(self.data.clone()).ok()
1942 }
1943
1944 pub fn is_instruction_size_warning(&self) -> bool {
1946 self.subtype == SystemSubtype::InstructionSizeWarning
1947 }
1948
1949 pub fn as_instruction_size_warning(&self) -> Option<InstructionSizeWarningMessage> {
1951 if self.subtype != SystemSubtype::InstructionSizeWarning {
1952 return None;
1953 }
1954 serde_json::from_value(self.data.clone()).ok()
1955 }
1956
1957 pub fn is_permission_check_status(&self) -> bool {
1959 self.subtype == SystemSubtype::PermissionCheckStatus
1960 }
1961
1962 pub fn as_permission_check_status(&self) -> Option<PermissionCheckStatusMessage> {
1964 if self.subtype != SystemSubtype::PermissionCheckStatus {
1965 return None;
1966 }
1967 serde_json::from_value(self.data.clone()).ok()
1968 }
1969
1970 pub fn is_inherited_asks_settled(&self) -> bool {
1972 self.subtype == SystemSubtype::InheritedAsksSettled
1973 }
1974
1975 pub fn as_inherited_asks_settled(&self) -> Option<InheritedAsksSettledMessage> {
1977 if self.subtype != SystemSubtype::InheritedAsksSettled {
1978 return None;
1979 }
1980 serde_json::from_value(self.data.clone()).ok()
1981 }
1982
1983 pub fn is_file_attachments_missing(&self) -> bool {
1985 self.subtype == SystemSubtype::FileAttachmentsMissing
1986 }
1987
1988 pub fn as_file_attachments_missing(&self) -> Option<FileAttachmentsMissingMessage> {
1990 if self.subtype != SystemSubtype::FileAttachmentsMissing {
1991 return None;
1992 }
1993 serde_json::from_value(self.data.clone()).ok()
1994 }
1995
1996 pub fn is_ui_focus(&self) -> bool {
1998 self.subtype == SystemSubtype::UiFocus
1999 }
2000
2001 pub fn as_ui_focus(&self) -> Option<UiFocusMessage> {
2003 if self.subtype != SystemSubtype::UiFocus {
2004 return None;
2005 }
2006 serde_json::from_value(self.data.clone()).ok()
2007 }
2008
2009 pub fn is_ui_invalidate(&self) -> bool {
2011 self.subtype == SystemSubtype::UiInvalidate
2012 }
2013
2014 pub fn as_ui_invalidate(&self) -> Option<UiInvalidateMessage> {
2016 if self.subtype != SystemSubtype::UiInvalidate {
2017 return None;
2018 }
2019 serde_json::from_value(self.data.clone()).ok()
2020 }
2021
2022 pub fn is_ui_log(&self) -> bool {
2024 self.subtype == SystemSubtype::UiLog
2025 }
2026
2027 pub fn as_ui_log(&self) -> Option<UiLogMessage> {
2029 if self.subtype != SystemSubtype::UiLog {
2030 return None;
2031 }
2032 serde_json::from_value(self.data.clone()).ok()
2033 }
2034
2035 pub fn is_ui_notify(&self) -> bool {
2037 self.subtype == SystemSubtype::UiNotify
2038 }
2039
2040 pub fn as_ui_notify(&self) -> Option<UiNotifyMessage> {
2042 if self.subtype != SystemSubtype::UiNotify {
2043 return None;
2044 }
2045 serde_json::from_value(self.data.clone()).ok()
2046 }
2047
2048 pub fn is_ui_notify_cancel(&self) -> bool {
2050 self.subtype == SystemSubtype::UiNotifyCancel
2051 }
2052
2053 pub fn as_ui_notify_cancel(&self) -> Option<UiNotifyCancelMessage> {
2055 if self.subtype != SystemSubtype::UiNotifyCancel {
2056 return None;
2057 }
2058 serde_json::from_value(self.data.clone()).ok()
2059 }
2060
2061 pub fn is_ui_panes(&self) -> bool {
2063 self.subtype == SystemSubtype::UiPanes
2064 }
2065
2066 pub fn as_ui_panes(&self) -> Option<UiPanesMessage> {
2068 if self.subtype != SystemSubtype::UiPanes {
2069 return None;
2070 }
2071 serde_json::from_value(self.data.clone()).ok()
2072 }
2073
2074 pub fn is_ui_placed(&self) -> bool {
2076 self.subtype == SystemSubtype::UiPlaced
2077 }
2078
2079 pub fn as_ui_placed(&self) -> Option<UiPlacedMessage> {
2081 if self.subtype != SystemSubtype::UiPlaced {
2082 return None;
2083 }
2084 serde_json::from_value(self.data.clone()).ok()
2085 }
2086
2087 pub fn is_ui_scroll(&self) -> bool {
2089 self.subtype == SystemSubtype::UiScroll
2090 }
2091
2092 pub fn as_ui_scroll(&self) -> Option<UiScrollMessage> {
2094 if self.subtype != SystemSubtype::UiScroll {
2095 return None;
2096 }
2097 serde_json::from_value(self.data.clone()).ok()
2098 }
2099
2100 pub fn is_ui_status(&self) -> bool {
2102 self.subtype == SystemSubtype::UiStatus
2103 }
2104
2105 pub fn as_ui_status(&self) -> Option<UiStatusMessage> {
2107 if self.subtype != SystemSubtype::UiStatus {
2108 return None;
2109 }
2110 serde_json::from_value(self.data.clone()).ok()
2111 }
2112
2113 pub fn is_ui_toast(&self) -> bool {
2115 self.subtype == SystemSubtype::UiToast
2116 }
2117
2118 pub fn as_ui_toast(&self) -> Option<UiToastMessage> {
2120 if self.subtype != SystemSubtype::UiToast {
2121 return None;
2122 }
2123 serde_json::from_value(self.data.clone()).ok()
2124 }
2125
2126 pub fn as_known_system_event(&self) -> Option<KnownSystemEvent> {
2128 macro_rules! parse {
2129 ($variant:ident, $ty:ty) => {
2130 serde_json::from_value::<$ty>(self.data.clone())
2131 .ok()
2132 .map(KnownSystemEvent::$variant)
2133 };
2134 }
2135
2136 match self.subtype {
2137 SystemSubtype::Init => parse!(Init, InitMessage),
2138 SystemSubtype::Status => parse!(Status, StatusMessage),
2139 SystemSubtype::CompactBoundary => parse!(CompactBoundary, CompactBoundaryMessage),
2140 SystemSubtype::ThinkingTokens => parse!(ThinkingTokens, ThinkingTokensMessage),
2141 SystemSubtype::TaskStarted => parse!(TaskStarted, TaskStartedMessage),
2142 SystemSubtype::TaskProgress => parse!(TaskProgress, TaskProgressMessage),
2143 SystemSubtype::TaskUpdated => parse!(TaskUpdated, TaskUpdatedMessage),
2144 SystemSubtype::TaskNotification => parse!(TaskNotification, TaskNotificationMessage),
2145 SystemSubtype::ApiRetry => parse!(ApiRetry, ApiRetryMessage),
2146 SystemSubtype::ControlRequestProgress => {
2147 parse!(ControlRequestProgress, ControlRequestProgressMessage)
2148 }
2149 SystemSubtype::ModelRefusalFallback => {
2150 parse!(ModelRefusalFallback, ModelRefusalFallbackMessage)
2151 }
2152 SystemSubtype::ModelRefusalNoFallback => {
2153 parse!(ModelRefusalNoFallback, ModelRefusalNoFallbackMessage)
2154 }
2155 SystemSubtype::LocalCommandOutput => {
2156 parse!(LocalCommandOutput, LocalCommandOutputMessage)
2157 }
2158 SystemSubtype::HookStarted => parse!(HookStarted, HookStartedMessage),
2159 SystemSubtype::HookProgress => parse!(HookProgress, HookProgressMessage),
2160 SystemSubtype::HookResponse => parse!(HookResponse, HookResponseMessage),
2161 SystemSubtype::PluginInstall => parse!(PluginInstall, PluginInstallMessage),
2162 SystemSubtype::BackgroundTasksChanged => {
2163 parse!(BackgroundTasksChanged, BackgroundTasksChangedMessage)
2164 }
2165 SystemSubtype::SessionStateChanged => {
2166 parse!(SessionStateChanged, SessionStateChangedMessage)
2167 }
2168 SystemSubtype::WorkerShuttingDown => {
2169 parse!(WorkerShuttingDown, WorkerShuttingDownMessage)
2170 }
2171 SystemSubtype::CommandsChanged => parse!(CommandsChanged, CommandsChangedMessage),
2172 SystemSubtype::Notification => parse!(Notification, NotificationMessage),
2173 SystemSubtype::FilesPersisted => parse!(FilesPersisted, FilesPersistedMessage),
2174 SystemSubtype::MemoryRecall => parse!(MemoryRecall, MemoryRecallMessage),
2175 SystemSubtype::ElicitationComplete => {
2176 parse!(ElicitationComplete, ElicitationCompleteMessage)
2177 }
2178 SystemSubtype::PermissionDenied => parse!(PermissionDenied, PermissionDeniedMessage),
2179 SystemSubtype::MirrorError => parse!(MirrorError, MirrorErrorMessage),
2180 SystemSubtype::Informational => parse!(Informational, InformationalMessage),
2181 SystemSubtype::CodeChangePublished => {
2182 parse!(CodeChangePublished, CodeChangePublishedMessage)
2183 }
2184 SystemSubtype::VcsStateChanged => parse!(VcsStateChanged, VcsStateChangedMessage),
2185 SystemSubtype::FeedbackDraftQueued => {
2186 parse!(FeedbackDraftQueued, FeedbackDraftQueuedMessage)
2187 }
2188 SystemSubtype::CloudSessionDelta => {
2189 parse!(CloudSessionDelta, CloudSessionDeltaMessage)
2190 }
2191 SystemSubtype::DevIntent => parse!(DevIntent, DevIntentMessage),
2192 SystemSubtype::TurnHandoffAvailable => {
2193 parse!(TurnHandoffAvailable, TurnHandoffAvailableMessage)
2194 }
2195 SystemSubtype::TurnPreempted => parse!(TurnPreempted, TurnPreemptedMessage),
2196 SystemSubtype::PeerMessageHold => parse!(PeerMessageHold, PeerMessageHoldMessage),
2197 SystemSubtype::PerTurnEffortChanged => {
2198 parse!(PerTurnEffortChanged, PerTurnEffortChangedMessage)
2199 }
2200 SystemSubtype::SessionTitleChanged => {
2201 parse!(SessionTitleChanged, SessionTitleChangedMessage)
2202 }
2203 SystemSubtype::SessionWritesLost => {
2204 parse!(SessionWritesLost, SessionWritesLostMessage)
2205 }
2206 SystemSubtype::InstructionSizeWarning => {
2207 parse!(InstructionSizeWarning, InstructionSizeWarningMessage)
2208 }
2209 SystemSubtype::FileAttachmentsMissing => {
2210 parse!(FileAttachmentsMissing, FileAttachmentsMissingMessage)
2211 }
2212 SystemSubtype::PermissionCheckStatus => {
2213 parse!(PermissionCheckStatus, PermissionCheckStatusMessage)
2214 }
2215 SystemSubtype::InheritedAsksSettled => {
2216 parse!(InheritedAsksSettled, InheritedAsksSettledMessage)
2217 }
2218 SystemSubtype::UiFocus => parse!(UiFocus, UiFocusMessage),
2219 SystemSubtype::UiInvalidate => parse!(UiInvalidate, UiInvalidateMessage),
2220 SystemSubtype::UiLog => parse!(UiLog, UiLogMessage),
2221 SystemSubtype::UiNotify => parse!(UiNotify, UiNotifyMessage),
2222 SystemSubtype::UiNotifyCancel => parse!(UiNotifyCancel, UiNotifyCancelMessage),
2223 SystemSubtype::UiPanes => parse!(UiPanes, UiPanesMessage),
2224 SystemSubtype::UiPlaced => parse!(UiPlaced, UiPlacedMessage),
2225 SystemSubtype::UiScroll => parse!(UiScroll, UiScrollMessage),
2226 SystemSubtype::UiStatus => parse!(UiStatus, UiStatusMessage),
2227 SystemSubtype::UiToast => parse!(UiToast, UiToastMessage),
2228 SystemSubtype::Unknown(_) => None,
2229 }
2230 }
2231
2232 pub fn typed_value(&self) -> Option<Value> {
2241 fn reserialize<T: Serialize>(parsed: Option<T>) -> Option<Value> {
2242 parsed.and_then(|v| serde_json::to_value(v).ok())
2243 }
2244 match self.subtype {
2245 SystemSubtype::Init => reserialize(self.as_init()),
2246 SystemSubtype::Status => reserialize(self.as_status()),
2247 SystemSubtype::CompactBoundary => reserialize(self.as_compact_boundary()),
2248 SystemSubtype::ThinkingTokens => reserialize(self.as_thinking_tokens()),
2249 SystemSubtype::TaskStarted => reserialize(self.as_task_started()),
2250 SystemSubtype::TaskProgress => reserialize(self.as_task_progress()),
2251 SystemSubtype::TaskUpdated => reserialize(self.as_task_updated()),
2252 SystemSubtype::TaskNotification => reserialize(self.as_task_notification()),
2253 SystemSubtype::ApiRetry => reserialize(parse_system::<ApiRetryMessage>(self)),
2254 SystemSubtype::ControlRequestProgress => {
2255 reserialize(parse_system::<ControlRequestProgressMessage>(self))
2256 }
2257 SystemSubtype::ModelRefusalFallback => {
2258 reserialize(parse_system::<ModelRefusalFallbackMessage>(self))
2259 }
2260 SystemSubtype::ModelRefusalNoFallback => {
2261 reserialize(parse_system::<ModelRefusalNoFallbackMessage>(self))
2262 }
2263 SystemSubtype::LocalCommandOutput => {
2264 reserialize(parse_system::<LocalCommandOutputMessage>(self))
2265 }
2266 SystemSubtype::HookStarted => reserialize(parse_system::<HookStartedMessage>(self)),
2267 SystemSubtype::HookProgress => reserialize(parse_system::<HookProgressMessage>(self)),
2268 SystemSubtype::HookResponse => reserialize(parse_system::<HookResponseMessage>(self)),
2269 SystemSubtype::PluginInstall => reserialize(parse_system::<PluginInstallMessage>(self)),
2270 SystemSubtype::BackgroundTasksChanged => {
2271 reserialize(parse_system::<BackgroundTasksChangedMessage>(self))
2272 }
2273 SystemSubtype::SessionStateChanged => {
2274 reserialize(parse_system::<SessionStateChangedMessage>(self))
2275 }
2276 SystemSubtype::WorkerShuttingDown => {
2277 reserialize(parse_system::<WorkerShuttingDownMessage>(self))
2278 }
2279 SystemSubtype::CommandsChanged => {
2280 reserialize(parse_system::<CommandsChangedMessage>(self))
2281 }
2282 SystemSubtype::Notification => reserialize(parse_system::<NotificationMessage>(self)),
2283 SystemSubtype::FilesPersisted => {
2284 reserialize(parse_system::<FilesPersistedMessage>(self))
2285 }
2286 SystemSubtype::MemoryRecall => reserialize(parse_system::<MemoryRecallMessage>(self)),
2287 SystemSubtype::ElicitationComplete => {
2288 reserialize(parse_system::<ElicitationCompleteMessage>(self))
2289 }
2290 SystemSubtype::PermissionDenied => {
2291 reserialize(parse_system::<PermissionDeniedMessage>(self))
2292 }
2293 SystemSubtype::MirrorError => reserialize(parse_system::<MirrorErrorMessage>(self)),
2294 SystemSubtype::Informational => reserialize(parse_system::<InformationalMessage>(self)),
2295 SystemSubtype::CodeChangePublished => {
2296 reserialize(parse_system::<CodeChangePublishedMessage>(self))
2297 }
2298 SystemSubtype::VcsStateChanged => {
2299 reserialize(parse_system::<VcsStateChangedMessage>(self))
2300 }
2301 SystemSubtype::FeedbackDraftQueued => {
2302 reserialize(parse_system::<FeedbackDraftQueuedMessage>(self))
2303 }
2304 SystemSubtype::CloudSessionDelta => {
2305 reserialize(parse_system::<CloudSessionDeltaMessage>(self))
2306 }
2307 SystemSubtype::DevIntent => reserialize(parse_system::<DevIntentMessage>(self)),
2308 SystemSubtype::TurnHandoffAvailable => {
2309 reserialize(parse_system::<TurnHandoffAvailableMessage>(self))
2310 }
2311 SystemSubtype::TurnPreempted => reserialize(parse_system::<TurnPreemptedMessage>(self)),
2312 SystemSubtype::PeerMessageHold => {
2313 reserialize(parse_system::<PeerMessageHoldMessage>(self))
2314 }
2315 SystemSubtype::PerTurnEffortChanged => {
2316 reserialize(parse_system::<PerTurnEffortChangedMessage>(self))
2317 }
2318 SystemSubtype::SessionTitleChanged => {
2319 reserialize(parse_system::<SessionTitleChangedMessage>(self))
2320 }
2321 SystemSubtype::SessionWritesLost => {
2322 reserialize(parse_system::<SessionWritesLostMessage>(self))
2323 }
2324 SystemSubtype::InstructionSizeWarning => {
2325 reserialize(parse_system::<InstructionSizeWarningMessage>(self))
2326 }
2327 SystemSubtype::FileAttachmentsMissing => {
2328 reserialize(parse_system::<FileAttachmentsMissingMessage>(self))
2329 }
2330 SystemSubtype::PermissionCheckStatus => {
2331 reserialize(parse_system::<PermissionCheckStatusMessage>(self))
2332 }
2333 SystemSubtype::InheritedAsksSettled => {
2334 reserialize(parse_system::<InheritedAsksSettledMessage>(self))
2335 }
2336 SystemSubtype::UiFocus => reserialize(parse_system::<UiFocusMessage>(self)),
2337 SystemSubtype::UiInvalidate => reserialize(parse_system::<UiInvalidateMessage>(self)),
2338 SystemSubtype::UiLog => reserialize(parse_system::<UiLogMessage>(self)),
2339 SystemSubtype::UiNotify => reserialize(parse_system::<UiNotifyMessage>(self)),
2340 SystemSubtype::UiNotifyCancel => {
2341 reserialize(parse_system::<UiNotifyCancelMessage>(self))
2342 }
2343 SystemSubtype::UiPanes => reserialize(parse_system::<UiPanesMessage>(self)),
2344 SystemSubtype::UiPlaced => reserialize(parse_system::<UiPlacedMessage>(self)),
2345 SystemSubtype::UiScroll => reserialize(parse_system::<UiScrollMessage>(self)),
2346 SystemSubtype::UiStatus => reserialize(parse_system::<UiStatusMessage>(self)),
2347 SystemSubtype::UiToast => reserialize(parse_system::<UiToastMessage>(self)),
2348 SystemSubtype::Unknown(_) => None,
2349 }
2350 }
2351}
2352
2353fn parse_system<T: serde::de::DeserializeOwned>(message: &SystemMessage) -> Option<T> {
2354 serde_json::from_value(message.data.clone()).ok()
2355}
2356
2357#[allow(clippy::large_enum_variant)]
2363#[derive(Debug, Clone, Serialize, Deserialize)]
2364pub enum KnownSystemEvent {
2365 Init(InitMessage),
2366 Status(StatusMessage),
2367 CompactBoundary(CompactBoundaryMessage),
2368 ThinkingTokens(ThinkingTokensMessage),
2369 TaskStarted(TaskStartedMessage),
2370 TaskProgress(TaskProgressMessage),
2371 TaskUpdated(TaskUpdatedMessage),
2372 TaskNotification(TaskNotificationMessage),
2373 ApiRetry(ApiRetryMessage),
2374 ControlRequestProgress(ControlRequestProgressMessage),
2375 ModelRefusalFallback(ModelRefusalFallbackMessage),
2376 ModelRefusalNoFallback(ModelRefusalNoFallbackMessage),
2377 LocalCommandOutput(LocalCommandOutputMessage),
2378 HookStarted(HookStartedMessage),
2379 HookProgress(HookProgressMessage),
2380 HookResponse(HookResponseMessage),
2381 PluginInstall(PluginInstallMessage),
2382 BackgroundTasksChanged(BackgroundTasksChangedMessage),
2383 SessionStateChanged(SessionStateChangedMessage),
2384 WorkerShuttingDown(WorkerShuttingDownMessage),
2385 CommandsChanged(CommandsChangedMessage),
2386 Notification(NotificationMessage),
2387 FilesPersisted(FilesPersistedMessage),
2388 MemoryRecall(MemoryRecallMessage),
2389 ElicitationComplete(ElicitationCompleteMessage),
2390 PermissionDenied(PermissionDeniedMessage),
2391 MirrorError(MirrorErrorMessage),
2392 Informational(InformationalMessage),
2393 CodeChangePublished(CodeChangePublishedMessage),
2394 VcsStateChanged(VcsStateChangedMessage),
2395 FeedbackDraftQueued(FeedbackDraftQueuedMessage),
2396 CloudSessionDelta(CloudSessionDeltaMessage),
2397 DevIntent(DevIntentMessage),
2398 TurnHandoffAvailable(TurnHandoffAvailableMessage),
2399 TurnPreempted(TurnPreemptedMessage),
2400 PeerMessageHold(PeerMessageHoldMessage),
2401 PerTurnEffortChanged(PerTurnEffortChangedMessage),
2402 SessionTitleChanged(SessionTitleChangedMessage),
2403 SessionWritesLost(SessionWritesLostMessage),
2404 InstructionSizeWarning(InstructionSizeWarningMessage),
2405 FileAttachmentsMissing(FileAttachmentsMissingMessage),
2406 PermissionCheckStatus(PermissionCheckStatusMessage),
2407 InheritedAsksSettled(InheritedAsksSettledMessage),
2408 UiFocus(UiFocusMessage),
2409 UiInvalidate(UiInvalidateMessage),
2410 UiLog(UiLogMessage),
2411 UiNotify(UiNotifyMessage),
2412 UiNotifyCancel(UiNotifyCancelMessage),
2413 UiPanes(UiPanesMessage),
2414 UiPlaced(UiPlacedMessage),
2415 UiScroll(UiScrollMessage),
2416 UiStatus(UiStatusMessage),
2417 UiToast(UiToastMessage),
2418}
2419
2420#[derive(Debug, Clone, Serialize, Deserialize)]
2421pub struct ApiRetryMessage {
2422 pub attempt: u64,
2423 pub max_retries: u64,
2424 pub retry_delay_ms: u64,
2425 pub error_status: Option<u16>,
2426 pub error: String,
2427 #[serde(default, skip_serializing_if = "Option::is_none")]
2432 pub no_response: Option<ApiRetryNoResponse>,
2433 #[serde(default, skip_serializing_if = "Option::is_none")]
2434 pub uuid: Option<String>,
2435 #[serde(default, skip_serializing_if = "Option::is_none")]
2436 pub session_id: Option<String>,
2437}
2438
2439#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2442pub struct ApiRetryNoResponse {
2443 pub waited_ms: u64,
2445 pub retry_wait_ms: u64,
2447}
2448
2449#[derive(Debug, Clone, Serialize, Deserialize)]
2450pub struct ControlRequestProgressMessage {
2451 pub request_id: String,
2452 pub status: String,
2453 #[serde(default, skip_serializing_if = "Option::is_none")]
2454 pub attempt: Option<u64>,
2455 #[serde(default, skip_serializing_if = "Option::is_none")]
2456 pub max_retries: Option<u64>,
2457 #[serde(default, skip_serializing_if = "Option::is_none")]
2458 pub retry_delay_ms: Option<u64>,
2459 #[serde(default, skip_serializing_if = "Option::is_none")]
2460 pub error_status: Option<u16>,
2461 #[serde(default, skip_serializing_if = "Option::is_none")]
2462 pub error: Option<String>,
2463 #[serde(default, skip_serializing_if = "Option::is_none")]
2464 pub uuid: Option<String>,
2465 #[serde(default, skip_serializing_if = "Option::is_none")]
2466 pub session_id: Option<String>,
2467}
2468
2469#[derive(Debug, Clone, Serialize, Deserialize)]
2470pub struct ModelRefusalFallbackMessage {
2471 pub trigger: String,
2472 pub direction: String,
2473 #[serde(default, skip_serializing_if = "Option::is_none")]
2479 pub scope: Option<RefusalFallbackScope>,
2480 pub original_model: String,
2481 pub fallback_model: String,
2482 pub request_id: Option<String>,
2483 #[serde(default, skip_serializing_if = "Option::is_none")]
2484 pub api_refusal_category: Option<String>,
2485 #[serde(default, skip_serializing_if = "Option::is_none")]
2490 pub saw_cyber_refusal: Option<bool>,
2491 #[serde(default, skip_serializing_if = "Option::is_none")]
2492 pub api_refusal_explanation: Option<String>,
2493 #[serde(default, skip_serializing_if = "Option::is_none")]
2501 pub api_refusal_cyber_verification: Option<CyberVerificationStatus>,
2502 #[serde(default, skip_serializing_if = "Option::is_none")]
2503 pub retracted_message_uuids: Option<Vec<String>>,
2504 #[serde(default, skip_serializing_if = "Option::is_none")]
2505 pub refused_user_message_uuid: Option<String>,
2506 pub content: Value,
2507 #[serde(default, skip_serializing_if = "Option::is_none")]
2508 pub uuid: Option<String>,
2509 #[serde(default, skip_serializing_if = "Option::is_none")]
2510 pub session_id: Option<String>,
2511}
2512
2513#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2517pub struct CyberVerificationStatus {
2518 #[serde(rename = "type")]
2519 pub verification_type: String,
2520 #[serde(default, skip_serializing_if = "Option::is_none")]
2521 pub tier: Option<String>,
2522 #[serde(default, skip_serializing_if = "Option::is_none")]
2523 pub reason: Option<String>,
2524}
2525
2526#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2530pub enum RefusalFallbackScope {
2531 Session,
2533 Local,
2536 Unknown(String),
2538}
2539
2540impl RefusalFallbackScope {
2541 pub fn as_str(&self) -> &str {
2542 match self {
2543 Self::Session => "session",
2544 Self::Local => "local",
2545 Self::Unknown(s) => s.as_str(),
2546 }
2547 }
2548}
2549
2550impl fmt::Display for RefusalFallbackScope {
2551 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2552 f.write_str(self.as_str())
2553 }
2554}
2555
2556impl From<&str> for RefusalFallbackScope {
2557 fn from(s: &str) -> Self {
2558 match s {
2559 "session" => Self::Session,
2560 "local" => Self::Local,
2561 other => Self::Unknown(other.to_string()),
2562 }
2563 }
2564}
2565
2566impl Serialize for RefusalFallbackScope {
2567 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
2568 serializer.serialize_str(self.as_str())
2569 }
2570}
2571
2572impl<'de> Deserialize<'de> for RefusalFallbackScope {
2573 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
2574 let s = String::deserialize(deserializer)?;
2575 Ok(Self::from(s.as_str()))
2576 }
2577}
2578
2579#[derive(Debug, Clone, Serialize, Deserialize)]
2580pub struct ModelRefusalNoFallbackMessage {
2581 pub original_model: String,
2582 pub request_id: Option<String>,
2583 #[serde(default, skip_serializing_if = "Option::is_none")]
2584 pub api_refusal_category: Option<String>,
2585 #[serde(default, skip_serializing_if = "Option::is_none")]
2586 pub api_refusal_explanation: Option<String>,
2587 pub content: Value,
2588 #[serde(default, skip_serializing_if = "Option::is_none")]
2589 pub uuid: Option<String>,
2590 #[serde(default, skip_serializing_if = "Option::is_none")]
2591 pub session_id: Option<String>,
2592}
2593
2594#[derive(Debug, Clone, Serialize, Deserialize)]
2595pub struct LocalCommandOutputMessage {
2596 pub content: String,
2597 #[serde(default, skip_serializing_if = "Option::is_none")]
2598 pub uuid: Option<String>,
2599 #[serde(default, skip_serializing_if = "Option::is_none")]
2600 pub session_id: Option<String>,
2601}
2602
2603#[derive(Debug, Clone, Serialize, Deserialize)]
2604pub struct HookStartedMessage {
2605 pub hook_id: String,
2606 pub hook_name: String,
2607 pub hook_event: String,
2608 #[serde(default, skip_serializing_if = "Option::is_none")]
2609 pub uuid: Option<String>,
2610 #[serde(default, skip_serializing_if = "Option::is_none")]
2611 pub session_id: Option<String>,
2612}
2613
2614#[derive(Debug, Clone, Serialize, Deserialize)]
2615pub struct HookProgressMessage {
2616 pub hook_id: String,
2617 pub hook_name: String,
2618 pub hook_event: String,
2619 #[serde(default, skip_serializing_if = "Option::is_none")]
2620 pub stdout: Option<String>,
2621 #[serde(default, skip_serializing_if = "Option::is_none")]
2622 pub stderr: Option<String>,
2623 #[serde(default, skip_serializing_if = "Option::is_none")]
2624 pub output: Option<String>,
2625 #[serde(default, skip_serializing_if = "Option::is_none")]
2626 pub uuid: Option<String>,
2627 #[serde(default, skip_serializing_if = "Option::is_none")]
2628 pub session_id: Option<String>,
2629}
2630
2631#[derive(Debug, Clone, Serialize, Deserialize)]
2632pub struct HookResponseMessage {
2633 pub hook_id: String,
2634 pub hook_name: String,
2635 pub hook_event: String,
2636 #[serde(default, skip_serializing_if = "Option::is_none")]
2637 pub stdout: Option<String>,
2638 #[serde(default, skip_serializing_if = "Option::is_none")]
2639 pub stderr: Option<String>,
2640 #[serde(default, skip_serializing_if = "Option::is_none")]
2641 pub output: Option<String>,
2642 #[serde(default, skip_serializing_if = "Option::is_none")]
2643 pub exit_code: Option<i32>,
2644 pub outcome: String,
2645 #[serde(default, skip_serializing_if = "Option::is_none")]
2646 pub uuid: Option<String>,
2647 #[serde(default, skip_serializing_if = "Option::is_none")]
2648 pub session_id: Option<String>,
2649}
2650
2651#[derive(Debug, Clone, Serialize, Deserialize)]
2652pub struct PluginInstallMessage {
2653 pub status: String,
2654 #[serde(default, skip_serializing_if = "Option::is_none")]
2655 pub name: Option<String>,
2656 #[serde(default, skip_serializing_if = "Option::is_none")]
2657 pub error: Option<String>,
2658 #[serde(default, skip_serializing_if = "Option::is_none")]
2659 pub uuid: Option<String>,
2660 #[serde(default, skip_serializing_if = "Option::is_none")]
2661 pub session_id: Option<String>,
2662}
2663
2664#[derive(Debug, Clone, Serialize, Deserialize)]
2665pub struct BackgroundTasksChangedMessage {
2666 pub tasks: Vec<BackgroundTaskInfo>,
2667 #[serde(default, skip_serializing_if = "Option::is_none")]
2668 pub uuid: Option<String>,
2669 #[serde(default, skip_serializing_if = "Option::is_none")]
2670 pub session_id: Option<String>,
2671}
2672
2673#[derive(Debug, Clone, Serialize, Deserialize)]
2674pub struct BackgroundTaskInfo {
2675 pub task_id: String,
2676 #[serde(default, skip_serializing_if = "Option::is_none")]
2679 pub run_id: Option<String>,
2680 pub task_type: String,
2681 #[serde(default, skip_serializing_if = "Option::is_none")]
2685 pub subagent_type: Option<String>,
2686 pub description: String,
2687 #[serde(default, skip_serializing_if = "Option::is_none")]
2690 pub parent_task_id: Option<String>,
2691 #[serde(default, skip_serializing_if = "Option::is_none")]
2694 pub ambient: Option<bool>,
2695 #[serde(default, skip_serializing_if = "Option::is_none")]
2698 pub awaited: Option<bool>,
2699 #[serde(default, skip_serializing_if = "Option::is_none")]
2703 pub off_host: Option<bool>,
2704}
2705
2706#[derive(Debug, Clone, Serialize, Deserialize)]
2707pub struct SessionStateChangedMessage {
2708 pub state: String,
2709 #[serde(default, skip_serializing_if = "Option::is_none")]
2710 pub uuid: Option<String>,
2711 #[serde(default, skip_serializing_if = "Option::is_none")]
2712 pub session_id: Option<String>,
2713}
2714
2715#[derive(Debug, Clone, Serialize, Deserialize)]
2716pub struct WorkerShuttingDownMessage {
2717 pub reason: String,
2718 #[serde(default, skip_serializing_if = "Option::is_none")]
2719 pub uuid: Option<String>,
2720 #[serde(default, skip_serializing_if = "Option::is_none")]
2721 pub session_id: Option<String>,
2722}
2723
2724#[derive(Debug, Clone, Serialize, Deserialize)]
2725pub struct CommandsChangedMessage {
2726 pub commands: Vec<CommandInfo>,
2727 #[serde(default, skip_serializing_if = "Option::is_none")]
2728 pub uuid: Option<String>,
2729 #[serde(default, skip_serializing_if = "Option::is_none")]
2730 pub session_id: Option<String>,
2731}
2732
2733#[derive(Debug, Clone, Serialize, Deserialize)]
2734pub struct CommandInfo {
2735 pub name: String,
2736 pub description: String,
2737 #[serde(rename = "argumentHint")]
2738 pub argument_hint: String,
2739 #[serde(default, skip_serializing_if = "Option::is_none")]
2740 pub aliases: Option<Vec<String>>,
2741 #[serde(default, skip_serializing_if = "Option::is_none")]
2747 pub builtin: Option<bool>,
2748}
2749
2750#[derive(Debug, Clone, Serialize, Deserialize)]
2751pub struct NotificationMessage {
2752 pub key: String,
2753 pub text: String,
2754 pub priority: String,
2755 #[serde(default, skip_serializing_if = "Option::is_none")]
2756 pub color: Option<String>,
2757 #[serde(default, skip_serializing_if = "Option::is_none")]
2758 pub timeout_ms: Option<u64>,
2759 #[serde(default, skip_serializing_if = "Option::is_none")]
2760 pub uuid: Option<String>,
2761 #[serde(default, skip_serializing_if = "Option::is_none")]
2762 pub session_id: Option<String>,
2763}
2764
2765#[derive(Debug, Clone, Serialize, Deserialize)]
2766pub struct FilesPersistedMessage {
2767 pub files: Vec<PersistedFile>,
2768 pub failed: Vec<FailedPersistedFile>,
2769 pub processed_at: String,
2770 #[serde(default, skip_serializing_if = "Option::is_none")]
2771 pub uuid: Option<String>,
2772 #[serde(default, skip_serializing_if = "Option::is_none")]
2773 pub session_id: Option<String>,
2774}
2775
2776#[derive(Debug, Clone, Serialize, Deserialize)]
2777pub struct PersistedFile {
2778 pub filename: String,
2779 pub file_id: String,
2780}
2781
2782#[derive(Debug, Clone, Serialize, Deserialize)]
2783pub struct FailedPersistedFile {
2784 pub filename: String,
2785 pub error: String,
2786}
2787
2788#[derive(Debug, Clone, Serialize, Deserialize)]
2789pub struct MemoryRecallMessage {
2790 pub mode: String,
2791 pub memories: Vec<MemoryRecallItem>,
2792 #[serde(default, skip_serializing_if = "Option::is_none")]
2793 pub uuid: Option<String>,
2794 #[serde(default, skip_serializing_if = "Option::is_none")]
2795 pub session_id: Option<String>,
2796}
2797
2798#[derive(Debug, Clone, Serialize, Deserialize)]
2799pub struct MemoryRecallItem {
2800 pub path: String,
2801 pub scope: String,
2802 #[serde(default, skip_serializing_if = "Option::is_none")]
2803 pub content: Option<String>,
2804}
2805
2806#[derive(Debug, Clone, Serialize, Deserialize)]
2807pub struct ElicitationCompleteMessage {
2808 pub mcp_server_name: String,
2809 pub elicitation_id: String,
2810 #[serde(default, skip_serializing_if = "Option::is_none")]
2811 pub uuid: Option<String>,
2812 #[serde(default, skip_serializing_if = "Option::is_none")]
2813 pub session_id: Option<String>,
2814}
2815
2816#[derive(Debug, Clone, Serialize, Deserialize)]
2817pub struct PermissionDeniedMessage {
2818 pub tool_name: String,
2819 pub tool_use_id: String,
2820 #[serde(default, skip_serializing_if = "Option::is_none")]
2821 pub agent_id: Option<String>,
2822 #[serde(default, skip_serializing_if = "Option::is_none")]
2823 pub decision_reason_type: Option<String>,
2824 #[serde(default, skip_serializing_if = "Option::is_none")]
2828 pub decision_reason_code: Option<PermissionDeniedReasonCode>,
2829 #[serde(default, skip_serializing_if = "Option::is_none")]
2830 pub decision_reason: Option<String>,
2831 pub message: String,
2832 #[serde(default, skip_serializing_if = "Option::is_none")]
2833 pub uuid: Option<String>,
2834 #[serde(default, skip_serializing_if = "Option::is_none")]
2835 pub session_id: Option<String>,
2836}
2837
2838#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2841pub enum PermissionDeniedReasonCode {
2842 ClassifierTranscriptTooLong,
2844 OutsideReadsBlocked,
2846 MemoryPaused,
2848 AutoModeNoCheckInSession,
2853 AutoModeStopNoCheckInSession,
2857 AutoModeStopNoResultForCalls,
2860 AutoModeStopNoVerdict,
2864 Unknown(String),
2866}
2867
2868impl PermissionDeniedReasonCode {
2869 pub fn as_str(&self) -> &str {
2870 match self {
2871 Self::ClassifierTranscriptTooLong => "classifier_transcript_too_long",
2872 Self::OutsideReadsBlocked => "outside_reads_blocked",
2873 Self::MemoryPaused => "memory_paused",
2874 Self::AutoModeNoCheckInSession => "auto_mode_no_check_in_session",
2875 Self::AutoModeStopNoCheckInSession => "auto_mode_stop_no_check_in_session",
2876 Self::AutoModeStopNoResultForCalls => "auto_mode_stop_no_result_for_calls",
2877 Self::AutoModeStopNoVerdict => "auto_mode_stop_no_verdict",
2878 Self::Unknown(s) => s.as_str(),
2879 }
2880 }
2881}
2882
2883impl fmt::Display for PermissionDeniedReasonCode {
2884 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2885 f.write_str(self.as_str())
2886 }
2887}
2888
2889impl From<&str> for PermissionDeniedReasonCode {
2890 fn from(s: &str) -> Self {
2891 match s {
2892 "classifier_transcript_too_long" => Self::ClassifierTranscriptTooLong,
2893 "outside_reads_blocked" => Self::OutsideReadsBlocked,
2894 "memory_paused" => Self::MemoryPaused,
2895 "auto_mode_no_check_in_session" => Self::AutoModeNoCheckInSession,
2896 "auto_mode_stop_no_check_in_session" => Self::AutoModeStopNoCheckInSession,
2897 "auto_mode_stop_no_result_for_calls" => Self::AutoModeStopNoResultForCalls,
2898 "auto_mode_stop_no_verdict" => Self::AutoModeStopNoVerdict,
2899 other => Self::Unknown(other.to_string()),
2900 }
2901 }
2902}
2903
2904impl Serialize for PermissionDeniedReasonCode {
2905 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
2906 serializer.serialize_str(self.as_str())
2907 }
2908}
2909
2910impl<'de> Deserialize<'de> for PermissionDeniedReasonCode {
2911 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
2912 let s = String::deserialize(deserializer)?;
2913 Ok(Self::from(s.as_str()))
2914 }
2915}
2916
2917#[derive(Debug, Clone, Serialize, Deserialize)]
2918pub struct MirrorErrorMessage {
2919 pub error: String,
2920 pub key: MirrorErrorKey,
2921 #[serde(default, skip_serializing_if = "Option::is_none")]
2922 pub uuid: Option<String>,
2923 #[serde(default, skip_serializing_if = "Option::is_none")]
2924 pub session_id: Option<String>,
2925}
2926
2927#[derive(Debug, Clone, Serialize, Deserialize)]
2928pub struct MirrorErrorKey {
2929 #[serde(rename = "projectKey")]
2930 pub project_key: String,
2931 #[serde(rename = "sessionId")]
2932 pub session_id: String,
2933 #[serde(default, skip_serializing_if = "Option::is_none")]
2934 pub subpath: Option<String>,
2935}
2936
2937#[derive(Debug, Clone, Serialize, Deserialize)]
2938pub struct InformationalMessage {
2939 pub content: String,
2940 pub level: String,
2941 #[serde(default, skip_serializing_if = "Option::is_none")]
2942 pub tool_use_id: Option<String>,
2943 #[serde(default, skip_serializing_if = "Option::is_none")]
2944 pub prevent_continuation: Option<bool>,
2945 #[serde(default, skip_serializing_if = "Option::is_none")]
2948 pub tag: Option<String>,
2949 #[serde(default, skip_serializing_if = "Option::is_none")]
2955 pub prompt_submit_outcome: Option<PromptSubmitOutcome>,
2956 #[serde(default, skip_serializing_if = "Option::is_none")]
2960 pub model_restriction: Option<ModelRestriction>,
2961 #[serde(default, skip_serializing_if = "Option::is_none")]
2967 pub hook_no_verdict: Option<HookNoVerdict>,
2968 #[serde(default, skip_serializing_if = "Option::is_none")]
2969 pub uuid: Option<String>,
2970 #[serde(default, skip_serializing_if = "Option::is_none")]
2971 pub session_id: Option<String>,
2972}
2973
2974#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
2980pub struct HookNoVerdict {
2981 pub hook_event: String,
2983 pub tool_use_id: String,
2985 pub timed_out: bool,
2987 #[serde(default, skip_serializing_if = "Option::is_none")]
2989 pub plugin_id: Option<String>,
2990 #[serde(default, skip_serializing_if = "Option::is_none")]
2992 pub plugin_root: Option<String>,
2993}
2994
2995#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3001pub struct ModelRestriction {
3002 pub requested_model: String,
3005 pub effective_model: String,
3008 #[serde(default, skip_serializing_if = "Option::is_none")]
3013 pub at: Option<String>,
3014}
3015
3016#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3019pub struct PromptSubmitOutcome {
3020 #[serde(default, skip_serializing_if = "Option::is_none")]
3024 pub kind: Option<PromptSubmitOutcomeKind>,
3025 #[serde(default, skip_serializing_if = "Option::is_none")]
3032 pub no_verdict_kind: Option<String>,
3033 pub prompt_kept: bool,
3036 #[serde(default, skip_serializing_if = "Option::is_none")]
3040 pub reason: Option<String>,
3041}
3042
3043#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3045pub enum PromptSubmitOutcomeKind {
3046 BlockedByHook,
3048 StoppedByHook,
3050 DroppedByHook,
3052 NotPassedOn,
3054 NoVerdict,
3057 Other(String),
3059}
3060
3061impl PromptSubmitOutcomeKind {
3062 pub fn as_str(&self) -> &str {
3063 match self {
3064 Self::BlockedByHook => "blocked_by_hook",
3065 Self::StoppedByHook => "stopped_by_hook",
3066 Self::DroppedByHook => "dropped_by_hook",
3067 Self::NotPassedOn => "not_passed_on",
3068 Self::NoVerdict => "no_verdict",
3069 Self::Other(s) => s.as_str(),
3070 }
3071 }
3072}
3073
3074impl fmt::Display for PromptSubmitOutcomeKind {
3075 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3076 f.write_str(self.as_str())
3077 }
3078}
3079
3080impl From<&str> for PromptSubmitOutcomeKind {
3081 fn from(s: &str) -> Self {
3082 match s {
3083 "blocked_by_hook" => Self::BlockedByHook,
3084 "stopped_by_hook" => Self::StoppedByHook,
3085 "dropped_by_hook" => Self::DroppedByHook,
3086 "not_passed_on" => Self::NotPassedOn,
3087 "no_verdict" => Self::NoVerdict,
3088 other => Self::Other(other.to_string()),
3089 }
3090 }
3091}
3092
3093impl Serialize for PromptSubmitOutcomeKind {
3094 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
3095 serializer.serialize_str(self.as_str())
3096 }
3097}
3098
3099impl<'de> Deserialize<'de> for PromptSubmitOutcomeKind {
3100 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
3101 let s = String::deserialize(deserializer)?;
3102 Ok(Self::from(s.as_str()))
3103 }
3104}
3105
3106#[derive(Debug, Clone, Serialize, Deserialize)]
3108pub struct PluginInfo {
3109 pub name: String,
3111 pub path: String,
3113 #[serde(skip_serializing_if = "Option::is_none")]
3115 pub source: Option<String>,
3116 #[serde(default, skip_serializing_if = "Option::is_none")]
3118 pub version: Option<String>,
3119}
3120
3121#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
3123pub struct PluginDiagnostic {
3124 pub plugin: String,
3125 #[serde(rename = "type")]
3126 pub diagnostic_type: String,
3127 pub message: String,
3128 #[serde(default, skip_serializing_if = "Option::is_none")]
3134 pub path: Option<String>,
3135 #[serde(default, skip_serializing_if = "Option::is_none")]
3138 pub managed_lock: Option<PluginManagedLock>,
3139}
3140
3141#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3148pub struct PluginManagedLock {
3149 pub plugin_enabled: bool,
3153 pub name: String,
3156 #[serde(default, skip_serializing_if = "Option::is_none")]
3159 pub marketplace: Option<String>,
3160}
3161
3162#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
3164pub struct MemoryPaths {
3165 #[serde(default, skip_serializing_if = "Option::is_none")]
3166 pub auto: Option<String>,
3167 #[serde(default, skip_serializing_if = "Option::is_none")]
3168 pub team: Option<String>,
3169 #[serde(flatten)]
3170 pub extra: serde_json::Map<String, Value>,
3171}
3172
3173#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
3177pub struct McpServerError {
3178 pub name: String,
3179 #[serde(rename = "type")]
3181 pub error_type: String,
3182 pub message: String,
3183}
3184
3185#[derive(Debug, Clone, Serialize, Deserialize)]
3187pub struct InitMessage {
3188 pub session_id: String,
3190 #[serde(skip_serializing_if = "Option::is_none")]
3192 pub cwd: Option<String>,
3193 #[serde(skip_serializing_if = "Option::is_none")]
3195 pub model: Option<String>,
3196 #[serde(default, skip_serializing_if = "Vec::is_empty")]
3198 pub tools: Vec<String>,
3199 #[serde(default, skip_serializing_if = "Vec::is_empty")]
3201 pub mcp_servers: Vec<Value>,
3202 #[serde(default, skip_serializing_if = "Vec::is_empty")]
3204 pub slash_commands: Vec<String>,
3205 #[serde(default, skip_serializing_if = "Vec::is_empty")]
3208 pub terminal_slash_commands: Vec<String>,
3209 #[serde(default, skip_serializing_if = "Vec::is_empty")]
3211 pub agents: Vec<String>,
3212 #[serde(default, skip_serializing_if = "Vec::is_empty")]
3214 pub plugins: Vec<PluginInfo>,
3215 #[serde(default, skip_serializing_if = "Vec::is_empty")]
3217 pub skills: Vec<Value>,
3218 #[serde(skip_serializing_if = "Option::is_none")]
3220 pub claude_code_version: Option<String>,
3221 #[serde(skip_serializing_if = "Option::is_none")]
3224 pub messaging_socket_path: Option<String>,
3225 #[serde(skip_serializing_if = "Option::is_none", rename = "apiKeySource")]
3227 pub api_key_source: Option<ApiKeySource>,
3228 #[serde(skip_serializing_if = "Option::is_none")]
3230 pub output_style: Option<OutputStyle>,
3231 #[serde(skip_serializing_if = "Option::is_none", rename = "permissionMode")]
3233 pub permission_mode: Option<InitPermissionMode>,
3234
3235 #[serde(skip_serializing_if = "Option::is_none")]
3237 pub uuid: Option<String>,
3238
3239 #[serde(skip_serializing_if = "Option::is_none")]
3241 pub memory_paths: Option<MemoryPaths>,
3242
3243 #[serde(default, skip_serializing_if = "Option::is_none")]
3248 pub scratchpad_path: Option<String>,
3249
3250 #[serde(skip_serializing_if = "Option::is_none")]
3252 pub fast_mode_state: Option<String>,
3253
3254 #[serde(default, skip_serializing_if = "Option::is_none")]
3256 pub fast_mode_disabled_reason: Option<super::result::FastModeDisabledReason>,
3257
3258 #[serde(default, skip_serializing_if = "Option::is_none")]
3261 pub mcp_server_errors: Option<Vec<McpServerError>>,
3262
3263 #[serde(default, skip_serializing_if = "Option::is_none")]
3265 pub analytics_disabled: Option<bool>,
3266
3267 #[serde(default, skip_serializing_if = "Option::is_none")]
3269 pub product_feedback_disabled: Option<bool>,
3270
3271 #[serde(default, skip_serializing_if = "Vec::is_empty")]
3273 pub betas: Vec<String>,
3274
3275 #[serde(default, skip_serializing_if = "Vec::is_empty")]
3277 pub capabilities: Vec<String>,
3278
3279 #[serde(default, skip_serializing_if = "Vec::is_empty")]
3281 pub plugin_errors: Vec<PluginDiagnostic>,
3282
3283 #[serde(default, skip_serializing_if = "Vec::is_empty")]
3285 pub plugin_warnings: Vec<PluginDiagnostic>,
3286
3287 #[serde(default, skip_serializing_if = "Option::is_none")]
3292 pub effort: Option<String>,
3293
3294 #[serde(default, skip_serializing_if = "Option::is_none")]
3299 pub cloud_session: Option<Value>,
3300
3301 #[serde(default, skip_serializing_if = "Option::is_none")]
3305 pub footer_indicator: Option<FooterIndicator>,
3306
3307 #[serde(default, skip_serializing_if = "Option::is_none")]
3311 pub worker_epoch: Option<u64>,
3312
3313 #[serde(default, skip_serializing_if = "Option::is_none")]
3317 pub powershell_path: Option<Option<String>>,
3318
3319 #[serde(default, skip_serializing_if = "Option::is_none")]
3323 pub startup_timing: Option<serde_json::Map<String, Value>>,
3324
3325 #[serde(default, skip_serializing_if = "Option::is_none")]
3335 pub per_turn_effort_active: Option<bool>,
3336
3337 #[serde(default, skip_serializing_if = "Option::is_none")]
3345 pub ultrathink_available: Option<bool>,
3346
3347 #[serde(default, skip_serializing_if = "Option::is_none")]
3357 pub ultrathink_typed_raises: Option<bool>,
3358
3359 #[serde(default, skip_serializing_if = "Option::is_none")]
3364 pub client_thinking: Option<ClientThinking>,
3365
3366 #[serde(default, skip_serializing_if = "Option::is_none")]
3371 pub flag_restate_noop: Option<bool>,
3372
3373 #[serde(default, skip_serializing_if = "Option::is_none")]
3381 pub synced_skills_path: Option<String>,
3382
3383 #[serde(default, skip_serializing_if = "Option::is_none")]
3390 pub view_mode: Option<ViewMode>,
3391
3392 #[serde(default, skip_serializing_if = "Option::is_none")]
3399 pub original_cwd: Option<String>,
3400
3401 #[serde(default, skip_serializing_if = "Option::is_none")]
3410 pub additional_directories: Option<Vec<String>>,
3411}
3412
3413#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
3416pub struct ClientThinking {
3417 #[serde(default)]
3420 pub max_thinking_tokens: Option<u64>,
3421 #[serde(default)]
3425 pub thinking_display: Option<String>,
3426}
3427
3428#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
3432pub struct FooterIndicator {
3433 pub text: String,
3436}
3437
3438#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3441pub enum ViewMode {
3442 Focus,
3445 Default,
3447 Unknown(String),
3449}
3450
3451impl ViewMode {
3452 pub fn as_str(&self) -> &str {
3453 match self {
3454 Self::Focus => "focus",
3455 Self::Default => "default",
3456 Self::Unknown(s) => s.as_str(),
3457 }
3458 }
3459}
3460
3461impl fmt::Display for ViewMode {
3462 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3463 f.write_str(self.as_str())
3464 }
3465}
3466
3467impl From<&str> for ViewMode {
3468 fn from(s: &str) -> Self {
3469 match s {
3470 "focus" => Self::Focus,
3471 "default" => Self::Default,
3472 other => Self::Unknown(other.to_string()),
3473 }
3474 }
3475}
3476
3477impl Serialize for ViewMode {
3478 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
3479 serializer.serialize_str(self.as_str())
3480 }
3481}
3482
3483impl<'de> Deserialize<'de> for ViewMode {
3484 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
3485 let s = String::deserialize(deserializer)?;
3486 Ok(Self::from(s.as_str()))
3487 }
3488}
3489
3490#[derive(Debug, Clone, Serialize, Deserialize)]
3492pub struct StatusMessage {
3493 pub session_id: String,
3495 pub status: Option<StatusMessageStatus>,
3497 #[serde(skip_serializing_if = "Option::is_none")]
3499 pub uuid: Option<String>,
3500 #[serde(skip_serializing_if = "Option::is_none", rename = "permissionMode")]
3502 pub permission_mode: Option<InitPermissionMode>,
3503 #[serde(skip_serializing_if = "Option::is_none")]
3504 pub compact_result: Option<String>,
3505 #[serde(skip_serializing_if = "Option::is_none")]
3506 pub compact_error: Option<String>,
3507 #[serde(default, skip_serializing_if = "Option::is_none")]
3514 pub compact_output_chars: Option<u64>,
3515 #[serde(default, skip_serializing_if = "Option::is_none")]
3522 pub resume_held_for_plan: Option<bool>,
3523}
3524
3525#[derive(Debug, Clone, Serialize, Deserialize)]
3527pub struct CompactBoundaryMessage {
3528 pub session_id: String,
3530 pub compact_metadata: CompactMetadata,
3532 #[serde(
3536 default,
3537 skip_serializing_if = "Option::is_none",
3538 alias = "content",
3539 alias = "text"
3540 )]
3541 pub summary: Option<String>,
3542 #[serde(
3546 default,
3547 skip_serializing_if = "Option::is_none",
3548 alias = "message_count"
3549 )]
3550 pub leaf_message_count: Option<u32>,
3551 #[serde(default, skip_serializing_if = "Option::is_none")]
3553 pub duration_ms: Option<u64>,
3554 #[serde(skip_serializing_if = "Option::is_none")]
3556 pub uuid: Option<String>,
3557 #[serde(skip_serializing_if = "Option::is_none")]
3559 pub logical_parent_uuid: Option<Option<String>>,
3560 #[serde(default, skip_serializing_if = "Option::is_none")]
3564 pub historical: Option<bool>,
3565}
3566
3567#[derive(Debug, Clone, Serialize, Deserialize)]
3569pub struct CompactMetadata {
3570 pub pre_tokens: u64,
3572 pub trigger: CompactionTrigger,
3574 #[serde(default, skip_serializing_if = "Option::is_none")]
3575 pub post_tokens: Option<u64>,
3576 #[serde(default, skip_serializing_if = "Option::is_none")]
3577 pub cumulative_dropped_tokens: Option<u64>,
3578 #[serde(default, skip_serializing_if = "Option::is_none")]
3579 pub duration_ms: Option<u64>,
3580 #[serde(default, skip_serializing_if = "Option::is_none")]
3581 pub user_context: Option<String>,
3582 #[serde(default, skip_serializing_if = "Option::is_none")]
3583 pub messages_summarized: Option<u64>,
3584 #[serde(default, skip_serializing_if = "Option::is_none")]
3585 pub precomputed: Option<bool>,
3586 #[serde(default, skip_serializing_if = "Option::is_none")]
3587 pub pre_compact_discovered_tools: Option<Vec<String>>,
3588 #[serde(default, skip_serializing_if = "Option::is_none")]
3593 pub pre_compact_artifact_read_versions: Option<Vec<ArtifactReadVersion>>,
3594 #[serde(default, skip_serializing_if = "Option::is_none")]
3595 pub preserved_segment: Option<PreservedSegment>,
3596 #[serde(default, skip_serializing_if = "Option::is_none")]
3597 pub preserved_messages: Option<PreservedMessages>,
3598}
3599
3600#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
3603pub struct ArtifactReadVersion {
3604 pub slug: String,
3606 pub ver: String,
3608}
3609
3610#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
3611pub struct PreservedSegment {
3612 pub head_uuid: String,
3613 pub anchor_uuid: String,
3614 pub tail_uuid: String,
3615}
3616
3617#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
3618pub struct PreservedMessages {
3619 pub anchor_uuid: String,
3620 pub uuids: Vec<String>,
3621 #[serde(default, skip_serializing_if = "Option::is_none")]
3622 pub all_uuids: Option<Vec<String>>,
3623}
3624
3625#[derive(Debug, Clone, Serialize, Deserialize)]
3631pub struct TaskUsage {
3632 pub duration_ms: u64,
3634 pub tool_uses: u64,
3636 pub total_tokens: u64,
3638}
3639
3640#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3642pub enum TaskType {
3643 LocalAgent,
3645 LocalBash,
3647 LocalWorkflow,
3649 Unknown(String),
3651}
3652
3653impl TaskType {
3654 pub fn as_str(&self) -> &str {
3655 match self {
3656 Self::LocalAgent => "local_agent",
3657 Self::LocalBash => "local_bash",
3658 Self::LocalWorkflow => "local_workflow",
3659 Self::Unknown(s) => s.as_str(),
3660 }
3661 }
3662}
3663
3664impl fmt::Display for TaskType {
3665 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3666 f.write_str(self.as_str())
3667 }
3668}
3669
3670impl From<&str> for TaskType {
3671 fn from(s: &str) -> Self {
3672 match s {
3673 "local_agent" => Self::LocalAgent,
3674 "local_bash" => Self::LocalBash,
3675 "local_workflow" => Self::LocalWorkflow,
3676 other => Self::Unknown(other.to_string()),
3677 }
3678 }
3679}
3680
3681impl Serialize for TaskType {
3682 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
3683 serializer.serialize_str(self.as_str())
3684 }
3685}
3686
3687impl<'de> Deserialize<'de> for TaskType {
3688 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
3689 let s = String::deserialize(deserializer)?;
3690 Ok(Self::from(s.as_str()))
3691 }
3692}
3693
3694#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3696pub enum TaskStatus {
3697 Pending,
3698 Running,
3699 Completed,
3700 Failed,
3701 Killed,
3702 Paused,
3703 Stopped,
3704 Unknown(String),
3705}
3706
3707impl TaskStatus {
3708 pub fn as_str(&self) -> &str {
3709 match self {
3710 Self::Pending => "pending",
3711 Self::Running => "running",
3712 Self::Completed => "completed",
3713 Self::Failed => "failed",
3714 Self::Killed => "killed",
3715 Self::Paused => "paused",
3716 Self::Stopped => "stopped",
3717 Self::Unknown(s) => s.as_str(),
3718 }
3719 }
3720}
3721
3722impl fmt::Display for TaskStatus {
3723 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3724 f.write_str(self.as_str())
3725 }
3726}
3727
3728impl From<&str> for TaskStatus {
3729 fn from(s: &str) -> Self {
3730 match s {
3731 "pending" => Self::Pending,
3732 "running" => Self::Running,
3733 "completed" => Self::Completed,
3734 "failed" => Self::Failed,
3735 "killed" => Self::Killed,
3736 "paused" => Self::Paused,
3737 "stopped" => Self::Stopped,
3738 other => Self::Unknown(other.to_string()),
3739 }
3740 }
3741}
3742
3743impl Serialize for TaskStatus {
3744 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
3745 serializer.serialize_str(self.as_str())
3746 }
3747}
3748
3749impl<'de> Deserialize<'de> for TaskStatus {
3750 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
3751 let s = String::deserialize(deserializer)?;
3752 Ok(Self::from(s.as_str()))
3753 }
3754}
3755
3756#[derive(Debug, Clone, Serialize, Deserialize)]
3758pub struct TaskStartedMessage {
3759 pub session_id: String,
3760 pub task_id: String,
3761 #[serde(default, skip_serializing_if = "Option::is_none")]
3767 pub run_id: Option<String>,
3768 #[serde(default, skip_serializing_if = "Option::is_none")]
3774 pub parent_task_id: Option<String>,
3775 #[serde(default, skip_serializing_if = "Option::is_none")]
3776 pub task_type: Option<TaskType>,
3777 #[serde(default, skip_serializing_if = "Option::is_none")]
3778 pub tool_use_id: Option<String>,
3779 pub description: String,
3780 #[serde(default, skip_serializing_if = "Option::is_none")]
3783 pub subagent_type: Option<String>,
3784 #[serde(default, skip_serializing_if = "Option::is_none")]
3790 pub is_backgrounded: Option<bool>,
3791 #[serde(default, skip_serializing_if = "Option::is_none")]
3799 pub awaited: Option<bool>,
3800 #[serde(default, skip_serializing_if = "Option::is_none")]
3804 pub spawn_depth: Option<u32>,
3805 #[serde(default, skip_serializing_if = "Option::is_none")]
3807 pub prompt: Option<String>,
3808 #[serde(default, skip_serializing_if = "Option::is_none")]
3809 pub workflow_name: Option<String>,
3810 #[serde(default, skip_serializing_if = "Option::is_none")]
3811 pub skip_transcript: Option<bool>,
3812 #[serde(default, skip_serializing_if = "Option::is_none")]
3817 pub ambient: Option<bool>,
3818 pub uuid: String,
3819}
3820
3821#[derive(Debug, Clone, Serialize, Deserialize)]
3825pub struct TaskUpdatedMessage {
3826 pub session_id: String,
3827 pub task_id: String,
3828 #[serde(default, skip_serializing_if = "Option::is_none")]
3831 pub run_id: Option<String>,
3832 pub patch: TaskPatch,
3833 pub uuid: String,
3834}
3835
3836#[derive(Debug, Clone, Default, Serialize, Deserialize)]
3839pub struct TaskPatch {
3840 #[serde(default, skip_serializing_if = "Option::is_none")]
3841 pub status: Option<TaskStatus>,
3842 #[serde(default, skip_serializing_if = "Option::is_none")]
3845 pub end_time: Option<u64>,
3846 #[serde(default, skip_serializing_if = "Option::is_none")]
3847 pub description: Option<String>,
3848 #[serde(default, skip_serializing_if = "Option::is_none")]
3849 pub total_paused_ms: Option<u64>,
3850 #[serde(default, skip_serializing_if = "Option::is_none")]
3851 pub error: Option<String>,
3852 #[serde(default, skip_serializing_if = "Option::is_none")]
3853 pub is_backgrounded: Option<bool>,
3854}
3855
3856#[derive(Debug, Clone, Serialize, Deserialize)]
3859pub struct ThinkingTokensMessage {
3860 pub session_id: String,
3861 pub estimated_tokens: u64,
3863 pub estimated_tokens_delta: u64,
3865 #[serde(default, skip_serializing_if = "Option::is_none")]
3872 pub user_message_uuid: Option<String>,
3873 pub uuid: String,
3874}
3875
3876#[derive(Debug, Clone, Serialize, Deserialize)]
3879pub struct TaskProgressMessage {
3880 pub session_id: String,
3881 pub task_id: String,
3882 #[serde(default, skip_serializing_if = "Option::is_none")]
3885 pub run_id: Option<String>,
3886 #[serde(default, skip_serializing_if = "Option::is_none")]
3887 pub tool_use_id: Option<String>,
3888 pub description: String,
3889 #[serde(default, skip_serializing_if = "Option::is_none")]
3890 pub last_tool_name: Option<String>,
3891 pub usage: TaskUsage,
3892 #[serde(default, skip_serializing_if = "Option::is_none")]
3894 pub subagent_type: Option<String>,
3895 #[serde(default, skip_serializing_if = "Option::is_none")]
3896 pub summary: Option<String>,
3897 pub uuid: String,
3898}
3899
3900#[derive(Debug, Clone, Serialize, Deserialize)]
3903pub struct TaskNotificationMessage {
3904 pub session_id: String,
3905 pub task_id: String,
3906 #[serde(default, skip_serializing_if = "Option::is_none")]
3909 pub run_id: Option<String>,
3910 pub status: TaskStatus,
3911 #[serde(default, skip_serializing_if = "Option::is_none")]
3914 pub reason: Option<TaskEndReason>,
3915 pub summary: String,
3916 pub output_file: Option<String>,
3917 #[serde(skip_serializing_if = "Option::is_none")]
3918 pub tool_use_id: Option<String>,
3919 #[serde(skip_serializing_if = "Option::is_none")]
3920 pub usage: Option<TaskUsage>,
3921 #[serde(default, skip_serializing_if = "Vec::is_empty")]
3927 pub resource_links: Vec<ResourceLink>,
3928 #[serde(default, skip_serializing_if = "Option::is_none")]
3935 pub handback: Option<TaskHandback>,
3936 #[serde(default, skip_serializing_if = "Option::is_none")]
3940 pub handback_report: Option<HandbackReport>,
3941 #[serde(default, skip_serializing_if = "Option::is_none")]
3942 pub skip_transcript: Option<bool>,
3943 #[serde(default, skip_serializing_if = "Option::is_none")]
3946 pub ambient: Option<bool>,
3947 #[serde(skip_serializing_if = "Option::is_none")]
3948 pub uuid: Option<String>,
3949}
3950
3951#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3954pub enum TaskHandback {
3955 Send,
3957 Flagged,
3959 Withheld,
3961 Unknown(String),
3963}
3964
3965impl TaskHandback {
3966 pub fn as_str(&self) -> &str {
3967 match self {
3968 Self::Send => "send",
3969 Self::Flagged => "flagged",
3970 Self::Withheld => "withheld",
3971 Self::Unknown(s) => s.as_str(),
3972 }
3973 }
3974}
3975
3976impl fmt::Display for TaskHandback {
3977 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
3978 f.write_str(self.as_str())
3979 }
3980}
3981
3982impl From<&str> for TaskHandback {
3983 fn from(s: &str) -> Self {
3984 match s {
3985 "send" => Self::Send,
3986 "flagged" => Self::Flagged,
3987 "withheld" => Self::Withheld,
3988 other => Self::Unknown(other.to_string()),
3989 }
3990 }
3991}
3992
3993impl Serialize for TaskHandback {
3994 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
3995 serializer.serialize_str(self.as_str())
3996 }
3997}
3998
3999impl<'de> Deserialize<'de> for TaskHandback {
4000 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
4001 let s = String::deserialize(deserializer)?;
4002 Ok(Self::from(s.as_str()))
4003 }
4004}
4005
4006#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
4009pub struct HandbackReport {
4010 pub text: String,
4013 #[serde(default, skip_serializing_if = "Option::is_none")]
4016 pub warning: Option<String>,
4017}
4018
4019#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4021pub enum AssistantErrorKind {
4022 AuthenticationFailed,
4023 OauthOrgNotAllowed,
4024 AccountOnHold,
4025 BillingError,
4026 RateLimit,
4027 Overloaded,
4028 InvalidRequest,
4029 ModelNotFound,
4030 ServerError,
4031 UnknownError,
4032 MaxOutputTokens,
4033 Unknown(String),
4034}
4035
4036impl AssistantErrorKind {
4037 pub fn as_str(&self) -> &str {
4038 match self {
4039 Self::AuthenticationFailed => "authentication_failed",
4040 Self::OauthOrgNotAllowed => "oauth_org_not_allowed",
4041 Self::AccountOnHold => "account_on_hold",
4042 Self::BillingError => "billing_error",
4043 Self::RateLimit => "rate_limit",
4044 Self::Overloaded => "overloaded",
4045 Self::InvalidRequest => "invalid_request",
4046 Self::ModelNotFound => "model_not_found",
4047 Self::ServerError => "server_error",
4048 Self::UnknownError => "unknown",
4049 Self::MaxOutputTokens => "max_output_tokens",
4050 Self::Unknown(s) => s.as_str(),
4051 }
4052 }
4053}
4054
4055impl fmt::Display for AssistantErrorKind {
4056 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4057 f.write_str(self.as_str())
4058 }
4059}
4060
4061impl From<&str> for AssistantErrorKind {
4062 fn from(s: &str) -> Self {
4063 match s {
4064 "authentication_failed" => Self::AuthenticationFailed,
4065 "oauth_org_not_allowed" => Self::OauthOrgNotAllowed,
4066 "account_on_hold" => Self::AccountOnHold,
4067 "billing_error" => Self::BillingError,
4068 "rate_limit" => Self::RateLimit,
4069 "overloaded" => Self::Overloaded,
4070 "invalid_request" => Self::InvalidRequest,
4071 "model_not_found" => Self::ModelNotFound,
4072 "server_error" => Self::ServerError,
4073 "unknown" => Self::UnknownError,
4074 "max_output_tokens" => Self::MaxOutputTokens,
4075 other => Self::Unknown(other.to_string()),
4076 }
4077 }
4078}
4079
4080impl Serialize for AssistantErrorKind {
4081 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
4082 serializer.serialize_str(self.as_str())
4083 }
4084}
4085
4086impl<'de> Deserialize<'de> for AssistantErrorKind {
4087 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
4088 let s = String::deserialize(deserializer)?;
4089 Ok(Self::from(s.as_str()))
4090 }
4091}
4092
4093#[derive(Debug, Clone, Serialize, Deserialize)]
4100pub struct CodeChangePublishedMessage {
4101 pub provider: String,
4105 pub url: String,
4107 pub repo: String,
4110 pub identifier: String,
4112 #[serde(default, skip_serializing_if = "Option::is_none")]
4121 pub action: Option<String>,
4122 #[serde(default, skip_serializing_if = "Option::is_none")]
4130 pub branch: Option<String>,
4131 pub uuid: String,
4132 pub session_id: String,
4133}
4134
4135#[derive(Debug, Clone, Serialize, Deserialize)]
4140pub struct VcsStateChangedMessage {
4141 pub kind: VcsMutationKind,
4144 pub cwd: String,
4147 #[serde(default, skip_serializing_if = "Option::is_none")]
4152 pub branch: Option<String>,
4153 pub uuid: String,
4154 pub session_id: String,
4155}
4156
4157#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4159pub enum VcsMutationKind {
4160 Commit,
4161 Push,
4162 Merge,
4163 Rebase,
4164 Unknown(String),
4166}
4167
4168impl VcsMutationKind {
4169 pub fn as_str(&self) -> &str {
4170 match self {
4171 Self::Commit => "commit",
4172 Self::Push => "push",
4173 Self::Merge => "merge",
4174 Self::Rebase => "rebase",
4175 Self::Unknown(s) => s.as_str(),
4176 }
4177 }
4178}
4179
4180impl fmt::Display for VcsMutationKind {
4181 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4182 f.write_str(self.as_str())
4183 }
4184}
4185
4186impl From<&str> for VcsMutationKind {
4187 fn from(s: &str) -> Self {
4188 match s {
4189 "commit" => Self::Commit,
4190 "push" => Self::Push,
4191 "merge" => Self::Merge,
4192 "rebase" => Self::Rebase,
4193 other => Self::Unknown(other.to_string()),
4194 }
4195 }
4196}
4197
4198impl Serialize for VcsMutationKind {
4199 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
4200 serializer.serialize_str(self.as_str())
4201 }
4202}
4203
4204impl<'de> Deserialize<'de> for VcsMutationKind {
4205 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
4206 let s = String::deserialize(deserializer)?;
4207 Ok(Self::from(s.as_str()))
4208 }
4209}
4210
4211#[derive(Debug, Clone, Serialize, Deserialize)]
4213pub struct FeedbackDraftQueuedMessage {
4214 pub draft_id: String,
4215 pub draft_type: String,
4216 pub title: String,
4217 pub details_preview: String,
4218 #[serde(default, skip_serializing_if = "Option::is_none")]
4219 pub uuid: Option<String>,
4220 #[serde(default, skip_serializing_if = "Option::is_none")]
4221 pub session_id: Option<String>,
4222 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
4223 pub extra: serde_json::Map<String, Value>,
4224}
4225
4226#[derive(Debug, Clone, Serialize, Deserialize)]
4234pub struct CloudSessionDeltaMessage {
4235 pub seq: u64,
4239 pub changed: Vec<String>,
4243 pub cloud_session: Value,
4247 pub uuid: String,
4248 pub session_id: String,
4249 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
4250 pub extra: serde_json::Map<String, Value>,
4251}
4252
4253#[derive(Debug, Clone, Serialize, Deserialize)]
4269pub struct DevIntentMessage {
4270 pub kind: DevIntentKind,
4272 #[serde(default, skip_serializing_if = "Option::is_none")]
4278 pub trigger: Option<DevIntentTrigger>,
4279 pub uuid: String,
4280 pub session_id: String,
4281 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
4282 pub extra: serde_json::Map<String, Value>,
4283}
4284
4285#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4289pub enum DevIntentKind {
4290 IosApp,
4296 AndroidApp,
4303 Unknown(String),
4305}
4306
4307impl DevIntentKind {
4308 pub fn as_str(&self) -> &str {
4309 match self {
4310 Self::IosApp => "ios_app",
4311 Self::AndroidApp => "android_app",
4312 Self::Unknown(s) => s.as_str(),
4313 }
4314 }
4315}
4316
4317impl fmt::Display for DevIntentKind {
4318 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4319 f.write_str(self.as_str())
4320 }
4321}
4322
4323impl From<&str> for DevIntentKind {
4324 fn from(s: &str) -> Self {
4325 match s {
4326 "ios_app" => Self::IosApp,
4327 "android_app" => Self::AndroidApp,
4328 other => Self::Unknown(other.to_string()),
4329 }
4330 }
4331}
4332
4333impl Serialize for DevIntentKind {
4334 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
4335 serializer.serialize_str(self.as_str())
4336 }
4337}
4338
4339impl<'de> Deserialize<'de> for DevIntentKind {
4340 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
4341 let s = String::deserialize(deserializer)?;
4342 Ok(Self::from(s.as_str()))
4343 }
4344}
4345
4346#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4350pub enum DevIntentTrigger {
4351 SwiftEdit,
4353 UikitImport,
4355 XcodeProject,
4358 IosCommand,
4361 KotlinEdit,
4363 JavaEdit,
4365 AndroidImport,
4367 AndroidManifest,
4369 GradlePlugin,
4371 AndroidCommand,
4374 ProjectScan,
4377 Unknown(String),
4379}
4380
4381impl DevIntentTrigger {
4382 pub fn as_str(&self) -> &str {
4383 match self {
4384 Self::SwiftEdit => "swift_edit",
4385 Self::UikitImport => "uikit_import",
4386 Self::XcodeProject => "xcode_project",
4387 Self::IosCommand => "ios_command",
4388 Self::KotlinEdit => "kotlin_edit",
4389 Self::JavaEdit => "java_edit",
4390 Self::AndroidImport => "android_import",
4391 Self::AndroidManifest => "android_manifest",
4392 Self::GradlePlugin => "gradle_plugin",
4393 Self::AndroidCommand => "android_command",
4394 Self::ProjectScan => "project_scan",
4395 Self::Unknown(s) => s.as_str(),
4396 }
4397 }
4398}
4399
4400impl fmt::Display for DevIntentTrigger {
4401 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4402 f.write_str(self.as_str())
4403 }
4404}
4405
4406impl From<&str> for DevIntentTrigger {
4407 fn from(s: &str) -> Self {
4408 match s {
4409 "swift_edit" => Self::SwiftEdit,
4410 "uikit_import" => Self::UikitImport,
4411 "xcode_project" => Self::XcodeProject,
4412 "ios_command" => Self::IosCommand,
4413 "kotlin_edit" => Self::KotlinEdit,
4414 "java_edit" => Self::JavaEdit,
4415 "android_import" => Self::AndroidImport,
4416 "android_manifest" => Self::AndroidManifest,
4417 "gradle_plugin" => Self::GradlePlugin,
4418 "android_command" => Self::AndroidCommand,
4419 "project_scan" => Self::ProjectScan,
4420 other => Self::Unknown(other.to_string()),
4421 }
4422 }
4423}
4424
4425impl Serialize for DevIntentTrigger {
4426 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
4427 serializer.serialize_str(self.as_str())
4428 }
4429}
4430
4431impl<'de> Deserialize<'de> for DevIntentTrigger {
4432 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
4433 let s = String::deserialize(deserializer)?;
4434 Ok(Self::from(s.as_str()))
4435 }
4436}
4437
4438#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4442pub enum TaskEndReason {
4443 WorkerRestart,
4446 Unknown(String),
4448}
4449
4450impl TaskEndReason {
4451 pub fn as_str(&self) -> &str {
4452 match self {
4453 Self::WorkerRestart => "worker_restart",
4454 Self::Unknown(s) => s.as_str(),
4455 }
4456 }
4457}
4458
4459impl fmt::Display for TaskEndReason {
4460 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4461 f.write_str(self.as_str())
4462 }
4463}
4464
4465impl From<&str> for TaskEndReason {
4466 fn from(s: &str) -> Self {
4467 match s {
4468 "worker_restart" => Self::WorkerRestart,
4469 other => Self::Unknown(other.to_string()),
4470 }
4471 }
4472}
4473
4474impl Serialize for TaskEndReason {
4475 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
4476 serializer.serialize_str(self.as_str())
4477 }
4478}
4479
4480impl<'de> Deserialize<'de> for TaskEndReason {
4481 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
4482 let s = String::deserialize(deserializer)?;
4483 Ok(Self::from(s.as_str()))
4484 }
4485}
4486
4487#[derive(Debug, Clone, Serialize, Deserialize)]
4496pub struct TurnHandoffAvailableMessage {
4497 pub v: u64,
4499 pub tools: Vec<String>,
4501 pub worker_epoch: u64,
4503 #[serde(default, skip_serializing_if = "Option::is_none")]
4507 pub relay_marker: Option<bool>,
4508 #[serde(default, skip_serializing_if = "Option::is_none")]
4516 pub staged_files: Option<bool>,
4517 #[serde(default, skip_serializing_if = "Option::is_none")]
4524 pub no_query_first: Option<bool>,
4525 #[serde(default, skip_serializing_if = "Option::is_none")]
4533 pub home_files: Option<bool>,
4534 #[serde(default, skip_serializing_if = "Option::is_none")]
4538 pub file_names: Option<bool>,
4539 #[serde(default, skip_serializing_if = "Option::is_none")]
4549 pub carried_writes: Option<bool>,
4550 #[serde(default, skip_serializing_if = "Option::is_none")]
4564 pub hydrates_carried_lines: Option<bool>,
4565 #[serde(default, skip_serializing_if = "Option::is_none")]
4571 pub shared_message_id: Option<bool>,
4572 #[serde(default, skip_serializing_if = "Option::is_none")]
4577 pub requires_rewind_request_id: Option<bool>,
4578 pub uuid: String,
4579 pub session_id: String,
4580 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
4581 pub extra: serde_json::Map<String, Value>,
4582}
4583
4584#[derive(Debug, Clone, Serialize, Deserialize)]
4596pub struct TurnPreemptedMessage {
4597 pub reason: String,
4601 pub preempted_by_uuid: String,
4605 #[serde(default)]
4608 pub preempted_message_uuids: Vec<String>,
4609 pub uuid: String,
4610 pub session_id: String,
4611 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
4612 pub extra: serde_json::Map<String, Value>,
4613}
4614
4615#[derive(Debug, Clone, Serialize, Deserialize)]
4623pub struct PeerMessageHoldMessage {
4624 pub state: PeerMessageHoldState,
4630 #[serde(default, skip_serializing_if = "Option::is_none")]
4637 pub message_uuid: Option<String>,
4638 pub lane: PeerMessageLane,
4640 pub from: String,
4645 #[serde(default, skip_serializing_if = "Option::is_none")]
4648 pub from_name: Option<String>,
4649 #[serde(default, skip_serializing_if = "Option::is_none")]
4651 pub cause: Option<PeerMessageHoldCause>,
4652 #[serde(default, skip_serializing_if = "Option::is_none")]
4654 pub outcome: Option<PeerMessageHoldOutcome>,
4655 pub uuid: String,
4656 pub session_id: String,
4657 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
4658 pub extra: serde_json::Map<String, Value>,
4659}
4660
4661#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4663pub enum PeerMessageHoldState {
4664 Held,
4666 Released,
4668 Dropped,
4670 Unknown(String),
4672}
4673
4674impl PeerMessageHoldState {
4675 pub fn as_str(&self) -> &str {
4676 match self {
4677 Self::Held => "held",
4678 Self::Released => "released",
4679 Self::Dropped => "dropped",
4680 Self::Unknown(s) => s.as_str(),
4681 }
4682 }
4683}
4684
4685impl fmt::Display for PeerMessageHoldState {
4686 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4687 f.write_str(self.as_str())
4688 }
4689}
4690
4691impl From<&str> for PeerMessageHoldState {
4692 fn from(s: &str) -> Self {
4693 match s {
4694 "held" => Self::Held,
4695 "released" => Self::Released,
4696 "dropped" => Self::Dropped,
4697 other => Self::Unknown(other.to_string()),
4698 }
4699 }
4700}
4701
4702impl Serialize for PeerMessageHoldState {
4703 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
4704 serializer.serialize_str(self.as_str())
4705 }
4706}
4707
4708impl<'de> Deserialize<'de> for PeerMessageHoldState {
4709 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
4710 let s = String::deserialize(deserializer)?;
4711 Ok(Self::from(s.as_str()))
4712 }
4713}
4714
4715#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4717pub enum PeerMessageLane {
4718 Bridge,
4720 Stdin,
4722 Socket,
4724 Unknown(String),
4726}
4727
4728impl PeerMessageLane {
4729 pub fn as_str(&self) -> &str {
4730 match self {
4731 Self::Bridge => "bridge",
4732 Self::Stdin => "stdin",
4733 Self::Socket => "socket",
4734 Self::Unknown(s) => s.as_str(),
4735 }
4736 }
4737}
4738
4739impl fmt::Display for PeerMessageLane {
4740 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4741 f.write_str(self.as_str())
4742 }
4743}
4744
4745impl From<&str> for PeerMessageLane {
4746 fn from(s: &str) -> Self {
4747 match s {
4748 "bridge" => Self::Bridge,
4749 "stdin" => Self::Stdin,
4750 "socket" => Self::Socket,
4751 other => Self::Unknown(other.to_string()),
4752 }
4753 }
4754}
4755
4756impl Serialize for PeerMessageLane {
4757 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
4758 serializer.serialize_str(self.as_str())
4759 }
4760}
4761
4762impl<'de> Deserialize<'de> for PeerMessageLane {
4763 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
4764 let s = String::deserialize(deserializer)?;
4765 Ok(Self::from(s.as_str()))
4766 }
4767}
4768
4769#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4776pub enum PeerMessageHoldCause {
4777 ExplicitSetting,
4778 ManagedSetting,
4779 RepoSetting,
4780 InvalidSetting,
4781 BypassDefault,
4782 ModeUnknown,
4783 ModeMismatch,
4784 NoModeAsserted,
4785 Unknown(String),
4787}
4788
4789impl PeerMessageHoldCause {
4790 pub fn as_str(&self) -> &str {
4791 match self {
4792 Self::ExplicitSetting => "explicit-setting",
4793 Self::ManagedSetting => "managed-setting",
4794 Self::RepoSetting => "repo-setting",
4795 Self::InvalidSetting => "invalid-setting",
4796 Self::BypassDefault => "bypass-default",
4797 Self::ModeUnknown => "mode-unknown",
4798 Self::ModeMismatch => "mode-mismatch",
4799 Self::NoModeAsserted => "no-mode-asserted",
4800 Self::Unknown(s) => s.as_str(),
4801 }
4802 }
4803}
4804
4805impl fmt::Display for PeerMessageHoldCause {
4806 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4807 f.write_str(self.as_str())
4808 }
4809}
4810
4811impl From<&str> for PeerMessageHoldCause {
4812 fn from(s: &str) -> Self {
4813 match s {
4814 "explicit-setting" => Self::ExplicitSetting,
4815 "managed-setting" => Self::ManagedSetting,
4816 "repo-setting" => Self::RepoSetting,
4817 "invalid-setting" => Self::InvalidSetting,
4818 "bypass-default" => Self::BypassDefault,
4819 "mode-unknown" => Self::ModeUnknown,
4820 "mode-mismatch" => Self::ModeMismatch,
4821 "no-mode-asserted" => Self::NoModeAsserted,
4822 other => Self::Unknown(other.to_string()),
4823 }
4824 }
4825}
4826
4827impl Serialize for PeerMessageHoldCause {
4828 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
4829 serializer.serialize_str(self.as_str())
4830 }
4831}
4832
4833impl<'de> Deserialize<'de> for PeerMessageHoldCause {
4834 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
4835 let s = String::deserialize(deserializer)?;
4836 Ok(Self::from(s.as_str()))
4837 }
4838}
4839
4840#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4843pub enum PeerMessageHoldOutcome {
4844 Expired,
4848 Refused,
4850 Dropped,
4853 Discarded,
4855 Unknown(String),
4857}
4858
4859impl PeerMessageHoldOutcome {
4860 pub fn as_str(&self) -> &str {
4861 match self {
4862 Self::Expired => "expired",
4863 Self::Refused => "refused",
4864 Self::Dropped => "dropped",
4865 Self::Discarded => "discarded",
4866 Self::Unknown(s) => s.as_str(),
4867 }
4868 }
4869}
4870
4871impl fmt::Display for PeerMessageHoldOutcome {
4872 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
4873 f.write_str(self.as_str())
4874 }
4875}
4876
4877impl From<&str> for PeerMessageHoldOutcome {
4878 fn from(s: &str) -> Self {
4879 match s {
4880 "expired" => Self::Expired,
4881 "refused" => Self::Refused,
4882 "dropped" => Self::Dropped,
4883 "discarded" => Self::Discarded,
4884 other => Self::Unknown(other.to_string()),
4885 }
4886 }
4887}
4888
4889impl Serialize for PeerMessageHoldOutcome {
4890 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
4891 serializer.serialize_str(self.as_str())
4892 }
4893}
4894
4895impl<'de> Deserialize<'de> for PeerMessageHoldOutcome {
4896 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
4897 let s = String::deserialize(deserializer)?;
4898 Ok(Self::from(s.as_str()))
4899 }
4900}
4901
4902#[derive(Debug, Clone, Serialize, Deserialize)]
4913pub struct PerTurnEffortChangedMessage {
4914 pub per_turn_effort_active: bool,
4916 pub uuid: String,
4917 pub session_id: String,
4918}
4919
4920#[derive(Debug, Clone, Serialize, Deserialize)]
4927pub struct InstructionSizeWarningMessage {
4928 pub total_chars: u64,
4931 pub total_limit_chars: u64,
4934 pub file_count: u64,
4937 #[serde(default, skip_serializing_if = "Option::is_none")]
4941 pub largest_chars: Option<u64>,
4942 pub uuid: String,
4943 pub session_id: String,
4944}
4945
4946#[derive(Debug, Clone, Serialize, Deserialize)]
4953pub struct FileAttachmentsMissingMessage {
4954 pub message_uuid: String,
4957 pub sent_count: u64,
4959 pub missing: Vec<MissingFileAttachment>,
4961 pub uuid: String,
4962 pub session_id: String,
4963}
4964
4965#[derive(Debug, Clone, Serialize, Deserialize)]
4975pub struct PermissionCheckStatusMessage {
4976 pub tool_use_id: String,
4977 #[serde(default, skip_serializing_if = "Option::is_none")]
4980 pub agent_id: Option<String>,
4981 pub status: PermissionCheckStatus,
4982 pub uuid: String,
4983 pub session_id: String,
4984}
4985
4986#[derive(Debug, Clone, Serialize, Deserialize)]
4991pub struct InheritedAsksSettledMessage {
4992 pub kept_request_ids: Vec<String>,
4995 pub uuid: String,
4996 pub session_id: String,
4997}
4998
4999#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5001pub enum PermissionCheckStatus {
5002 Checking,
5005 Done,
5007 Unknown(String),
5009}
5010
5011impl PermissionCheckStatus {
5012 pub fn as_str(&self) -> &str {
5013 match self {
5014 Self::Checking => "checking",
5015 Self::Done => "done",
5016 Self::Unknown(s) => s.as_str(),
5017 }
5018 }
5019}
5020
5021impl fmt::Display for PermissionCheckStatus {
5022 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5023 f.write_str(self.as_str())
5024 }
5025}
5026
5027impl From<&str> for PermissionCheckStatus {
5028 fn from(s: &str) -> Self {
5029 match s {
5030 "checking" => Self::Checking,
5031 "done" => Self::Done,
5032 other => Self::Unknown(other.to_string()),
5033 }
5034 }
5035}
5036
5037impl Serialize for PermissionCheckStatus {
5038 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
5039 serializer.serialize_str(self.as_str())
5040 }
5041}
5042
5043impl<'de> Deserialize<'de> for PermissionCheckStatus {
5044 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
5045 let s = String::deserialize(deserializer)?;
5046 Ok(Self::from(s.as_str()))
5047 }
5048}
5049
5050#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5052pub struct MissingFileAttachment {
5053 pub file_uuid: String,
5055 pub reason: String,
5060}
5061
5062#[derive(Debug, Clone, Serialize, Deserialize)]
5072pub struct SessionTitleChangedMessage {
5073 pub title: String,
5078 pub uuid: String,
5079 pub session_id: String,
5080}
5081
5082#[derive(Debug, Clone, Serialize, Deserialize)]
5092pub struct SessionWritesLostMessage {
5093 pub error_code: SessionWriteErrorCode,
5096 pub lost: Vec<LostSessionWrite>,
5098 #[serde(default, skip_serializing_if = "Option::is_none")]
5104 pub transcript_session_ids: Option<Vec<String>>,
5105 pub uuid: String,
5106 pub session_id: String,
5110}
5111
5112#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5114pub enum SessionWriteErrorCode {
5115 Enospc,
5117 Edquot,
5119 Unknown(String),
5121}
5122
5123impl SessionWriteErrorCode {
5124 pub fn as_str(&self) -> &str {
5125 match self {
5126 Self::Enospc => "ENOSPC",
5127 Self::Edquot => "EDQUOT",
5128 Self::Unknown(s) => s.as_str(),
5129 }
5130 }
5131}
5132
5133impl fmt::Display for SessionWriteErrorCode {
5134 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5135 f.write_str(self.as_str())
5136 }
5137}
5138
5139impl From<&str> for SessionWriteErrorCode {
5140 fn from(s: &str) -> Self {
5141 match s {
5142 "ENOSPC" => Self::Enospc,
5143 "EDQUOT" => Self::Edquot,
5144 other => Self::Unknown(other.to_string()),
5145 }
5146 }
5147}
5148
5149impl Serialize for SessionWriteErrorCode {
5150 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
5151 serializer.serialize_str(self.as_str())
5152 }
5153}
5154
5155impl<'de> Deserialize<'de> for SessionWriteErrorCode {
5156 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
5157 let s = String::deserialize(deserializer)?;
5158 Ok(Self::from(s.as_str()))
5159 }
5160}
5161
5162#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5164pub enum LostSessionWrite {
5165 Transcript,
5168 GlobalConfig,
5170 Unknown(String),
5172}
5173
5174impl LostSessionWrite {
5175 pub fn as_str(&self) -> &str {
5176 match self {
5177 Self::Transcript => "transcript",
5178 Self::GlobalConfig => "global_config",
5179 Self::Unknown(s) => s.as_str(),
5180 }
5181 }
5182}
5183
5184impl fmt::Display for LostSessionWrite {
5185 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5186 f.write_str(self.as_str())
5187 }
5188}
5189
5190impl From<&str> for LostSessionWrite {
5191 fn from(s: &str) -> Self {
5192 match s {
5193 "transcript" => Self::Transcript,
5194 "global_config" => Self::GlobalConfig,
5195 other => Self::Unknown(other.to_string()),
5196 }
5197 }
5198}
5199
5200impl Serialize for LostSessionWrite {
5201 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
5202 serializer.serialize_str(self.as_str())
5203 }
5204}
5205
5206impl<'de> Deserialize<'de> for LostSessionWrite {
5207 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
5208 let s = String::deserialize(deserializer)?;
5209 Ok(Self::from(s.as_str()))
5210 }
5211}
5212
5213#[derive(Debug, Clone, Serialize, Deserialize)]
5217pub struct UiLogMessage {
5218 pub plugin: String,
5220 pub text: String,
5224 pub uuid: String,
5225 pub session_id: String,
5226}
5227
5228#[derive(Debug, Clone, Serialize, Deserialize)]
5233pub struct UiNotifyMessage {
5234 pub plugin: String,
5239 pub source: String,
5243 pub title: String,
5247 pub text: String,
5251 #[serde(default, skip_serializing_if = "Option::is_none")]
5255 pub key: Option<String>,
5256 #[serde(default, skip_serializing_if = "Option::is_none")]
5260 pub delay_ms: Option<u64>,
5261 #[serde(default, skip_serializing_if = "Option::is_none")]
5264 pub at: Option<u64>,
5265 #[serde(default, skip_serializing_if = "Option::is_none")]
5268 pub until_back: Option<bool>,
5269 #[serde(default)]
5274 pub rewritten: bool,
5275 pub uuid: String,
5276 pub session_id: String,
5277}
5278
5279#[derive(Debug, Clone, Serialize, Deserialize)]
5284pub struct UiNotifyCancelMessage {
5285 pub plugin: String,
5288 pub source: String,
5291 #[serde(default, skip_serializing_if = "Option::is_none")]
5296 pub key: Option<String>,
5297 pub uuid: String,
5298 pub session_id: String,
5299}
5300
5301#[derive(Debug, Clone, Serialize, Deserialize)]
5306pub struct UiToastMessage {
5307 pub plugin: String,
5309 pub text: String,
5313 pub timeout_ms: u64,
5316 pub uuid: String,
5317 pub session_id: String,
5318}
5319
5320#[derive(Debug, Clone, Serialize, Deserialize)]
5324pub struct UiStatusMessage {
5325 pub plugin: String,
5327 pub text: Option<String>,
5332 pub uuid: String,
5333 pub session_id: String,
5334}
5335
5336#[derive(Debug, Clone, Serialize, Deserialize)]
5343pub struct UiInvalidateMessage {
5344 pub event: String,
5347 #[serde(default, skip_serializing_if = "Option::is_none")]
5359 pub instances: Option<Vec<UiInvalidatedInstance>>,
5360 #[serde(default, skip_serializing_if = "Option::is_none")]
5368 pub prompts_screened: Option<bool>,
5369 pub uuid: String,
5370 pub session_id: String,
5371}
5372
5373#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5375pub struct UiInvalidatedInstance {
5376 pub surface: String,
5378 pub component: String,
5380 pub instance_id: String,
5383}
5384
5385#[derive(Debug, Clone, Serialize, Deserialize)]
5392pub struct UiPanesMessage {
5393 pub panes: Vec<UiPane>,
5396 pub shown_id: Option<String>,
5399 pub focused_id: Option<String>,
5402 pub focus_requested_id: Option<String>,
5406 pub uuid: String,
5407 pub session_id: String,
5408}
5409
5410#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5412pub struct UiPane {
5413 pub id: String,
5416 pub title: String,
5419 pub plugin: String,
5421 #[serde(default, skip_serializing_if = "Option::is_none")]
5424 pub close_on_escape: Option<bool>,
5425 #[serde(default, skip_serializing_if = "Option::is_none")]
5428 pub hold_toasts: Option<bool>,
5429 #[serde(default, skip_serializing_if = "Option::is_none")]
5434 pub background_color: Option<String>,
5435 #[serde(default, skip_serializing_if = "Option::is_none")]
5438 pub rows: Option<u64>,
5439 #[serde(default, skip_serializing_if = "Option::is_none")]
5442 pub columns: Option<u64>,
5443 #[serde(default, skip_serializing_if = "Option::is_none")]
5450 pub placement: Option<String>,
5451}
5452
5453#[derive(Debug, Clone, Serialize, Deserialize)]
5461pub struct UiPlacedMessage {
5462 pub rows: Vec<UiPlacedRow>,
5464 pub uuid: String,
5465 pub session_id: String,
5466}
5467
5468#[derive(Debug, Clone, Serialize, Deserialize)]
5470pub struct UiPlacedRow {
5471 pub plugin: String,
5473 pub id: String,
5475 pub request_id: String,
5478 #[serde(default, skip_serializing_if = "Option::is_none")]
5481 pub after_uuid: Option<String>,
5482}
5483
5484#[derive(Debug, Clone, Serialize, Deserialize)]
5488pub struct UiScrollMessage {
5489 pub client_id: String,
5491 pub component: UiSiteComponent,
5493 pub instance_id: String,
5495 pub offset: u64,
5498 #[serde(default, skip_serializing_if = "Option::is_none")]
5501 pub follow_end: Option<bool>,
5502 pub uuid: String,
5503 pub session_id: String,
5504}
5505
5506#[derive(Debug, Clone, Serialize, Deserialize)]
5511pub struct UiFocusMessage {
5512 pub client_id: String,
5514 pub component: UiSiteComponent,
5516 pub instance_id: String,
5518 pub plugin: String,
5520 pub key: String,
5522 pub uuid: String,
5523 pub session_id: String,
5524}
5525
5526#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5528pub enum UiSiteComponent {
5529 Pane,
5531 AbovePrompt,
5533 Unknown(String),
5535}
5536
5537impl UiSiteComponent {
5538 pub fn as_str(&self) -> &str {
5539 match self {
5540 Self::Pane => "Pane",
5541 Self::AbovePrompt => "AbovePrompt",
5542 Self::Unknown(s) => s.as_str(),
5543 }
5544 }
5545}
5546
5547impl fmt::Display for UiSiteComponent {
5548 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5549 f.write_str(self.as_str())
5550 }
5551}
5552
5553impl From<&str> for UiSiteComponent {
5554 fn from(s: &str) -> Self {
5555 match s {
5556 "Pane" => Self::Pane,
5557 "AbovePrompt" => Self::AbovePrompt,
5558 other => Self::Unknown(other.to_string()),
5559 }
5560 }
5561}
5562
5563impl Serialize for UiSiteComponent {
5564 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
5565 serializer.serialize_str(self.as_str())
5566 }
5567}
5568
5569impl<'de> Deserialize<'de> for UiSiteComponent {
5570 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
5571 let s = String::deserialize(deserializer)?;
5572 Ok(Self::from(s.as_str()))
5573 }
5574}
5575
5576#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
5579pub struct LocalCommandRun {
5580 pub command: String,
5582 pub args: String,
5585 #[serde(default, skip_serializing_if = "Option::is_none")]
5590 pub plugin: Option<String>,
5591}
5592
5593#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
5597pub struct LocalCommandOutcome {
5598 pub kind: LocalCommandOutcomeKind,
5599 #[serde(default, skip_serializing_if = "Option::is_none")]
5602 pub suggestion: Option<String>,
5603}
5604
5605#[derive(Debug, Clone, PartialEq, Eq, Hash)]
5610pub enum LocalCommandOutcomeKind {
5611 UnavailableHeadless,
5613 Unknown,
5616 Failed,
5618 RestartRequired,
5620 Other(String),
5622}
5623
5624impl LocalCommandOutcomeKind {
5625 pub fn as_str(&self) -> &str {
5626 match self {
5627 Self::UnavailableHeadless => "unavailable_headless",
5628 Self::Unknown => "unknown",
5629 Self::Failed => "failed",
5630 Self::RestartRequired => "restart_required",
5631 Self::Other(s) => s.as_str(),
5632 }
5633 }
5634}
5635
5636impl fmt::Display for LocalCommandOutcomeKind {
5637 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
5638 f.write_str(self.as_str())
5639 }
5640}
5641
5642impl From<&str> for LocalCommandOutcomeKind {
5643 fn from(s: &str) -> Self {
5644 match s {
5645 "unavailable_headless" => Self::UnavailableHeadless,
5646 "unknown" => Self::Unknown,
5647 "failed" => Self::Failed,
5648 "restart_required" => Self::RestartRequired,
5649 other => Self::Other(other.to_string()),
5650 }
5651 }
5652}
5653
5654impl Serialize for LocalCommandOutcomeKind {
5655 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
5656 serializer.serialize_str(self.as_str())
5657 }
5658}
5659
5660impl<'de> Deserialize<'de> for LocalCommandOutcomeKind {
5661 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
5662 let s = String::deserialize(deserializer)?;
5663 Ok(Self::from(s.as_str()))
5664 }
5665}
5666
5667#[derive(Debug, Clone, Serialize, Deserialize)]
5673pub struct UsageReport {
5674 pub session: super::control::UsageSession,
5676 pub rate_limits: Option<UsageReportRateLimits>,
5680 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
5681 pub extra: serde_json::Map<String, Value>,
5682}
5683
5684#[derive(Debug, Clone, Serialize, Deserialize)]
5686pub struct UsageReportRateLimits {
5687 pub limits: Option<Vec<UsageReportLimit>>,
5695 #[serde(default, skip_serializing_if = "Option::is_none")]
5698 pub extra_usage: Option<UsageReportExtraUsage>,
5699 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
5700 pub extra: serde_json::Map<String, Value>,
5701}
5702
5703#[derive(Debug, Clone, Serialize, Deserialize)]
5705pub struct UsageReportLimit {
5706 pub kind: String,
5709 pub group: String,
5712 pub percent: f64,
5714 pub resets_at: Option<String>,
5716 #[serde(default, skip_serializing_if = "Option::is_none")]
5719 pub scope: Option<UsageReportScope>,
5720 #[serde(default, skip_serializing_if = "Option::is_none")]
5724 pub severity: Option<String>,
5725 #[serde(default, skip_serializing_if = "Option::is_none")]
5727 pub is_active: Option<bool>,
5728 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
5729 pub extra: serde_json::Map<String, Value>,
5730}
5731
5732#[derive(Debug, Clone, Serialize, Deserialize)]
5734pub struct UsageReportScope {
5735 #[serde(default, skip_serializing_if = "Option::is_none")]
5736 pub model: Option<UsageReportScopeLabel>,
5737 #[serde(default, skip_serializing_if = "Option::is_none")]
5738 pub surface: Option<UsageReportScopeLabel>,
5739 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
5740 pub extra: serde_json::Map<String, Value>,
5741}
5742
5743#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
5745pub struct UsageReportScopeLabel {
5746 pub display_name: String,
5747}
5748
5749#[derive(Debug, Clone, Serialize, Deserialize)]
5753pub struct UsageReportExtraUsage {
5754 pub is_enabled: bool,
5756 pub monthly_limit: Option<f64>,
5757 pub used_credits: Option<f64>,
5758 pub utilization: Option<f64>,
5759 #[serde(default, skip_serializing_if = "Option::is_none")]
5760 pub currency: Option<String>,
5761 #[serde(flatten, default, skip_serializing_if = "serde_json::Map::is_empty")]
5762 pub extra: serde_json::Map<String, Value>,
5763}
5764
5765#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
5768pub struct BatchToolUse {
5769 pub id: String,
5770 pub name: String,
5771}
5772
5773#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
5778pub struct ContextUsage {
5779 pub model: String,
5781 pub total_tokens: u64,
5784 pub raw_max_tokens: u64,
5787 pub percentage: u64,
5789 #[serde(default, skip_serializing_if = "Option::is_none")]
5791 pub over_limit: Option<ContextOverLimit>,
5792 #[serde(default)]
5794 pub categories: Vec<ContextCategory>,
5795 #[serde(default)]
5797 pub mcp_tools: Vec<ContextMcpTool>,
5798 #[serde(default)]
5800 pub memory_files: Vec<ContextMemoryFile>,
5801 #[serde(default)]
5803 pub agents: Vec<ContextAgent>,
5804 #[serde(default, skip_serializing_if = "Option::is_none")]
5806 pub skills: Option<Vec<ContextSkill>>,
5807}
5808
5809#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
5811pub struct ContextOverLimit {
5812 pub tokens_over: u64,
5813 pub kind: String,
5816}
5817
5818#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
5820pub struct ContextCategory {
5821 pub name: String,
5824 pub tokens: u64,
5825 pub kind: String,
5829}
5830
5831#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
5833pub struct ContextMcpTool {
5834 pub name: String,
5836 pub server_name: String,
5837 pub tokens: u64,
5838}
5839
5840#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
5842pub struct ContextMemoryFile {
5843 pub path: String,
5844 #[serde(rename = "type")]
5846 pub file_type: String,
5847 pub tokens: u64,
5848}
5849
5850#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
5852pub struct ContextAgent {
5853 pub agent_type: String,
5854 pub source: String,
5856 pub tokens: u64,
5857}
5858
5859#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
5861pub struct ContextSkill {
5862 pub name: String,
5863 pub source: String,
5865 #[serde(default, skip_serializing_if = "Option::is_none")]
5866 pub plugin_name: Option<String>,
5867 pub tokens: u64,
5868}
5869
5870#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
5872pub struct ToolUseMeta {
5873 pub id: String,
5874 pub display_name: String,
5875 #[serde(default, skip_serializing_if = "Option::is_none")]
5876 pub server_display_name: Option<String>,
5877 #[serde(default, skip_serializing_if = "Option::is_none")]
5878 pub icon_url: Option<String>,
5879 #[serde(default, skip_serializing_if = "Option::is_none")]
5884 pub server_id: Option<String>,
5885 #[serde(default, skip_serializing_if = "Option::is_none")]
5893 pub server_id_stamp: Option<String>,
5894 #[serde(default, skip_serializing_if = "Option::is_none")]
5897 pub tool_name: Option<String>,
5898 #[serde(default, skip_serializing_if = "Option::is_none")]
5907 pub artifact_publish: Option<bool>,
5908}
5909
5910#[derive(Debug, Clone, Serialize, Deserialize)]
5912pub struct AssistantMessage {
5913 pub message: AssistantMessageContent,
5914 #[serde(alias = "sessionId")]
5915 pub session_id: String,
5916 #[serde(skip_serializing_if = "Option::is_none")]
5917 pub uuid: Option<String>,
5918 #[serde(skip_serializing_if = "Option::is_none")]
5919 pub parent_tool_use_id: Option<String>,
5920 #[serde(skip_serializing_if = "Option::is_none")]
5922 pub request_id: Option<String>,
5923 #[serde(default, skip_serializing_if = "Option::is_none")]
5928 pub refused_message_id: Option<String>,
5929 #[serde(default, skip_serializing_if = "Option::is_none")]
5938 pub user_message_uuid: Option<String>,
5939 #[serde(default, skip_serializing_if = "Vec::is_empty")]
5945 pub user_message_uuids: Vec<String>,
5946 #[serde(default, skip_serializing_if = "Option::is_none")]
5950 pub agent_id: Option<String>,
5951 #[serde(skip_serializing_if = "Option::is_none")]
5954 pub subagent_type: Option<String>,
5955 #[serde(skip_serializing_if = "Option::is_none")]
5957 pub task_description: Option<String>,
5958 #[serde(skip_serializing_if = "Option::is_none")]
5959 pub error: Option<AssistantErrorKind>,
5960 #[serde(default, skip_serializing_if = "Option::is_none")]
5964 pub aborted: Option<bool>,
5965 #[serde(default, skip_serializing_if = "Option::is_none")]
5970 pub resumed_from_incomplete_thinking: Option<bool>,
5971 #[serde(default, skip_serializing_if = "Vec::is_empty")]
5978 pub supersedes: Vec<String>,
5979 #[serde(skip_serializing_if = "Option::is_none")]
5980 pub timestamp: Option<String>,
5981 #[serde(default, skip_serializing_if = "Vec::is_empty")]
5982 pub tool_use_meta: Vec<ToolUseMeta>,
5983 #[serde(default, skip_serializing_if = "Vec::is_empty")]
5988 pub batch_tool_uses: Vec<BatchToolUse>,
5989 #[serde(default, skip_serializing_if = "Option::is_none")]
5995 pub wire_tool_inputs: Option<serde_json::Map<String, Value>>,
5996 #[serde(default, skip_serializing_if = "Option::is_none")]
6002 pub wire_ingest_context: Option<serde_json::Map<String, Value>>,
6003 #[serde(default, skip_serializing_if = "Option::is_none")]
6007 pub historical: Option<bool>,
6008 #[serde(default, skip_serializing_if = "Option::is_none")]
6016 pub resume_reason: Option<String>,
6017 #[serde(default, skip_serializing_if = "Option::is_none")]
6023 pub local_command_source: Option<String>,
6024 #[serde(default, skip_serializing_if = "Vec::is_empty")]
6033 pub narration_block_indexes: Vec<usize>,
6034 #[serde(default, skip_serializing_if = "Option::is_none")]
6038 pub narration_hint: Option<String>,
6039 #[serde(default, skip_serializing_if = "Option::is_none")]
6048 pub thinking_duration_ms: Option<u64>,
6049 #[serde(default, skip_serializing_if = "Option::is_none")]
6060 pub thinking_display: Option<String>,
6061 #[serde(default, skip_serializing_if = "Option::is_none")]
6065 pub context_usage: Option<ContextUsage>,
6066 #[serde(default, skip_serializing_if = "Option::is_none")]
6074 pub usage_report: Option<Box<UsageReport>>,
6075 #[serde(default, skip_serializing_if = "Option::is_none")]
6082 pub local_command_run: Option<LocalCommandRun>,
6083 #[serde(default, skip_serializing_if = "Option::is_none")]
6089 pub local_command_outcome: Option<LocalCommandOutcome>,
6090 #[serde(default, skip_serializing_if = "Option::is_none")]
6091 pub is_meta: Option<bool>,
6092 #[serde(default, skip_serializing_if = "Option::is_none")]
6093 pub is_virtual: Option<bool>,
6094 #[serde(default, skip_serializing_if = "Option::is_none")]
6095 pub is_api_error_message: Option<bool>,
6096 #[serde(skip_serializing_if = "Option::is_none")]
6097 pub api_error_status: Option<u16>,
6098 #[serde(skip_serializing_if = "Option::is_none")]
6147 pub api_error: Option<String>,
6148 #[serde(default, skip_serializing_if = "Option::is_none")]
6155 pub api_error_code: Option<String>,
6156 #[serde(default, skip_serializing_if = "Option::is_none")]
6168 pub api_error_type: Option<String>,
6169 #[serde(default, skip_serializing_if = "Option::is_none")]
6180 pub api_error_origin: Option<String>,
6181 #[serde(default, skip_serializing_if = "Option::is_none")]
6184 pub api_error_params: Option<ApiErrorParams>,
6185 #[serde(skip_serializing_if = "Option::is_none")]
6186 pub error_details: Option<String>,
6187 #[serde(skip_serializing_if = "Option::is_none")]
6188 pub advisor_model: Option<String>,
6189 #[serde(skip_serializing_if = "Option::is_none")]
6190 pub attribution_agent: Option<String>,
6191 #[serde(skip_serializing_if = "Option::is_none")]
6192 pub attribution_skill: Option<String>,
6193 #[serde(skip_serializing_if = "Option::is_none")]
6194 pub attribution_plugin: Option<String>,
6195 #[serde(skip_serializing_if = "Option::is_none")]
6196 pub attribution_mcp_server: Option<String>,
6197 #[serde(skip_serializing_if = "Option::is_none")]
6198 pub attribution_mcp_tool: Option<String>,
6199}
6200
6201#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
6205pub struct ApiErrorParams {
6206 #[serde(default, skip_serializing_if = "Option::is_none")]
6208 pub effort: Option<String>,
6209 #[serde(default, skip_serializing_if = "Option::is_none")]
6212 pub provider: Option<ApiErrorProvider>,
6213 #[serde(default, skip_serializing_if = "Option::is_none")]
6216 pub remedy: Option<ApiErrorRemedy>,
6217 #[serde(default, skip_serializing_if = "Option::is_none")]
6220 pub media: Option<ApiErrorMedia>,
6221 #[serde(default, skip_serializing_if = "Option::is_none")]
6223 pub media_reason: Option<ApiErrorMediaReason>,
6224 #[serde(default, skip_serializing_if = "Option::is_none")]
6246 pub rate_limit_info: Option<RateLimitInfo>,
6247 #[serde(default, skip_serializing_if = "Option::is_none")]
6252 pub cut: Option<ApiErrorCut>,
6253}
6254
6255#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6257pub enum ApiErrorCut {
6258 OutputLimit,
6260 ContextWindow,
6262 Unknown(String),
6264}
6265
6266impl ApiErrorCut {
6267 pub fn as_str(&self) -> &str {
6268 match self {
6269 Self::OutputLimit => "output_limit",
6270 Self::ContextWindow => "context_window",
6271 Self::Unknown(s) => s.as_str(),
6272 }
6273 }
6274}
6275
6276impl fmt::Display for ApiErrorCut {
6277 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6278 f.write_str(self.as_str())
6279 }
6280}
6281
6282impl From<&str> for ApiErrorCut {
6283 fn from(s: &str) -> Self {
6284 match s {
6285 "output_limit" => Self::OutputLimit,
6286 "context_window" => Self::ContextWindow,
6287 other => Self::Unknown(other.to_string()),
6288 }
6289 }
6290}
6291
6292impl Serialize for ApiErrorCut {
6293 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
6294 serializer.serialize_str(self.as_str())
6295 }
6296}
6297
6298impl<'de> Deserialize<'de> for ApiErrorCut {
6299 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
6300 let s = String::deserialize(deserializer)?;
6301 Ok(Self::from(s.as_str()))
6302 }
6303}
6304
6305#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6307pub enum ApiErrorMedia {
6308 Image,
6309 Document,
6310 Unknown(String),
6312}
6313
6314impl ApiErrorMedia {
6315 pub fn as_str(&self) -> &str {
6316 match self {
6317 Self::Image => "image",
6318 Self::Document => "document",
6319 Self::Unknown(s) => s.as_str(),
6320 }
6321 }
6322}
6323
6324impl fmt::Display for ApiErrorMedia {
6325 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6326 f.write_str(self.as_str())
6327 }
6328}
6329
6330impl From<&str> for ApiErrorMedia {
6331 fn from(s: &str) -> Self {
6332 match s {
6333 "image" => Self::Image,
6334 "document" => Self::Document,
6335 other => Self::Unknown(other.to_string()),
6336 }
6337 }
6338}
6339
6340impl Serialize for ApiErrorMedia {
6341 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
6342 serializer.serialize_str(self.as_str())
6343 }
6344}
6345
6346impl<'de> Deserialize<'de> for ApiErrorMedia {
6347 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
6348 let s = String::deserialize(deserializer)?;
6349 Ok(Self::from(s.as_str()))
6350 }
6351}
6352
6353#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6356pub enum ApiErrorMediaReason {
6357 Unprocessable,
6360 UnsupportedByModel,
6362 MediaBudget,
6365 Unknown(String),
6367}
6368
6369impl ApiErrorMediaReason {
6370 pub fn as_str(&self) -> &str {
6371 match self {
6372 Self::Unprocessable => "unprocessable",
6373 Self::UnsupportedByModel => "unsupported_by_model",
6374 Self::MediaBudget => "media_budget",
6375 Self::Unknown(s) => s.as_str(),
6376 }
6377 }
6378}
6379
6380impl fmt::Display for ApiErrorMediaReason {
6381 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6382 f.write_str(self.as_str())
6383 }
6384}
6385
6386impl From<&str> for ApiErrorMediaReason {
6387 fn from(s: &str) -> Self {
6388 match s {
6389 "unprocessable" => Self::Unprocessable,
6390 "unsupported_by_model" => Self::UnsupportedByModel,
6391 "media_budget" => Self::MediaBudget,
6392 other => Self::Unknown(other.to_string()),
6393 }
6394 }
6395}
6396
6397impl Serialize for ApiErrorMediaReason {
6398 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
6399 serializer.serialize_str(self.as_str())
6400 }
6401}
6402
6403impl<'de> Deserialize<'de> for ApiErrorMediaReason {
6404 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
6405 let s = String::deserialize(deserializer)?;
6406 Ok(Self::from(s.as_str()))
6407 }
6408}
6409
6410#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6412pub enum ApiErrorProvider {
6413 Bedrock,
6414 AnthropicAws,
6415 Mantle,
6416 AnthropicGoogleCloud,
6417 Vertex,
6418 Foundry,
6419 Gateway,
6420 Unknown(String),
6422}
6423
6424impl ApiErrorProvider {
6425 pub fn as_str(&self) -> &str {
6426 match self {
6427 Self::Bedrock => "bedrock",
6428 Self::AnthropicAws => "anthropicAws",
6429 Self::Mantle => "mantle",
6430 Self::AnthropicGoogleCloud => "anthropicGoogleCloud",
6431 Self::Vertex => "vertex",
6432 Self::Foundry => "foundry",
6433 Self::Gateway => "gateway",
6434 Self::Unknown(s) => s.as_str(),
6435 }
6436 }
6437}
6438
6439impl fmt::Display for ApiErrorProvider {
6440 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6441 f.write_str(self.as_str())
6442 }
6443}
6444
6445impl From<&str> for ApiErrorProvider {
6446 fn from(s: &str) -> Self {
6447 match s {
6448 "bedrock" => Self::Bedrock,
6449 "anthropicAws" => Self::AnthropicAws,
6450 "mantle" => Self::Mantle,
6451 "anthropicGoogleCloud" => Self::AnthropicGoogleCloud,
6452 "vertex" => Self::Vertex,
6453 "foundry" => Self::Foundry,
6454 "gateway" => Self::Gateway,
6455 other => Self::Unknown(other.to_string()),
6456 }
6457 }
6458}
6459
6460impl Serialize for ApiErrorProvider {
6461 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
6462 serializer.serialize_str(self.as_str())
6463 }
6464}
6465
6466impl<'de> Deserialize<'de> for ApiErrorProvider {
6467 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
6468 let s = String::deserialize(deserializer)?;
6469 Ok(Self::from(s.as_str()))
6470 }
6471}
6472
6473#[derive(Debug, Clone, PartialEq, Eq, Hash)]
6475pub enum ApiErrorRemedy {
6476 RefreshCommand,
6479 RefreshCredentials,
6481 Adc,
6484 GatewayToken,
6487 HostManaged,
6489 ModelAccess,
6492 Unknown(String),
6494}
6495
6496impl ApiErrorRemedy {
6497 pub fn as_str(&self) -> &str {
6498 match self {
6499 Self::RefreshCommand => "refresh_command",
6500 Self::RefreshCredentials => "refresh_credentials",
6501 Self::Adc => "adc",
6502 Self::GatewayToken => "gateway_token",
6503 Self::HostManaged => "host_managed",
6504 Self::ModelAccess => "model_access",
6505 Self::Unknown(s) => s.as_str(),
6506 }
6507 }
6508}
6509
6510impl fmt::Display for ApiErrorRemedy {
6511 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6512 f.write_str(self.as_str())
6513 }
6514}
6515
6516impl From<&str> for ApiErrorRemedy {
6517 fn from(s: &str) -> Self {
6518 match s {
6519 "refresh_command" => Self::RefreshCommand,
6520 "refresh_credentials" => Self::RefreshCredentials,
6521 "adc" => Self::Adc,
6522 "gateway_token" => Self::GatewayToken,
6523 "host_managed" => Self::HostManaged,
6524 "model_access" => Self::ModelAccess,
6525 other => Self::Unknown(other.to_string()),
6526 }
6527 }
6528}
6529
6530impl Serialize for ApiErrorRemedy {
6531 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
6532 serializer.serialize_str(self.as_str())
6533 }
6534}
6535
6536impl<'de> Deserialize<'de> for ApiErrorRemedy {
6537 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
6538 let s = String::deserialize(deserializer)?;
6539 Ok(Self::from(s.as_str()))
6540 }
6541}
6542
6543#[derive(Debug, Clone, Serialize, Deserialize)]
6545pub struct AssistantMessageContent {
6546 pub id: String,
6547 #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
6549 pub message_type: Option<String>,
6550 pub role: MessageRole,
6551 pub model: String,
6552 pub content: Vec<ContentBlock>,
6553 #[serde(skip_serializing_if = "Option::is_none")]
6554 pub stop_reason: Option<StopReason>,
6555 #[serde(skip_serializing_if = "Option::is_none")]
6556 pub stop_sequence: Option<String>,
6557 #[serde(skip_serializing_if = "Option::is_none")]
6558 pub usage: Option<AssistantUsage>,
6559 #[serde(skip_serializing_if = "Option::is_none")]
6561 pub stop_details: Option<Value>,
6562 #[serde(skip_serializing_if = "Option::is_none")]
6564 pub context_management: Option<Value>,
6565}
6566
6567#[derive(Debug, Clone, Serialize, Deserialize)]
6569pub struct AssistantUsage {
6570 #[serde(default)]
6572 pub input_tokens: u32,
6573
6574 #[serde(default)]
6576 pub output_tokens: u32,
6577
6578 #[serde(default)]
6580 pub cache_creation_input_tokens: u32,
6581
6582 #[serde(default)]
6584 pub cache_read_input_tokens: u32,
6585
6586 #[serde(skip_serializing_if = "Option::is_none")]
6588 pub service_tier: Option<String>,
6589
6590 #[serde(skip_serializing_if = "Option::is_none")]
6592 pub cache_creation: Option<CacheCreationDetails>,
6593
6594 #[serde(skip_serializing_if = "Option::is_none")]
6596 pub inference_geo: Option<String>,
6597
6598 #[serde(default, skip_serializing_if = "Option::is_none")]
6601 pub speed: Option<String>,
6602
6603 #[serde(default, skip_serializing_if = "Option::is_none")]
6606 pub fallback_credit: Option<Value>,
6607}
6608
6609#[derive(Debug, Clone, Serialize, Deserialize)]
6611pub struct CacheCreationDetails {
6612 #[serde(default)]
6614 pub ephemeral_1h_input_tokens: u32,
6615
6616 #[serde(default)]
6618 pub ephemeral_5m_input_tokens: u32,
6619}
6620
6621#[cfg(test)]
6622mod tests {
6623 use crate::io::ClaudeOutput;
6624
6625 #[test]
6626 fn test_subagent_usage_rollup_accumulates_task_results() {
6627 use super::SubagentUsageRollup;
6628
6629 let mut rollup = SubagentUsageRollup::default();
6630
6631 let task_result = r#"{"type":"user","message":{"role":"user","content":[]},"session_id":"7fbc568e-2bd6-45aa-b217-a1cf80004ba1","tool_use_result":{"status":"completed","prompt":"Compute 6 times 7.","agentId":"ab52f22445470d454","agentType":"general-purpose","resolvedModel":"claude-sonnet-4-6","totalDurationMs":1853,"totalTokens":10201,"totalToolUseCount":3}}"#;
6632 let output: ClaudeOutput = serde_json::from_str(task_result).unwrap();
6633 assert!(rollup.observe(&output));
6634 assert_eq!(rollup.subagent_tokens, 10201);
6635 assert_eq!(rollup.agent_count, 1);
6636 assert_eq!(rollup.tool_uses, 3);
6637 assert_eq!(rollup.duration_ms, 1853);
6638
6639 assert!(!rollup.observe(&output));
6641 assert_eq!(rollup.agent_count, 1);
6642 assert_eq!(rollup.subagent_tokens, 10201);
6643
6644 let second = r#"{"type":"user","message":{"role":"user","content":[]},"session_id":"7fbc568e-2bd6-45aa-b217-a1cf80004ba1","tool_use_result":{"status":"completed","agentId":"ffff00001111","totalDurationMs":100,"totalTokens":500,"totalToolUseCount":1}}"#;
6646 let output: ClaudeOutput = serde_json::from_str(second).unwrap();
6647 assert!(rollup.observe(&output));
6648 assert_eq!(rollup.agent_count, 2);
6649 assert_eq!(rollup.subagent_tokens, 10701);
6650 }
6651
6652 #[test]
6653 fn test_subagent_usage_rollup_ignores_non_task_results() {
6654 use super::SubagentUsageRollup;
6655
6656 let mut rollup = SubagentUsageRollup::default();
6657
6658 let tool_search = r#"{"type":"user","message":{"role":"user","content":[]},"session_id":"7fbc568e-2bd6-45aa-b217-a1cf80004ba1","tool_use_result":{"matches":["TaskCreate"],"query":"select:TaskCreate","total_deferred_tools":27}}"#;
6661 let output: ClaudeOutput = serde_json::from_str(tool_search).unwrap();
6662 assert!(!rollup.observe(&output));
6663
6664 let plain = r#"{"type":"user","message":{"role":"user","content":[]},"session_id":"7fbc568e-2bd6-45aa-b217-a1cf80004ba1"}"#;
6666 let output: ClaudeOutput = serde_json::from_str(plain).unwrap();
6667 assert!(!rollup.observe(&output));
6668
6669 let system = r#"{"type":"system","subtype":"status","status":null,"session_id":"7fbc568e-2bd6-45aa-b217-a1cf80004ba1"}"#;
6671 let output: ClaudeOutput = serde_json::from_str(system).unwrap();
6672 assert!(!rollup.observe(&output));
6673
6674 assert_eq!(rollup, SubagentUsageRollup::default());
6675 }
6676
6677 #[test]
6678 fn test_subagent_usage_rollup_over_captured_session() {
6679 use super::SubagentUsageRollup;
6680
6681 let mut rollup = SubagentUsageRollup::default();
6682 let fixture =
6683 include_str!("../../test_cases/subagent_sessions/general_purpose_compute.jsonl");
6684 for line in fixture.lines().filter(|l| !l.trim().is_empty()) {
6685 if let Ok(output) = serde_json::from_str::<ClaudeOutput>(line) {
6686 rollup.observe(&output);
6687 }
6688 }
6689 assert_eq!(rollup.agent_count, 1);
6690 assert_eq!(rollup.subagent_tokens, 10201);
6691 }
6692
6693 #[test]
6694 fn test_system_message_init() {
6695 let json = r#"{
6696 "type": "system",
6697 "subtype": "init",
6698 "session_id": "test-session-123",
6699 "cwd": "/home/user/project",
6700 "model": "claude-sonnet-4",
6701 "tools": ["Bash", "Read", "Write"],
6702 "mcp_servers": [],
6703 "slash_commands": ["compact", "cost", "review"],
6704 "agents": ["Bash", "Explore", "Plan"],
6705 "plugins": [{"name": "rust-analyzer-lsp", "path": "/home/user/.claude/plugins/rust-analyzer-lsp/1.0.0"}],
6706 "skills": [],
6707 "claude_code_version": "2.1.15",
6708 "apiKeySource": "none",
6709 "output_style": "default",
6710 "permissionMode": "default"
6711 }"#;
6712
6713 let output: ClaudeOutput = serde_json::from_str(json).unwrap();
6714 if let ClaudeOutput::System(sys) = output {
6715 assert!(sys.is_init());
6716 assert!(!sys.is_status());
6717 assert!(!sys.is_compact_boundary());
6718
6719 let init = sys.as_init().expect("Should parse as init");
6720 assert_eq!(init.session_id, "test-session-123");
6721 assert_eq!(init.cwd, Some("/home/user/project".to_string()));
6722 assert_eq!(init.model, Some("claude-sonnet-4".to_string()));
6723 assert_eq!(init.tools, vec!["Bash", "Read", "Write"]);
6724 assert_eq!(init.slash_commands, vec!["compact", "cost", "review"]);
6725 assert_eq!(init.agents, vec!["Bash", "Explore", "Plan"]);
6726 assert_eq!(init.plugins.len(), 1);
6727 assert_eq!(init.plugins[0].name, "rust-analyzer-lsp");
6728 assert_eq!(init.claude_code_version, Some("2.1.15".to_string()));
6729 assert_eq!(init.api_key_source, Some(super::ApiKeySource::None));
6730 assert_eq!(init.output_style, Some(super::OutputStyle::Default));
6731 assert_eq!(
6732 init.permission_mode,
6733 Some(super::InitPermissionMode::Default)
6734 );
6735 } else {
6736 panic!("Expected System message");
6737 }
6738 }
6739
6740 #[test]
6741 fn test_system_message_init_from_real_capture() {
6742 let json = include_str!("../../test_cases/tool_use_captures/tool_msg_0.json");
6743 let output: ClaudeOutput = serde_json::from_str(json).unwrap();
6744 if let ClaudeOutput::System(sys) = output {
6745 let init = sys.as_init().expect("Should parse real init capture");
6746 assert_eq!(init.slash_commands.len(), 8);
6747 assert!(init.slash_commands.contains(&"compact".to_string()));
6748 assert!(init.slash_commands.contains(&"review".to_string()));
6749 assert_eq!(init.agents.len(), 5);
6750 assert!(init.agents.contains(&"Bash".to_string()));
6751 assert!(init.agents.contains(&"Explore".to_string()));
6752 assert_eq!(init.plugins.len(), 1);
6753 assert_eq!(init.plugins[0].name, "rust-analyzer-lsp");
6754 assert_eq!(init.claude_code_version, Some("2.1.15".to_string()));
6755 } else {
6756 panic!("Expected System message");
6757 }
6758 }
6759
6760 #[test]
6761 fn test_system_message_status() {
6762 let json = r#"{
6763 "type": "system",
6764 "subtype": "status",
6765 "session_id": "879c1a88-3756-4092-aa95-0020c4ed9692",
6766 "status": "compacting",
6767 "uuid": "32eb9f9d-5ef7-47ff-8fce-bbe22fe7ed93"
6768 }"#;
6769
6770 let output: ClaudeOutput = serde_json::from_str(json).unwrap();
6771 if let ClaudeOutput::System(sys) = output {
6772 assert!(sys.is_status());
6773 assert!(!sys.is_init());
6774
6775 let status = sys.as_status().expect("Should parse as status");
6776 assert_eq!(status.session_id, "879c1a88-3756-4092-aa95-0020c4ed9692");
6777 assert_eq!(status.status, Some(super::StatusMessageStatus::Compacting));
6778 assert_eq!(
6779 status.uuid,
6780 Some("32eb9f9d-5ef7-47ff-8fce-bbe22fe7ed93".to_string())
6781 );
6782 } else {
6783 panic!("Expected System message");
6784 }
6785 }
6786
6787 #[test]
6788 fn test_system_message_status_null() {
6789 let json = r#"{
6790 "type": "system",
6791 "subtype": "status",
6792 "session_id": "879c1a88-3756-4092-aa95-0020c4ed9692",
6793 "status": null,
6794 "uuid": "92d9637e-d00e-418e-acd2-a504e3861c6a"
6795 }"#;
6796
6797 let output: ClaudeOutput = serde_json::from_str(json).unwrap();
6798 if let ClaudeOutput::System(sys) = output {
6799 let status = sys.as_status().expect("Should parse as status");
6800 assert_eq!(status.status, None);
6801 } else {
6802 panic!("Expected System message");
6803 }
6804 }
6805
6806 #[test]
6807 fn test_system_message_task_started() {
6808 let json = r#"{
6809 "type": "system",
6810 "subtype": "task_started",
6811 "session_id": "9abbc466-dad0-4b8e-b6b0-cad5eb7a16b9",
6812 "task_id": "b6daf3f",
6813 "task_type": "local_bash",
6814 "tool_use_id": "toolu_011rfSTFumpJZdCCfzeD7jaS",
6815 "description": "Wait for CI on PR #12",
6816 "uuid": "c4243261-c128-4747-b8c3-5e1c7c10eeb8"
6817 }"#;
6818
6819 let output: ClaudeOutput = serde_json::from_str(json).unwrap();
6820 if let ClaudeOutput::System(sys) = output {
6821 assert!(sys.is_task_started());
6822 assert!(!sys.is_task_progress());
6823 assert!(!sys.is_task_notification());
6824
6825 let task = sys.as_task_started().expect("Should parse as task_started");
6826 assert_eq!(task.session_id, "9abbc466-dad0-4b8e-b6b0-cad5eb7a16b9");
6827 assert_eq!(task.task_id, "b6daf3f");
6828 assert_eq!(task.task_type, Some(super::TaskType::LocalBash));
6829 assert_eq!(
6830 task.tool_use_id.as_deref(),
6831 Some("toolu_011rfSTFumpJZdCCfzeD7jaS")
6832 );
6833 assert_eq!(task.description, "Wait for CI on PR #12");
6834 } else {
6835 panic!("Expected System message");
6836 }
6837 }
6838
6839 #[test]
6840 fn test_system_message_task_started_agent() {
6841 let json = r#"{
6842 "type": "system",
6843 "subtype": "task_started",
6844 "session_id": "bff4f716-17c1-4255-ab7b-eea9d33824e3",
6845 "task_id": "a4a7e0906e5fc64cc",
6846 "task_type": "local_agent",
6847 "tool_use_id": "toolu_01SFz9FwZ1cYgCSy8vRM7wep",
6848 "description": "Explore Scene/ArrayScene duplication",
6849 "uuid": "85a39f5a-e4d4-47f7-9a6d-1125f1a8035f"
6850 }"#;
6851
6852 let output: ClaudeOutput = serde_json::from_str(json).unwrap();
6853 if let ClaudeOutput::System(sys) = output {
6854 let task = sys.as_task_started().expect("Should parse as task_started");
6855 assert_eq!(task.task_type, Some(super::TaskType::LocalAgent));
6856 assert_eq!(task.task_id, "a4a7e0906e5fc64cc");
6857 } else {
6858 panic!("Expected System message");
6859 }
6860 }
6861
6862 #[test]
6863 fn test_system_message_task_progress() {
6864 let json = r#"{
6865 "type": "system",
6866 "subtype": "task_progress",
6867 "session_id": "bff4f716-17c1-4255-ab7b-eea9d33824e3",
6868 "task_id": "a4a7e0906e5fc64cc",
6869 "tool_use_id": "toolu_01SFz9FwZ1cYgCSy8vRM7wep",
6870 "description": "Reading src/jplephem/chebyshev.rs",
6871 "last_tool_name": "Read",
6872 "usage": {
6873 "duration_ms": 13996,
6874 "tool_uses": 9,
6875 "total_tokens": 38779
6876 },
6877 "uuid": "85a39f5a-e4d4-47f7-9a6d-1125f1a8035f"
6878 }"#;
6879
6880 let output: ClaudeOutput = serde_json::from_str(json).unwrap();
6881 if let ClaudeOutput::System(sys) = output {
6882 assert!(sys.is_task_progress());
6883 assert!(!sys.is_task_started());
6884
6885 let progress = sys
6886 .as_task_progress()
6887 .expect("Should parse as task_progress");
6888 assert_eq!(progress.task_id, "a4a7e0906e5fc64cc");
6889 assert_eq!(progress.description, "Reading src/jplephem/chebyshev.rs");
6890 assert_eq!(progress.last_tool_name.as_deref(), Some("Read"));
6891 assert_eq!(progress.usage.duration_ms, 13996);
6892 assert_eq!(progress.usage.tool_uses, 9);
6893 assert_eq!(progress.usage.total_tokens, 38779);
6894 } else {
6895 panic!("Expected System message");
6896 }
6897 }
6898
6899 #[test]
6900 fn test_system_message_task_notification_completed() {
6901 let json = r#"{
6902 "type": "system",
6903 "subtype": "task_notification",
6904 "session_id": "bff4f716-17c1-4255-ab7b-eea9d33824e3",
6905 "task_id": "a0ba761e9dc9c316f",
6906 "tool_use_id": "toolu_01Ho6XVXFLVNjTQ9YqowdBXW",
6907 "status": "completed",
6908 "summary": "Agent \"Write Hipparcos data source doc\" completed",
6909 "output_file": "",
6910 "usage": {
6911 "duration_ms": 172300,
6912 "tool_uses": 11,
6913 "total_tokens": 42005
6914 },
6915 "uuid": "269f49b9-218d-4c8d-9f7e-3a5383a0c5b2"
6916 }"#;
6917
6918 let output: ClaudeOutput = serde_json::from_str(json).unwrap();
6919 if let ClaudeOutput::System(sys) = output {
6920 assert!(sys.is_task_notification());
6921
6922 let notif = sys
6923 .as_task_notification()
6924 .expect("Should parse as task_notification");
6925 assert_eq!(notif.status, super::TaskStatus::Completed);
6926 assert_eq!(
6927 notif.summary,
6928 "Agent \"Write Hipparcos data source doc\" completed"
6929 );
6930 assert_eq!(notif.output_file, Some("".to_string()));
6931 assert_eq!(
6932 notif.tool_use_id,
6933 Some("toolu_01Ho6XVXFLVNjTQ9YqowdBXW".to_string())
6934 );
6935 let usage = notif.usage.expect("Should have usage");
6936 assert_eq!(usage.duration_ms, 172300);
6937 assert_eq!(usage.tool_uses, 11);
6938 assert_eq!(usage.total_tokens, 42005);
6939 } else {
6940 panic!("Expected System message");
6941 }
6942 }
6943
6944 #[test]
6945 fn test_system_message_task_notification_failed_no_usage() {
6946 let json = r#"{
6947 "type": "system",
6948 "subtype": "task_notification",
6949 "session_id": "ea629737-3c36-48a8-a1c4-ad761ad35784",
6950 "task_id": "b98f6a3",
6951 "status": "failed",
6952 "summary": "Background command \"Run FSM calibration\" failed with exit code 1",
6953 "output_file": "/tmp/claude-1000/tasks/b98f6a3.output"
6954 }"#;
6955
6956 let output: ClaudeOutput = serde_json::from_str(json).unwrap();
6957 if let ClaudeOutput::System(sys) = output {
6958 let notif = sys
6959 .as_task_notification()
6960 .expect("Should parse as task_notification");
6961 assert_eq!(notif.status, super::TaskStatus::Failed);
6962 assert!(notif.tool_use_id.is_none());
6963 assert!(notif.usage.is_none());
6964 assert_eq!(
6965 notif.output_file,
6966 Some("/tmp/claude-1000/tasks/b98f6a3.output".to_string())
6967 );
6968 } else {
6969 panic!("Expected System message");
6970 }
6971 }
6972
6973 #[test]
6979 fn test_task_messages_roundtrip_through_value() {
6980 let cases = [
6981 r#"{"type":"system","subtype":"task_started","session_id":"s1",
6982 "task_id":"t1","task_type":"local_bash","tool_use_id":"tu1",
6983 "description":"Sleep 3s","uuid":"u1"}"#,
6984 r#"{"type":"system","subtype":"task_progress","session_id":"s1",
6985 "task_id":"t1","tool_use_id":"tu1","description":"Running ls",
6986 "last_tool_name":"Bash",
6987 "usage":{"duration_ms":100,"tool_uses":1,"total_tokens":500},
6988 "uuid":"u2"}"#,
6989 r#"{"type":"system","subtype":"task_notification","session_id":"s1",
6990 "task_id":"t1","tool_use_id":"tu1","status":"completed",
6991 "summary":"done","output_file":"",
6992 "usage":{"duration_ms":100,"tool_uses":1,"total_tokens":500},
6993 "uuid":"u3"}"#,
6994 ];
6995
6996 for json in cases {
6997 let output: ClaudeOutput = serde_json::from_str(json).unwrap();
6998 let value = serde_json::to_value(&output).unwrap();
6999 let reparsed: ClaudeOutput = serde_json::from_value(value).unwrap();
7000
7001 let ClaudeOutput::System(sys) = reparsed else {
7002 panic!("Expected System variant after round-trip");
7003 };
7004
7005 match sys.subtype {
7006 super::SystemSubtype::TaskStarted => {
7007 assert!(
7008 sys.as_task_started().is_some(),
7009 "as_task_started failed after round-trip"
7010 );
7011 }
7012 super::SystemSubtype::TaskProgress => {
7013 assert!(
7014 sys.as_task_progress().is_some(),
7015 "as_task_progress failed after round-trip"
7016 );
7017 }
7018 super::SystemSubtype::TaskNotification => {
7019 assert!(
7020 sys.as_task_notification().is_some(),
7021 "as_task_notification failed after round-trip"
7022 );
7023 }
7024 other => panic!("unexpected subtype after round-trip: {other:?}"),
7025 }
7026 }
7027 }
7028
7029 #[test]
7030 fn test_system_message_compact_boundary() {
7031 let json = r#"{
7032 "type": "system",
7033 "subtype": "compact_boundary",
7034 "session_id": "879c1a88-3756-4092-aa95-0020c4ed9692",
7035 "compact_metadata": {
7036 "pre_tokens": 155285,
7037 "trigger": "auto"
7038 },
7039 "uuid": "a67780d5-74cb-48b1-9137-7a6e7cee45d7"
7040 }"#;
7041
7042 let output: ClaudeOutput = serde_json::from_str(json).unwrap();
7043 if let ClaudeOutput::System(sys) = output {
7044 assert!(sys.is_compact_boundary());
7045 assert!(!sys.is_init());
7046 assert!(!sys.is_status());
7047
7048 let compact = sys
7049 .as_compact_boundary()
7050 .expect("Should parse as compact_boundary");
7051 assert_eq!(compact.session_id, "879c1a88-3756-4092-aa95-0020c4ed9692");
7052 assert_eq!(compact.compact_metadata.pre_tokens, 155285);
7053 assert_eq!(
7054 compact.compact_metadata.trigger,
7055 super::CompactionTrigger::Auto
7056 );
7057 assert!(compact.summary.is_none());
7059 assert!(compact.leaf_message_count.is_none());
7060 assert!(compact.duration_ms.is_none());
7061 } else {
7062 panic!("Expected System message");
7063 }
7064 }
7065
7066 #[test]
7067 fn test_compact_boundary_with_summary_stats() {
7068 let json = r#"{
7070 "type": "system",
7071 "subtype": "compact_boundary",
7072 "session_id": "s1",
7073 "compact_metadata": { "pre_tokens": 1000, "trigger": "manual" },
7074 "summary": "Summarized the earlier exploration.",
7075 "leaf_message_count": 42,
7076 "duration_ms": 1234,
7077 "uuid": "u1"
7078 }"#;
7079 let output: ClaudeOutput = serde_json::from_str(json).unwrap();
7080 let ClaudeOutput::System(sys) = output else {
7081 panic!("Expected System message");
7082 };
7083 let compact = sys.as_compact_boundary().expect("compact_boundary");
7084 assert_eq!(
7085 compact.summary.as_deref(),
7086 Some("Summarized the earlier exploration.")
7087 );
7088 assert_eq!(compact.leaf_message_count, Some(42));
7089 assert_eq!(compact.duration_ms, Some(1234));
7090
7091 let json_alt = r#"{
7094 "type": "system",
7095 "subtype": "compact_boundary",
7096 "session_id": "s2",
7097 "compact_metadata": { "pre_tokens": 2000, "trigger": "auto" },
7098 "content": "alt-key summary",
7099 "message_count": 7
7100 }"#;
7101 let output: ClaudeOutput = serde_json::from_str(json_alt).unwrap();
7102 let ClaudeOutput::System(sys) = output else {
7103 panic!("Expected System message");
7104 };
7105 let compact = sys.as_compact_boundary().expect("compact_boundary");
7106 assert_eq!(compact.summary.as_deref(), Some("alt-key summary"));
7107 assert_eq!(compact.leaf_message_count, Some(7));
7108 }
7109
7110 #[test]
7111 fn test_init_message_with_new_fields() {
7112 let json = r#"{
7113 "type": "system",
7114 "subtype": "init",
7115 "session_id": "test-session",
7116 "cwd": "/home/user",
7117 "model": "claude-opus-4-7",
7118 "tools": ["Bash"],
7119 "mcp_servers": [],
7120 "permissionMode": "default",
7121 "apiKeySource": "none",
7122 "uuid": "44841a0d-182d-493a-86b5-79800d3d9665",
7123 "memory_paths": {"auto": "/home/user/.claude/projects/memory/"},
7124 "fast_mode_state": "off",
7125 "plugins": [{"name": "lsp", "path": "/plugins/lsp", "source": "lsp@official"}],
7126 "claude_code_version": "2.1.117"
7127 }"#;
7128
7129 let output: ClaudeOutput = serde_json::from_str(json).unwrap();
7130 if let ClaudeOutput::System(sys) = output {
7131 let init = sys.as_init().expect("Should parse as init");
7132 assert_eq!(
7133 init.uuid.as_deref(),
7134 Some("44841a0d-182d-493a-86b5-79800d3d9665")
7135 );
7136 assert!(init.memory_paths.is_some());
7137 assert_eq!(init.fast_mode_state.as_deref(), Some("off"));
7138 assert_eq!(init.plugins[0].source.as_deref(), Some("lsp@official"));
7139 assert_eq!(init.claude_code_version.as_deref(), Some("2.1.117"));
7140 } else {
7141 panic!("Expected System message");
7142 }
7143 }
7144
7145 #[test]
7146 fn test_assistant_message_with_new_fields() {
7147 let json = r#"{
7148 "type": "assistant",
7149 "message": {
7150 "id": "msg_1",
7151 "type": "message",
7152 "role": "assistant",
7153 "model": "claude-opus-4-7",
7154 "content": [{"type": "text", "text": "Hello"}],
7155 "stop_reason": "end_turn",
7156 "stop_details": null,
7157 "context_management": null,
7158 "usage": {
7159 "input_tokens": 100,
7160 "output_tokens": 10,
7161 "cache_creation_input_tokens": 50,
7162 "cache_read_input_tokens": 0,
7163 "service_tier": "standard",
7164 "inference_geo": "not_available"
7165 }
7166 },
7167 "session_id": "abc",
7168 "uuid": "msg-uuid-123"
7169 }"#;
7170
7171 let output: ClaudeOutput = serde_json::from_str(json).unwrap();
7172 if let ClaudeOutput::Assistant(asst) = output {
7173 assert_eq!(asst.message.stop_details, None);
7174 assert_eq!(asst.message.context_management, None);
7175 let usage = asst.message.usage.unwrap();
7176 assert_eq!(usage.inference_geo.as_deref(), Some("not_available"));
7177 } else {
7178 panic!("Expected Assistant message");
7179 }
7180 }
7181
7182 #[test]
7183 fn test_user_message_with_new_fields() {
7184 let json = r#"{
7185 "type": "user",
7186 "message": {
7187 "role": "user",
7188 "content": [{"type": "text", "text": "Hello"}]
7189 },
7190 "session_id": "9abbc466-dad0-4b8e-b6b0-cad5eb7a16b9",
7191 "parent_tool_use_id": "toolu_123",
7192 "uuid": "user-msg-456"
7193 }"#;
7194
7195 let output: ClaudeOutput = serde_json::from_str(json).unwrap();
7196 if let ClaudeOutput::User(user) = output {
7197 assert_eq!(user.parent_tool_use_id.as_deref(), Some("toolu_123"));
7198 assert_eq!(user.uuid.as_deref(), Some("user-msg-456"));
7199 } else {
7200 panic!("Expected User message");
7201 }
7202 }
7203
7204 #[test]
7210 fn test_user_message_preserves_tool_use_result_and_timestamp() {
7211 let json = r#"{
7212 "type":"user",
7213 "message":{"role":"user","content":[{"type":"tool_result","content":"User has answered your questions: . You can now continue with the user's answers in mind.","tool_use_id":"toolu_01331duMqP2PrRaqR2yWa8e4"}]},
7214 "parent_tool_use_id":null,
7215 "session_id":"622ae0c3-3d50-4fa7-9ee0-69d691238c6d",
7216 "uuid":"8ef6e997-a849-4d15-bed3-2837c3d3f4cd",
7217 "timestamp":"2026-05-12T23:12:04.121Z",
7218 "tool_use_result":{"questions":[{"question":"Which color do you prefer?","header":"Color","options":[{"label":"Red","description":"A warm color"},{"label":"Blue","description":"A cool color"}],"multiSelect":false}],"answers":{"Color":"Blue"}}
7219 }"#;
7220
7221 let output: ClaudeOutput = serde_json::from_str(json).unwrap();
7222 let user = match output {
7223 ClaudeOutput::User(u) => u,
7224 other => panic!("Expected User message, got {:?}", other.message_type()),
7225 };
7226
7227 assert_eq!(user.timestamp.as_deref(), Some("2026-05-12T23:12:04.121Z"));
7228 let raw = user
7229 .tool_use_result
7230 .as_ref()
7231 .expect("tool_use_result must be captured");
7232 assert_eq!(raw["answers"]["Color"], "Blue");
7233 assert_eq!(raw["questions"][0]["header"], "Color");
7234
7235 let reser: serde_json::Value = serde_json::to_value(&user).unwrap();
7239 assert_eq!(reser["timestamp"], "2026-05-12T23:12:04.121Z");
7240 assert_eq!(reser["tool_use_result"]["answers"]["Color"], "Blue");
7241 assert_eq!(
7242 reser["tool_use_result"]["questions"][0]["question"],
7243 "Which color do you prefer?"
7244 );
7245
7246 let typed: crate::AskUserQuestionInput = user
7249 .tool_use_result_as::<crate::AskUserQuestionInput>()
7250 .expect("tool_use_result present")
7251 .expect("AskUserQuestionInput parses");
7252 assert_eq!(typed.questions.len(), 1);
7253 assert_eq!(typed.questions[0].header, "Color");
7254 let answers = typed.answers.expect("answers populated");
7255 assert_eq!(answers.get("Color").map(String::as_str), Some("Blue"));
7256 }
7257
7258 #[test]
7261 fn test_user_message_without_tool_use_result_omits_field() {
7262 let json = r#"{
7263 "type":"user",
7264 "message":{"role":"user","content":[{"type":"text","text":"hello"}]},
7265 "session_id":"622ae0c3-3d50-4fa7-9ee0-69d691238c6d"
7266 }"#;
7267
7268 let output: ClaudeOutput = serde_json::from_str(json).unwrap();
7269 let user = match output {
7270 ClaudeOutput::User(u) => u,
7271 _ => panic!("Expected User message"),
7272 };
7273 assert!(user.tool_use_result.is_none());
7274 assert!(user.timestamp.is_none());
7275
7276 let reser = serde_json::to_value(&user).unwrap();
7277 assert!(reser.get("tool_use_result").is_none());
7278 assert!(reser.get("timestamp").is_none());
7279 }
7280
7281 #[test]
7285 fn test_subagent_result_exposes_token_accounting() {
7286 let json = r#"{
7287 "type":"user",
7288 "message":{"role":"user","content":[{"tool_use_id":"toolu_01","type":"tool_result","content":[{"type":"text","text":"21"}]}]},
7289 "session_id":"d3fc5942-75e5-4aa1-a87d-b9484a176541",
7290 "tool_use_result":{
7291 "status":"completed",
7292 "prompt":"Count the .rs files.",
7293 "agentId":"ac4f0276e9d4b6232",
7294 "agentType":"Explore",
7295 "content":[{"type":"text","text":"21"}],
7296 "resolvedModel":"claude-haiku-4-5-20251001",
7297 "totalDurationMs":6869,
7298 "totalTokens":7834,
7299 "totalToolUseCount":1,
7300 "usage":{"input_tokens":6,"cache_creation_input_tokens":125,"cache_read_input_tokens":7699,"output_tokens":4,"service_tier":"standard"},
7301 "toolStats":{"readCount":0,"searchCount":0,"bashCount":1,"editFileCount":0,"linesAdded":0,"linesRemoved":0,"otherToolCount":0}
7302 }
7303 }"#;
7304
7305 let output: ClaudeOutput = serde_json::from_str(json).unwrap();
7306 let user = match output {
7307 ClaudeOutput::User(u) => u,
7308 _ => panic!("Expected User message"),
7309 };
7310
7311 let result = user.subagent_result().expect("subagent result parses");
7312 assert_eq!(result.agent_type.as_deref(), Some("Explore"));
7313 assert_eq!(
7314 result.resolved_model.as_deref(),
7315 Some("claude-haiku-4-5-20251001")
7316 );
7317 assert_eq!(result.total_tokens, Some(7834));
7318 assert_eq!(result.total_duration_ms, Some(6869));
7319 assert_eq!(result.total_tool_use_count, Some(1));
7320
7321 let usage = result.usage.expect("nested usage present");
7322 assert_eq!(usage.input_tokens, 6);
7323 assert_eq!(usage.cache_read_input_tokens, 7699);
7324
7325 let stats = result.tool_stats.expect("toolStats present");
7326 assert_eq!(stats.bash_count, 1);
7327 }
7328
7329 #[test]
7333 fn test_subagent_result_absent_for_non_task_result() {
7334 let json = r#"{
7335 "type":"user",
7336 "message":{"role":"user","content":[{"type":"text","text":"hi"}]},
7337 "session_id":"622ae0c3-3d50-4fa7-9ee0-69d691238c6d",
7338 "tool_use_result":{"questions":[],"answers":{"Color":"Blue"}}
7339 }"#;
7340
7341 let output: ClaudeOutput = serde_json::from_str(json).unwrap();
7342 let user = match output {
7343 ClaudeOutput::User(u) => u,
7344 _ => panic!("Expected User message"),
7345 };
7346
7347 let result = user.subagent_result().expect("lenient parse");
7348 assert_eq!(result.total_tokens, None);
7349 assert_eq!(result.agent_type, None);
7350 }
7351
7352 #[test]
7353 fn test_init_fast_mode_reason_and_mcp_server_errors_fully_wrapped() {
7354 use serde_json::Value;
7355
7356 let raw: Value = serde_json::from_str(
7357 r#"{
7358 "type":"system","subtype":"init","session_id":"s1","uuid":"u1",
7359 "fast_mode_state":"off",
7360 "fast_mode_disabled_reason":"not_first_party",
7361 "mcp_server_errors":[{"name":"broken","type":"invalid_config","message":"url entry with no type"}]
7362 }"#,
7363 )
7364 .unwrap();
7365 crate::io::assert_fully_wrapped(&raw);
7366
7367 let output: ClaudeOutput = serde_json::from_value(raw).unwrap();
7368 let ClaudeOutput::System(sys) = output else {
7369 panic!("expected System");
7370 };
7371 let init = sys.as_init().expect("parses as init");
7372 assert_eq!(
7373 init.fast_mode_disabled_reason,
7374 Some(crate::FastModeDisabledReason::NotFirstParty)
7375 );
7376 let errs = init.mcp_server_errors.unwrap();
7377 assert_eq!(errs.len(), 1);
7378 assert_eq!(errs[0].name, "broken");
7379 assert_eq!(errs[0].error_type, "invalid_config");
7380 }
7381
7382 #[test]
7383 fn test_code_change_published_fully_wrapped() {
7384 use super::{KnownSystemEvent, SystemSubtype};
7385 use serde_json::Value;
7386
7387 let raw: Value = serde_json::from_str(
7388 r#"{
7389 "type":"system","subtype":"code_change_published",
7390 "provider":"github","url":"https://github.com/owner/repo/pull/42",
7391 "repo":"owner/repo","identifier":"42",
7392 "uuid":"u1","session_id":"s1"
7393 }"#,
7394 )
7395 .unwrap();
7396 crate::io::assert_fully_wrapped(&raw);
7397
7398 let output: ClaudeOutput = serde_json::from_value(raw).unwrap();
7399 let ClaudeOutput::System(sys) = output else {
7400 panic!("expected System");
7401 };
7402 assert_eq!(sys.subtype, SystemSubtype::CodeChangePublished);
7403 let Some(KnownSystemEvent::CodeChangePublished(msg)) = sys.as_known_system_event() else {
7404 panic!("expected CodeChangePublished event");
7405 };
7406 assert_eq!(msg.provider, "github");
7407 assert_eq!(msg.repo, "owner/repo");
7408 assert_eq!(msg.identifier, "42");
7409
7410 assert!(sys.is_code_change_published());
7411 assert!(!sys.is_vcs_state_changed());
7412 let direct = sys.as_code_change_published().expect("direct accessor");
7413 assert_eq!(direct.url, "https://github.com/owner/repo/pull/42");
7414 assert!(sys.as_vcs_state_changed().is_none());
7415 }
7416
7417 #[test]
7418 fn test_feedback_draft_queued_fully_wrapped() {
7419 use super::{KnownSystemEvent, SystemSubtype};
7420 use serde_json::Value;
7421
7422 let raw: Value = serde_json::from_str(
7423 r#"{
7424 "type":"system","subtype":"feedback_draft_queued",
7425 "draft_id":"draft-1","draft_type":"bug_report",
7426 "title":"Tool output was truncated",
7427 "details_preview":"The last command omitted its final lines",
7428 "uuid":"u1","session_id":"s1","future_field":"preserved"
7429 }"#,
7430 )
7431 .unwrap();
7432 crate::io::assert_fully_wrapped(&raw);
7433
7434 let output: ClaudeOutput = serde_json::from_value(raw).unwrap();
7435 let ClaudeOutput::System(sys) = output else {
7436 panic!("expected System");
7437 };
7438 assert_eq!(sys.subtype, SystemSubtype::FeedbackDraftQueued);
7439 assert!(sys.is_feedback_draft_queued());
7440 assert!(!sys.is_vcs_state_changed());
7441
7442 let direct = sys
7443 .as_feedback_draft_queued()
7444 .expect("direct typed accessor");
7445 assert_eq!(direct.draft_id, "draft-1");
7446 assert_eq!(direct.draft_type, "bug_report");
7447 assert_eq!(direct.extra["future_field"], "preserved");
7448
7449 let Some(KnownSystemEvent::FeedbackDraftQueued(known)) = sys.as_known_system_event() else {
7450 panic!("expected FeedbackDraftQueued event");
7451 };
7452 assert_eq!(known.title, "Tool output was truncated");
7453 assert_eq!(
7454 sys.typed_value().expect("typed value")["future_field"],
7455 "preserved"
7456 );
7457 }
7458
7459 #[test]
7460 fn test_cloud_session_delta_fully_wrapped() {
7461 use super::{KnownSystemEvent, SystemSubtype};
7462 use serde_json::Value;
7463
7464 let raw: Value = serde_json::from_str(
7465 r#"{
7466 "type":"system","subtype":"cloud_session_delta",
7467 "seq":3,"changed":["serving","connection"],
7468 "cloud_session":{"id":"session_abc","view_url":"https://example.invalid/s/abc",
7469 "serving":{"state":"on"},"connection":{"state":"live"}},
7470 "uuid":"u1","session_id":"s1","future_field":"preserved"
7471 }"#,
7472 )
7473 .unwrap();
7474 crate::io::assert_fully_wrapped(&raw);
7475
7476 let output: ClaudeOutput = serde_json::from_value(raw).unwrap();
7477 let ClaudeOutput::System(sys) = output else {
7478 panic!("expected System");
7479 };
7480 assert_eq!(sys.subtype, SystemSubtype::CloudSessionDelta);
7481 assert!(sys.is_cloud_session_delta());
7482 assert!(!sys.is_feedback_draft_queued());
7483
7484 let direct = sys.as_cloud_session_delta().expect("direct typed accessor");
7485 assert_eq!(direct.seq, 3);
7486 assert_eq!(direct.changed, vec!["serving", "connection"]);
7487 assert_eq!(direct.cloud_session["id"], "session_abc");
7488 assert_eq!(direct.extra["future_field"], "preserved");
7489
7490 let Some(KnownSystemEvent::CloudSessionDelta(known)) = sys.as_known_system_event() else {
7491 panic!("expected CloudSessionDelta event");
7492 };
7493 assert_eq!(known.session_id, "s1");
7494 assert_eq!(
7495 sys.typed_value().expect("typed value")["future_field"],
7496 "preserved"
7497 );
7498 }
7499
7500 #[test]
7501 fn test_vcs_state_changed_fully_wrapped() {
7502 use super::{KnownSystemEvent, VcsMutationKind};
7503 use serde_json::Value;
7504
7505 for kind in ["commit", "push", "merge", "rebase"] {
7506 let raw: Value = serde_json::from_str(&format!(
7507 r#"{{"type":"system","subtype":"vcs_state_changed","kind":"{}","cwd":"/repo","uuid":"u1","session_id":"s1"}}"#,
7508 kind
7509 ))
7510 .unwrap();
7511 crate::io::assert_fully_wrapped(&raw);
7512
7513 let output: ClaudeOutput = serde_json::from_value(raw).unwrap();
7514 let ClaudeOutput::System(sys) = output else {
7515 panic!("expected System");
7516 };
7517 let Some(KnownSystemEvent::VcsStateChanged(msg)) = sys.as_known_system_event() else {
7518 panic!("expected VcsStateChanged event");
7519 };
7520 assert_eq!(msg.kind.as_str(), kind);
7521 assert!(!matches!(msg.kind, VcsMutationKind::Unknown(_)));
7522 }
7523
7524 let raw: Value = serde_json::from_str(
7526 r#"{"type":"system","subtype":"vcs_state_changed","kind":"tag","cwd":"/repo","uuid":"u2","session_id":"s2"}"#,
7527 )
7528 .unwrap();
7529 crate::io::assert_fully_wrapped(&raw);
7530 let output: ClaudeOutput = serde_json::from_value(raw).unwrap();
7531 let ClaudeOutput::System(sys) = output else {
7532 panic!("expected System");
7533 };
7534 let Some(KnownSystemEvent::VcsStateChanged(msg)) = sys.as_known_system_event() else {
7535 panic!("expected VcsStateChanged event");
7536 };
7537 assert_eq!(msg.kind, VcsMutationKind::Unknown("tag".to_string()));
7538
7539 assert!(sys.is_vcs_state_changed());
7540 let direct = sys.as_vcs_state_changed().expect("direct accessor");
7541 assert_eq!(direct.cwd, "/repo");
7542 assert!(sys.as_code_change_published().is_none());
7543 }
7544
7545 #[test]
7546 fn test_assistant_aborted_and_resume_flags_roundtrip() {
7547 let json = r#"{
7548 "type":"assistant",
7549 "message":{"id":"msg_1","role":"assistant","model":"claude-3","content":[{"type":"text","text":"partial"}]},
7550 "session_id":"s1",
7551 "aborted":true,
7552 "resumed_from_incomplete_thinking":true
7553 }"#;
7554 let output: ClaudeOutput = serde_json::from_str(json).unwrap();
7555 let ClaudeOutput::Assistant(msg) = &output else {
7556 panic!("expected Assistant");
7557 };
7558 assert_eq!(msg.aborted, Some(true));
7559 assert_eq!(msg.resumed_from_incomplete_thinking, Some(true));
7560 let reserialized = serde_json::to_string(&output).unwrap();
7561 assert!(reserialized.contains("\"aborted\":true"));
7562 assert!(reserialized.contains("\"resumed_from_incomplete_thinking\":true"));
7563
7564 let json = r#"{
7566 "type":"assistant",
7567 "message":{"id":"msg_2","role":"assistant","model":"claude-3","content":[]},
7568 "session_id":"s2"
7569 }"#;
7570 let output: ClaudeOutput = serde_json::from_str(json).unwrap();
7571 let reserialized = serde_json::to_string(&output).unwrap();
7572 assert!(!reserialized.contains("aborted"));
7573 assert!(!reserialized.contains("resumed_from_incomplete_thinking"));
7574 }
7575
7576 #[test]
7577 fn test_user_tool_result_meta_roundtrip() {
7578 let json = r#"{
7579 "type":"user",
7580 "message":{"role":"user","content":[{"type":"tool_result","tool_use_id":"toolu_1","content":"denied"}]},
7581 "session_id":"622ae0c3-3d50-4fa7-9ee0-69d691238c6d",
7582 "tool_result_meta":[
7583 {"id":"toolu_1","non_execution_kind":"user-rejected","user_feedback":"use the staging db"},
7584 {"id":"toolu_2","non_execution_kind":"permission-rule"}
7585 ]
7586 }"#;
7587 let output: ClaudeOutput = serde_json::from_str(json).unwrap();
7588 let ClaudeOutput::User(user) = &output else {
7589 panic!("expected User");
7590 };
7591 let meta = user.tool_result_meta.as_ref().unwrap();
7592 assert_eq!(meta.len(), 2);
7593 assert_eq!(meta[0].non_execution_kind.as_deref(), Some("user-rejected"));
7594 assert_eq!(meta[0].user_feedback.as_deref(), Some("use the staging db"));
7595 assert_eq!(meta[1].user_feedback, None);
7596
7597 let reserialized = serde_json::to_string(&output).unwrap();
7598 assert!(reserialized.contains("\"non_execution_kind\":\"user-rejected\""));
7599 assert!(!reserialized.contains("\"user_feedback\":null"));
7600 }
7601
7602 #[test]
7606 fn model_refusal_fallback_scope_roundtrips_and_defaults() {
7607 use super::{ModelRefusalFallbackMessage, RefusalFallbackScope};
7608 let with_scope = serde_json::json!({
7609 "trigger": "refusal",
7610 "direction": "retry",
7611 "scope": "local",
7612 "original_model": "claude-fable-5",
7613 "fallback_model": "claude-opus-5",
7614 "request_id": null,
7615 "content": "Refused; retried on fallback model.",
7616 "uuid": "u1",
7617 "session_id": "s1"
7618 });
7619 let msg: ModelRefusalFallbackMessage = serde_json::from_value(with_scope.clone()).unwrap();
7620 assert_eq!(msg.scope, Some(RefusalFallbackScope::Local));
7621 assert_eq!(serde_json::to_value(&msg).unwrap(), with_scope);
7622
7623 let mut without = with_scope.clone();
7626 without.as_object_mut().unwrap().remove("scope");
7627 let msg: ModelRefusalFallbackMessage = serde_json::from_value(without.clone()).unwrap();
7628 assert_eq!(msg.scope, None);
7629 assert_eq!(serde_json::to_value(&msg).unwrap(), without);
7630
7631 assert_eq!(
7633 RefusalFallbackScope::from("workspace").as_str(),
7634 "workspace"
7635 );
7636 }
7637}