Skip to main content

claude_codes/io/
claude_input.rs

1use serde::{Deserialize, Serialize};
2use serde_json::Value;
3use uuid::Uuid;
4
5use super::content_blocks::{ContentBlock, ImageBlock, ImageSource, TextBlock};
6use super::control::{ControlRequest, ControlResponse};
7use super::message_types::{MessageContent, UserMessage};
8
9/// Top-level enum for all possible Claude input messages.
10///
11/// Keep variants unboxed so pattern matches and constructors stay ergonomic.
12#[allow(clippy::large_enum_variant)]
13#[derive(Debug, Clone, Serialize, Deserialize)]
14#[serde(tag = "type", rename_all = "snake_case")]
15pub enum ClaudeInput {
16    /// User message input
17    User(UserMessage),
18
19    /// Control request (for initialization handshake)
20    ControlRequest(ControlRequest),
21
22    /// Control response (for tool permission responses)
23    ControlResponse(ControlResponse),
24
25    /// Raw JSON for untyped messages
26    #[serde(untagged)]
27    Raw(Value),
28}
29
30impl ClaudeInput {
31    /// Create a simple text user message
32    pub fn user_message(text: impl Into<String>, session_id: Uuid) -> Self {
33        Self::text_user_message(text, Some(session_id))
34    }
35
36    /// Create a simple text user message associated with the current CLI
37    /// process session.
38    pub fn user_message_without_session(text: impl Into<String>) -> Self {
39        Self::text_user_message(text, None)
40    }
41
42    fn text_user_message(text: impl Into<String>, session_id: Option<Uuid>) -> Self {
43        ClaudeInput::User(UserMessage {
44            message: MessageContent {
45                role: super::MessageRole::User,
46                content: vec![ContentBlock::Text(TextBlock {
47                    text: text.into(),
48                    citations: Vec::new(),
49                })],
50            },
51            session_id,
52            parent_tool_use_id: None,
53            uuid: None,
54            timestamp: None,
55            tool_use_result: None,
56            agent_id: None,
57            subagent_type: None,
58            task_description: None,
59            origin: None,
60            priority: None,
61            is_synthetic: None,
62            should_query: None,
63            is_meta: None,
64            is_visible_in_transcript_only: None,
65            is_virtual: None,
66            is_compact_summary: None,
67            summarize_metadata: None,
68            mcp_meta: None,
69            tool_result_meta: None,
70            source_tool_use_id: None,
71            source_tool_assistant_uuid: None,
72            image_paste_ids: None,
73            client_platform: None,
74            inbound_origin: None,
75            keeps_request_id: None,
76            is_replay: None,
77            file_attachments: None,
78            seeded_summon: None,
79            client_composed: None,
80            text_not_typed: None,
81            initiator: None,
82            pasted_content: None,
83            historical: None,
84            server_received_wall_ms: None,
85            refused_message_id: None,
86            requeue_if_interrupted_within_ms: None,
87            ultrathink_typed: None,
88            tool_states: None,
89            plugin_prompt: None,
90            retracted_message_uuids: None,
91        })
92    }
93
94    /// Create a user message with content blocks
95    pub fn user_message_blocks(blocks: Vec<ContentBlock>, session_id: Uuid) -> Self {
96        ClaudeInput::User(UserMessage {
97            message: MessageContent {
98                role: super::MessageRole::User,
99                content: blocks,
100            },
101            session_id: Some(session_id),
102            parent_tool_use_id: None,
103            uuid: None,
104            timestamp: None,
105            tool_use_result: None,
106            agent_id: None,
107            subagent_type: None,
108            task_description: None,
109            origin: None,
110            priority: None,
111            is_synthetic: None,
112            should_query: None,
113            is_meta: None,
114            is_visible_in_transcript_only: None,
115            is_virtual: None,
116            is_compact_summary: None,
117            summarize_metadata: None,
118            mcp_meta: None,
119            tool_result_meta: None,
120            source_tool_use_id: None,
121            source_tool_assistant_uuid: None,
122            image_paste_ids: None,
123            client_platform: None,
124            inbound_origin: None,
125            keeps_request_id: None,
126            is_replay: None,
127            file_attachments: None,
128            seeded_summon: None,
129            client_composed: None,
130            text_not_typed: None,
131            initiator: None,
132            pasted_content: None,
133            historical: None,
134            server_received_wall_ms: None,
135            refused_message_id: None,
136            requeue_if_interrupted_within_ms: None,
137            ultrathink_typed: None,
138            tool_states: None,
139            plugin_prompt: None,
140            retracted_message_uuids: None,
141        })
142    }
143
144    /// Create an interrupt control request.
145    ///
146    /// Serializes to the `control_request` envelope the CLI requires:
147    /// `{"type":"control_request","request_id":...,"request":{"subtype":"interrupt"}}`,
148    /// telling Claude to stop its current response and return control
149    /// without killing the session. The CLI acknowledges with a
150    /// `control_response` carrying the same `request_id`.
151    ///
152    /// `request_id` must be unique per request; the clients generate
153    /// `interrupt-<uuid>` ids.
154    pub fn interrupt(request_id: impl Into<String>) -> Self {
155        ClaudeInput::ControlRequest(ControlRequest {
156            request_id: request_id.into(),
157            request: super::ControlRequestPayload::Interrupt,
158        })
159    }
160
161    /// Create an `apply_flag_settings` control request, e.g. to change the
162    /// session's effort level or toggle ultracode mid-session.
163    ///
164    /// Serializes to
165    /// `{"type":"control_request","request_id":...,"request":{"subtype":"apply_flag_settings","settings":{...}}}`.
166    /// The CLI answers with a `control_response` carrying the same
167    /// `request_id`. The clients generate `apply-flag-settings-<uuid>` ids.
168    pub fn apply_flag_settings(
169        request_id: impl Into<String>,
170        settings: super::ApplyFlagSettingsRequest,
171    ) -> Self {
172        ClaudeInput::ControlRequest(ControlRequest {
173            request_id: request_id.into(),
174            request: super::ControlRequestPayload::ApplyFlagSettings(settings),
175        })
176    }
177
178    /// Create a user message with an image and optional text
179    /// Only supports JPEG, PNG, GIF, and WebP media types
180    pub fn user_message_with_image(
181        image_data: String,
182        media_type: super::MediaType,
183        text: Option<String>,
184        session_id: Uuid,
185    ) -> Result<Self, String> {
186        // Validate media type
187        match &media_type {
188            super::MediaType::Jpeg
189            | super::MediaType::Png
190            | super::MediaType::Gif
191            | super::MediaType::Webp => {}
192            other => {
193                return Err(format!(
194                    "Invalid media type '{}'. Only JPEG, PNG, GIF, and WebP are supported.",
195                    other
196                ));
197            }
198        }
199
200        let mut blocks = vec![ContentBlock::Image(ImageBlock {
201            source: ImageSource {
202                source_type: super::ImageSourceType::Base64,
203                media_type,
204                data: image_data,
205            },
206        })];
207
208        if let Some(text_content) = text {
209            blocks.push(ContentBlock::Text(TextBlock {
210                text: text_content,
211                citations: Vec::new(),
212            }));
213        }
214
215        Ok(Self::user_message_blocks(blocks, session_id))
216    }
217}
218
219#[cfg(test)]
220mod tests {
221    use super::*;
222
223    #[test]
224    fn test_interrupt_serializes_to_control_request_envelope() {
225        let input = ClaudeInput::interrupt("interrupt-abc");
226        assert_eq!(
227            serde_json::to_value(&input).unwrap(),
228            serde_json::json!({
229                "type": "control_request",
230                "request_id": "interrupt-abc",
231                "request": {"subtype": "interrupt"}
232            })
233        );
234    }
235
236    #[test]
237    fn test_serialize_user_message() {
238        let session_uuid = Uuid::parse_str("550e8400-e29b-41d4-a716-446655440000").unwrap();
239        let input = ClaudeInput::user_message("Hello, Claude!", session_uuid);
240        let json = serde_json::to_string(&input).unwrap();
241        assert!(json.contains("\"type\":\"user\""));
242        assert!(json.contains("\"role\":\"user\""));
243        assert!(json.contains("\"text\":\"Hello, Claude!\""));
244        assert!(json.contains("550e8400-e29b-41d4-a716-446655440000"));
245    }
246
247    #[test]
248    fn test_serialize_user_message_without_session() {
249        let input = ClaudeInput::user_message_without_session("Hello, Claude!");
250        let json = serde_json::to_string(&input).unwrap();
251        assert!(json.contains("\"type\":\"user\""));
252        assert!(!json.contains("session_id"));
253    }
254}