1use super::generate_content as response;
7use crate::Rest;
8use serde::{Deserialize, Serialize};
9
10pub type StreamResponse = crate::WireResponse<crate::connection::ByteStream>;
11pub type StreamUsage = response::Usage;
12pub type StreamStopReason = response::StopReason;
13pub type StreamMessageType = response::GenerateContentResponseBodyType;
14fn present_nullable<'de, D, T>(d: D) -> Result<Option<Option<T>>, D::Error>
15where
16 D: serde::Deserializer<'de>,
17 T: Deserialize<'de>,
18{
19 Option::<T>::deserialize(d).map(Some)
20}
21
22#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
23#[serde(tag = "type")]
24#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
25#[derive(gproxy_protocol_macros::DeclaredFields)]
26pub enum StreamEvent {
27 #[serde(rename = "message_start")]
28 MessageStart(Box<MessageStartEvent>),
29 #[serde(rename = "content_block_start")]
30 ContentBlockStart(ContentBlockStartEvent),
31 #[serde(rename = "content_block_delta")]
32 ContentBlockDelta(ContentBlockDeltaEvent),
33 #[serde(rename = "content_block_stop")]
34 ContentBlockStop(ContentBlockStopEvent),
35 #[serde(rename = "message_delta")]
36 MessageDelta(Box<MessageDeltaEvent>),
37 #[serde(rename = "message_stop")]
38 MessageStop(MessageStopEvent),
39 #[serde(rename = "ping")]
40 Ping(PingEvent),
41 #[serde(rename = "error")]
42 Error(ErrorEvent),
43}
44
45#[derive(
46 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
47)]
48#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
49#[derive(gproxy_protocol_macros::DeclaredFields)]
50pub struct MessageStartEvent {
51 pub message: StreamMessage,
52 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
53 pub rest: Rest,
54}
55
56#[derive(
57 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
58)]
59#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
60#[derive(gproxy_protocol_macros::DeclaredFields)]
61pub struct StreamMessage {
62 #[serde(
63 default,
64 deserialize_with = "present_nullable",
65 skip_serializing_if = "Option::is_none"
66 )]
67 pub input_transformations: Option<Option<Vec<response::InputTransformation>>>,
68
69 #[serde(rename = "type")]
70 pub type_: StreamMessageType,
71 pub id: String,
72 #[serde(
73 default,
74 deserialize_with = "present_nullable",
75 skip_serializing_if = "Option::is_none"
76 )]
77 pub container: Option<Option<response::ResponseContainer>>,
78 pub content: Vec<response::ResponseContentBlock>,
79 #[serde(
80 default,
81 deserialize_with = "present_nullable",
82 skip_serializing_if = "Option::is_none"
83 )]
84 pub context_management: Option<Option<response::ContextManagementResponse>>,
85 #[serde(
86 default,
87 deserialize_with = "present_nullable",
88 skip_serializing_if = "Option::is_none"
89 )]
90 pub diagnostics: Option<Option<response::DiagnosticsResponse>>,
91 pub model: String,
92 pub role: response::ResponseRole,
93 #[serde(
94 default,
95 deserialize_with = "present_nullable",
96 skip_serializing_if = "Option::is_none"
97 )]
98 pub stop_details: Option<Option<response::RefusalStopDetails>>,
99 #[serde(
100 default,
101 deserialize_with = "present_nullable",
102 skip_serializing_if = "Option::is_none"
103 )]
104 pub stop_reason: Option<Option<StreamStopReason>>,
105 #[serde(
106 default,
107 deserialize_with = "present_nullable",
108 skip_serializing_if = "Option::is_none"
109 )]
110 pub stop_sequence: Option<Option<String>>,
111 pub usage: StreamUsage,
112 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
113 pub rest: Rest,
114}
115
116#[derive(
117 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
118)]
119#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
120#[derive(gproxy_protocol_macros::DeclaredFields)]
121pub struct ContentBlockStartEvent {
122 pub index: i64,
123 pub content_block: response::ResponseContentBlock,
124 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
125 pub rest: Rest,
126}
127
128#[derive(
129 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
130)]
131#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
132#[derive(gproxy_protocol_macros::DeclaredFields)]
133pub struct ContentBlockDeltaEvent {
134 pub index: i64,
135 pub delta: ContentBlockDelta,
136 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
137 pub rest: Rest,
138}
139
140#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
141#[serde(tag = "type")]
142#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
143#[derive(gproxy_protocol_macros::DeclaredFields)]
144pub enum ContentBlockDelta {
145 #[serde(rename = "text_delta")]
146 Text(TextDelta),
147 #[serde(rename = "input_json_delta")]
148 InputJson(InputJsonDelta),
149 #[serde(rename = "thinking_delta")]
150 Thinking(ThinkingDelta),
151 #[serde(rename = "signature_delta")]
152 Signature(SignatureDelta),
153 #[serde(rename = "citations_delta")]
154 Citations(CitationsDelta),
155 #[serde(rename = "compaction_delta")]
156 Compaction(CompactionDelta),
157}
158
159#[derive(
160 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
161)]
162#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
163#[derive(gproxy_protocol_macros::DeclaredFields)]
164pub struct TextDelta {
165 pub text: String,
166 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
167 pub rest: Rest,
168}
169
170#[derive(
171 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
172)]
173#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
174#[derive(gproxy_protocol_macros::DeclaredFields)]
175pub struct InputJsonDelta {
176 pub partial_json: String,
177 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
178 pub rest: Rest,
179}
180
181#[derive(
182 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
183)]
184#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
185#[derive(gproxy_protocol_macros::DeclaredFields)]
186pub struct ThinkingDelta {
187 pub thinking: String,
188 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
189 pub rest: Rest,
190}
191
192#[derive(
193 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
194)]
195#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
196#[derive(gproxy_protocol_macros::DeclaredFields)]
197pub struct SignatureDelta {
198 pub signature: String,
199 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
200 pub rest: Rest,
201}
202
203#[derive(
204 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
205)]
206#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
207#[derive(gproxy_protocol_macros::DeclaredFields)]
208pub struct CitationsDelta {
209 pub citation: response::ResponseTextCitation,
210 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
211 pub rest: Rest,
212}
213
214#[derive(
215 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
216)]
217#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
218#[derive(gproxy_protocol_macros::DeclaredFields)]
219pub struct CompactionDelta {
220 #[serde(
221 default,
222 deserialize_with = "present_nullable",
223 skip_serializing_if = "Option::is_none"
224 )]
225 pub content: Option<Option<String>>,
226 #[serde(
227 default,
228 deserialize_with = "present_nullable",
229 skip_serializing_if = "Option::is_none"
230 )]
231 pub encrypted_content: Option<Option<String>>,
232 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
233 pub rest: Rest,
234}
235
236#[derive(
237 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
238)]
239#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
240#[derive(gproxy_protocol_macros::DeclaredFields)]
241pub struct ContentBlockStopEvent {
242 pub index: i64,
243 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
244 pub rest: Rest,
245}
246
247#[derive(
248 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
249)]
250#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
251#[derive(gproxy_protocol_macros::DeclaredFields)]
252pub struct MessageDeltaEvent {
253 #[serde(
254 default,
255 deserialize_with = "present_nullable",
256 skip_serializing_if = "Option::is_none"
257 )]
258 pub input_transformations: Option<Option<Vec<response::InputTransformation>>>,
259
260 #[serde(
261 default,
262 deserialize_with = "present_nullable",
263 skip_serializing_if = "Option::is_none"
264 )]
265 pub context_management: Option<Option<response::ContextManagementResponse>>,
266 pub delta: MessageDelta,
267 pub usage: MessageDeltaUsage,
268 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
269 pub rest: Rest,
270}
271
272#[derive(
273 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
274)]
275#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
276#[derive(gproxy_protocol_macros::DeclaredFields)]
277pub struct MessageDelta {
278 #[serde(
279 default,
280 deserialize_with = "present_nullable",
281 skip_serializing_if = "Option::is_none"
282 )]
283 pub container: Option<Option<response::ResponseContainer>>,
284 #[serde(
285 default,
286 deserialize_with = "present_nullable",
287 skip_serializing_if = "Option::is_none"
288 )]
289 pub stop_details: Option<Option<response::RefusalStopDetails>>,
290 #[serde(
291 default,
292 deserialize_with = "present_nullable",
293 skip_serializing_if = "Option::is_none"
294 )]
295 pub stop_reason: Option<Option<StreamStopReason>>,
296 #[serde(
297 default,
298 deserialize_with = "present_nullable",
299 skip_serializing_if = "Option::is_none"
300 )]
301 pub stop_sequence: Option<Option<String>>,
302 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
303 pub rest: Rest,
304}
305
306#[derive(
307 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
308)]
309#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
310#[derive(gproxy_protocol_macros::DeclaredFields)]
311pub struct MessageDeltaUsage {
312 #[serde(
313 default,
314 deserialize_with = "present_nullable",
315 skip_serializing_if = "Option::is_none"
316 )]
317 pub cache_creation_input_tokens: Option<Option<i64>>,
318 #[serde(
319 default,
320 deserialize_with = "present_nullable",
321 skip_serializing_if = "Option::is_none"
322 )]
323 pub cache_read_input_tokens: Option<Option<i64>>,
324 #[serde(
325 default,
326 deserialize_with = "present_nullable",
327 skip_serializing_if = "Option::is_none"
328 )]
329 pub fallback_credit: Option<Option<response::FallbackCreditUsage>>,
330 #[serde(
331 default,
332 deserialize_with = "present_nullable",
333 skip_serializing_if = "Option::is_none"
334 )]
335 pub input_tokens: Option<Option<i64>>,
336 #[serde(
337 default,
338 deserialize_with = "present_nullable",
339 skip_serializing_if = "Option::is_none"
340 )]
341 pub iterations: Option<Option<Vec<response::IterationUsage>>>,
342 pub output_tokens: i64,
343 #[serde(
344 default,
345 deserialize_with = "present_nullable",
346 skip_serializing_if = "Option::is_none"
347 )]
348 pub output_tokens_details: Option<Option<response::OutputTokensDetails>>,
349 #[serde(
350 default,
351 deserialize_with = "present_nullable",
352 skip_serializing_if = "Option::is_none"
353 )]
354 pub server_tool_use: Option<Option<response::ServerToolUsage>>,
355 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
356 pub rest: Rest,
357}
358
359#[derive(
360 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
361)]
362#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
363#[derive(gproxy_protocol_macros::DeclaredFields)]
364pub struct MessageStopEvent {
365 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
366 pub rest: Rest,
367}
368
369#[derive(
370 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
371)]
372#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
373#[derive(gproxy_protocol_macros::DeclaredFields)]
374pub struct PingEvent {
375 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
376 pub rest: Rest,
377}
378
379#[derive(
380 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
381)]
382#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
383#[derive(gproxy_protocol_macros::DeclaredFields)]
384pub struct ErrorEvent {
385 pub error: StreamError,
386 #[serde(
387 default,
388 deserialize_with = "present_nullable",
389 skip_serializing_if = "Option::is_none"
390 )]
391 pub request_id: Option<Option<String>>,
392 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
393 pub rest: Rest,
394}
395
396#[derive(
397 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
398)]
399#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
400#[derive(gproxy_protocol_macros::DeclaredFields)]
401pub struct StreamError {
402 #[serde(rename = "type")]
403 pub type_: StreamErrorType,
404 pub message: String,
405 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
406 pub rest: Rest,
407}
408
409#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
410#[serde(rename_all = "snake_case")]
411#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
412#[derive(gproxy_protocol_macros::DeclaredFields)]
413pub enum StreamErrorType {
414 ApiError,
415 AuthenticationError,
416 BillingError,
417 InvalidRequestError,
418 NotFoundError,
419 OverloadedError,
420 PermissionError,
421 RateLimitError,
422 TimeoutError,
423 ConflictError,
424 RequestTooLarge,
425}