1use super::{
2 content::{CacheControl, Message, TextBlock},
3 tools::ToolUnion,
4};
5use crate::Rest;
6use serde::{Deserialize, Serialize};
7
8#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
9#[serde(rename_all = "snake_case")]
10#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
11#[derive(gproxy_protocol_macros::DeclaredFields)]
12pub struct CountTokensRequestBody {
13 pub messages: Vec<Message>,
14 pub model: String,
15 #[serde(skip_serializing_if = "Option::is_none")]
16 pub cache_control: Option<CacheControl>,
17 #[serde(skip_serializing_if = "Option::is_none")]
18 pub context_management: Option<ContextManagementConfig>,
19 #[serde(skip_serializing_if = "Option::is_none")]
20 pub mcp_servers: Option<Vec<McpServerUrlDefinition>>,
21 #[serde(skip_serializing_if = "Option::is_none")]
22 pub output_config: Option<OutputConfig>,
23 #[serde(skip_serializing_if = "Option::is_none")]
24 pub output_format: Option<JsonOutputFormat>,
25 #[serde(skip_serializing_if = "Option::is_none")]
26 pub speed: Option<Speed>,
27 #[serde(skip_serializing_if = "Option::is_none")]
28 pub system: Option<SystemPrompt>,
29 #[serde(skip_serializing_if = "Option::is_none")]
30 pub thinking: Option<ThinkingConfig>,
31 #[serde(skip_serializing_if = "Option::is_none")]
32 pub tool_choice: Option<ToolChoice>,
33 #[serde(skip_serializing_if = "Option::is_none")]
34 pub tools: Option<Vec<ToolUnion>>,
35 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
36 pub rest: Rest,
37}
38
39#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
40#[serde(rename_all = "snake_case")]
41#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
42#[derive(gproxy_protocol_macros::DeclaredFields)]
43pub struct ContextManagementConfig {
44 #[serde(skip_serializing_if = "Option::is_none")]
45 pub edits: Option<Vec<ContextEdit>>,
46 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
47 pub rest: Rest,
48}
49#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
50#[serde(untagged)]
51#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
52#[derive(gproxy_protocol_macros::DeclaredFields)]
53pub enum ContextEdit {
54 ClearToolUses(ClearToolUsesEdit),
55 ClearThinking(ClearThinkingEdit),
56 Compact(CompactEdit),
57}
58#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
59#[serde(rename_all = "snake_case")]
60#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
61#[derive(gproxy_protocol_macros::DeclaredFields)]
62pub struct ClearToolUsesEdit {
63 #[serde(rename = "type")]
64 pub type_: ClearToolUsesType,
65 #[serde(skip_serializing_if = "Option::is_none")]
66 pub clear_at_least: Option<InputTokensThreshold>,
67 #[serde(skip_serializing_if = "Option::is_none")]
68 pub clear_tool_inputs: Option<ClearToolInputs>,
69 #[serde(skip_serializing_if = "Option::is_none")]
70 pub exclude_tools: Option<Vec<String>>,
71 #[serde(skip_serializing_if = "Option::is_none")]
72 pub keep: Option<ToolUsesKeep>,
73 #[serde(skip_serializing_if = "Option::is_none")]
74 pub trigger: Option<ContextTrigger>,
75 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
76 pub rest: Rest,
77}
78#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
79#[serde(rename_all = "snake_case")]
80#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
81#[derive(gproxy_protocol_macros::DeclaredFields)]
82pub enum ClearToolUsesType {
83 #[serde(rename = "clear_tool_uses_20250919")]
84 Clear,
85}
86#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
87#[serde(untagged)]
88#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
89#[derive(gproxy_protocol_macros::DeclaredFields)]
90pub enum ClearToolInputs {
91 All(bool),
92 Names(Vec<String>),
93}
94#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
95#[serde(rename_all = "snake_case")]
96#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
97#[derive(gproxy_protocol_macros::DeclaredFields)]
98pub struct InputTokensThreshold {
99 #[serde(rename = "type")]
100 pub type_: InputTokensType,
101 pub value: i64,
102 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
103 pub rest: Rest,
104}
105#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
106#[serde(rename_all = "snake_case")]
107#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
108#[derive(gproxy_protocol_macros::DeclaredFields)]
109pub enum InputTokensType {
110 InputTokens,
111}
112#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
113#[serde(rename_all = "snake_case")]
114#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
115#[derive(gproxy_protocol_macros::DeclaredFields)]
116pub struct ToolUsesKeep {
117 #[serde(rename = "type")]
118 pub type_: ToolUsesType,
119 pub value: i64,
120 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
121 pub rest: Rest,
122}
123#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
124#[serde(rename_all = "snake_case")]
125#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
126#[derive(gproxy_protocol_macros::DeclaredFields)]
127pub enum ToolUsesType {
128 ToolUses,
129}
130#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
131#[serde(untagged)]
132#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
133#[derive(gproxy_protocol_macros::DeclaredFields)]
134pub enum ContextTrigger {
135 Input(InputTokensThreshold),
136 Tools(ToolUsesKeep),
137}
138#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
139#[serde(rename_all = "snake_case")]
140#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
141#[derive(gproxy_protocol_macros::DeclaredFields)]
142pub struct ClearThinkingEdit {
143 #[serde(rename = "type")]
144 pub type_: ClearThinkingType,
145 #[serde(skip_serializing_if = "Option::is_none")]
146 pub keep: Option<ThinkingKeep>,
147 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
148 pub rest: Rest,
149}
150#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
151#[serde(rename_all = "snake_case")]
152#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
153#[derive(gproxy_protocol_macros::DeclaredFields)]
154pub enum ClearThinkingType {
155 #[serde(rename = "clear_thinking_20251015")]
156 Clear,
157}
158#[derive(
159 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
160)]
161#[serde(rename_all = "snake_case")]
162#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
163#[derive(gproxy_protocol_macros::DeclaredFields)]
164pub struct AllThinkingTurns {
165 #[serde(rename = "type")]
166 pub type_: AllThinkingType,
167 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
168 pub rest: Rest,
169}
170#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
171#[serde(rename_all = "snake_case")]
172#[derive(gproxy_protocol_macros::DeclaredFields)]
173pub enum AllThinkingType {
174 #[serde(rename = "all")]
175 All,
176}
177#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
178#[serde(rename_all = "snake_case")]
179#[derive(gproxy_protocol_macros::DeclaredFields)]
180pub enum AllStringThinkingTurns {
181 #[serde(rename = "all")]
182 All,
183}
184#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
185#[serde(untagged)]
186#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
187#[derive(gproxy_protocol_macros::DeclaredFields)]
188pub enum ThinkingKeep {
189 Turns(ThinkingTurns),
190 All(AllThinkingTurns),
191 AllString(AllStringThinkingTurns),
192}
193#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
194#[serde(rename_all = "snake_case")]
195#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
196#[derive(gproxy_protocol_macros::DeclaredFields)]
197pub struct ThinkingTurns {
198 #[serde(rename = "type")]
199 pub type_: ThinkingTurnsType,
200 pub value: i64,
201 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
202 pub rest: Rest,
203}
204#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
205#[serde(rename_all = "snake_case")]
206#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
207#[derive(gproxy_protocol_macros::DeclaredFields)]
208pub enum ThinkingTurnsType {
209 ThinkingTurns,
210}
211#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
212#[serde(rename_all = "snake_case")]
213#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
214#[derive(gproxy_protocol_macros::DeclaredFields)]
215pub struct CompactEdit {
216 #[serde(rename = "type")]
217 pub type_: CompactType,
218 #[serde(skip_serializing_if = "Option::is_none")]
219 pub instructions: Option<String>,
220 #[serde(skip_serializing_if = "Option::is_none")]
221 pub pause_after_compaction: Option<bool>,
222 #[serde(skip_serializing_if = "Option::is_none")]
223 pub trigger: Option<InputTokensThreshold>,
224 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
225 pub rest: Rest,
226}
227#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
228#[serde(rename_all = "snake_case")]
229#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
230#[derive(gproxy_protocol_macros::DeclaredFields)]
231pub enum CompactType {
232 #[serde(rename = "compact_20260112")]
233 Compact,
234}
235
236#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
237#[serde(rename_all = "snake_case")]
238#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
239#[derive(gproxy_protocol_macros::DeclaredFields)]
240pub struct McpServerUrlDefinition {
241 pub name: String,
242 #[serde(rename = "type")]
243 pub type_: McpServerType,
244 pub url: String,
245 #[serde(skip_serializing_if = "Option::is_none")]
246 pub authorization_token: Option<String>,
247 #[serde(skip_serializing_if = "Option::is_none")]
248 pub tool_configuration: Option<McpToolConfiguration>,
249 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
250 pub rest: Rest,
251}
252#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
253#[serde(rename_all = "snake_case")]
254#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
255#[derive(gproxy_protocol_macros::DeclaredFields)]
256pub enum McpServerType {
257 Url,
258}
259#[derive(
260 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
261)]
262#[serde(rename_all = "snake_case")]
263#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
264#[derive(gproxy_protocol_macros::DeclaredFields)]
265pub struct McpToolConfiguration {
266 #[serde(skip_serializing_if = "Option::is_none")]
267 pub allowed_tools: Option<Vec<String>>,
268 #[serde(skip_serializing_if = "Option::is_none")]
269 pub enabled: Option<bool>,
270 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
271 pub rest: Rest,
272}
273#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
274#[serde(rename_all = "snake_case")]
275#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
276#[derive(gproxy_protocol_macros::DeclaredFields)]
277pub struct OutputConfig {
278 #[serde(skip_serializing_if = "Option::is_none")]
279 pub effort: Option<Effort>,
280 #[serde(skip_serializing_if = "Option::is_none")]
281 pub format: Option<JsonOutputFormat>,
282 #[serde(skip_serializing_if = "Option::is_none")]
283 pub task_budget: Option<TokenTaskBudget>,
284 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
285 pub rest: Rest,
286}
287
288#[derive(
289 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
290)]
291#[serde(rename_all = "snake_case")]
292#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
293#[derive(gproxy_protocol_macros::DeclaredFields)]
294pub struct TokenTaskBudget {
295 pub total: i64,
296 #[serde(rename = "type")]
297 pub type_: TokenTaskBudgetType,
298 #[serde(skip_serializing_if = "Option::is_none")]
299 pub remaining: Option<i64>,
300 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
301 pub rest: Rest,
302}
303#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
304#[serde(rename_all = "snake_case")]
305#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
306#[derive(gproxy_protocol_macros::DeclaredFields)]
307pub enum TokenTaskBudgetType {
308 Tokens,
309}
310#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
311#[serde(rename_all = "snake_case")]
312#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
313#[derive(gproxy_protocol_macros::DeclaredFields)]
314pub enum Effort {
315 Low,
316 Medium,
317 High,
318 Xhigh,
319 Max,
320}
321#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
322#[serde(rename_all = "snake_case")]
323#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
324#[derive(gproxy_protocol_macros::DeclaredFields)]
325pub struct JsonOutputFormat {
326 #[serde(rename = "type")]
327 pub type_: JsonOutputFormatType,
328 pub schema: serde_json::Value,
329 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
330 pub rest: Rest,
331}
332#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
333#[serde(rename_all = "snake_case")]
334#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
335#[derive(gproxy_protocol_macros::DeclaredFields)]
336pub enum JsonOutputFormatType {
337 JsonSchema,
338}
339#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
340#[serde(rename_all = "snake_case")]
341#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
342#[derive(gproxy_protocol_macros::DeclaredFields)]
343pub enum Speed {
344 Standard,
345 Fast,
346}
347#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
348#[serde(untagged)]
349#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
350#[derive(gproxy_protocol_macros::DeclaredFields)]
351pub enum SystemPrompt {
352 Text(String),
353 Blocks(Vec<TextBlock>),
354}
355#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
356#[serde(tag = "type")]
357#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
358#[derive(gproxy_protocol_macros::DeclaredFields)]
359pub enum ThinkingConfig {
360 #[serde(rename = "enabled")]
361 Enabled(ThinkingEnabled),
362 #[serde(rename = "disabled")]
363 Disabled(ThinkingDisabled),
364 #[serde(rename = "adaptive")]
365 Adaptive(ThinkingAdaptive),
366 #[serde(rename = "between_tools")]
367 BetweenTools,
369}
370#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
371#[serde(rename_all = "snake_case")]
372#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
373#[derive(gproxy_protocol_macros::DeclaredFields)]
374pub struct ThinkingEnabled {
375 #[serde(skip_serializing_if = "Option::is_none")]
376 pub block_binding: Option<ThinkingBlockBinding>,
377
378 pub budget_tokens: i64,
379 #[serde(skip_serializing_if = "Option::is_none")]
380 pub display: Option<ThinkingDisplay>,
381 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
382 pub rest: Rest,
383}
384#[derive(
385 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
386)]
387#[serde(rename_all = "snake_case")]
388#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
389#[derive(gproxy_protocol_macros::DeclaredFields)]
390pub struct ThinkingDisabled {
391 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
392 pub rest: Rest,
393}
394#[derive(
395 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
396)]
397#[serde(rename_all = "snake_case")]
398#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
399#[derive(gproxy_protocol_macros::DeclaredFields)]
400pub struct ThinkingAdaptive {
401 #[serde(skip_serializing_if = "Option::is_none")]
402 pub block_binding: Option<ThinkingBlockBinding>,
403
404 #[serde(skip_serializing_if = "Option::is_none")]
405 pub display: Option<ThinkingDisplay>,
406 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
407 pub rest: Rest,
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 ThinkingDisplay {
414 Summarized,
415 Omitted,
416 Updates,
417}
418#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
419#[serde(tag = "type")]
420#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
421#[derive(gproxy_protocol_macros::DeclaredFields)]
422pub enum ToolChoice {
423 #[serde(rename = "auto")]
424 Auto(ToolChoiceAuto),
425 #[serde(rename = "any")]
426 Any(ToolChoiceAny),
427 #[serde(rename = "tool")]
428 Tool(ToolChoiceTool),
429 #[serde(rename = "none")]
430 None(ToolChoiceNone),
431}
432#[derive(
433 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
434)]
435#[serde(rename_all = "snake_case")]
436#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
437#[derive(gproxy_protocol_macros::DeclaredFields)]
438pub struct ToolChoiceAuto {
439 #[serde(skip_serializing_if = "Option::is_none")]
440 pub disable_parallel_tool_use: Option<bool>,
441 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
442 pub rest: Rest,
443}
444#[derive(
445 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
446)]
447#[serde(rename_all = "snake_case")]
448#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
449#[derive(gproxy_protocol_macros::DeclaredFields)]
450pub struct ToolChoiceAny {
451 #[serde(skip_serializing_if = "Option::is_none")]
452 pub disable_parallel_tool_use: Option<bool>,
453 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
454 pub rest: Rest,
455}
456#[derive(
457 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
458)]
459#[serde(rename_all = "snake_case")]
460#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
461#[derive(gproxy_protocol_macros::DeclaredFields)]
462pub struct ToolChoiceTool {
463 pub name: String,
464 #[serde(skip_serializing_if = "Option::is_none")]
465 pub disable_parallel_tool_use: Option<bool>,
466 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
467 pub rest: Rest,
468}
469#[derive(
470 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
471)]
472#[serde(rename_all = "snake_case")]
473#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
474#[derive(gproxy_protocol_macros::DeclaredFields)]
475pub struct ToolChoiceNone {
476 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
477 pub rest: Rest,
478}
479
480pub type CountTokensRequest = crate::WireRequest<CountTokensRequestBody>;
481
482#[derive(
483 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
484)]
485#[serde(rename_all = "snake_case")]
486#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
487#[derive(gproxy_protocol_macros::DeclaredFields)]
488pub struct CountTokensResponseBody {
489 pub context_management: CountTokensContextManagementResponse,
490 pub input_tokens: i64,
491 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
492 pub rest: Rest,
493}
494
495pub type CountTokensResponse = crate::WireResponse<CountTokensResponseBody>;
496#[derive(
497 Debug, Clone, PartialEq, Eq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder,
498)]
499#[serde(rename_all = "snake_case")]
500#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
501#[derive(gproxy_protocol_macros::DeclaredFields)]
502pub struct CountTokensContextManagementResponse {
503 pub original_input_tokens: i64,
504 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
505 pub rest: Rest,
506}
507
508#[derive(
509 Debug,
510 Clone,
511 PartialEq,
512 Eq,
513 Serialize,
514 Deserialize,
515 gproxy_protocol_macros::WireBuilder,
516 gproxy_protocol_macros::DeclaredFields,
517)]
518#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
519pub struct ThinkingBlockBinding {
520 #[serde(skip_serializing_if = "Option::is_none")]
521 pub prefix_mismatch_behavior: Option<ThinkingPrefixMismatchBehavior>,
522 #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
523 pub rest: Rest,
524}
525
526#[derive(
527 Debug,
528 Clone,
529 Copy,
530 PartialEq,
531 Eq,
532 Serialize,
533 Deserialize,
534 gproxy_protocol_macros::DeclaredFields,
535)]
536#[serde(rename_all = "snake_case")]
537#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
538pub enum ThinkingPrefixMismatchBehavior {
539 Error,
540 DropBlock,
541}