1use std::collections::{BTreeMap, btree_map};
4use std::fmt::{self, Debug, Formatter};
5
6use crate::opaque::{Envelope, Payload};
7use crate::redact;
8
9#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
11#[non_exhaustive]
12pub enum KnownPartKind {
13 Text,
15 Image,
17 File,
19 ToolResult,
21 Thinking,
23}
24
25impl KnownPartKind {
26 #[must_use]
33 pub const fn as_part_kind(self) -> PartKind {
34 PartKind::from_i64(match self {
35 Self::Text => 0,
36 Self::Image => 1,
37 Self::File => 2,
38 Self::ToolResult => 3,
39 Self::Thinking => 4,
40 })
41 }
42}
43
44#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
79pub struct PartKind(i64);
80
81impl PartKind {
82 #[must_use]
84 pub const fn from_i64(value: i64) -> Self {
85 Self(value)
86 }
87
88 #[must_use]
90 pub const fn as_i64(self) -> i64 {
91 self.0
92 }
93
94 #[must_use]
98 pub const fn known(self) -> Option<KnownPartKind> {
99 match self.0 {
100 0 => Some(KnownPartKind::Text),
101 1 => Some(KnownPartKind::Image),
102 2 => Some(KnownPartKind::File),
103 3 => Some(KnownPartKind::ToolResult),
104 4 => Some(KnownPartKind::Thinking),
105 _ => None,
106 }
107 }
108}
109
110#[derive(Clone)]
140pub struct Metadata(BTreeMap<String, MetadataValue>);
141
142impl Debug for Metadata {
143 fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
151 formatter
152 .debug_struct("Metadata")
153 .field("entries", &self.0.len())
154 .finish()
155 }
156}
157
158#[expect(
159 clippy::new_without_default,
160 reason = "ADR-004 freezes Metadata::new as the sole empty constructor"
161)]
162impl Metadata {
163 #[must_use]
165 pub const fn new() -> Self {
166 Self(BTreeMap::new())
167 }
168
169 #[must_use]
171 pub fn get(&self, key: &str) -> Option<&MetadataValue> {
172 self.0.get(key)
173 }
174
175 pub fn insert(&mut self, key: String, value: MetadataValue) -> Option<MetadataValue> {
177 self.0.insert(key, value)
178 }
179
180 #[must_use]
182 pub fn iter(&self) -> MetadataIter<'_> {
183 MetadataIter(self.0.iter())
184 }
185}
186
187impl FromIterator<(String, MetadataValue)> for Metadata {
188 fn from_iter<I: IntoIterator<Item = (String, MetadataValue)>>(entries: I) -> Self {
190 Self(entries.into_iter().collect())
191 }
192}
193
194impl IntoIterator for Metadata {
195 type Item = (String, MetadataValue);
196 type IntoIter = MetadataIntoIter;
197
198 fn into_iter(self) -> Self::IntoIter {
200 MetadataIntoIter(self.0.into_iter())
201 }
202}
203
204impl<'a> IntoIterator for &'a Metadata {
205 type Item = (&'a str, &'a MetadataValue);
206 type IntoIter = MetadataIter<'a>;
207
208 fn into_iter(self) -> Self::IntoIter {
209 self.iter()
210 }
211}
212
213pub struct MetadataIter<'a>(btree_map::Iter<'a, String, MetadataValue>);
218
219impl Debug for MetadataIter<'_> {
220 fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
222 formatter
223 .debug_struct("MetadataIter")
224 .field("remaining", &self.0.len())
225 .finish()
226 }
227}
228
229impl<'a> Iterator for MetadataIter<'a> {
230 type Item = (&'a str, &'a MetadataValue);
231
232 fn next(&mut self) -> Option<Self::Item> {
233 self.0.next().map(|(key, value)| (key.as_str(), value))
234 }
235
236 fn size_hint(&self) -> (usize, Option<usize>) {
237 self.0.size_hint()
238 }
239}
240
241impl ExactSizeIterator for MetadataIter<'_> {
242 fn len(&self) -> usize {
243 self.0.len()
244 }
245}
246
247pub struct MetadataIntoIter(btree_map::IntoIter<String, MetadataValue>);
249
250impl Debug for MetadataIntoIter {
251 fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
253 formatter
254 .debug_struct("MetadataIntoIter")
255 .field("remaining", &self.0.len())
256 .finish()
257 }
258}
259
260impl Iterator for MetadataIntoIter {
261 type Item = (String, MetadataValue);
262
263 fn next(&mut self) -> Option<Self::Item> {
264 self.0.next()
265 }
266
267 fn size_hint(&self) -> (usize, Option<usize>) {
268 self.0.size_hint()
269 }
270}
271
272impl ExactSizeIterator for MetadataIntoIter {
273 fn len(&self) -> usize {
274 self.0.len()
275 }
276}
277
278pub enum MetadataValue {
292 Null,
294 Bool(bool),
296 Signed(i64),
298 Unsigned(u64),
300 Float(f64),
302 String(String),
304 Bytes(Box<[u8]>),
306 Array(Vec<MetadataValue>),
308 Object(Metadata),
310}
311
312#[derive(Clone, Copy)]
318pub enum MetadataValueRef<'a> {
319 Null,
321 Bool(bool),
323 Signed(i64),
325 Unsigned(u64),
327 Float(f64),
329 String(&'a str),
331 Bytes(&'a [u8]),
333 Array(&'a [MetadataValue]),
335 Object(&'a Metadata),
337}
338
339impl MetadataValue {
340 #[must_use]
342 pub fn as_borrowed(&self) -> MetadataValueRef<'_> {
343 match self {
344 Self::Null => MetadataValueRef::Null,
345 Self::Bool(value) => MetadataValueRef::Bool(*value),
346 Self::Signed(value) => MetadataValueRef::Signed(*value),
347 Self::Unsigned(value) => MetadataValueRef::Unsigned(*value),
348 Self::Float(value) => MetadataValueRef::Float(*value),
349 Self::String(value) => MetadataValueRef::String(value.as_str()),
350 Self::Bytes(value) => MetadataValueRef::Bytes(value),
351 Self::Array(value) => MetadataValueRef::Array(value),
352 Self::Object(value) => MetadataValueRef::Object(value),
353 }
354 }
355}
356
357fn debug_metadata_value(formatter: &mut Formatter<'_>, value: MetadataValueRef<'_>) -> fmt::Result {
363 match value {
364 MetadataValueRef::Null => formatter.write_str("Null"),
365 MetadataValueRef::Bool(_) => formatter.write_str("Bool(..)"),
369 MetadataValueRef::Signed(_) => formatter.write_str("Signed(..)"),
370 MetadataValueRef::Unsigned(_) => formatter.write_str("Unsigned(..)"),
371 MetadataValueRef::Float(_) => formatter.write_str("Float(..)"),
372 MetadataValueRef::String(text) => formatter
373 .debug_tuple("String")
374 .field(&redact::Bytes(text.len()))
375 .finish(),
376 MetadataValueRef::Bytes(bytes) => formatter
377 .debug_tuple("Bytes")
378 .field(&redact::Bytes(bytes.len()))
379 .finish(),
380 MetadataValueRef::Array(values) => formatter
381 .debug_tuple("Array")
382 .field(&redact::Items(values.len()))
383 .finish(),
384 MetadataValueRef::Object(metadata) => {
385 formatter.debug_tuple("Object").field(metadata).finish()
386 }
387 }
388}
389
390impl Debug for MetadataValue {
391 fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
393 debug_metadata_value(formatter, self.as_borrowed())
394 }
395}
396
397impl Debug for MetadataValueRef<'_> {
398 fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
400 debug_metadata_value(formatter, *self)
401 }
402}
403
404impl Clone for MetadataValue {
405 fn clone(&self) -> Self {
406 enum Task<'a> {
407 Clone(&'a MetadataValue),
408 FinishArray(usize),
409 FinishObject(Vec<String>),
410 }
411
412 let mut tasks = vec![Task::Clone(self)];
413 let mut completed = Vec::new();
414
415 while let Some(task) = tasks.pop() {
416 match task {
417 Task::Clone(value) => match value {
418 Self::Null => completed.push(Self::Null),
419 Self::Bool(value) => completed.push(Self::Bool(*value)),
420 Self::Signed(value) => completed.push(Self::Signed(*value)),
421 Self::Unsigned(value) => completed.push(Self::Unsigned(*value)),
422 Self::Float(value) => completed.push(Self::Float(*value)),
423 Self::String(value) => completed.push(Self::String(value.clone())),
424 Self::Bytes(value) => completed.push(Self::Bytes(value.clone())),
425 Self::Array(values) => {
426 tasks.push(Task::FinishArray(values.len()));
427 tasks.extend(values.iter().rev().map(Task::Clone));
428 }
429 Self::Object(metadata) => {
430 tasks.push(Task::FinishObject(metadata.0.keys().cloned().collect()));
431 tasks.extend(metadata.0.values().rev().map(Task::Clone));
432 }
433 },
434 Task::FinishArray(length) => {
435 let values = completed.split_off(completed.len() - length);
436 completed.push(Self::Array(values));
437 }
438 Task::FinishObject(keys) => {
439 let values = completed.split_off(completed.len() - keys.len());
440 completed.push(Self::Object(keys.into_iter().zip(values).collect()));
441 }
442 }
443 }
444
445 completed.remove(0)
446 }
447}
448
449impl Drop for MetadataValue {
450 fn drop(&mut self) {
451 let mut pending = Vec::new();
452 take_nested_values(self, &mut pending);
453 while let Some(mut value) = pending.pop() {
454 take_nested_values(&mut value, &mut pending);
455 }
456 }
457}
458
459fn take_nested_values(value: &mut MetadataValue, pending: &mut Vec<MetadataValue>) {
460 match value {
461 MetadataValue::Array(values) => pending.append(values),
462 MetadataValue::Object(metadata) => {
463 pending.extend(std::mem::take(&mut metadata.0).into_values());
464 }
465 MetadataValue::Null
466 | MetadataValue::Bool(_)
467 | MetadataValue::Signed(_)
468 | MetadataValue::Unsigned(_)
469 | MetadataValue::Float(_)
470 | MetadataValue::String(_)
471 | MetadataValue::Bytes(_) => {}
472 }
473}
474
475#[derive(Clone)]
492pub struct PartFields {
493 text: String,
494 mime: String,
495 data: Option<Box<[u8]>>,
496 reference: String,
497 metadata: Option<Metadata>,
498 raw: Option<Payload>,
499}
500
501impl Debug for PartFields {
502 fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
508 formatter
509 .debug_struct("PartFields")
510 .field("text", &redact::Bytes(self.text.len()))
511 .field("mime", &redact::Bytes(self.mime.len()))
512 .field(
513 "data",
514 &self.data.as_deref().map(|data| redact::Bytes(data.len())),
515 )
516 .field("reference", &redact::Bytes(self.reference.len()))
517 .field("metadata", &self.metadata)
518 .field("raw", &self.raw)
519 .finish()
520 }
521}
522
523impl PartFields {
524 #[must_use]
526 pub const fn new(
527 text: String,
528 mime: String,
529 data: Option<Box<[u8]>>,
530 reference: String,
531 metadata: Option<Metadata>,
532 raw: Option<Payload>,
533 ) -> Self {
534 Self {
535 text,
536 mime,
537 data,
538 reference,
539 metadata,
540 raw,
541 }
542 }
543
544 #[must_use]
546 pub fn text(&self) -> &str {
547 &self.text
548 }
549
550 #[must_use]
552 pub fn mime(&self) -> &str {
553 &self.mime
554 }
555
556 #[must_use]
558 pub fn data(&self) -> Option<&[u8]> {
559 self.data.as_deref()
560 }
561
562 #[must_use]
564 pub fn reference(&self) -> &str {
565 &self.reference
566 }
567
568 #[must_use]
570 pub const fn metadata(&self) -> Option<&Metadata> {
571 self.metadata.as_ref()
572 }
573
574 #[must_use]
576 pub const fn raw_payload(&self) -> Option<&Payload> {
577 self.raw.as_ref()
578 }
579}
580
581#[derive(Clone, Debug)]
588pub struct Part {
589 kind: PartKind,
590 fields: PartFields,
591}
592
593impl Part {
594 #[must_use]
596 pub const fn new(kind: PartKind, fields: PartFields) -> Self {
597 Self { kind, fields }
598 }
599
600 #[must_use]
602 pub const fn text(text: String) -> Self {
603 Self::new(
604 KnownPartKind::Text.as_part_kind(),
605 PartFields::new(text, String::new(), None, String::new(), None, None),
606 )
607 }
608
609 #[must_use]
611 pub const fn kind(&self) -> PartKind {
612 self.kind
613 }
614
615 #[must_use]
617 pub const fn fields(&self) -> &PartFields {
618 &self.fields
619 }
620
621 #[must_use]
623 pub fn into_parts(self) -> (PartKind, PartFields) {
624 (self.kind, self.fields)
625 }
626}
627
628pub(crate) fn is_valid_system_instruction(parts: &[Part]) -> bool {
630 parts.iter().all(|part| {
631 part.kind().known() == Some(KnownPartKind::Text) && !part.fields().text().is_empty()
632 })
633}
634
635#[derive(Clone)]
637pub struct SegmentExtensions {
638 signature: String,
639 raw: Option<Payload>,
640 provider_data: Option<Vec<Envelope>>,
641 item_id: Option<String>,
642}
643
644impl Debug for SegmentExtensions {
645 fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
654 formatter
655 .debug_struct("SegmentExtensions")
656 .field("signature", &redact::Presence(!self.signature.is_empty()))
657 .field("raw", &self.raw)
658 .field("provider_data", &self.provider_data)
659 .field("item_id", &self.item_id)
664 .finish()
665 }
666}
667
668impl SegmentExtensions {
669 #[must_use]
676 pub const fn new(
677 signature: String,
678 raw: Option<Payload>,
679 provider_data: Option<Vec<Envelope>>,
680 ) -> Self {
681 Self {
682 signature,
683 raw,
684 provider_data,
685 item_id: None,
686 }
687 }
688
689 #[must_use]
707 pub fn with_item_id(mut self, id: String) -> Self {
708 self.item_id = Some(id);
709 self
710 }
711
712 #[must_use]
717 pub fn item_id(&self) -> Option<&str> {
718 self.item_id.as_deref()
719 }
720
721 #[must_use]
723 pub fn signature(&self) -> &str {
724 &self.signature
725 }
726
727 #[must_use]
729 pub const fn raw_payload(&self) -> Option<&Payload> {
730 self.raw.as_ref()
731 }
732
733 #[must_use]
735 pub fn provider_data(&self) -> Option<&[Envelope]> {
736 self.provider_data.as_deref()
737 }
738
739 #[must_use]
741 pub fn into_parts(
742 self,
743 ) -> (
744 String,
745 Option<Payload>,
746 Option<Vec<Envelope>>,
747 Option<String>,
748 ) {
749 (self.signature, self.raw, self.provider_data, self.item_id)
750 }
751}
752
753#[derive(Clone)]
775pub enum Segment {
776 Text {
778 text: String,
780 extensions: SegmentExtensions,
782 },
783 Thinking {
785 text: String,
787 extensions: SegmentExtensions,
789 },
790 ToolCall {
792 call: super::tool_call::ToolCall,
794 extensions: SegmentExtensions,
796 },
797}
798
799impl Debug for Segment {
800 fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
809 match self {
810 Self::Text { text, extensions } => formatter
811 .debug_struct("Text")
812 .field("text", &redact::Bytes(text.len()))
813 .field("extensions", extensions)
814 .finish(),
815 Self::Thinking { text, extensions } => formatter
816 .debug_struct("Thinking")
817 .field("text", &redact::Bytes(text.len()))
818 .field("extensions", extensions)
819 .finish(),
820 Self::ToolCall { call, extensions } => formatter
821 .debug_struct("ToolCall")
822 .field("call", call)
823 .field("extensions", extensions)
824 .finish(),
825 }
826 }
827}
828
829pub(crate) fn join_blocks<'a>(blocks: impl Iterator<Item = &'a str>) -> String {
836 let mut rendered = String::new();
837 for block in blocks.filter(|block| !block.is_empty()) {
838 if !rendered.is_empty() {
839 rendered.push('\n');
840 }
841 rendered.push_str(block);
842 }
843 rendered
844}
845
846#[cfg(feature = "serde")]
867mod serde_impl {
868 use std::fmt::{self, Formatter};
869
870 use serde_core::de::{
871 Deserialize, DeserializeSeed, Deserializer, EnumAccess, Error as DeError, MapAccess,
872 SeqAccess, VariantAccess, Visitor,
873 };
874 use serde_core::ser::{
875 Error as SerError, Serialize, SerializeMap, SerializeSeq, SerializeStruct,
876 SerializeStructVariant, Serializer,
877 };
878
879 use super::{Metadata, MetadataValue, Part, PartFields, PartKind, Segment, SegmentExtensions};
880 use crate::opaque::{Envelope, Payload};
881 use crate::wire::{self, ByteBuf, Bytes, IdentifierSeed};
882
883 pub(super) const MAX_METADATA_DEPTH: usize = 128;
889
890 const VALUE_NAME: &str = "MetadataValue";
891 const VALUE_VARIANTS: &[&str] = &[
892 "null", "bool", "signed", "unsigned", "float", "string", "bytes", "array", "object",
893 ];
894 const PART_FIELDS: &[&str] = &["kind", "fields"];
895 const FIELDS_FIELDS: &[&str] = &["text", "mime", "data", "reference", "metadata", "raw"];
896 const EXTENSIONS_FIELDS: &[&str] = &["signature", "raw", "provider_data", "item_id"];
897 const SEGMENT_NAME: &str = "Segment";
898 const SEGMENT_VARIANTS: &[&str] = &["text", "thinking", "tool_call"];
899 const TEXT_SEGMENT_FIELDS: &[&str] = &["text", "extensions"];
900 const TOOL_CALL_SEGMENT_FIELDS: &[&str] = &["call", "extensions"];
901
902 struct TooDeep;
904
905 impl fmt::Display for TooDeep {
906 fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
907 write!(
908 formatter,
909 "metadata value nests deeper than the {MAX_METADATA_DEPTH}-level serialization limit"
910 )
911 }
912 }
913
914 impl Serialize for PartKind {
917 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
918 where
919 S: Serializer,
920 {
921 serializer.serialize_i64(self.0)
922 }
923 }
924
925 impl<'de> Deserialize<'de> for PartKind {
926 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
927 where
928 D: Deserializer<'de>,
929 {
930 i64::deserialize(deserializer).map(Self::from_i64)
931 }
932 }
933
934 struct DepthValue<'a>(&'a MetadataValue, usize);
938
939 struct DepthElements<'a>(&'a [MetadataValue], usize);
941
942 struct DepthEntries<'a>(&'a Metadata, usize);
944
945 impl Serialize for DepthValue<'_> {
946 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
947 where
948 S: Serializer,
949 {
950 if self.1 > MAX_METADATA_DEPTH {
951 return Err(S::Error::custom(TooDeep));
952 }
953 let nested = self.1 + 1;
954 match self.0 {
955 MetadataValue::Null => serializer.serialize_unit_variant(VALUE_NAME, 0, "null"),
956 MetadataValue::Bool(value) => {
957 serializer.serialize_newtype_variant(VALUE_NAME, 1, "bool", value)
958 }
959 MetadataValue::Signed(value) => {
960 serializer.serialize_newtype_variant(VALUE_NAME, 2, "signed", value)
961 }
962 MetadataValue::Unsigned(value) => {
963 serializer.serialize_newtype_variant(VALUE_NAME, 3, "unsigned", value)
964 }
965 MetadataValue::Float(value) => {
966 serializer.serialize_newtype_variant(VALUE_NAME, 4, "float", value)
967 }
968 MetadataValue::String(value) => {
969 serializer.serialize_newtype_variant(VALUE_NAME, 5, "string", value)
970 }
971 MetadataValue::Bytes(value) => {
972 serializer.serialize_newtype_variant(VALUE_NAME, 6, "bytes", &Bytes(value))
973 }
974 MetadataValue::Array(values) => serializer.serialize_newtype_variant(
975 VALUE_NAME,
976 7,
977 "array",
978 &DepthElements(values, nested),
979 ),
980 MetadataValue::Object(metadata) => serializer.serialize_newtype_variant(
981 VALUE_NAME,
982 8,
983 "object",
984 &DepthEntries(metadata, nested),
985 ),
986 }
987 }
988 }
989
990 impl Serialize for DepthElements<'_> {
991 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
992 where
993 S: Serializer,
994 {
995 let mut sequence = serializer.serialize_seq(Some(self.0.len()))?;
996 for value in self.0 {
997 sequence.serialize_element(&DepthValue(value, self.1))?;
998 }
999 sequence.end()
1000 }
1001 }
1002
1003 impl Serialize for DepthEntries<'_> {
1004 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1005 where
1006 S: Serializer,
1007 {
1008 let mut entries = serializer.serialize_map(Some(self.0.iter().len()))?;
1009 for (key, value) in self.0 {
1010 entries.serialize_entry(key, &DepthValue(value, self.1))?;
1011 }
1012 entries.end()
1013 }
1014 }
1015
1016 impl Serialize for MetadataValue {
1017 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1018 where
1019 S: Serializer,
1020 {
1021 DepthValue(self, 1).serialize(serializer)
1022 }
1023 }
1024
1025 impl Serialize for Metadata {
1026 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1027 where
1028 S: Serializer,
1029 {
1030 DepthEntries(self, 1).serialize(serializer)
1031 }
1032 }
1033
1034 struct ValueSeed(usize);
1036
1037 impl<'de> DeserializeSeed<'de> for ValueSeed {
1038 type Value = MetadataValue;
1039
1040 fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
1041 where
1042 D: Deserializer<'de>,
1043 {
1044 if self.0 > MAX_METADATA_DEPTH {
1045 return Err(D::Error::custom(TooDeep));
1046 }
1047 deserializer.deserialize_enum(VALUE_NAME, VALUE_VARIANTS, ValueVisitor(self.0))
1048 }
1049 }
1050
1051 struct ValueVisitor(usize);
1052
1053 impl<'de> Visitor<'de> for ValueVisitor {
1054 type Value = MetadataValue;
1055
1056 fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
1057 formatter.write_str("a metadata value")
1058 }
1059
1060 fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
1061 where
1062 A: EnumAccess<'de>,
1063 {
1064 let (tag, variant) = data.variant_seed(IdentifierSeed(VALUE_VARIANTS))?;
1065 let nested = self.0 + 1;
1066 match tag.0.as_str() {
1067 "null" => {
1068 variant.unit_variant()?;
1069 Ok(MetadataValue::Null)
1070 }
1071 "bool" => variant.newtype_variant().map(MetadataValue::Bool),
1072 "signed" => variant.newtype_variant().map(MetadataValue::Signed),
1073 "unsigned" => variant.newtype_variant().map(MetadataValue::Unsigned),
1074 "float" => variant.newtype_variant().map(MetadataValue::Float),
1075 "string" => variant.newtype_variant().map(MetadataValue::String),
1076 "bytes" => variant
1077 .newtype_variant::<ByteBuf>()
1078 .map(|buffer| MetadataValue::Bytes(buffer.0)),
1079 "array" => variant
1080 .newtype_variant_seed(ElementsSeed(nested))
1081 .map(MetadataValue::Array),
1082 "object" => variant
1083 .newtype_variant_seed(EntriesSeed(nested))
1084 .map(MetadataValue::Object),
1085 unknown => Err(A::Error::unknown_variant(unknown, VALUE_VARIANTS)),
1086 }
1087 }
1088 }
1089
1090 struct ElementsSeed(usize);
1091
1092 impl<'de> DeserializeSeed<'de> for ElementsSeed {
1093 type Value = Vec<MetadataValue>;
1094
1095 fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
1096 where
1097 D: Deserializer<'de>,
1098 {
1099 deserializer.deserialize_seq(ElementsVisitor(self.0))
1100 }
1101 }
1102
1103 struct ElementsVisitor(usize);
1104
1105 impl<'de> Visitor<'de> for ElementsVisitor {
1106 type Value = Vec<MetadataValue>;
1107
1108 fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
1109 formatter.write_str("an array of metadata values")
1110 }
1111
1112 fn visit_seq<A>(self, mut sequence: A) -> Result<Self::Value, A::Error>
1113 where
1114 A: SeqAccess<'de>,
1115 {
1116 let mut values = Vec::new();
1117 while let Some(value) = sequence.next_element_seed(ValueSeed(self.0))? {
1118 values.push(value);
1119 }
1120 Ok(values)
1121 }
1122 }
1123
1124 struct EntriesSeed(usize);
1125
1126 impl<'de> DeserializeSeed<'de> for EntriesSeed {
1127 type Value = Metadata;
1128
1129 fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
1130 where
1131 D: Deserializer<'de>,
1132 {
1133 deserializer.deserialize_map(EntriesVisitor(self.0))
1134 }
1135 }
1136
1137 struct EntriesVisitor(usize);
1138
1139 impl<'de> Visitor<'de> for EntriesVisitor {
1140 type Value = Metadata;
1141
1142 fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
1143 formatter.write_str("a metadata object")
1144 }
1145
1146 fn visit_map<A>(self, mut entries: A) -> Result<Self::Value, A::Error>
1149 where
1150 A: MapAccess<'de>,
1151 {
1152 let mut metadata = Metadata::new();
1153 while let Some(key) = entries.next_key::<String>()? {
1154 let value = entries.next_value_seed(ValueSeed(self.0))?;
1155 drop(metadata.insert(key, value));
1156 }
1157 Ok(metadata)
1158 }
1159 }
1160
1161 impl<'de> Deserialize<'de> for MetadataValue {
1162 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1163 where
1164 D: Deserializer<'de>,
1165 {
1166 ValueSeed(1).deserialize(deserializer)
1167 }
1168 }
1169
1170 impl<'de> Deserialize<'de> for Metadata {
1171 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1172 where
1173 D: Deserializer<'de>,
1174 {
1175 EntriesSeed(1).deserialize(deserializer)
1176 }
1177 }
1178
1179 impl Serialize for PartFields {
1182 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1183 where
1184 S: Serializer,
1185 {
1186 let mut record = serializer.serialize_struct("PartFields", 6)?;
1187 record.serialize_field("text", &self.text)?;
1188 record.serialize_field("mime", &self.mime)?;
1189 record.serialize_field("data", &self.data.as_deref().map(Bytes))?;
1190 record.serialize_field("reference", &self.reference)?;
1191 record.serialize_field("metadata", &self.metadata)?;
1192 record.serialize_field("raw", &self.raw)?;
1193 record.end()
1194 }
1195 }
1196
1197 impl<'de> Deserialize<'de> for PartFields {
1198 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1199 where
1200 D: Deserializer<'de>,
1201 {
1202 deserializer.deserialize_struct("PartFields", FIELDS_FIELDS, FieldsVisitor)
1203 }
1204 }
1205
1206 struct FieldsVisitor;
1207
1208 impl<'de> Visitor<'de> for FieldsVisitor {
1209 type Value = PartFields;
1210
1211 fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
1212 formatter.write_str("a complete part field set")
1213 }
1214
1215 fn visit_seq<A>(self, mut sequence: A) -> Result<Self::Value, A::Error>
1216 where
1217 A: SeqAccess<'de>,
1218 {
1219 let text = wire::element(&mut sequence, 0)?;
1220 let mime = wire::element(&mut sequence, 1)?;
1221 let data = wire::element::<Option<ByteBuf>, _>(&mut sequence, 2)?;
1222 let reference = wire::element(&mut sequence, 3)?;
1223 let metadata = wire::element(&mut sequence, 4)?;
1224 let raw = wire::element(&mut sequence, 5)?;
1225 wire::end(&mut sequence, 6)?;
1226 Ok(PartFields::new(
1227 text,
1228 mime,
1229 ByteBuf::into_optional(data),
1230 reference,
1231 metadata,
1232 raw,
1233 ))
1234 }
1235
1236 fn visit_map<A>(self, mut entries: A) -> Result<Self::Value, A::Error>
1237 where
1238 A: MapAccess<'de>,
1239 {
1240 let mut text = None;
1241 let mut mime = None;
1242 let mut data = None::<Option<ByteBuf>>;
1243 let mut reference = None;
1244 let mut metadata = None;
1245 let mut raw = None;
1246 while let Some(field) = entries.next_key_seed(IdentifierSeed(FIELDS_FIELDS))? {
1247 match field.0.as_str() {
1248 "text" => wire::accept(&mut text, entries.next_value()?, "text")?,
1249 "mime" => wire::accept(&mut mime, entries.next_value()?, "mime")?,
1250 "data" => wire::accept(&mut data, entries.next_value()?, "data")?,
1251 "reference" => {
1252 wire::accept(&mut reference, entries.next_value()?, "reference")?;
1253 }
1254 "metadata" => wire::accept(&mut metadata, entries.next_value()?, "metadata")?,
1255 "raw" => wire::accept(&mut raw, entries.next_value()?, "raw")?,
1256 unknown => return Err(A::Error::unknown_field(unknown, FIELDS_FIELDS)),
1257 }
1258 }
1259 Ok(PartFields::new(
1260 wire::require(text, "text")?,
1261 wire::require(mime, "mime")?,
1262 ByteBuf::into_optional(wire::require(data, "data")?),
1263 wire::require(reference, "reference")?,
1264 wire::require(metadata, "metadata")?,
1265 wire::require(raw, "raw")?,
1266 ))
1267 }
1268 }
1269
1270 impl Serialize for Part {
1273 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1274 where
1275 S: Serializer,
1276 {
1277 let mut record = serializer.serialize_struct("Part", 2)?;
1278 record.serialize_field("kind", &self.kind)?;
1279 record.serialize_field("fields", &self.fields)?;
1280 record.end()
1281 }
1282 }
1283
1284 impl<'de> Deserialize<'de> for Part {
1285 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1286 where
1287 D: Deserializer<'de>,
1288 {
1289 deserializer.deserialize_struct("Part", PART_FIELDS, PartVisitor)
1290 }
1291 }
1292
1293 struct PartVisitor;
1294
1295 impl<'de> Visitor<'de> for PartVisitor {
1296 type Value = Part;
1297
1298 fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
1299 formatter.write_str("a message part")
1300 }
1301
1302 fn visit_seq<A>(self, mut sequence: A) -> Result<Self::Value, A::Error>
1303 where
1304 A: SeqAccess<'de>,
1305 {
1306 let kind = wire::element(&mut sequence, 0)?;
1307 let fields = wire::element(&mut sequence, 1)?;
1308 wire::end(&mut sequence, 2)?;
1309 Ok(Part::new(kind, fields))
1310 }
1311
1312 fn visit_map<A>(self, mut entries: A) -> Result<Self::Value, A::Error>
1313 where
1314 A: MapAccess<'de>,
1315 {
1316 let mut kind = None;
1317 let mut fields = None;
1318 while let Some(field) = entries.next_key_seed(IdentifierSeed(PART_FIELDS))? {
1319 match field.0.as_str() {
1320 "kind" => wire::accept(&mut kind, entries.next_value()?, "kind")?,
1321 "fields" => wire::accept(&mut fields, entries.next_value()?, "fields")?,
1322 unknown => return Err(A::Error::unknown_field(unknown, PART_FIELDS)),
1323 }
1324 }
1325 Ok(Part::new(
1326 wire::require(kind, "kind")?,
1327 wire::require(fields, "fields")?,
1328 ))
1329 }
1330 }
1331
1332 fn extensions(
1341 signature: String,
1342 raw: Option<Payload>,
1343 provider_data: Option<Vec<Envelope>>,
1344 item_id: Option<String>,
1345 ) -> SegmentExtensions {
1346 let extensions = SegmentExtensions::new(signature, raw, provider_data);
1347 match item_id {
1348 Some(id) => extensions.with_item_id(id),
1349 None => extensions,
1350 }
1351 }
1352
1353 impl Serialize for SegmentExtensions {
1354 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1355 where
1356 S: Serializer,
1357 {
1358 let mut record = serializer.serialize_struct("SegmentExtensions", 4)?;
1359 record.serialize_field("signature", &self.signature)?;
1360 record.serialize_field("raw", &self.raw)?;
1361 record.serialize_field("provider_data", &self.provider_data)?;
1362 record.serialize_field("item_id", &self.item_id)?;
1363 record.end()
1364 }
1365 }
1366
1367 impl<'de> Deserialize<'de> for SegmentExtensions {
1368 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1369 where
1370 D: Deserializer<'de>,
1371 {
1372 deserializer.deserialize_struct(
1373 "SegmentExtensions",
1374 EXTENSIONS_FIELDS,
1375 ExtensionsVisitor,
1376 )
1377 }
1378 }
1379
1380 struct ExtensionsVisitor;
1381
1382 impl<'de> Visitor<'de> for ExtensionsVisitor {
1383 type Value = SegmentExtensions;
1384
1385 fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
1386 formatter.write_str("segment extensions")
1387 }
1388
1389 fn visit_seq<A>(self, mut sequence: A) -> Result<Self::Value, A::Error>
1390 where
1391 A: SeqAccess<'de>,
1392 {
1393 let signature = wire::element(&mut sequence, 0)?;
1394 let raw = wire::element(&mut sequence, 1)?;
1395 let provider_data = wire::element(&mut sequence, 2)?;
1396 let item_id = wire::element(&mut sequence, 3)?;
1397 wire::end(&mut sequence, 4)?;
1398 Ok(extensions(signature, raw, provider_data, item_id))
1399 }
1400
1401 fn visit_map<A>(self, mut entries: A) -> Result<Self::Value, A::Error>
1402 where
1403 A: MapAccess<'de>,
1404 {
1405 let mut signature = None;
1406 let mut raw = None;
1407 let mut provider_data = None;
1408 let mut item_id = None;
1409 while let Some(field) = entries.next_key_seed(IdentifierSeed(EXTENSIONS_FIELDS))? {
1410 match field.0.as_str() {
1411 "signature" => {
1412 wire::accept(&mut signature, entries.next_value()?, "signature")?;
1413 }
1414 "raw" => wire::accept(&mut raw, entries.next_value()?, "raw")?,
1415 "provider_data" => {
1416 wire::accept(&mut provider_data, entries.next_value()?, "provider_data")?;
1417 }
1418 "item_id" => wire::accept(&mut item_id, entries.next_value()?, "item_id")?,
1419 unknown => return Err(A::Error::unknown_field(unknown, EXTENSIONS_FIELDS)),
1420 }
1421 }
1422 Ok(extensions(
1423 wire::require(signature, "signature")?,
1424 wire::require(raw, "raw")?,
1425 wire::require(provider_data, "provider_data")?,
1426 wire::require(item_id, "item_id")?,
1427 ))
1428 }
1429 }
1430
1431 const fn text_segment(text: String, extensions: SegmentExtensions) -> Segment {
1434 Segment::Text { text, extensions }
1435 }
1436
1437 const fn thinking_segment(text: String, extensions: SegmentExtensions) -> Segment {
1438 Segment::Thinking { text, extensions }
1439 }
1440
1441 impl Serialize for Segment {
1442 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1443 where
1444 S: Serializer,
1445 {
1446 match self {
1447 Self::Text { text, extensions } => {
1448 let mut record =
1449 serializer.serialize_struct_variant(SEGMENT_NAME, 0, "text", 2)?;
1450 record.serialize_field("text", text)?;
1451 record.serialize_field("extensions", extensions)?;
1452 record.end()
1453 }
1454 Self::Thinking { text, extensions } => {
1455 let mut record =
1456 serializer.serialize_struct_variant(SEGMENT_NAME, 1, "thinking", 2)?;
1457 record.serialize_field("text", text)?;
1458 record.serialize_field("extensions", extensions)?;
1459 record.end()
1460 }
1461 Self::ToolCall { call, extensions } => {
1462 let mut record =
1463 serializer.serialize_struct_variant(SEGMENT_NAME, 2, "tool_call", 2)?;
1464 record.serialize_field("call", call)?;
1465 record.serialize_field("extensions", extensions)?;
1466 record.end()
1467 }
1468 }
1469 }
1470 }
1471
1472 impl<'de> Deserialize<'de> for Segment {
1473 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1474 where
1475 D: Deserializer<'de>,
1476 {
1477 deserializer.deserialize_enum(SEGMENT_NAME, SEGMENT_VARIANTS, SegmentVisitor)
1478 }
1479 }
1480
1481 struct SegmentVisitor;
1482
1483 impl<'de> Visitor<'de> for SegmentVisitor {
1484 type Value = Segment;
1485
1486 fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
1487 formatter.write_str("an assistant content segment")
1488 }
1489
1490 fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
1491 where
1492 A: EnumAccess<'de>,
1493 {
1494 let (tag, variant) = data.variant_seed(IdentifierSeed(SEGMENT_VARIANTS))?;
1495 match tag.0.as_str() {
1496 "text" => variant.struct_variant(TEXT_SEGMENT_FIELDS, TextVisitor(text_segment)),
1497 "thinking" => {
1498 variant.struct_variant(TEXT_SEGMENT_FIELDS, TextVisitor(thinking_segment))
1499 }
1500 "tool_call" => {
1501 variant.struct_variant(TOOL_CALL_SEGMENT_FIELDS, ToolCallSegmentVisitor)
1502 }
1503 unknown => Err(A::Error::unknown_variant(unknown, SEGMENT_VARIANTS)),
1504 }
1505 }
1506 }
1507
1508 struct TextVisitor(fn(String, SegmentExtensions) -> Segment);
1511
1512 impl<'de> Visitor<'de> for TextVisitor {
1513 type Value = Segment;
1514
1515 fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
1516 formatter.write_str("a text-bearing segment")
1517 }
1518
1519 fn visit_seq<A>(self, mut sequence: A) -> Result<Self::Value, A::Error>
1520 where
1521 A: SeqAccess<'de>,
1522 {
1523 let text = wire::element(&mut sequence, 0)?;
1524 let extensions = wire::element(&mut sequence, 1)?;
1525 wire::end(&mut sequence, 2)?;
1526 Ok((self.0)(text, extensions))
1527 }
1528
1529 fn visit_map<A>(self, mut entries: A) -> Result<Self::Value, A::Error>
1530 where
1531 A: MapAccess<'de>,
1532 {
1533 let mut text = None;
1534 let mut extensions = None;
1535 while let Some(field) = entries.next_key_seed(IdentifierSeed(TEXT_SEGMENT_FIELDS))? {
1536 match field.0.as_str() {
1537 "text" => wire::accept(&mut text, entries.next_value()?, "text")?,
1538 "extensions" => {
1539 wire::accept(&mut extensions, entries.next_value()?, "extensions")?;
1540 }
1541 unknown => return Err(A::Error::unknown_field(unknown, TEXT_SEGMENT_FIELDS)),
1542 }
1543 }
1544 Ok((self.0)(
1545 wire::require(text, "text")?,
1546 wire::require(extensions, "extensions")?,
1547 ))
1548 }
1549 }
1550
1551 struct ToolCallSegmentVisitor;
1552
1553 impl<'de> Visitor<'de> for ToolCallSegmentVisitor {
1554 type Value = Segment;
1555
1556 fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
1557 formatter.write_str("a tool-call segment")
1558 }
1559
1560 fn visit_seq<A>(self, mut sequence: A) -> Result<Self::Value, A::Error>
1561 where
1562 A: SeqAccess<'de>,
1563 {
1564 let call = wire::element(&mut sequence, 0)?;
1565 let extensions = wire::element(&mut sequence, 1)?;
1566 wire::end(&mut sequence, 2)?;
1567 Ok(Segment::ToolCall { call, extensions })
1568 }
1569
1570 fn visit_map<A>(self, mut entries: A) -> Result<Self::Value, A::Error>
1571 where
1572 A: MapAccess<'de>,
1573 {
1574 let mut call = None;
1575 let mut extensions = None;
1576 while let Some(field) =
1577 entries.next_key_seed(IdentifierSeed(TOOL_CALL_SEGMENT_FIELDS))?
1578 {
1579 match field.0.as_str() {
1580 "call" => wire::accept(&mut call, entries.next_value()?, "call")?,
1581 "extensions" => {
1582 wire::accept(&mut extensions, entries.next_value()?, "extensions")?;
1583 }
1584 unknown => {
1585 return Err(A::Error::unknown_field(unknown, TOOL_CALL_SEGMENT_FIELDS));
1586 }
1587 }
1588 }
1589 Ok(Segment::ToolCall {
1590 call: wire::require(call, "call")?,
1591 extensions: wire::require(extensions, "extensions")?,
1592 })
1593 }
1594 }
1595}