ccwire 0.1.2

A Rust SDK for Claude Code: the stream-json protocol, typed
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

//! [`UserInput`]: a user message written to the CLI's stdin.

use serde::{Serialize, Serializer};
use serde_json::Value;

use super::{ContentBlock, Extra, MessageContent};

/// A user message for `--input-format stream-json`:
/// `{"type": "user", "message": {"role": "user", "content": ...}, "uuid"?: ...}`.
///
/// Optional keys are left out when `None`.
#[derive(Debug, Clone, Default, PartialEq)]
pub struct UserInput {
    pub content: MessageContent,
    /// Names the message: the CLI echoes it (replays, `command_lifecycle`).
    pub uuid: Option<String>,
    /// Answers under a subagent's tool call.
    pub parent_tool_use_id: Option<String>,
    pub session_id: Option<String>,
    /// More top-level keys (`priority`, ...).
    pub extra: Extra,
}

impl UserInput {
    /// A text message.
    pub fn text(text: impl Into<String>) -> Self {
        Self {
            content: MessageContent::Text(text.into()),
            ..Self::default()
        }
    }

    /// A message of content blocks (text, images).
    pub fn blocks(blocks: Vec<ContentBlock>) -> Self {
        Self {
            content: MessageContent::Blocks(blocks),
            ..Self::default()
        }
    }

    #[must_use]
    pub fn with_uuid(mut self, uuid: impl Into<String>) -> Self {
        self.uuid = Some(uuid.into());
        self
    }

    #[must_use]
    pub fn with_session_id(mut self, session_id: impl Into<String>) -> Self {
        self.session_id = Some(session_id.into());
        self
    }

    #[must_use]
    pub fn with_parent_tool_use_id(mut self, id: impl Into<String>) -> Self {
        self.parent_tool_use_id = Some(id.into());
        self
    }

    /// The JSON object.
    ///
    /// # Errors
    /// A value in it doesn't serialize (a hand-built `Other` block whose
    /// `raw` isn't an object, say).
    pub fn to_value(&self) -> Result<Value, serde_json::Error> {
        serde_json::to_value(self)
    }
}

impl From<&str> for UserInput {
    fn from(s: &str) -> Self {
        Self::text(s)
    }
}

impl From<String> for UserInput {
    fn from(s: String) -> Self {
        Self::text(s)
    }
}

impl From<Vec<ContentBlock>> for UserInput {
    fn from(b: Vec<ContentBlock>) -> Self {
        Self::blocks(b)
    }
}

#[derive(Serialize)]
struct Wire<'a> {
    #[serde(rename = "type")]
    type_: &'static str,
    message: WireMessage<'a>,
    #[serde(skip_serializing_if = "Option::is_none")]
    uuid: Option<&'a str>,
    #[serde(skip_serializing_if = "Option::is_none")]
    parent_tool_use_id: Option<&'a str>,
    #[serde(skip_serializing_if = "Option::is_none")]
    session_id: Option<&'a str>,
    #[serde(flatten)]
    extra: &'a Extra,
}

#[derive(Serialize)]
struct WireMessage<'a> {
    role: &'static str,
    content: &'a MessageContent,
}

impl Serialize for UserInput {
    fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
        Wire {
            type_: "user",
            message: WireMessage {
                role: "user",
                content: &self.content,
            },
            uuid: self.uuid.as_deref(),
            parent_tool_use_id: self.parent_tool_use_id.as_deref(),
            session_id: self.session_id.as_deref(),
            extra: &self.extra,
        }
        .serialize(s)
    }
}