1use crate::error::OpenAIError;
2pub use crate::types::{
3 CompletionTokensDetails, ImageDetail, PromptTokensDetails, ReasoningEffort,
4 ResponseFormatJsonSchema,
5};
6use derive_builder::Builder;
7use serde::{Deserialize, Serialize};
8use serde_json::Value;
9use std::collections::HashMap;
10
11#[derive(Debug, Serialize, Deserialize, Clone, Copy, PartialEq)]
13#[serde(rename_all = "lowercase")]
14pub enum Role {
15 User,
16 Assistant,
17 System,
18 Developer,
19}
20
21#[derive(Debug, Serialize, Deserialize, Clone, Copy, PartialEq)]
23#[serde(rename_all = "snake_case")]
24pub enum OutputStatus {
25 InProgress,
26 Completed,
27 Incomplete,
28}
29
30#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
32#[serde(untagged)]
33pub enum Input {
34 Text(String),
36 Items(Vec<InputItem>),
38}
39
40#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
42#[serde(untagged, rename_all = "snake_case")]
43pub enum InputItem {
44 Message(InputMessage),
45 Custom(serde_json::Value),
46}
47
48#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Default, Builder)]
50#[builder(
51 name = "InputMessageArgs",
52 pattern = "mutable",
53 setter(into, strip_option),
54 default
55)]
56#[builder(build_fn(error = "OpenAIError"))]
57pub struct InputMessage {
58 #[serde(default, rename = "type")]
59 pub kind: InputMessageType,
60 pub role: Role,
62 pub content: InputContent,
65}
66
67#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Default)]
68#[serde(rename_all = "snake_case")]
69pub enum InputMessageType {
70 #[default]
71 Message,
72}
73
74#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
75#[serde(untagged)]
76pub enum InputContent {
77 TextInput(String),
79 InputItemContentList(Vec<ContentType>),
81}
82
83#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
85#[serde(tag = "type", rename_all = "snake_case")]
86pub enum ContentType {
87 InputText(InputText),
89 InputImage(InputImage),
91 InputFile(InputFile),
93}
94
95#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
96pub struct InputText {
97 text: String,
98}
99
100#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Default, Builder)]
101#[builder(
102 name = "InputImageArgs",
103 pattern = "mutable",
104 setter(into, strip_option),
105 default
106)]
107#[builder(build_fn(error = "OpenAIError"))]
108pub struct InputImage {
109 detail: ImageDetail,
111 #[serde(skip_serializing_if = "Option::is_none")]
113 file_id: Option<String>,
114 #[serde(skip_serializing_if = "Option::is_none")]
117 image_url: Option<String>,
118}
119
120#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Default, Builder)]
121#[builder(
122 name = "InputFileArgs",
123 pattern = "mutable",
124 setter(into, strip_option),
125 default
126)]
127#[builder(build_fn(error = "OpenAIError"))]
128pub struct InputFile {
129 #[serde(skip_serializing_if = "Option::is_none")]
131 file_data: Option<String>,
132 #[serde(skip_serializing_if = "Option::is_none")]
134 file_id: Option<String>,
135 #[serde(skip_serializing_if = "Option::is_none")]
137 filename: Option<String>,
138}
139
140#[derive(Clone, Serialize, Deserialize, Debug, Default, Builder, PartialEq)]
142#[builder(
143 name = "CreateResponseArgs",
144 pattern = "mutable",
145 setter(into, strip_option),
146 default
147)]
148#[builder(build_fn(error = "OpenAIError"))]
149pub struct CreateResponse {
150 pub input: Input,
152
153 pub model: String,
157
158 #[serde(skip_serializing_if = "Option::is_none")]
161 pub background: Option<bool>,
162
163 #[serde(skip_serializing_if = "Option::is_none")]
181 pub include: Option<Vec<String>>,
182
183 #[serde(skip_serializing_if = "Option::is_none")]
189 pub instructions: Option<String>,
190
191 #[serde(skip_serializing_if = "Option::is_none")]
194 pub max_output_tokens: Option<u32>,
195
196 pub max_tool_calls: Option<u32>,
200
201 #[serde(skip_serializing_if = "Option::is_none")]
208 pub metadata: Option<HashMap<String, String>>,
209
210 #[serde(skip_serializing_if = "Option::is_none")]
212 pub parallel_tool_calls: Option<bool>,
213
214 #[serde(skip_serializing_if = "Option::is_none")]
217 pub previous_response_id: Option<String>,
218
219 #[serde(skip_serializing_if = "Option::is_none")]
221 pub prompt: Option<PromptConfig>,
222
223 #[serde(skip_serializing_if = "Option::is_none")]
225 pub reasoning: Option<ReasoningConfig>,
226
227 #[serde(skip_serializing_if = "Option::is_none")]
247 pub service_tier: Option<ServiceTier>,
248
249 #[serde(skip_serializing_if = "Option::is_none")]
251 pub store: Option<bool>,
252
253 #[serde(skip_serializing_if = "Option::is_none")]
256 pub stream: Option<bool>,
257
258 #[serde(skip_serializing_if = "Option::is_none")]
263 pub temperature: Option<f32>,
264
265 #[serde(skip_serializing_if = "Option::is_none")]
268 pub text: Option<TextConfig>,
269
270 #[serde(skip_serializing_if = "Option::is_none")]
273 pub tool_choice: Option<ToolChoice>,
274
275 #[serde(skip_serializing_if = "Option::is_none")]
279 pub tools: Option<Vec<ToolDefinition>>,
280
281 #[serde(skip_serializing_if = "Option::is_none")]
284 pub top_logprobs: Option<u32>, #[serde(skip_serializing_if = "Option::is_none")]
292 pub top_p: Option<f32>,
293
294 #[serde(skip_serializing_if = "Option::is_none")]
298 pub truncation: Option<Truncation>,
299
300 #[serde(skip_serializing_if = "Option::is_none")]
303 pub user: Option<String>,
304}
305
306#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
308pub struct PromptConfig {
309 pub id: String,
311
312 #[serde(skip_serializing_if = "Option::is_none")]
314 pub version: Option<String>,
315
316 #[serde(skip_serializing_if = "Option::is_none")]
320 pub variables: Option<HashMap<String, String>>,
321}
322
323#[derive(Debug, Serialize, Deserialize, Clone, Copy, PartialEq)]
325#[serde(rename_all = "lowercase")]
326pub enum ServiceTier {
327 Auto,
328 Default,
329 Flex,
330}
331
332#[derive(Debug, Serialize, Deserialize, Clone, Copy, PartialEq)]
334#[serde(rename_all = "lowercase")]
335pub enum Truncation {
336 Auto,
337 Disabled,
338}
339
340#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Default, Builder)]
342#[builder(
343 name = "ReasoningConfigArgs",
344 pattern = "mutable",
345 setter(into, strip_option),
346 default
347)]
348#[builder(build_fn(error = "OpenAIError"))]
349pub struct ReasoningConfig {
350 #[serde(skip_serializing_if = "Option::is_none")]
352 pub effort: Option<ReasoningEffort>,
353 #[serde(skip_serializing_if = "Option::is_none")]
355 pub summary: Option<ReasoningSummary>,
356}
357
358#[derive(Debug, Serialize, Deserialize, Clone, Copy, PartialEq)]
359#[serde(rename_all = "lowercase")]
360pub enum ReasoningSummary {
361 Auto,
362 Concise,
363 Detailed,
364}
365
366#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
368pub struct TextConfig {
369 pub format: TextResponseFormat,
371}
372
373#[derive(Debug, Deserialize, Serialize, Clone, PartialEq)]
374#[serde(tag = "type", rename_all = "snake_case")]
375pub enum TextResponseFormat {
376 Text,
378 JsonObject,
380 JsonSchema(ResponseFormatJsonSchema),
382}
383
384#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
386#[serde(tag = "type", rename_all = "snake_case")]
387pub enum ToolDefinition {
388 FileSearch(FileSearch),
390 Function(Function),
392 WebSearchPreview(WebSearchPreview),
394 ComputerUsePreview(ComputerUsePreview),
396 Mcp(Mcp),
398 CodeInterpreter(CodeInterpreter),
400 ImageGeneration(ImageGeneration),
402 LocalShell,
404}
405
406#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Default, Builder)]
407#[builder(
408 name = "FileSearchArgs",
409 pattern = "mutable",
410 setter(into, strip_option),
411 default
412)]
413#[builder(build_fn(error = "OpenAIError"))]
414pub struct FileSearch {
415 pub vector_store_ids: Vec<String>,
417 #[serde(skip_serializing_if = "Option::is_none")]
419 pub max_num_results: Option<u32>,
420 #[serde(skip_serializing_if = "Option::is_none")]
422 pub filters: Option<Filter>,
423 #[serde(skip_serializing_if = "Option::is_none")]
425 pub ranking_options: Option<RankingOptions>,
426}
427
428#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Default, Builder)]
429#[builder(
430 name = "FunctionArgs",
431 pattern = "mutable",
432 setter(into, strip_option),
433 default
434)]
435pub struct Function {
436 pub name: String,
438 pub parameters: serde_json::Value,
440 pub strict: bool,
442 #[serde(skip_serializing_if = "Option::is_none")]
445 pub description: Option<String>,
446}
447
448#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Default, Builder)]
449#[builder(
450 name = "WebSearchPreviewArgs",
451 pattern = "mutable",
452 setter(into, strip_option),
453 default
454)]
455pub struct WebSearchPreview {
456 #[serde(skip_serializing_if = "Option::is_none")]
458 pub user_location: Option<Location>,
459 #[serde(skip_serializing_if = "Option::is_none")]
461 pub search_context_size: Option<WebSearchContextSize>,
462}
463
464#[derive(Debug, Serialize, Deserialize, Clone, Copy, PartialEq, Eq)]
465#[serde(rename_all = "lowercase")]
466pub enum WebSearchContextSize {
467 Low,
468 Medium,
469 High,
470}
471
472#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Default, Builder)]
473#[builder(
474 name = "ComputerUsePreviewArgs",
475 pattern = "mutable",
476 setter(into, strip_option),
477 default
478)]
479pub struct ComputerUsePreview {
480 environment: String,
482 display_width: u32,
484 display_height: u32,
486}
487
488#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
490pub struct RankingOptions {
491 pub ranker: String,
493 #[serde(skip_serializing_if = "Option::is_none")]
496 pub score_threshold: Option<f32>,
497}
498
499#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
501#[serde(untagged)]
502pub enum Filter {
503 Comparison(ComparisonFilter),
506 Compound(CompoundFilter),
508}
509
510#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
512pub struct ComparisonFilter {
513 #[serde(rename = "type")]
515 pub op: ComparisonType,
516 pub key: String,
518 pub value: serde_json::Value,
520}
521
522#[derive(Debug, Serialize, Deserialize, Clone, Copy, PartialEq)]
523pub enum ComparisonType {
524 #[serde(rename = "eq")]
525 Equals,
526 #[serde(rename = "ne")]
527 NotEquals,
528 #[serde(rename = "gt")]
529 GreaterThan,
530 #[serde(rename = "gte")]
531 GreaterThanOrEqualTo,
532 #[serde(rename = "lt")]
533 LessThan,
534 #[serde(rename = "lte")]
535 LessThanOrEqualTo,
536}
537
538#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
540pub struct CompoundFilter {
541 #[serde(rename = "type")]
543 pub op: ComparisonType,
544 pub filters: Vec<Filter>,
546}
547
548#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
549#[serde(rename_all = "lowercase")]
550pub enum CompoundType {
551 And,
552 Or,
553}
554
555#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Default, Builder)]
557#[builder(
558 name = "LocationArgs",
559 pattern = "mutable",
560 setter(into, strip_option),
561 default
562)]
563#[builder(build_fn(error = "OpenAIError"))]
564pub struct Location {
565 #[serde(rename = "type")]
567 pub kind: String,
568 #[serde(skip_serializing_if = "Option::is_none")]
570 pub city: Option<String>,
571 #[serde(skip_serializing_if = "Option::is_none")]
573 pub country: Option<String>,
574 #[serde(skip_serializing_if = "Option::is_none")]
576 pub region: Option<String>,
577 #[serde(skip_serializing_if = "Option::is_none")]
579 pub timezone: Option<String>,
580}
581
582#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Default, Builder)]
584#[builder(
585 name = "McpArgs",
586 pattern = "mutable",
587 setter(into, strip_option),
588 default
589)]
590#[builder(build_fn(error = "OpenAIError"))]
591pub struct Mcp {
592 pub server_label: String,
594 pub server_url: String,
596 #[serde(skip_serializing_if = "Option::is_none")]
598 pub allowed_tools: Option<AllowedTools>,
599 #[serde(skip_serializing_if = "Option::is_none")]
601 pub headers: Option<Value>,
602 #[serde(skip_serializing_if = "Option::is_none")]
604 pub require_approval: Option<RequireApproval>,
605}
606
607#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
609#[serde(untagged)]
610pub enum AllowedTools {
611 List(Vec<String>),
613 Filter(McpAllowedToolsFilter),
615}
616
617#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
619pub struct McpAllowedToolsFilter {
620 #[serde(skip_serializing_if = "Option::is_none")]
622 pub tool_names: Option<Vec<String>>,
623}
624
625#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
627#[serde(untagged)]
628pub enum RequireApproval {
629 Policy(RequireApprovalPolicy),
631 Filter(McpApprovalFilter),
633}
634
635#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
636#[serde(rename_all = "lowercase")]
637pub enum RequireApprovalPolicy {
638 Always,
639 Never,
640}
641
642#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
644pub struct McpApprovalFilter {
645 #[serde(skip_serializing_if = "Option::is_none")]
647 pub always: Option<McpAllowedToolsFilter>,
648 #[serde(skip_serializing_if = "Option::is_none")]
650 pub never: Option<McpAllowedToolsFilter>,
651}
652
653#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
655#[serde(untagged)]
656pub enum CodeInterpreterContainer {
657 Id(String),
659 Container(CodeInterpreterContainerKind),
661}
662
663#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
665#[serde(tag = "type", rename_all = "snake_case")]
666pub enum CodeInterpreterContainerKind {
667 Auto {
668 #[serde(skip_serializing_if = "Option::is_none")]
670 file_ids: Option<Vec<String>>,
671 },
672}
673
674#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Default, Builder)]
676#[builder(
677 name = "CodeInterpreterArgs",
678 pattern = "mutable",
679 setter(into, strip_option),
680 default
681)]
682#[builder(build_fn(error = "OpenAIError"))]
683pub struct CodeInterpreter {
684 pub container: CodeInterpreterContainer,
686}
687
688#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
690pub struct InputImageMask {
691 #[serde(skip_serializing_if = "Option::is_none")]
693 pub image_url: Option<String>,
694 #[serde(skip_serializing_if = "Option::is_none")]
696 pub file_id: Option<String>,
697}
698
699#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Default, Builder)]
701#[builder(
702 name = "ImageGenerationArgs",
703 pattern = "mutable",
704 setter(into, strip_option),
705 default
706)]
707#[builder(build_fn(error = "OpenAIError"))]
708pub struct ImageGeneration {
709 #[serde(skip_serializing_if = "Option::is_none")]
711 pub background: Option<ImageGenerationBackground>,
712 #[serde(skip_serializing_if = "Option::is_none")]
714 pub input_image_mask: Option<InputImageMask>,
715 #[serde(skip_serializing_if = "Option::is_none")]
717 pub model: Option<String>,
718 #[serde(skip_serializing_if = "Option::is_none")]
720 pub moderation: Option<String>,
721 #[serde(skip_serializing_if = "Option::is_none")]
723 pub output_compression: Option<u8>,
724 #[serde(skip_serializing_if = "Option::is_none")]
726 pub output_format: Option<ImageGenerationOutputFormat>,
727 #[serde(skip_serializing_if = "Option::is_none")]
729 pub partial_images: Option<u8>,
730 #[serde(skip_serializing_if = "Option::is_none")]
732 pub quality: Option<ImageGenerationQuality>,
733 #[serde(skip_serializing_if = "Option::is_none")]
735 pub size: Option<ImageGenerationSize>,
736}
737
738#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
739#[serde(rename_all = "lowercase")]
740pub enum ImageGenerationBackground {
741 Transparent,
742 Opaque,
743 Auto,
744}
745
746#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
747#[serde(rename_all = "lowercase")]
748pub enum ImageGenerationOutputFormat {
749 Png,
750 Webp,
751 Jpeg,
752}
753
754#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
755#[serde(rename_all = "lowercase")]
756pub enum ImageGenerationQuality {
757 Low,
758 Medium,
759 High,
760 Auto,
761}
762
763#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
764#[serde(rename_all = "lowercase")]
765pub enum ImageGenerationSize {
766 Auto,
767 #[serde(rename = "1024x1024")]
768 Size1024x1024,
769 #[serde(rename = "1024x1536")]
770 Size1024x1536,
771 #[serde(rename = "1536x1024")]
772 Size1536x1024,
773}
774
775#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
777#[serde(untagged)]
778pub enum ToolChoice {
779 Mode(ToolChoiceMode),
781 Hosted {
783 #[serde(rename = "type")]
785 kind: HostedToolType,
786 },
787 Function {
789 name: String,
791 },
792}
793
794#[derive(Debug, Serialize, Deserialize, Clone, Copy, PartialEq)]
796#[serde(rename_all = "lowercase")]
797pub enum ToolChoiceMode {
798 None,
800 Auto,
802 Required,
804}
805
806#[derive(Debug, Serialize, Deserialize, Clone, Copy, PartialEq)]
808#[serde(rename_all = "snake_case")]
809pub enum HostedToolType {
810 FileSearch,
811 WebSearchPreview,
812 ComputerUsePreview,
813}
814
815#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
817pub struct ErrorObject {
818 pub code: String,
820 pub message: String,
822}
823
824#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
826pub struct IncompleteDetails {
827 pub reason: String,
829}
830
831#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
833pub struct OutputText {
834 pub annotations: Vec<Annotation>,
836 pub text: String,
838}
839
840#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
841#[serde(tag = "type", rename_all = "snake_case")]
842pub enum Annotation {
843 FileCitation(FileCitation),
845 UrlCitation(UrlCitation),
847 FilePath(FilePath),
849}
850
851#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
852pub struct FileCitation {
853 file_id: String,
855 index: u32,
857}
858
859#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
860pub struct UrlCitation {
861 end_index: u32,
863 start_index: u32,
865 title: String,
867 url: String,
869}
870
871#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
872pub struct FilePath {
873 file_id: String,
875 index: u32,
877}
878
879#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
881pub struct Refusal {
882 pub refusal: String,
884}
885
886#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
888pub struct OutputMessage {
889 pub content: Vec<Content>,
891 pub id: String,
893 pub role: Role,
895 pub status: OutputStatus,
897}
898
899#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
900#[serde(tag = "type", rename_all = "snake_case")]
901pub enum Content {
902 OutputText(OutputText),
904 Refusal(Refusal),
906}
907
908#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
910#[serde(tag = "type", rename_all = "snake_case")]
911pub enum OutputContent {
912 Message(OutputMessage),
914 FileSearchCall(FileSearchCallOutput),
916 FunctionCall(FunctionCall),
918 WebSearchCall(WebSearchCallOutput),
920 ComputerCall(ComputerCallOutput),
922 Reasoning(ReasoningItem),
926 ImageGenerationCall(ImageGenerationCallOutput),
928 CodeInterpreterCall(CodeInterpreterCallOutput),
930 LocalShellCall(LocalShellCallOutput),
932 McpCall(McpCallOutput),
934 McpListTools(McpListToolsOutput),
936 McpApprovalRequest(McpApprovalRequestOutput),
938}
939
940#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
942pub struct ReasoningItem {
943 pub id: String,
945 pub summary: Vec<SummaryText>,
947 #[serde(skip_serializing_if = "Option::is_none")]
950 pub encrypted_content: Option<String>,
951 #[serde(skip_serializing_if = "Option::is_none")]
953 pub status: Option<OutputStatus>,
954}
955
956#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
958pub struct SummaryText {
959 pub text: String,
961}
962
963#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
965pub struct FileSearchCallOutput {
966 pub id: String,
968 pub queries: Vec<String>,
970 pub status: FileSearchCallOutputStatus,
972 #[serde(skip_serializing_if = "Option::is_none")]
974 pub results: Option<Vec<FileSearchResult>>,
975}
976
977#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
978#[serde(rename_all = "snake_case")]
979pub enum FileSearchCallOutputStatus {
980 InProgress,
981 Searching,
982 Incomplete,
983 Failed,
984 Completed,
985}
986
987#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
989pub struct FileSearchResult {
990 pub file_id: String,
992 pub filename: String,
994 pub score: f32,
996 pub text: String,
998 pub attributes: HashMap<String, serde_json::Value>,
1003}
1004
1005#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
1006pub struct SafetyCheck {
1007 pub id: String,
1009 pub code: String,
1011 pub message: String,
1013}
1014
1015#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
1017pub struct WebSearchCallOutput {
1018 pub id: String,
1020 pub status: String,
1022}
1023
1024#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
1026pub struct ComputerCallOutput {
1027 pub action: ComputerCallAction,
1028 pub call_id: String,
1030 pub id: String,
1032 pub pending_safety_checks: Vec<SafetyCheck>,
1034 pub status: OutputStatus,
1036}
1037
1038#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1040pub struct Point {
1041 pub x: i32,
1042 pub y: i32,
1043}
1044
1045#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1047#[serde(tag = "type", rename_all = "snake_case")]
1048pub enum ComputerCallAction {
1049 Click(Click),
1051
1052 DoubleClick(DoubleClick),
1054
1055 Drag(Drag),
1057
1058 KeyPress(KeyPress),
1060
1061 Move(MoveAction),
1063
1064 Screenshot,
1066
1067 Scroll(Scroll),
1069
1070 Type(TypeAction),
1072
1073 Wait,
1075}
1076
1077#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1078#[serde(rename_all = "snake_case")]
1079pub enum ButtonPress {
1080 Left,
1081 Right,
1082 Wheel,
1083 Back,
1084 Forward,
1085}
1086
1087#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1089pub struct Click {
1090 pub button: ButtonPress,
1092 pub x: i32,
1094 pub y: i32,
1096}
1097
1098#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1100pub struct DoubleClick {
1101 pub x: i32,
1103 pub y: i32,
1105}
1106
1107#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1109pub struct Drag {
1110 pub path: Vec<Point>,
1112 pub x: i32,
1114 pub y: i32,
1116}
1117
1118#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1120pub struct KeyPress {
1121 pub keys: Vec<String>,
1123}
1124
1125#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1127pub struct MoveAction {
1128 pub x: i32,
1130 pub y: i32,
1132}
1133
1134#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1136pub struct Scroll {
1137 pub scroll_x: i32,
1139 pub scroll_y: i32,
1141 pub x: i32,
1143 pub y: i32,
1145}
1146
1147#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
1149pub struct TypeAction {
1150 pub text: String,
1152}
1153
1154#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
1156pub struct FunctionCall {
1157 pub id: String,
1159 pub call_id: String,
1161 pub name: String,
1163 pub arguments: String,
1165 pub status: OutputStatus,
1167}
1168
1169#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
1171pub struct ImageGenerationCallOutput {
1172 pub id: String,
1174 pub result: Option<String>,
1176 pub status: String,
1178}
1179
1180#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
1182pub struct CodeInterpreterCallOutput {
1183 pub code: String,
1185 pub id: String,
1187 pub status: String,
1189 pub container_id: String,
1191 pub results: Vec<CodeInterpreterResult>,
1193}
1194
1195#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
1197#[serde(tag = "type", rename_all = "snake_case")]
1198pub enum CodeInterpreterResult {
1199 Logs(CodeInterpreterTextOutput),
1201 Files(CodeInterpreterFileOutput),
1203}
1204
1205#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
1207pub struct CodeInterpreterTextOutput {
1208 pub logs: String,
1210}
1211
1212#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
1214pub struct CodeInterpreterFileOutput {
1215 pub files: Vec<CodeInterpreterFile>,
1217}
1218
1219#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
1220pub struct CodeInterpreterFile {
1221 file_id: String,
1223 mime_type: String,
1225}
1226
1227#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
1229pub struct LocalShellCallOutput {
1230 pub action: LocalShellAction,
1232 pub call_id: String,
1234 pub id: String,
1236 pub status: String,
1238}
1239
1240#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
1242pub struct LocalShellAction {
1243 pub command: Vec<String>,
1245 pub env: HashMap<String, String>,
1247 pub timeout_ms: Option<u64>,
1249 pub user: Option<String>,
1251 pub working_directory: Option<String>,
1253}
1254
1255#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
1257pub struct McpCallOutput {
1258 pub arguments: String,
1260 pub id: String,
1262 pub name: String,
1264 pub server_label: String,
1266 pub error: Option<String>,
1268 pub output: Option<String>,
1270}
1271
1272#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
1274pub struct McpListToolsOutput {
1275 pub id: String,
1277 pub server_label: String,
1279 pub tools: Vec<McpToolInfo>,
1281 #[serde(skip_serializing_if = "Option::is_none")]
1283 pub error: Option<String>,
1284}
1285
1286#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
1288pub struct McpToolInfo {
1289 pub name: String,
1291 pub input_schema: Value,
1293 #[serde(skip_serializing_if = "Option::is_none")]
1295 pub annotations: Option<Value>,
1296 #[serde(skip_serializing_if = "Option::is_none")]
1298 pub description: Option<String>,
1299}
1300
1301#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
1303pub struct McpApprovalRequestOutput {
1304 pub arguments: String,
1306 pub id: String,
1308 pub name: String,
1310 pub server_label: String,
1312}
1313
1314#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
1316pub struct Usage {
1317 pub input_tokens: u32,
1319 pub input_tokens_details: PromptTokensDetails,
1321 pub output_tokens: u32,
1323 pub output_tokens_details: CompletionTokensDetails,
1325 pub total_tokens: u32,
1327}
1328
1329#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
1331pub struct Response {
1332 pub created_at: u64,
1334
1335 #[serde(skip_serializing_if = "Option::is_none")]
1337 pub error: Option<ErrorObject>,
1338
1339 pub id: String,
1341
1342 #[serde(skip_serializing_if = "Option::is_none")]
1344 pub incomplete_details: Option<IncompleteDetails>,
1345
1346 #[serde(skip_serializing_if = "Option::is_none")]
1348 pub instructions: Option<String>,
1349
1350 #[serde(skip_serializing_if = "Option::is_none")]
1352 pub max_output_tokens: Option<u32>,
1353
1354 #[serde(skip_serializing_if = "Option::is_none")]
1356 pub metadata: Option<HashMap<String, String>>,
1357
1358 pub model: String,
1360
1361 pub object: String,
1363
1364 pub output: Vec<OutputContent>,
1366
1367 #[serde(skip_serializing_if = "Option::is_none")]
1371 pub output_text: Option<String>,
1372
1373 #[serde(skip_serializing_if = "Option::is_none")]
1375 pub parallel_tool_calls: Option<bool>,
1376
1377 #[serde(skip_serializing_if = "Option::is_none")]
1379 pub previous_response_id: Option<String>,
1380
1381 #[serde(skip_serializing_if = "Option::is_none")]
1383 pub reasoning: Option<ReasoningConfig>,
1384
1385 #[serde(skip_serializing_if = "Option::is_none")]
1387 pub store: Option<bool>,
1388
1389 #[serde(skip_serializing_if = "Option::is_none")]
1391 pub service_tier: Option<ServiceTier>,
1392
1393 pub status: Status,
1395
1396 #[serde(skip_serializing_if = "Option::is_none")]
1398 pub temperature: Option<f32>,
1399
1400 #[serde(skip_serializing_if = "Option::is_none")]
1402 pub text: Option<TextConfig>,
1403
1404 #[serde(skip_serializing_if = "Option::is_none")]
1406 pub tool_choice: Option<ToolChoice>,
1407
1408 #[serde(skip_serializing_if = "Option::is_none")]
1410 pub tools: Option<Vec<ToolDefinition>>,
1411
1412 #[serde(skip_serializing_if = "Option::is_none")]
1414 pub top_p: Option<f32>,
1415
1416 #[serde(skip_serializing_if = "Option::is_none")]
1418 pub truncation: Option<Truncation>,
1419
1420 #[serde(skip_serializing_if = "Option::is_none")]
1422 pub usage: Option<Usage>,
1423
1424 #[serde(skip_serializing_if = "Option::is_none")]
1426 pub user: Option<String>,
1427}
1428
1429#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
1430#[serde(rename_all = "snake_case")]
1431pub enum Status {
1432 Completed,
1433 Failed,
1434 InProgress,
1435 Incomplete,
1436}