use std::fmt::{self, Debug, Formatter};
use crate::opaque::Envelope;
use crate::redact;
use crate::value::content::{self, Metadata, Part, Segment};
use crate::value::tool_call::{self, Id};
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum ModelVisibility {
Visible,
Hidden,
}
#[derive(Clone, Debug)]
pub enum Item {
User(User),
Assistant(Assistant),
ToolResult(ToolResult),
System(System),
}
impl Item {
#[must_use]
pub fn to_plain_text(&self) -> String {
match self {
Self::User(user) => {
content::join_blocks(user.parts().iter().map(|part| part.fields().text()))
}
Self::Assistant(assistant) => {
content::join_blocks(assistant.content().iter().filter_map(
|segment| match segment {
Segment::Text { text, .. } => Some(text.as_str()),
Segment::Thinking { .. } | Segment::ToolCall { .. } => None,
},
))
}
Self::ToolResult(record) => record.result().to_plain_text(),
Self::System(system) => system.text().to_owned(),
}
}
}
#[derive(Clone, Debug)]
pub struct User {
parts: Vec<Part>,
visibility: ModelVisibility,
}
impl User {
#[must_use]
pub const fn new(parts: Vec<Part>, visibility: ModelVisibility) -> Self {
Self { parts, visibility }
}
#[must_use]
pub fn parts(&self) -> &[Part] {
&self.parts
}
#[must_use]
pub const fn visibility(&self) -> ModelVisibility {
self.visibility
}
}
#[derive(Clone, Debug)]
pub struct Assistant {
content: Vec<Segment>,
provider_data: Option<Vec<Envelope>>,
visibility: ModelVisibility,
}
impl Assistant {
#[must_use]
pub const fn new(content: Vec<Segment>, provider_data: Option<Vec<Envelope>>) -> Self {
Self {
content,
provider_data,
visibility: ModelVisibility::Visible,
}
}
#[must_use]
pub const fn with_visibility(mut self, visibility: ModelVisibility) -> Self {
self.visibility = visibility;
self
}
#[must_use]
pub fn content(&self) -> &[Segment] {
&self.content
}
#[must_use]
pub fn provider_data(&self) -> Option<&[Envelope]> {
self.provider_data.as_deref()
}
#[must_use]
pub const fn visibility(&self) -> ModelVisibility {
self.visibility
}
}
#[derive(Clone, Debug)]
pub struct ToolResult {
call_id: Id,
tool_name: tool_call::Name,
result: tool_call::ToolResult,
visibility: ModelVisibility,
metadata: Option<Metadata>,
}
impl ToolResult {
#[must_use]
pub const fn new(
call_id: Id,
tool_name: tool_call::Name,
result: tool_call::ToolResult,
visibility: ModelVisibility,
metadata: Option<Metadata>,
) -> Self {
Self {
call_id,
tool_name,
result,
visibility,
metadata,
}
}
#[must_use]
pub const fn call_id(&self) -> &Id {
&self.call_id
}
#[must_use]
pub const fn tool_name(&self) -> &tool_call::Name {
&self.tool_name
}
#[must_use]
pub const fn result(&self) -> &tool_call::ToolResult {
&self.result
}
#[must_use]
pub const fn visibility(&self) -> ModelVisibility {
self.visibility
}
#[must_use]
pub const fn metadata(&self) -> Option<&Metadata> {
self.metadata.as_ref()
}
#[must_use]
pub const fn is_business_error(&self) -> bool {
self.result.is_business_error()
}
}
#[derive(Clone)]
pub struct System {
subtype: String,
text: String,
visibility: ModelVisibility,
}
impl Debug for System {
fn fmt(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("System")
.field("subtype", &self.subtype)
.field("text", &redact::Bytes(self.text.len()))
.field("visibility", &self.visibility)
.finish()
}
}
impl System {
#[must_use]
pub const fn new(subtype: String, text: String, visibility: ModelVisibility) -> Self {
Self {
subtype,
text,
visibility,
}
}
#[must_use]
pub fn subtype(&self) -> &str {
&self.subtype
}
#[must_use]
pub fn text(&self) -> &str {
&self.text
}
#[must_use]
pub const fn visibility(&self) -> ModelVisibility {
self.visibility
}
}
#[cfg(feature = "serde")]
mod serde_impl {
use std::fmt::{self, Formatter};
use serde_core::de::{
Deserialize, Deserializer, EnumAccess, Error as DeError, MapAccess, SeqAccess,
VariantAccess, Visitor,
};
use serde_core::ser::{Serialize, SerializeStruct, Serializer};
use super::{Assistant, Item, ModelVisibility, System, ToolResult, User};
use crate::wire::{self, IdentifierSeed};
const VISIBILITY_NAME: &str = "ModelVisibility";
const VISIBILITY_VARIANTS: &[&str] = &["both", "user_only"];
const USER_FIELDS: &[&str] = &["parts", "visibility"];
const ASSISTANT_FIELDS: &[&str] = &["content", "provider_data", "visibility"];
const TOOL_RESULT_FIELDS: &[&str] =
&["call_id", "tool_name", "result", "visibility", "metadata"];
const SYSTEM_FIELDS: &[&str] = &["subtype", "text", "visibility"];
const ITEM_NAME: &str = "Item";
const ITEM_VARIANTS: &[&str] = &["user", "assistant", "tool_result", "system"];
impl Serialize for ModelVisibility {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let (index, tag) = match self {
Self::Visible => (0, "both"),
Self::Hidden => (1, "user_only"),
};
serializer.serialize_unit_variant(VISIBILITY_NAME, index, tag)
}
}
impl<'de> Deserialize<'de> for ModelVisibility {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
deserializer.deserialize_enum(VISIBILITY_NAME, VISIBILITY_VARIANTS, VisibilityVisitor)
}
}
struct VisibilityVisitor;
impl<'de> Visitor<'de> for VisibilityVisitor {
type Value = ModelVisibility;
fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
formatter.write_str("a record visibility")
}
fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
where
A: EnumAccess<'de>,
{
let (tag, variant) = data.variant_seed(IdentifierSeed(VISIBILITY_VARIANTS))?;
variant.unit_variant()?;
match tag.0.as_str() {
"both" => Ok(ModelVisibility::Visible),
"user_only" => Ok(ModelVisibility::Hidden),
unknown => Err(A::Error::unknown_variant(unknown, VISIBILITY_VARIANTS)),
}
}
}
impl Serialize for User {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let mut record = serializer.serialize_struct("User", 2)?;
record.serialize_field("parts", &self.parts)?;
record.serialize_field("visibility", &self.visibility)?;
record.end()
}
}
impl<'de> Deserialize<'de> for User {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
deserializer.deserialize_struct("User", USER_FIELDS, UserVisitor)
}
}
struct UserVisitor;
impl<'de> Visitor<'de> for UserVisitor {
type Value = User;
fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
formatter.write_str("a user record")
}
fn visit_seq<A>(self, mut sequence: A) -> Result<Self::Value, A::Error>
where
A: SeqAccess<'de>,
{
let parts = wire::element(&mut sequence, 0)?;
let visibility = wire::element(&mut sequence, 1)?;
wire::end(&mut sequence, 2)?;
Ok(User::new(parts, visibility))
}
fn visit_map<A>(self, mut entries: A) -> Result<Self::Value, A::Error>
where
A: MapAccess<'de>,
{
let mut parts = None;
let mut visibility = None;
while let Some(field) = entries.next_key_seed(IdentifierSeed(USER_FIELDS))? {
match field.0.as_str() {
"parts" => wire::accept(&mut parts, entries.next_value()?, "parts")?,
"visibility" => {
wire::accept(&mut visibility, entries.next_value()?, "visibility")?;
}
unknown => return Err(A::Error::unknown_field(unknown, USER_FIELDS)),
}
}
Ok(User::new(
wire::require(parts, "parts")?,
wire::require(visibility, "visibility")?,
))
}
}
impl Serialize for Assistant {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let mut record = serializer.serialize_struct("Assistant", 3)?;
record.serialize_field("content", &self.content)?;
record.serialize_field("provider_data", &self.provider_data)?;
record.serialize_field("visibility", &self.visibility)?;
record.end()
}
}
impl<'de> Deserialize<'de> for Assistant {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
deserializer.deserialize_struct("Assistant", ASSISTANT_FIELDS, AssistantVisitor)
}
}
struct AssistantVisitor;
impl<'de> Visitor<'de> for AssistantVisitor {
type Value = Assistant;
fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
formatter.write_str("an assistant record")
}
fn visit_seq<A>(self, mut sequence: A) -> Result<Self::Value, A::Error>
where
A: SeqAccess<'de>,
{
let content = wire::element(&mut sequence, 0)?;
let provider_data = wire::element(&mut sequence, 1)?;
let visibility = wire::element(&mut sequence, 2)?;
wire::end(&mut sequence, 3)?;
Ok(Assistant::new(content, provider_data).with_visibility(visibility))
}
fn visit_map<A>(self, mut entries: A) -> Result<Self::Value, A::Error>
where
A: MapAccess<'de>,
{
let mut content = None;
let mut provider_data = None;
let mut visibility = None;
while let Some(field) = entries.next_key_seed(IdentifierSeed(ASSISTANT_FIELDS))? {
match field.0.as_str() {
"content" => wire::accept(&mut content, entries.next_value()?, "content")?,
"provider_data" => {
wire::accept(&mut provider_data, entries.next_value()?, "provider_data")?;
}
"visibility" => {
wire::accept(&mut visibility, entries.next_value()?, "visibility")?;
}
unknown => return Err(A::Error::unknown_field(unknown, ASSISTANT_FIELDS)),
}
}
Ok(Assistant::new(
wire::require(content, "content")?,
wire::require(provider_data, "provider_data")?,
)
.with_visibility(wire::require(visibility, "visibility")?))
}
}
impl Serialize for ToolResult {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let mut record = serializer.serialize_struct("ToolResult", 5)?;
record.serialize_field("call_id", &self.call_id)?;
record.serialize_field("tool_name", &self.tool_name)?;
record.serialize_field("result", &self.result)?;
record.serialize_field("visibility", &self.visibility)?;
record.serialize_field("metadata", &self.metadata)?;
record.end()
}
}
impl<'de> Deserialize<'de> for ToolResult {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
deserializer.deserialize_struct("ToolResult", TOOL_RESULT_FIELDS, ToolResultVisitor)
}
}
struct ToolResultVisitor;
impl<'de> Visitor<'de> for ToolResultVisitor {
type Value = ToolResult;
fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
formatter.write_str("a tool-result record")
}
fn visit_seq<A>(self, mut sequence: A) -> Result<Self::Value, A::Error>
where
A: SeqAccess<'de>,
{
let call_id = wire::element(&mut sequence, 0)?;
let tool_name = wire::element(&mut sequence, 1)?;
let result = wire::element(&mut sequence, 2)?;
let visibility = wire::element(&mut sequence, 3)?;
let metadata = wire::element(&mut sequence, 4)?;
wire::end(&mut sequence, 5)?;
Ok(ToolResult::new(
call_id, tool_name, result, visibility, metadata,
))
}
fn visit_map<A>(self, mut entries: A) -> Result<Self::Value, A::Error>
where
A: MapAccess<'de>,
{
let mut call_id = None;
let mut tool_name = None;
let mut result = None;
let mut visibility = None;
let mut metadata = None;
while let Some(field) = entries.next_key_seed(IdentifierSeed(TOOL_RESULT_FIELDS))? {
match field.0.as_str() {
"call_id" => wire::accept(&mut call_id, entries.next_value()?, "call_id")?,
"tool_name" => {
wire::accept(&mut tool_name, entries.next_value()?, "tool_name")?;
}
"result" => wire::accept(&mut result, entries.next_value()?, "result")?,
"visibility" => {
wire::accept(&mut visibility, entries.next_value()?, "visibility")?;
}
"metadata" => wire::accept(&mut metadata, entries.next_value()?, "metadata")?,
unknown => return Err(A::Error::unknown_field(unknown, TOOL_RESULT_FIELDS)),
}
}
Ok(ToolResult::new(
wire::require(call_id, "call_id")?,
wire::require(tool_name, "tool_name")?,
wire::require(result, "result")?,
wire::require(visibility, "visibility")?,
wire::require(metadata, "metadata")?,
))
}
}
impl Serialize for System {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
let mut record = serializer.serialize_struct("System", 3)?;
record.serialize_field("subtype", &self.subtype)?;
record.serialize_field("text", &self.text)?;
record.serialize_field("visibility", &self.visibility)?;
record.end()
}
}
impl<'de> Deserialize<'de> for System {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
deserializer.deserialize_struct("System", SYSTEM_FIELDS, SystemVisitor)
}
}
struct SystemVisitor;
impl<'de> Visitor<'de> for SystemVisitor {
type Value = System;
fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
formatter.write_str("a system record")
}
fn visit_seq<A>(self, mut sequence: A) -> Result<Self::Value, A::Error>
where
A: SeqAccess<'de>,
{
let subtype = wire::element(&mut sequence, 0)?;
let text = wire::element(&mut sequence, 1)?;
let visibility = wire::element(&mut sequence, 2)?;
wire::end(&mut sequence, 3)?;
Ok(System::new(subtype, text, visibility))
}
fn visit_map<A>(self, mut entries: A) -> Result<Self::Value, A::Error>
where
A: MapAccess<'de>,
{
let mut subtype = None;
let mut text = None;
let mut visibility = None;
while let Some(field) = entries.next_key_seed(IdentifierSeed(SYSTEM_FIELDS))? {
match field.0.as_str() {
"subtype" => wire::accept(&mut subtype, entries.next_value()?, "subtype")?,
"text" => wire::accept(&mut text, entries.next_value()?, "text")?,
"visibility" => {
wire::accept(&mut visibility, entries.next_value()?, "visibility")?;
}
unknown => return Err(A::Error::unknown_field(unknown, SYSTEM_FIELDS)),
}
}
Ok(System::new(
wire::require(subtype, "subtype")?,
wire::require(text, "text")?,
wire::require(visibility, "visibility")?,
))
}
}
impl Serialize for Item {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::User(record) => {
serializer.serialize_newtype_variant(ITEM_NAME, 0, "user", record)
}
Self::Assistant(record) => {
serializer.serialize_newtype_variant(ITEM_NAME, 1, "assistant", record)
}
Self::ToolResult(record) => {
serializer.serialize_newtype_variant(ITEM_NAME, 2, "tool_result", record)
}
Self::System(record) => {
serializer.serialize_newtype_variant(ITEM_NAME, 3, "system", record)
}
}
}
}
impl<'de> Deserialize<'de> for Item {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
deserializer.deserialize_enum(ITEM_NAME, ITEM_VARIANTS, ItemVisitor)
}
}
struct ItemVisitor;
impl<'de> Visitor<'de> for ItemVisitor {
type Value = Item;
fn expecting(&self, formatter: &mut Formatter<'_>) -> fmt::Result {
formatter.write_str("a transcript record")
}
fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
where
A: EnumAccess<'de>,
{
let (tag, variant) = data.variant_seed(IdentifierSeed(ITEM_VARIANTS))?;
match tag.0.as_str() {
"user" => variant.newtype_variant().map(Item::User),
"assistant" => variant.newtype_variant().map(Item::Assistant),
"tool_result" => variant.newtype_variant().map(Item::ToolResult),
"system" => variant.newtype_variant().map(Item::System),
unknown => Err(A::Error::unknown_variant(unknown, ITEM_VARIANTS)),
}
}
}
}