Skip to main content

gproxy_protocol/protocol/openai/audio/
responses.rs

1use std::collections::BTreeMap;
2
3use serde::{Deserialize, Serialize};
4
5use super::super::common::Extra;
6use super::{AudioDurationUsageType, AudioTokenUsageType};
7
8#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
9#[serde(untagged)]
10#[non_exhaustive]
11pub enum TranscriptionResponse {
12    Verbose(TranscriptionVerbose),
13    Diarized(TranscriptionDiarized),
14    Json(Transcription),
15    Text(String),
16}
17
18#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
19#[serde(untagged)]
20#[non_exhaustive]
21pub enum TranslationResponse {
22    Verbose(TranslationVerbose),
23    Json(Translation),
24    Text(String),
25}
26
27#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
28#[non_exhaustive]
29pub struct Transcription {
30    pub text: String,
31    #[serde(skip_serializing_if = "Option::is_none")]
32    pub languages: Option<Vec<TranscriptionLanguage>>,
33    #[serde(skip_serializing_if = "Option::is_none")]
34    pub logprobs: Option<Vec<TranscriptionLogprob>>,
35    #[serde(skip_serializing_if = "Option::is_none")]
36    pub usage: Option<AudioUsage>,
37    #[serde(default, flatten, skip_serializing_if = "BTreeMap::is_empty")]
38    pub extra: Extra,
39}
40
41#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
42#[non_exhaustive]
43pub struct TranscriptionVerbose {
44    pub duration: f64,
45    pub language: String,
46    pub text: String,
47    #[serde(skip_serializing_if = "Option::is_none")]
48    pub task: Option<String>,
49    #[serde(skip_serializing_if = "Option::is_none")]
50    pub segments: Option<Vec<TranscriptionSegment>>,
51    #[serde(skip_serializing_if = "Option::is_none")]
52    pub usage: Option<AudioDurationUsage>,
53    #[serde(skip_serializing_if = "Option::is_none")]
54    pub words: Option<Vec<TranscriptionWord>>,
55    #[serde(default, flatten, skip_serializing_if = "BTreeMap::is_empty")]
56    pub extra: Extra,
57}
58
59#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
60#[non_exhaustive]
61pub struct TranscriptionDiarized {
62    pub duration: f64,
63    pub segments: Vec<TranscriptionDiarizedSegment>,
64    pub task: String,
65    pub text: String,
66    #[serde(skip_serializing_if = "Option::is_none")]
67    pub usage: Option<AudioUsage>,
68    #[serde(default, flatten, skip_serializing_if = "BTreeMap::is_empty")]
69    pub extra: Extra,
70}
71
72#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
73#[non_exhaustive]
74pub struct Translation {
75    pub text: String,
76    #[serde(default, flatten, skip_serializing_if = "BTreeMap::is_empty")]
77    pub extra: Extra,
78}
79
80#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
81#[non_exhaustive]
82pub struct TranslationVerbose {
83    pub duration: f64,
84    pub language: String,
85    pub text: String,
86    #[serde(skip_serializing_if = "Option::is_none")]
87    pub segments: Option<Vec<TranscriptionSegment>>,
88    #[serde(default, flatten, skip_serializing_if = "BTreeMap::is_empty")]
89    pub extra: Extra,
90}
91
92#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
93#[serde(untagged)]
94#[non_exhaustive]
95pub enum AudioUsage {
96    Tokens(AudioTokenUsage),
97    Duration(AudioDurationUsage),
98}
99
100#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
101#[non_exhaustive]
102pub struct AudioTokenUsage {
103    pub input_tokens: u64,
104    pub output_tokens: u64,
105    pub total_tokens: u64,
106    /// Present on buffered transcription responses; the official
107    /// `transcript.text.done` stream event currently omits this discriminator.
108    #[serde(rename = "type", skip_serializing_if = "Option::is_none")]
109    pub type_: Option<AudioTokenUsageType>,
110    #[serde(skip_serializing_if = "Option::is_none")]
111    pub input_token_details: Option<AudioInputTokenDetails>,
112    #[serde(default, flatten, skip_serializing_if = "BTreeMap::is_empty")]
113    pub extra: Extra,
114}
115
116#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
117#[non_exhaustive]
118pub struct AudioDurationUsage {
119    pub seconds: f64,
120    #[serde(rename = "type")]
121    pub type_: AudioDurationUsageType,
122    #[serde(default, flatten, skip_serializing_if = "BTreeMap::is_empty")]
123    pub extra: Extra,
124}
125
126#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
127#[non_exhaustive]
128pub struct AudioInputTokenDetails {
129    #[serde(skip_serializing_if = "Option::is_none")]
130    pub audio_tokens: Option<u64>,
131    #[serde(skip_serializing_if = "Option::is_none")]
132    pub text_tokens: Option<u64>,
133    #[serde(default, flatten, skip_serializing_if = "BTreeMap::is_empty")]
134    pub extra: Extra,
135}
136
137#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
138#[non_exhaustive]
139pub struct TranscriptionLanguage {
140    pub code: String,
141    #[serde(default, flatten, skip_serializing_if = "BTreeMap::is_empty")]
142    pub extra: Extra,
143}
144
145#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
146#[non_exhaustive]
147pub struct TranscriptionLogprob {
148    #[serde(skip_serializing_if = "Option::is_none")]
149    pub token: Option<String>,
150    #[serde(skip_serializing_if = "Option::is_none")]
151    pub bytes: Option<Vec<u8>>,
152    #[serde(skip_serializing_if = "Option::is_none")]
153    pub logprob: Option<f64>,
154    #[serde(default, flatten, skip_serializing_if = "BTreeMap::is_empty")]
155    pub extra: Extra,
156}
157
158#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
159#[non_exhaustive]
160pub struct TranscriptionSegment {
161    pub id: u64,
162    pub avg_logprob: f64,
163    pub compression_ratio: f64,
164    pub end: f64,
165    pub no_speech_prob: f64,
166    pub seek: u64,
167    pub start: f64,
168    pub temperature: f64,
169    pub text: String,
170    pub tokens: Vec<u64>,
171    #[serde(default, flatten, skip_serializing_if = "BTreeMap::is_empty")]
172    pub extra: Extra,
173}
174
175#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
176#[non_exhaustive]
177pub struct TranscriptionWord {
178    pub end: f64,
179    pub start: f64,
180    pub word: String,
181    #[serde(default, flatten, skip_serializing_if = "BTreeMap::is_empty")]
182    pub extra: Extra,
183}
184
185#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
186#[non_exhaustive]
187pub struct TranscriptionDiarizedSegment {
188    pub id: String,
189    pub end: f64,
190    pub speaker: String,
191    pub start: f64,
192    pub text: String,
193    #[serde(rename = "type")]
194    pub type_: TranscriptionSegmentType,
195    #[serde(default, flatten, skip_serializing_if = "BTreeMap::is_empty")]
196    pub extra: Extra,
197}
198
199#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
200#[non_exhaustive]
201pub enum TranscriptionSegmentType {
202    #[serde(rename = "transcript.text.segment")]
203    TranscriptTextSegment,
204}