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