pub use code_mode::CodeModeReceipt;
use serde::Deserialize;
use serde::Deserializer;
use serde::Serialize;
use serde::Serializer;
pub use vocabulary::ToolReceiptOperation;
pub use vocabulary::ToolReceiptOutcome;
pub(crate) mod code_mode;
pub(crate) mod vocabulary;
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct CronReceiptJob {
pub job_id: String,
pub next_fire_at_ms: i64,
}
#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct CronReceipt {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub job_id: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub next_fire_at_ms: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub jobs: Option<Vec<CronReceiptJob>>,
}
#[derive(Debug, Clone, PartialEq)]
#[non_exhaustive]
pub enum ToolReceiptBody {
Cron(CronReceipt),
CodeMode(CodeModeReceipt),
Unknown {
family: String,
details: Option<serde_json::Map<String, serde_json::Value>>,
},
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
#[non_exhaustive]
pub struct ToolReceipt {
pub operation: ToolReceiptOperation,
pub outcome: ToolReceiptOutcome,
#[serde(flatten)]
pub body: ToolReceiptBody,
}
impl Serialize for ToolReceiptBody {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
use serde::ser::SerializeMap;
match self {
Self::Cron(cron) => {
let empty = cron == &CronReceipt::default();
let mut map = serializer.serialize_map(Some(1 + usize::from(!empty)))?;
map.serialize_entry("family", "cron")?;
if !empty {
map.serialize_entry("details", cron)?;
}
map.end()
}
Self::CodeMode(code_mode) => {
let empty = code_mode.serializes_empty();
let mut map = serializer.serialize_map(Some(1 + usize::from(!empty)))?;
map.serialize_entry("family", "codeMode")?;
if !empty {
map.serialize_entry("details", code_mode)?;
}
map.end()
}
Self::Unknown { family, details } => {
let mut map = serializer.serialize_map(Some(1 + usize::from(details.is_some())))?;
map.serialize_entry("family", family)?;
if let Some(details) = details {
map.serialize_entry("details", details)?;
}
map.end()
}
}
}
}
impl<'de> Deserialize<'de> for ToolReceiptBody {
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
struct BodyVisitor;
impl<'de> serde::de::Visitor<'de> for BodyVisitor {
type Value = ToolReceiptBody;
fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
f.write_str("a toolReceipt body with a `family` discriminator")
}
fn visit_map<M: serde::de::MapAccess<'de>>(
self,
mut map: M,
) -> Result<Self::Value, M::Error> {
let mut family: Option<String> = None;
let mut details: Option<serde_json::Map<String, serde_json::Value>> = None;
while let Some(key) = map.next_key::<String>()? {
match key.as_str() {
"family" => {
if family.is_some() {
return Err(serde::de::Error::duplicate_field("family"));
}
family = Some(map.next_value()?);
}
"details" => {
if details.is_some() {
return Err(serde::de::Error::duplicate_field("details"));
}
details = Some(map.next_value()?);
}
_ => {
let _ = map.next_value::<serde::de::IgnoredAny>()?;
}
}
}
let family = family.ok_or_else(|| serde::de::Error::missing_field("family"))?;
if family == "cron" {
let cron = match details {
Some(value) => serde_json::from_value(serde_json::Value::Object(value))
.map_err(serde::de::Error::custom)?,
None => CronReceipt::default(),
};
return Ok(ToolReceiptBody::Cron(cron));
}
if family == "codeMode" {
let code_mode = match details {
Some(value) => serde_json::from_value(serde_json::Value::Object(value))
.map_err(serde::de::Error::custom)?,
None => CodeModeReceipt::default(),
};
return Ok(ToolReceiptBody::CodeMode(code_mode));
}
Ok(ToolReceiptBody::Unknown { family, details })
}
}
deserializer.deserialize_map(BodyVisitor)
}
}