Skip to main content

gproxy_protocol/protocol/openai/generate_content/response_items/
message.rs

1use std::collections::BTreeMap;
2
3use serde::{Deserialize, Serialize, de};
4use serde_json::Value;
5
6use super::super::super::common::*;
7use super::{ResponseEasyInputContent, ResponseInputContentPart, ResponseMessageOutputContentPart};
8
9#[derive(Debug, Clone, PartialEq, Serialize)]
10#[serde(untagged)]
11pub enum ResponseMessageItem {
12    Output(ResponseOutputMessageItem),
13    Input(ResponseInputMessageItem),
14    EasyInput(ResponseEasyInputMessageItem),
15}
16
17impl<'de> Deserialize<'de> for ResponseMessageItem {
18    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
19    where
20        D: serde::Deserializer<'de>,
21    {
22        let value = Value::deserialize(deserializer)?;
23        let role = value.get("role").and_then(Value::as_str);
24        let has_id = value.get("id").is_some();
25        let has_status = value.get("status").is_some();
26
27        if role == Some("assistant") && has_id && has_status {
28            return serde_json::from_value(value)
29                .map(Self::Output)
30                .map_err(de::Error::custom);
31        }
32
33        if has_id || has_status {
34            return serde_json::from_value(value)
35                .map(Self::Input)
36                .map_err(de::Error::custom);
37        }
38
39        serde_json::from_value(value)
40            .map(Self::EasyInput)
41            .map_err(de::Error::custom)
42    }
43}
44
45#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
46pub struct ResponseOutputMessageItem {
47    #[serde(rename = "type")]
48    pub type_: ResponseMessageItemType,
49    pub id: String,
50    pub role: ResponseOutputMessageRole,
51    pub content: Vec<ResponseMessageOutputContentPart>,
52    pub status: ResponseItemLifecycleStatus,
53    #[serde(skip_serializing_if = "Option::is_none")]
54    pub phase: Option<ResponsePhase>,
55    #[serde(default, flatten, skip_serializing_if = "BTreeMap::is_empty")]
56    pub extra: Extra,
57}
58
59#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
60pub struct ResponseInputMessageItem {
61    #[serde(skip_serializing_if = "Option::is_none")]
62    pub id: Option<String>,
63    #[serde(rename = "type", skip_serializing_if = "Option::is_none")]
64    pub type_: Option<ResponseMessageItemType>,
65    pub role: ResponseInputMessageRole,
66    pub content: Vec<ResponseInputContentPart>,
67    #[serde(skip_serializing_if = "Option::is_none")]
68    pub status: Option<ResponseItemLifecycleStatus>,
69    #[serde(default, flatten, skip_serializing_if = "BTreeMap::is_empty")]
70    pub extra: Extra,
71}
72
73#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
74pub struct ResponseEasyInputMessageItem {
75    #[serde(rename = "type", skip_serializing_if = "Option::is_none")]
76    pub type_: Option<ResponseMessageItemType>,
77    pub role: ResponseEasyInputMessageRole,
78    pub content: ResponseEasyInputContent,
79    #[serde(skip_serializing_if = "Option::is_none")]
80    pub phase: Option<ResponsePhase>,
81    #[serde(default, flatten, skip_serializing_if = "BTreeMap::is_empty")]
82    pub extra: Extra,
83}
84
85#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
86pub enum ResponseMessageItemType {
87    #[serde(rename = "message")]
88    Message,
89}
90
91#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
92pub enum ResponseOutputMessageRole {
93    #[serde(rename = "assistant")]
94    Assistant,
95}
96
97#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
98pub enum ResponseInputMessageRole {
99    #[serde(rename = "user")]
100    User,
101    #[serde(rename = "system")]
102    System,
103    #[serde(rename = "developer")]
104    Developer,
105}
106
107#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
108pub enum ResponseEasyInputMessageRole {
109    #[serde(rename = "user")]
110    User,
111    #[serde(rename = "assistant")]
112    Assistant,
113    #[serde(rename = "system")]
114    System,
115    #[serde(rename = "developer")]
116    Developer,
117}
118
119#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
120pub struct ResponseAgent {
121    pub agent_name: String,
122    #[serde(default, flatten, skip_serializing_if = "BTreeMap::is_empty")]
123    pub extra: Extra,
124}
125
126#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
127#[serde(tag = "type")]
128pub enum ResponseCaller {
129    #[serde(rename = "direct")]
130    Direct {
131        #[serde(default, flatten, skip_serializing_if = "BTreeMap::is_empty")]
132        extra: Extra,
133    },
134    #[serde(rename = "program")]
135    Program {
136        caller_id: String,
137        #[serde(default, flatten, skip_serializing_if = "BTreeMap::is_empty")]
138        extra: Extra,
139    },
140}