use std::collections::{BTreeMap, btree_map};
use std::fmt::{self, Debug, Formatter};
use crate::opaque::{Envelope, Payload};
use crate::redact;
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[non_exhaustive]
pub enum KnownPartKind {
Text,
Image,
File,
ToolResult,
Thinking,
}
impl KnownPartKind {
#[must_use]
pub const fn as_part_kind(self) -> PartKind {
PartKind::from_i64(match self {
Self::Text => 0,
Self::Image => 1,
Self::File => 2,
Self::ToolResult => 3,
Self::Thinking => 4,
})
}
}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct PartKind(i64);
impl PartKind {
#[must_use]
pub const fn from_i64(value: i64) -> Self {
Self(value)
}
#[must_use]
pub const fn as_i64(self) -> i64 {
self.0
}
#[must_use]
pub const fn known(self) -> Option<KnownPartKind> {
match self.0 {
0 => Some(KnownPartKind::Text),
1 => Some(KnownPartKind::Image),
2 => Some(KnownPartKind::File),
3 => Some(KnownPartKind::ToolResult),
4 => Some(KnownPartKind::Thinking),
_ => None,
}
}
}
#[derive(Clone)]
pub struct Metadata(BTreeMap<String, MetadataValue>);
impl Debug for Metadata {
fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("Metadata")
.field("entries", &self.0.len())
.finish()
}
}
#[expect(
clippy::new_without_default,
reason = "ADR-004 freezes Metadata::new as the sole empty constructor"
)]
impl Metadata {
#[must_use]
pub const fn new() -> Self {
Self(BTreeMap::new())
}
#[must_use]
pub fn get(&self, key: &str) -> Option<&MetadataValue> {
self.0.get(key)
}
pub fn insert(&mut self, key: String, value: MetadataValue) -> Option<MetadataValue> {
self.0.insert(key, value)
}
#[must_use]
pub fn iter(&self) -> MetadataIter<'_> {
MetadataIter(self.0.iter())
}
}
impl FromIterator<(String, MetadataValue)> for Metadata {
fn from_iter<I: IntoIterator<Item = (String, MetadataValue)>>(entries: I) -> Self {
Self(entries.into_iter().collect())
}
}
impl IntoIterator for Metadata {
type Item = (String, MetadataValue);
type IntoIter = MetadataIntoIter;
fn into_iter(self) -> Self::IntoIter {
MetadataIntoIter(self.0.into_iter())
}
}
impl<'a> IntoIterator for &'a Metadata {
type Item = (&'a str, &'a MetadataValue);
type IntoIter = MetadataIter<'a>;
fn into_iter(self) -> Self::IntoIter {
self.iter()
}
}
pub struct MetadataIter<'a>(btree_map::Iter<'a, String, MetadataValue>);
impl Debug for MetadataIter<'_> {
fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("MetadataIter")
.field("remaining", &self.0.len())
.finish()
}
}
impl<'a> Iterator for MetadataIter<'a> {
type Item = (&'a str, &'a MetadataValue);
fn next(&mut self) -> Option<Self::Item> {
self.0.next().map(|(key, value)| (key.as_str(), value))
}
fn size_hint(&self) -> (usize, Option<usize>) {
self.0.size_hint()
}
}
impl ExactSizeIterator for MetadataIter<'_> {
fn len(&self) -> usize {
self.0.len()
}
}
pub struct MetadataIntoIter(btree_map::IntoIter<String, MetadataValue>);
impl Debug for MetadataIntoIter {
fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("MetadataIntoIter")
.field("remaining", &self.0.len())
.finish()
}
}
impl Iterator for MetadataIntoIter {
type Item = (String, MetadataValue);
fn next(&mut self) -> Option<Self::Item> {
self.0.next()
}
fn size_hint(&self) -> (usize, Option<usize>) {
self.0.size_hint()
}
}
impl ExactSizeIterator for MetadataIntoIter {
fn len(&self) -> usize {
self.0.len()
}
}
pub enum MetadataValue {
Null,
Bool(bool),
Signed(i64),
Unsigned(u64),
Float(f64),
String(String),
Bytes(Box<[u8]>),
Array(Vec<MetadataValue>),
Object(Metadata),
}
#[derive(Clone, Copy)]
pub enum MetadataValueRef<'a> {
Null,
Bool(bool),
Signed(i64),
Unsigned(u64),
Float(f64),
String(&'a str),
Bytes(&'a [u8]),
Array(&'a [MetadataValue]),
Object(&'a Metadata),
}
impl MetadataValue {
#[must_use]
pub fn as_borrowed(&self) -> MetadataValueRef<'_> {
match self {
Self::Null => MetadataValueRef::Null,
Self::Bool(value) => MetadataValueRef::Bool(*value),
Self::Signed(value) => MetadataValueRef::Signed(*value),
Self::Unsigned(value) => MetadataValueRef::Unsigned(*value),
Self::Float(value) => MetadataValueRef::Float(*value),
Self::String(value) => MetadataValueRef::String(value.as_str()),
Self::Bytes(value) => MetadataValueRef::Bytes(value),
Self::Array(value) => MetadataValueRef::Array(value),
Self::Object(value) => MetadataValueRef::Object(value),
}
}
}
fn debug_metadata_value(formatter: &mut Formatter<'_>, value: MetadataValueRef<'_>) -> fmt::Result {
match value {
MetadataValueRef::Null => formatter.write_str("Null"),
MetadataValueRef::Bool(_) => formatter.write_str("Bool(..)"),
MetadataValueRef::Signed(_) => formatter.write_str("Signed(..)"),
MetadataValueRef::Unsigned(_) => formatter.write_str("Unsigned(..)"),
MetadataValueRef::Float(_) => formatter.write_str("Float(..)"),
MetadataValueRef::String(text) => formatter
.debug_tuple("String")
.field(&redact::Bytes(text.len()))
.finish(),
MetadataValueRef::Bytes(bytes) => formatter
.debug_tuple("Bytes")
.field(&redact::Bytes(bytes.len()))
.finish(),
MetadataValueRef::Array(values) => formatter
.debug_tuple("Array")
.field(&redact::Items(values.len()))
.finish(),
MetadataValueRef::Object(metadata) => {
formatter.debug_tuple("Object").field(metadata).finish()
}
}
}
impl Debug for MetadataValue {
fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
debug_metadata_value(formatter, self.as_borrowed())
}
}
impl Debug for MetadataValueRef<'_> {
fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
debug_metadata_value(formatter, *self)
}
}
impl Clone for MetadataValue {
fn clone(&self) -> Self {
enum Task<'a> {
Clone(&'a MetadataValue),
FinishArray(usize),
FinishObject(Vec<String>),
}
let mut tasks = vec![Task::Clone(self)];
let mut completed = Vec::new();
while let Some(task) = tasks.pop() {
match task {
Task::Clone(value) => match value {
Self::Null => completed.push(Self::Null),
Self::Bool(value) => completed.push(Self::Bool(*value)),
Self::Signed(value) => completed.push(Self::Signed(*value)),
Self::Unsigned(value) => completed.push(Self::Unsigned(*value)),
Self::Float(value) => completed.push(Self::Float(*value)),
Self::String(value) => completed.push(Self::String(value.clone())),
Self::Bytes(value) => completed.push(Self::Bytes(value.clone())),
Self::Array(values) => {
tasks.push(Task::FinishArray(values.len()));
tasks.extend(values.iter().rev().map(Task::Clone));
}
Self::Object(metadata) => {
tasks.push(Task::FinishObject(metadata.0.keys().cloned().collect()));
tasks.extend(metadata.0.values().rev().map(Task::Clone));
}
},
Task::FinishArray(length) => {
let values = completed.split_off(completed.len() - length);
completed.push(Self::Array(values));
}
Task::FinishObject(keys) => {
let values = completed.split_off(completed.len() - keys.len());
completed.push(Self::Object(keys.into_iter().zip(values).collect()));
}
}
}
completed.remove(0)
}
}
impl Drop for MetadataValue {
fn drop(&mut self) {
let mut pending = Vec::new();
take_nested_values(self, &mut pending);
while let Some(mut value) = pending.pop() {
take_nested_values(&mut value, &mut pending);
}
}
}
fn take_nested_values(value: &mut MetadataValue, pending: &mut Vec<MetadataValue>) {
match value {
MetadataValue::Array(values) => pending.append(values),
MetadataValue::Object(metadata) => {
pending.extend(std::mem::take(&mut metadata.0).into_values());
}
MetadataValue::Null
| MetadataValue::Bool(_)
| MetadataValue::Signed(_)
| MetadataValue::Unsigned(_)
| MetadataValue::Float(_)
| MetadataValue::String(_)
| MetadataValue::Bytes(_) => {}
}
}
#[derive(Clone)]
pub struct PartFields {
text: String,
mime: String,
data: Option<Box<[u8]>>,
reference: String,
metadata: Option<Metadata>,
raw: Option<Payload>,
}
impl Debug for PartFields {
fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("PartFields")
.field("text", &redact::Bytes(self.text.len()))
.field("mime", &redact::Bytes(self.mime.len()))
.field(
"data",
&self.data.as_deref().map(|data| redact::Bytes(data.len())),
)
.field("reference", &redact::Bytes(self.reference.len()))
.field("metadata", &self.metadata)
.field("raw", &self.raw)
.finish()
}
}
impl PartFields {
#[must_use]
pub const fn new(
text: String,
mime: String,
data: Option<Box<[u8]>>,
reference: String,
metadata: Option<Metadata>,
raw: Option<Payload>,
) -> Self {
Self {
text,
mime,
data,
reference,
metadata,
raw,
}
}
#[must_use]
pub fn text(&self) -> &str {
&self.text
}
#[must_use]
pub fn mime(&self) -> &str {
&self.mime
}
#[must_use]
pub fn data(&self) -> Option<&[u8]> {
self.data.as_deref()
}
#[must_use]
pub fn reference(&self) -> &str {
&self.reference
}
#[must_use]
pub const fn metadata(&self) -> Option<&Metadata> {
self.metadata.as_ref()
}
#[must_use]
pub const fn raw_payload(&self) -> Option<&Payload> {
self.raw.as_ref()
}
}
#[derive(Clone, Debug)]
pub struct Part {
kind: PartKind,
fields: PartFields,
}
impl Part {
#[must_use]
pub const fn new(kind: PartKind, fields: PartFields) -> Self {
Self { kind, fields }
}
#[must_use]
pub const fn text(text: String) -> Self {
Self::new(
KnownPartKind::Text.as_part_kind(),
PartFields::new(text, String::new(), None, String::new(), None, None),
)
}
#[must_use]
pub const fn kind(&self) -> PartKind {
self.kind
}
#[must_use]
pub const fn fields(&self) -> &PartFields {
&self.fields
}
#[must_use]
pub fn into_parts(self) -> (PartKind, PartFields) {
(self.kind, self.fields)
}
}
pub(crate) fn is_valid_system_instruction(parts: &[Part]) -> bool {
parts.iter().all(|part| {
part.kind().known() == Some(KnownPartKind::Text) && !part.fields().text().is_empty()
})
}
#[derive(Clone)]
pub struct SegmentExtensions {
signature: String,
raw: Option<Payload>,
provider_data: Option<Vec<Envelope>>,
item_id: Option<String>,
}
impl Debug for SegmentExtensions {
fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("SegmentExtensions")
.field("signature", &redact::Presence(!self.signature.is_empty()))
.field("raw", &self.raw)
.field("provider_data", &self.provider_data)
.field("item_id", &self.item_id)
.finish()
}
}
impl SegmentExtensions {
#[must_use]
pub const fn new(
signature: String,
raw: Option<Payload>,
provider_data: Option<Vec<Envelope>>,
) -> Self {
Self {
signature,
raw,
provider_data,
item_id: None,
}
}
#[must_use]
pub fn with_item_id(mut self, id: String) -> Self {
self.item_id = Some(id);
self
}
#[must_use]
pub fn item_id(&self) -> Option<&str> {
self.item_id.as_deref()
}
#[must_use]
pub fn signature(&self) -> &str {
&self.signature
}
#[must_use]
pub const fn raw_payload(&self) -> Option<&Payload> {
self.raw.as_ref()
}
#[must_use]
pub fn provider_data(&self) -> Option<&[Envelope]> {
self.provider_data.as_deref()
}
#[must_use]
pub fn into_parts(
self,
) -> (
String,
Option<Payload>,
Option<Vec<Envelope>>,
Option<String>,
) {
(self.signature, self.raw, self.provider_data, self.item_id)
}
}
#[derive(Clone)]
pub enum Segment {
Text {
text: String,
extensions: SegmentExtensions,
},
Thinking {
text: String,
extensions: SegmentExtensions,
},
ToolCall {
call: super::tool_call::ToolCall,
extensions: SegmentExtensions,
},
}
impl Debug for Segment {
fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
match self {
Self::Text { text, extensions } => formatter
.debug_struct("Text")
.field("text", &redact::Bytes(text.len()))
.field("extensions", extensions)
.finish(),
Self::Thinking { text, extensions } => formatter
.debug_struct("Thinking")
.field("text", &redact::Bytes(text.len()))
.field("extensions", extensions)
.finish(),
Self::ToolCall { call, extensions } => formatter
.debug_struct("ToolCall")
.field("call", call)
.field("extensions", extensions)
.finish(),
}
}
}
pub(crate) fn join_blocks<'a>(blocks: impl Iterator<Item = &'a str>) -> String {
let mut rendered = String::new();
for block in blocks.filter(|block| !block.is_empty()) {
if !rendered.is_empty() {
rendered.push('\n');
}
rendered.push_str(block);
}
rendered
}
#[cfg(feature = "serde")]
mod serde_impl {
use std::fmt::{self, Formatter};
use serde_core::de::{
Deserialize, DeserializeSeed, Deserializer, EnumAccess, Error as DeError, MapAccess,
SeqAccess, VariantAccess, Visitor,
};
use serde_core::ser::{
Error as SerError, Serialize, SerializeMap, SerializeSeq, SerializeStruct,
SerializeStructVariant, Serializer,
};
use super::{Metadata, MetadataValue, Part, PartFields, PartKind, Segment, SegmentExtensions};
use crate::opaque::{Envelope, Payload};
use crate::wire::{self, ByteBuf, Bytes, IdentifierSeed};
pub(super) const MAX_METADATA_DEPTH: usize = 128;
const VALUE_NAME: &str = "MetadataValue";
const VALUE_VARIANTS: &[&str] = &[
"null", "bool", "signed", "unsigned", "float", "string", "bytes", "array", "object",
];
const PART_FIELDS: &[&str] = &["kind", "fields"];
const FIELDS_FIELDS: &[&str] = &["text", "mime", "data", "reference", "metadata", "raw"];
const EXTENSIONS_FIELDS: &[&str] = &["signature", "raw", "provider_data", "item_id"];
const SEGMENT_NAME: &str = "Segment";
const SEGMENT_VARIANTS: &[&str] = &["text", "thinking", "tool_call"];
const TEXT_SEGMENT_FIELDS: &[&str] = &["text", "extensions"];
const TOOL_CALL_SEGMENT_FIELDS: &[&str] = &["call", "extensions"];
struct TooDeep;
impl fmt::Display for TooDeep {
fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
write!(
formatter,
"metadata value nests deeper than the {MAX_METADATA_DEPTH}-level serialization limit"
)
}
}
impl Serialize for PartKind {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
serializer.serialize_i64(self.0)
}
}
impl<'de> Deserialize<'de> for PartKind {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
i64::deserialize(deserializer).map(Self::from_i64)
}
}
struct DepthValue<'a>(&'a MetadataValue, usize);
struct DepthElements<'a>(&'a [MetadataValue], usize);
struct DepthEntries<'a>(&'a Metadata, usize);
impl Serialize for DepthValue<'_> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
if self.1 > MAX_METADATA_DEPTH {
return Err(S::Error::custom(TooDeep));
}
let nested = self.1 + 1;
match self.0 {
MetadataValue::Null => serializer.serialize_unit_variant(VALUE_NAME, 0, "null"),
MetadataValue::Bool(value) => {
serializer.serialize_newtype_variant(VALUE_NAME, 1, "bool", value)
}
MetadataValue::Signed(value) => {
serializer.serialize_newtype_variant(VALUE_NAME, 2, "signed", value)
}
MetadataValue::Unsigned(value) => {
serializer.serialize_newtype_variant(VALUE_NAME, 3, "unsigned", value)
}
MetadataValue::Float(value) => {
serializer.serialize_newtype_variant(VALUE_NAME, 4, "float", value)
}
MetadataValue::String(value) => {
serializer.serialize_newtype_variant(VALUE_NAME, 5, "string", value)
}
MetadataValue::Bytes(value) => {
serializer.serialize_newtype_variant(VALUE_NAME, 6, "bytes", &Bytes(value))
}
MetadataValue::Array(values) => serializer.serialize_newtype_variant(
VALUE_NAME,
7,
"array",
&DepthElements(values, nested),
),
MetadataValue::Object(metadata) => serializer.serialize_newtype_variant(
VALUE_NAME,
8,
"object",
&DepthEntries(metadata, nested),
),
}
}
}
impl Serialize for DepthElements<'_> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let mut sequence = serializer.serialize_seq(Some(self.0.len()))?;
for value in self.0 {
sequence.serialize_element(&DepthValue(value, self.1))?;
}
sequence.end()
}
}
impl Serialize for DepthEntries<'_> {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let mut entries = serializer.serialize_map(Some(self.0.iter().len()))?;
for (key, value) in self.0 {
entries.serialize_entry(key, &DepthValue(value, self.1))?;
}
entries.end()
}
}
impl Serialize for MetadataValue {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
DepthValue(self, 1).serialize(serializer)
}
}
impl Serialize for Metadata {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
DepthEntries(self, 1).serialize(serializer)
}
}
struct ValueSeed(usize);
impl<'de> DeserializeSeed<'de> for ValueSeed {
type Value = MetadataValue;
fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
where
D: Deserializer<'de>,
{
if self.0 > MAX_METADATA_DEPTH {
return Err(D::Error::custom(TooDeep));
}
deserializer.deserialize_enum(VALUE_NAME, VALUE_VARIANTS, ValueVisitor(self.0))
}
}
struct ValueVisitor(usize);
impl<'de> Visitor<'de> for ValueVisitor {
type Value = MetadataValue;
fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
formatter.write_str("a metadata value")
}
fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
where
A: EnumAccess<'de>,
{
let (tag, variant) = data.variant_seed(IdentifierSeed(VALUE_VARIANTS))?;
let nested = self.0 + 1;
match tag.0.as_str() {
"null" => {
variant.unit_variant()?;
Ok(MetadataValue::Null)
}
"bool" => variant.newtype_variant().map(MetadataValue::Bool),
"signed" => variant.newtype_variant().map(MetadataValue::Signed),
"unsigned" => variant.newtype_variant().map(MetadataValue::Unsigned),
"float" => variant.newtype_variant().map(MetadataValue::Float),
"string" => variant.newtype_variant().map(MetadataValue::String),
"bytes" => variant
.newtype_variant::<ByteBuf>()
.map(|buffer| MetadataValue::Bytes(buffer.0)),
"array" => variant
.newtype_variant_seed(ElementsSeed(nested))
.map(MetadataValue::Array),
"object" => variant
.newtype_variant_seed(EntriesSeed(nested))
.map(MetadataValue::Object),
unknown => Err(A::Error::unknown_variant(unknown, VALUE_VARIANTS)),
}
}
}
struct ElementsSeed(usize);
impl<'de> DeserializeSeed<'de> for ElementsSeed {
type Value = Vec<MetadataValue>;
fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
where
D: Deserializer<'de>,
{
deserializer.deserialize_seq(ElementsVisitor(self.0))
}
}
struct ElementsVisitor(usize);
impl<'de> Visitor<'de> for ElementsVisitor {
type Value = Vec<MetadataValue>;
fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
formatter.write_str("an array of metadata values")
}
fn visit_seq<A>(self, mut sequence: A) -> Result<Self::Value, A::Error>
where
A: SeqAccess<'de>,
{
let mut values = Vec::new();
while let Some(value) = sequence.next_element_seed(ValueSeed(self.0))? {
values.push(value);
}
Ok(values)
}
}
struct EntriesSeed(usize);
impl<'de> DeserializeSeed<'de> for EntriesSeed {
type Value = Metadata;
fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
where
D: Deserializer<'de>,
{
deserializer.deserialize_map(EntriesVisitor(self.0))
}
}
struct EntriesVisitor(usize);
impl<'de> Visitor<'de> for EntriesVisitor {
type Value = Metadata;
fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
formatter.write_str("a metadata object")
}
fn visit_map<A>(self, mut entries: A) -> Result<Self::Value, A::Error>
where
A: MapAccess<'de>,
{
let mut metadata = Metadata::new();
while let Some(key) = entries.next_key::<String>()? {
let value = entries.next_value_seed(ValueSeed(self.0))?;
drop(metadata.insert(key, value));
}
Ok(metadata)
}
}
impl<'de> Deserialize<'de> for MetadataValue {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
ValueSeed(1).deserialize(deserializer)
}
}
impl<'de> Deserialize<'de> for Metadata {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
EntriesSeed(1).deserialize(deserializer)
}
}
impl Serialize for PartFields {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let mut record = serializer.serialize_struct("PartFields", 6)?;
record.serialize_field("text", &self.text)?;
record.serialize_field("mime", &self.mime)?;
record.serialize_field("data", &self.data.as_deref().map(Bytes))?;
record.serialize_field("reference", &self.reference)?;
record.serialize_field("metadata", &self.metadata)?;
record.serialize_field("raw", &self.raw)?;
record.end()
}
}
impl<'de> Deserialize<'de> for PartFields {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
deserializer.deserialize_struct("PartFields", FIELDS_FIELDS, FieldsVisitor)
}
}
struct FieldsVisitor;
impl<'de> Visitor<'de> for FieldsVisitor {
type Value = PartFields;
fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
formatter.write_str("a complete part field set")
}
fn visit_seq<A>(self, mut sequence: A) -> Result<Self::Value, A::Error>
where
A: SeqAccess<'de>,
{
let text = wire::element(&mut sequence, 0)?;
let mime = wire::element(&mut sequence, 1)?;
let data = wire::element::<Option<ByteBuf>, _>(&mut sequence, 2)?;
let reference = wire::element(&mut sequence, 3)?;
let metadata = wire::element(&mut sequence, 4)?;
let raw = wire::element(&mut sequence, 5)?;
wire::end(&mut sequence, 6)?;
Ok(PartFields::new(
text,
mime,
ByteBuf::into_optional(data),
reference,
metadata,
raw,
))
}
fn visit_map<A>(self, mut entries: A) -> Result<Self::Value, A::Error>
where
A: MapAccess<'de>,
{
let mut text = None;
let mut mime = None;
let mut data = None::<Option<ByteBuf>>;
let mut reference = None;
let mut metadata = None;
let mut raw = None;
while let Some(field) = entries.next_key_seed(IdentifierSeed(FIELDS_FIELDS))? {
match field.0.as_str() {
"text" => wire::accept(&mut text, entries.next_value()?, "text")?,
"mime" => wire::accept(&mut mime, entries.next_value()?, "mime")?,
"data" => wire::accept(&mut data, entries.next_value()?, "data")?,
"reference" => {
wire::accept(&mut reference, entries.next_value()?, "reference")?;
}
"metadata" => wire::accept(&mut metadata, entries.next_value()?, "metadata")?,
"raw" => wire::accept(&mut raw, entries.next_value()?, "raw")?,
unknown => return Err(A::Error::unknown_field(unknown, FIELDS_FIELDS)),
}
}
Ok(PartFields::new(
wire::require(text, "text")?,
wire::require(mime, "mime")?,
ByteBuf::into_optional(wire::require(data, "data")?),
wire::require(reference, "reference")?,
wire::require(metadata, "metadata")?,
wire::require(raw, "raw")?,
))
}
}
impl Serialize for Part {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let mut record = serializer.serialize_struct("Part", 2)?;
record.serialize_field("kind", &self.kind)?;
record.serialize_field("fields", &self.fields)?;
record.end()
}
}
impl<'de> Deserialize<'de> for Part {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
deserializer.deserialize_struct("Part", PART_FIELDS, PartVisitor)
}
}
struct PartVisitor;
impl<'de> Visitor<'de> for PartVisitor {
type Value = Part;
fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
formatter.write_str("a message part")
}
fn visit_seq<A>(self, mut sequence: A) -> Result<Self::Value, A::Error>
where
A: SeqAccess<'de>,
{
let kind = wire::element(&mut sequence, 0)?;
let fields = wire::element(&mut sequence, 1)?;
wire::end(&mut sequence, 2)?;
Ok(Part::new(kind, fields))
}
fn visit_map<A>(self, mut entries: A) -> Result<Self::Value, A::Error>
where
A: MapAccess<'de>,
{
let mut kind = None;
let mut fields = None;
while let Some(field) = entries.next_key_seed(IdentifierSeed(PART_FIELDS))? {
match field.0.as_str() {
"kind" => wire::accept(&mut kind, entries.next_value()?, "kind")?,
"fields" => wire::accept(&mut fields, entries.next_value()?, "fields")?,
unknown => return Err(A::Error::unknown_field(unknown, PART_FIELDS)),
}
}
Ok(Part::new(
wire::require(kind, "kind")?,
wire::require(fields, "fields")?,
))
}
}
fn extensions(
signature: String,
raw: Option<Payload>,
provider_data: Option<Vec<Envelope>>,
item_id: Option<String>,
) -> SegmentExtensions {
let extensions = SegmentExtensions::new(signature, raw, provider_data);
match item_id {
Some(id) => extensions.with_item_id(id),
None => extensions,
}
}
impl Serialize for SegmentExtensions {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let mut record = serializer.serialize_struct("SegmentExtensions", 4)?;
record.serialize_field("signature", &self.signature)?;
record.serialize_field("raw", &self.raw)?;
record.serialize_field("provider_data", &self.provider_data)?;
record.serialize_field("item_id", &self.item_id)?;
record.end()
}
}
impl<'de> Deserialize<'de> for SegmentExtensions {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
deserializer.deserialize_struct(
"SegmentExtensions",
EXTENSIONS_FIELDS,
ExtensionsVisitor,
)
}
}
struct ExtensionsVisitor;
impl<'de> Visitor<'de> for ExtensionsVisitor {
type Value = SegmentExtensions;
fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
formatter.write_str("segment extensions")
}
fn visit_seq<A>(self, mut sequence: A) -> Result<Self::Value, A::Error>
where
A: SeqAccess<'de>,
{
let signature = wire::element(&mut sequence, 0)?;
let raw = wire::element(&mut sequence, 1)?;
let provider_data = wire::element(&mut sequence, 2)?;
let item_id = wire::element(&mut sequence, 3)?;
wire::end(&mut sequence, 4)?;
Ok(extensions(signature, raw, provider_data, item_id))
}
fn visit_map<A>(self, mut entries: A) -> Result<Self::Value, A::Error>
where
A: MapAccess<'de>,
{
let mut signature = None;
let mut raw = None;
let mut provider_data = None;
let mut item_id = None;
while let Some(field) = entries.next_key_seed(IdentifierSeed(EXTENSIONS_FIELDS))? {
match field.0.as_str() {
"signature" => {
wire::accept(&mut signature, entries.next_value()?, "signature")?;
}
"raw" => wire::accept(&mut raw, entries.next_value()?, "raw")?,
"provider_data" => {
wire::accept(&mut provider_data, entries.next_value()?, "provider_data")?;
}
"item_id" => wire::accept(&mut item_id, entries.next_value()?, "item_id")?,
unknown => return Err(A::Error::unknown_field(unknown, EXTENSIONS_FIELDS)),
}
}
Ok(extensions(
wire::require(signature, "signature")?,
wire::require(raw, "raw")?,
wire::require(provider_data, "provider_data")?,
wire::require(item_id, "item_id")?,
))
}
}
const fn text_segment(text: String, extensions: SegmentExtensions) -> Segment {
Segment::Text { text, extensions }
}
const fn thinking_segment(text: String, extensions: SegmentExtensions) -> Segment {
Segment::Thinking { text, extensions }
}
impl Serialize for Segment {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::Text { text, extensions } => {
let mut record =
serializer.serialize_struct_variant(SEGMENT_NAME, 0, "text", 2)?;
record.serialize_field("text", text)?;
record.serialize_field("extensions", extensions)?;
record.end()
}
Self::Thinking { text, extensions } => {
let mut record =
serializer.serialize_struct_variant(SEGMENT_NAME, 1, "thinking", 2)?;
record.serialize_field("text", text)?;
record.serialize_field("extensions", extensions)?;
record.end()
}
Self::ToolCall { call, extensions } => {
let mut record =
serializer.serialize_struct_variant(SEGMENT_NAME, 2, "tool_call", 2)?;
record.serialize_field("call", call)?;
record.serialize_field("extensions", extensions)?;
record.end()
}
}
}
}
impl<'de> Deserialize<'de> for Segment {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
deserializer.deserialize_enum(SEGMENT_NAME, SEGMENT_VARIANTS, SegmentVisitor)
}
}
struct SegmentVisitor;
impl<'de> Visitor<'de> for SegmentVisitor {
type Value = Segment;
fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
formatter.write_str("an assistant content segment")
}
fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
where
A: EnumAccess<'de>,
{
let (tag, variant) = data.variant_seed(IdentifierSeed(SEGMENT_VARIANTS))?;
match tag.0.as_str() {
"text" => variant.struct_variant(TEXT_SEGMENT_FIELDS, TextVisitor(text_segment)),
"thinking" => {
variant.struct_variant(TEXT_SEGMENT_FIELDS, TextVisitor(thinking_segment))
}
"tool_call" => {
variant.struct_variant(TOOL_CALL_SEGMENT_FIELDS, ToolCallSegmentVisitor)
}
unknown => Err(A::Error::unknown_variant(unknown, SEGMENT_VARIANTS)),
}
}
}
struct TextVisitor(fn(String, SegmentExtensions) -> Segment);
impl<'de> Visitor<'de> for TextVisitor {
type Value = Segment;
fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
formatter.write_str("a text-bearing segment")
}
fn visit_seq<A>(self, mut sequence: A) -> Result<Self::Value, A::Error>
where
A: SeqAccess<'de>,
{
let text = wire::element(&mut sequence, 0)?;
let extensions = wire::element(&mut sequence, 1)?;
wire::end(&mut sequence, 2)?;
Ok((self.0)(text, extensions))
}
fn visit_map<A>(self, mut entries: A) -> Result<Self::Value, A::Error>
where
A: MapAccess<'de>,
{
let mut text = None;
let mut extensions = None;
while let Some(field) = entries.next_key_seed(IdentifierSeed(TEXT_SEGMENT_FIELDS))? {
match field.0.as_str() {
"text" => wire::accept(&mut text, entries.next_value()?, "text")?,
"extensions" => {
wire::accept(&mut extensions, entries.next_value()?, "extensions")?;
}
unknown => return Err(A::Error::unknown_field(unknown, TEXT_SEGMENT_FIELDS)),
}
}
Ok((self.0)(
wire::require(text, "text")?,
wire::require(extensions, "extensions")?,
))
}
}
struct ToolCallSegmentVisitor;
impl<'de> Visitor<'de> for ToolCallSegmentVisitor {
type Value = Segment;
fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
formatter.write_str("a tool-call segment")
}
fn visit_seq<A>(self, mut sequence: A) -> Result<Self::Value, A::Error>
where
A: SeqAccess<'de>,
{
let call = wire::element(&mut sequence, 0)?;
let extensions = wire::element(&mut sequence, 1)?;
wire::end(&mut sequence, 2)?;
Ok(Segment::ToolCall { call, extensions })
}
fn visit_map<A>(self, mut entries: A) -> Result<Self::Value, A::Error>
where
A: MapAccess<'de>,
{
let mut call = None;
let mut extensions = None;
while let Some(field) =
entries.next_key_seed(IdentifierSeed(TOOL_CALL_SEGMENT_FIELDS))?
{
match field.0.as_str() {
"call" => wire::accept(&mut call, entries.next_value()?, "call")?,
"extensions" => {
wire::accept(&mut extensions, entries.next_value()?, "extensions")?;
}
unknown => {
return Err(A::Error::unknown_field(unknown, TOOL_CALL_SEGMENT_FIELDS));
}
}
}
Ok(Segment::ToolCall {
call: wire::require(call, "call")?,
extensions: wire::require(extensions, "extensions")?,
})
}
}
}