1use serde::{Deserialize, Serialize};
6
7#[derive(Debug, Clone, Serialize, Deserialize)]
8#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
9pub struct SourceFileContentContent {
10 pub item: std::collections::HashMap<String, serde_json::Value>,
11 #[serde(skip_serializing_if = "Option::is_none", default)]
12 pub sample: Option<std::collections::HashMap<String, serde_json::Value>>,
13}
14
15#[derive(Debug, Clone, Serialize, Deserialize)]
16#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
17pub struct SourceFileContent {
18 pub content: Vec<SourceFileContentContent>,
20 #[serde(rename = "type")]
22 pub type_: String,
23}
24
25#[derive(Debug, Clone, Serialize, Deserialize)]
26#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
27pub struct SourceFileID {
28 pub id: String,
30 #[serde(rename = "type")]
32 pub type_: String,
33}
34
35#[derive(Debug, Clone, Serialize, Deserialize)]
37#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
38pub struct SourceStoredCompletions {
39 #[serde(rename = "type")]
41 pub type_: String,
42 #[serde(skip_serializing_if = "Option::is_none", default)]
44 pub created_after: Option<i64>,
45 #[serde(skip_serializing_if = "Option::is_none", default)]
47 pub created_before: Option<i64>,
48 #[serde(skip_serializing_if = "Option::is_none", default)]
50 pub limit: Option<i64>,
51 #[serde(skip_serializing_if = "Option::is_none", default)]
53 pub metadata: Option<serde_json::Value>,
54 #[serde(skip_serializing_if = "Option::is_none", default)]
56 pub model: Option<String>,
57}
58
59pub type Source = serde_json::Value;
60
61#[derive(Debug, Clone, Serialize, Deserialize)]
63#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
64pub struct InputMessagesTemplateTemplateEvalItemContentOutputText {
65 pub text: String,
67 #[serde(rename = "type")]
69 pub type_: String,
70}
71
72#[derive(Debug, Clone, Serialize, Deserialize)]
74#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
75pub struct InputMessagesTemplateTemplateEvalItemContentInputImage {
76 pub image_url: String,
78 #[serde(rename = "type")]
80 pub type_: String,
81 #[serde(skip_serializing_if = "Option::is_none", default)]
83 pub detail: Option<String>,
84}
85
86pub type InputMessagesTemplateTemplateEvalItemContent = serde_json::Value;
87
88#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
89#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
90#[non_exhaustive]
91pub enum InputMessagesTemplateTemplateEvalItemRole {
92 #[serde(rename = "user")]
93 User,
94 #[serde(rename = "assistant")]
95 Assistant,
96 #[serde(rename = "system")]
97 System,
98 #[serde(rename = "developer")]
99 Developer,
100}
101
102#[derive(Debug, Clone, Serialize, Deserialize)]
104#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
105pub struct InputMessagesTemplateTemplateEvalItem {
106 pub content: InputMessagesTemplateTemplateEvalItemContent,
108 pub role: InputMessagesTemplateTemplateEvalItemRole,
110 #[serde(rename = "type", skip_serializing_if = "Option::is_none", default)]
112 pub type_: Option<String>,
113}
114
115pub type InputMessagesTemplateTemplate = serde_json::Value;
116
117#[derive(Debug, Clone, Serialize, Deserialize)]
118#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
119pub struct InputMessagesTemplate {
120 pub template: Vec<InputMessagesTemplateTemplate>,
122 #[serde(rename = "type")]
124 pub type_: String,
125}
126
127#[derive(Debug, Clone, Serialize, Deserialize)]
128#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
129pub struct InputMessagesItemReference {
130 pub item_reference: String,
132 #[serde(rename = "type")]
134 pub type_: String,
135}
136
137pub type InputMessages = serde_json::Value;
138
139pub type SamplingParamsResponseFormat = serde_json::Value;
140
141#[derive(Debug, Clone, Serialize, Deserialize)]
142#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
143pub struct SamplingParams {
144 #[serde(skip_serializing_if = "Option::is_none", default)]
146 pub max_completion_tokens: Option<i64>,
147 #[serde(skip_serializing_if = "Option::is_none", default)]
149 pub reasoning_effort: Option<serde_json::Value>,
150 #[serde(skip_serializing_if = "Option::is_none", default)]
152 pub response_format: Option<SamplingParamsResponseFormat>,
153 #[serde(skip_serializing_if = "Option::is_none", default)]
155 pub seed: Option<i64>,
156 #[serde(skip_serializing_if = "Option::is_none", default)]
158 pub temperature: Option<f64>,
159 #[serde(skip_serializing_if = "Option::is_none", default)]
161 pub tools: Option<Vec<serde_json::Value>>,
162 #[serde(skip_serializing_if = "Option::is_none", default)]
164 pub top_p: Option<f64>,
165}
166
167#[derive(Debug, Clone, Serialize, Deserialize)]
169#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
170pub struct CreateEvalCompletionsRunDataSource {
171 pub source: Source,
173 #[serde(rename = "type")]
175 pub type_: String,
176 #[serde(skip_serializing_if = "Option::is_none", default)]
178 pub input_messages: Option<InputMessages>,
179 #[serde(skip_serializing_if = "Option::is_none", default)]
181 pub model: Option<String>,
182 #[serde(skip_serializing_if = "Option::is_none", default)]
183 pub sampling_params: Option<SamplingParams>,
184}
185
186#[derive(Debug, Clone, Serialize, Deserialize)]
188#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
189pub struct CreateEvalJSONLRunDataSource {
190 pub source: Source,
192 #[serde(rename = "type")]
194 pub type_: String,
195}
196
197#[derive(Debug, Clone, Serialize, Deserialize)]
199#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
200pub struct EvalAPIError {
201 pub code: String,
203 pub message: String,
205}
206
207#[derive(Debug, Clone, Serialize, Deserialize)]
208#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
209pub struct DataSourceResponsesSourceFileContentContent {
210 pub item: std::collections::HashMap<String, serde_json::Value>,
211 #[serde(skip_serializing_if = "Option::is_none", default)]
212 pub sample: Option<std::collections::HashMap<String, serde_json::Value>>,
213}
214
215#[derive(Debug, Clone, Serialize, Deserialize)]
216#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
217pub struct DataSourceResponsesSourceFileContent {
218 pub content: Vec<DataSourceResponsesSourceFileContentContent>,
220 #[serde(rename = "type")]
222 pub type_: String,
223}
224
225#[derive(Debug, Clone, Serialize, Deserialize)]
226#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
227pub struct DataSourceResponsesSourceFileID {
228 pub id: String,
230 #[serde(rename = "type")]
232 pub type_: String,
233}
234
235#[derive(Debug, Clone, Serialize, Deserialize)]
237#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
238pub struct DataSourceResponsesSourceResponses {
239 #[serde(rename = "type")]
241 pub type_: String,
242 #[serde(skip_serializing_if = "Option::is_none", default)]
244 pub created_after: Option<i64>,
245 #[serde(skip_serializing_if = "Option::is_none", default)]
247 pub created_before: Option<i64>,
248 #[serde(skip_serializing_if = "Option::is_none", default)]
250 pub instructions_search: Option<String>,
251 #[serde(skip_serializing_if = "Option::is_none", default)]
253 pub metadata: Option<serde_json::Value>,
254 #[serde(skip_serializing_if = "Option::is_none", default)]
256 pub model: Option<String>,
257 #[serde(skip_serializing_if = "Option::is_none", default)]
259 pub reasoning_effort: Option<serde_json::Value>,
260 #[serde(skip_serializing_if = "Option::is_none", default)]
262 pub temperature: Option<f64>,
263 #[serde(skip_serializing_if = "Option::is_none", default)]
265 pub tools: Option<Vec<String>>,
266 #[serde(skip_serializing_if = "Option::is_none", default)]
268 pub top_p: Option<f64>,
269 #[serde(skip_serializing_if = "Option::is_none", default)]
271 pub users: Option<Vec<String>>,
272}
273
274pub type DataSourceResponsesSource = serde_json::Value;
275
276#[derive(Debug, Clone, Serialize, Deserialize)]
277#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
278pub struct DataSourceResponsesInputMessagesTemplateTemplateChatMessage {
279 pub content: String,
281 pub role: String,
283}
284
285#[derive(Debug, Clone, Serialize, Deserialize)]
287#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
288pub struct DataSourceResponsesInputMessagesTemplateTemplateEvalItemContentOutputText {
289 pub text: String,
291 #[serde(rename = "type")]
293 pub type_: String,
294}
295
296#[derive(Debug, Clone, Serialize, Deserialize)]
298#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
299pub struct DataSourceResponsesInputMessagesTemplateTemplateEvalItemContentInputImage {
300 pub image_url: String,
302 #[serde(rename = "type")]
304 pub type_: String,
305 #[serde(skip_serializing_if = "Option::is_none", default)]
307 pub detail: Option<String>,
308}
309
310pub type DataSourceResponsesInputMessagesTemplateTemplateEvalItemContent = serde_json::Value;
311
312#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
313#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
314#[non_exhaustive]
315pub enum DataSourceResponsesInputMessagesTemplateTemplateEvalItemRole {
316 #[serde(rename = "user")]
317 User,
318 #[serde(rename = "assistant")]
319 Assistant,
320 #[serde(rename = "system")]
321 System,
322 #[serde(rename = "developer")]
323 Developer,
324}
325
326#[derive(Debug, Clone, Serialize, Deserialize)]
328#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
329pub struct DataSourceResponsesInputMessagesTemplateTemplateEvalItem {
330 pub content: DataSourceResponsesInputMessagesTemplateTemplateEvalItemContent,
332 pub role: DataSourceResponsesInputMessagesTemplateTemplateEvalItemRole,
334 #[serde(rename = "type", skip_serializing_if = "Option::is_none", default)]
336 pub type_: Option<String>,
337}
338
339pub type DataSourceResponsesInputMessagesTemplateTemplate = serde_json::Value;
340
341#[derive(Debug, Clone, Serialize, Deserialize)]
342#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
343pub struct DataSourceResponsesInputMessagesTemplate {
344 pub template: Vec<DataSourceResponsesInputMessagesTemplateTemplate>,
346 #[serde(rename = "type")]
348 pub type_: String,
349}
350
351#[derive(Debug, Clone, Serialize, Deserialize)]
352#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
353pub struct DataSourceResponsesInputMessagesItemReference {
354 pub item_reference: String,
356 #[serde(rename = "type")]
358 pub type_: String,
359}
360
361pub type DataSourceResponsesInputMessages = serde_json::Value;
362
363#[derive(Debug, Clone, Serialize, Deserialize)]
365#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
366pub struct DataSourceResponsesSamplingParamsText {
367 #[serde(skip_serializing_if = "Option::is_none", default)]
369 pub format: Option<serde_json::Value>,
370}
371
372#[derive(Debug, Clone, Serialize, Deserialize)]
373#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
374pub struct DataSourceResponsesSamplingParams {
375 #[serde(skip_serializing_if = "Option::is_none", default)]
377 pub max_completion_tokens: Option<i64>,
378 #[serde(skip_serializing_if = "Option::is_none", default)]
380 pub reasoning_effort: Option<serde_json::Value>,
381 #[serde(skip_serializing_if = "Option::is_none", default)]
383 pub seed: Option<i64>,
384 #[serde(skip_serializing_if = "Option::is_none", default)]
386 pub temperature: Option<f64>,
387 #[serde(skip_serializing_if = "Option::is_none", default)]
389 pub text: Option<DataSourceResponsesSamplingParamsText>,
390 #[serde(skip_serializing_if = "Option::is_none", default)]
392 pub tools: Option<Vec<serde_json::Value>>,
393 #[serde(skip_serializing_if = "Option::is_none", default)]
395 pub top_p: Option<f64>,
396}
397
398#[derive(Debug, Clone, Serialize, Deserialize)]
400#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
401pub struct DataSourceResponses {
402 pub source: DataSourceResponsesSource,
404 #[serde(rename = "type")]
406 pub type_: String,
407 #[serde(skip_serializing_if = "Option::is_none", default)]
409 pub input_messages: Option<DataSourceResponsesInputMessages>,
410 #[serde(skip_serializing_if = "Option::is_none", default)]
412 pub model: Option<String>,
413 #[serde(skip_serializing_if = "Option::is_none", default)]
414 pub sampling_params: Option<DataSourceResponsesSamplingParams>,
415}
416
417pub type DataSource = serde_json::Value;
418
419#[derive(Debug, Clone, Serialize, Deserialize)]
420#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
421pub struct PerModelUsage {
422 pub cached_tokens: i64,
424 pub completion_tokens: i64,
426 pub invocation_count: i64,
428 #[serde(rename = "model_name")]
430 pub run_model_name: String,
431 pub prompt_tokens: i64,
433 pub total_tokens: i64,
435}
436
437#[derive(Debug, Clone, Serialize, Deserialize)]
438#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
439pub struct PerTestingCriteriaResult {
440 pub failed: i64,
442 pub passed: i64,
444 pub testing_criteria: String,
446}
447
448#[derive(Debug, Clone, Serialize, Deserialize)]
450#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
451pub struct ResultCounts {
452 pub errored: i64,
454 pub failed: i64,
456 pub passed: i64,
458 pub total: i64,
460}
461
462#[derive(Debug, Clone, Serialize, Deserialize)]
464#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
465pub struct RunCancelResponse {
466 pub id: String,
468 pub created_at: i64,
470 pub data_source: DataSource,
472 pub error: EvalAPIError,
474 pub eval_id: String,
476 #[serde(skip_serializing_if = "Option::is_none", default)]
478 pub metadata: Option<serde_json::Value>,
479 pub model: String,
481 pub name: String,
483 pub object: String,
485 pub per_model_usage: Vec<PerModelUsage>,
487 pub per_testing_criteria_results: Vec<PerTestingCriteriaResult>,
489 pub report_url: String,
491 pub result_counts: ResultCounts,
493 pub status: String,
495}
496
497#[derive(Debug, Clone, Serialize, Deserialize)]
498#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
499pub struct RunCreateParams {
500 pub data_source: DataSource,
502 #[serde(skip_serializing_if = "Option::is_none", default)]
504 pub metadata: Option<serde_json::Value>,
505 #[serde(skip_serializing_if = "Option::is_none", default)]
507 pub name: Option<String>,
508}
509
510#[derive(Debug, Clone, Serialize, Deserialize)]
511#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
512pub struct DataSourceCreateEvalResponsesRunDataSourceSourceFileContentContent {
513 pub item: std::collections::HashMap<String, serde_json::Value>,
514 #[serde(skip_serializing_if = "Option::is_none", default)]
515 pub sample: Option<std::collections::HashMap<String, serde_json::Value>>,
516}
517
518#[derive(Debug, Clone, Serialize, Deserialize)]
519#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
520pub struct DataSourceCreateEvalResponsesRunDataSourceSourceFileContent {
521 pub content: Vec<DataSourceCreateEvalResponsesRunDataSourceSourceFileContentContent>,
523 #[serde(rename = "type")]
525 pub type_: String,
526}
527
528#[derive(Debug, Clone, Serialize, Deserialize)]
529#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
530pub struct DataSourceCreateEvalResponsesRunDataSourceSourceFileID {
531 pub id: String,
533 #[serde(rename = "type")]
535 pub type_: String,
536}
537
538#[derive(Debug, Clone, Serialize, Deserialize)]
540#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
541pub struct DataSourceCreateEvalResponsesRunDataSourceSourceResponses {
542 #[serde(rename = "type")]
544 pub type_: String,
545 #[serde(skip_serializing_if = "Option::is_none", default)]
547 pub created_after: Option<i64>,
548 #[serde(skip_serializing_if = "Option::is_none", default)]
550 pub created_before: Option<i64>,
551 #[serde(skip_serializing_if = "Option::is_none", default)]
553 pub instructions_search: Option<String>,
554 #[serde(skip_serializing_if = "Option::is_none", default)]
556 pub metadata: Option<serde_json::Value>,
557 #[serde(skip_serializing_if = "Option::is_none", default)]
559 pub model: Option<String>,
560 #[serde(skip_serializing_if = "Option::is_none", default)]
562 pub reasoning_effort: Option<serde_json::Value>,
563 #[serde(skip_serializing_if = "Option::is_none", default)]
565 pub temperature: Option<f64>,
566 #[serde(skip_serializing_if = "Option::is_none", default)]
568 pub tools: Option<serde_json::Value>,
569 #[serde(skip_serializing_if = "Option::is_none", default)]
571 pub top_p: Option<f64>,
572 #[serde(skip_serializing_if = "Option::is_none", default)]
574 pub users: Option<serde_json::Value>,
575}
576
577pub type DataSourceCreateEvalResponsesRunDataSourceSource = serde_json::Value;
578
579#[derive(Debug, Clone, Serialize, Deserialize)]
580#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
581pub struct DataSourceCreateEvalResponsesRunDataSourceInputMessagesTemplateTemplateChatMessage {
582 pub content: String,
584 pub role: String,
586}
587
588#[derive(Debug, Clone, Serialize, Deserialize)]
590#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
591pub struct DataSourceCreateEvalResponsesRunDataSourceInputMessagesTemplateTemplateEvalItemContentOutputText
592{
593 pub text: String,
595 #[serde(rename = "type")]
597 pub type_: String,
598}
599
600#[derive(Debug, Clone, Serialize, Deserialize)]
602#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
603pub struct DataSourceCreateEvalResponsesRunDataSourceInputMessagesTemplateTemplateEvalItemContentInputImage
604{
605 pub image_url: String,
607 #[serde(rename = "type")]
609 pub type_: String,
610 #[serde(skip_serializing_if = "Option::is_none", default)]
612 pub detail: Option<String>,
613}
614
615pub type DataSourceCreateEvalResponsesRunDataSourceInputMessagesTemplateTemplateEvalItemContent =
616 serde_json::Value;
617
618#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
619#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
620#[non_exhaustive]
621pub enum DataSourceCreateEvalResponsesRunDataSourceInputMessagesTemplateTemplateEvalItemRole {
622 #[serde(rename = "user")]
623 User,
624 #[serde(rename = "assistant")]
625 Assistant,
626 #[serde(rename = "system")]
627 System,
628 #[serde(rename = "developer")]
629 Developer,
630}
631
632#[derive(Debug, Clone, Serialize, Deserialize)]
634#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
635pub struct DataSourceCreateEvalResponsesRunDataSourceInputMessagesTemplateTemplateEvalItem {
636 pub content:
638 DataSourceCreateEvalResponsesRunDataSourceInputMessagesTemplateTemplateEvalItemContent,
639 pub role: DataSourceCreateEvalResponsesRunDataSourceInputMessagesTemplateTemplateEvalItemRole,
641 #[serde(rename = "type", skip_serializing_if = "Option::is_none", default)]
643 pub type_: Option<String>,
644}
645
646pub type DataSourceCreateEvalResponsesRunDataSourceInputMessagesTemplateTemplate =
647 serde_json::Value;
648
649#[derive(Debug, Clone, Serialize, Deserialize)]
650#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
651pub struct DataSourceCreateEvalResponsesRunDataSourceInputMessagesTemplate {
652 pub template: Vec<DataSourceCreateEvalResponsesRunDataSourceInputMessagesTemplateTemplate>,
654 #[serde(rename = "type")]
656 pub type_: String,
657}
658
659#[derive(Debug, Clone, Serialize, Deserialize)]
660#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
661pub struct DataSourceCreateEvalResponsesRunDataSourceInputMessagesItemReference {
662 pub item_reference: String,
664 #[serde(rename = "type")]
666 pub type_: String,
667}
668
669pub type DataSourceCreateEvalResponsesRunDataSourceInputMessages = serde_json::Value;
670
671#[derive(Debug, Clone, Serialize, Deserialize)]
673#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
674pub struct DataSourceCreateEvalResponsesRunDataSourceSamplingParamsText {
675 #[serde(skip_serializing_if = "Option::is_none", default)]
677 pub format: Option<serde_json::Value>,
678}
679
680#[derive(Debug, Clone, Serialize, Deserialize)]
681#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
682pub struct DataSourceCreateEvalResponsesRunDataSourceSamplingParams {
683 #[serde(skip_serializing_if = "Option::is_none", default)]
685 pub max_completion_tokens: Option<i64>,
686 #[serde(skip_serializing_if = "Option::is_none", default)]
688 pub reasoning_effort: Option<serde_json::Value>,
689 #[serde(skip_serializing_if = "Option::is_none", default)]
691 pub seed: Option<i64>,
692 #[serde(skip_serializing_if = "Option::is_none", default)]
694 pub temperature: Option<f64>,
695 #[serde(skip_serializing_if = "Option::is_none", default)]
697 pub text: Option<DataSourceCreateEvalResponsesRunDataSourceSamplingParamsText>,
698 #[serde(skip_serializing_if = "Option::is_none", default)]
700 pub tools: Option<Vec<serde_json::Value>>,
701 #[serde(skip_serializing_if = "Option::is_none", default)]
703 pub top_p: Option<f64>,
704}
705
706#[derive(Debug, Clone, Serialize, Deserialize)]
708#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
709pub struct DataSourceCreateEvalResponsesRunDataSource {
710 pub source: DataSourceCreateEvalResponsesRunDataSourceSource,
712 #[serde(rename = "type")]
714 pub type_: String,
715 #[serde(skip_serializing_if = "Option::is_none", default)]
717 pub input_messages: Option<DataSourceCreateEvalResponsesRunDataSourceInputMessages>,
718 #[serde(skip_serializing_if = "Option::is_none", default)]
720 pub model: Option<String>,
721 #[serde(skip_serializing_if = "Option::is_none", default)]
722 pub sampling_params: Option<DataSourceCreateEvalResponsesRunDataSourceSamplingParams>,
723}
724
725#[derive(Debug, Clone, Serialize, Deserialize)]
727#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
728pub struct RunCreateResponse {
729 pub id: String,
731 pub created_at: i64,
733 pub data_source: DataSource,
735 pub error: EvalAPIError,
737 pub eval_id: String,
739 #[serde(skip_serializing_if = "Option::is_none", default)]
741 pub metadata: Option<serde_json::Value>,
742 pub model: String,
744 pub name: String,
746 pub object: String,
748 pub per_model_usage: Vec<PerModelUsage>,
750 pub per_testing_criteria_results: Vec<PerTestingCriteriaResult>,
752 pub report_url: String,
754 pub result_counts: ResultCounts,
756 pub status: String,
758}
759
760#[derive(Debug, Clone, Serialize, Deserialize)]
761#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
762pub struct RunDeleteResponse {
763 #[serde(skip_serializing_if = "Option::is_none", default)]
764 pub deleted: Option<bool>,
765 #[serde(skip_serializing_if = "Option::is_none", default)]
766 pub object: Option<String>,
767 #[serde(skip_serializing_if = "Option::is_none", default)]
768 pub run_id: Option<String>,
769}
770
771#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
772#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
773#[non_exhaustive]
774pub enum RunListParamsOrder {
775 #[serde(rename = "asc")]
776 Asc,
777 #[serde(rename = "desc")]
778 Desc,
779}
780
781#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
782#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
783#[non_exhaustive]
784pub enum RunListParamsStatus {
785 #[serde(rename = "queued")]
786 Queued,
787 #[serde(rename = "in_progress")]
788 InProgress,
789 #[serde(rename = "completed")]
790 Completed,
791 #[serde(rename = "canceled")]
792 Canceled,
793 #[serde(rename = "failed")]
794 Failed,
795}
796
797#[derive(Debug, Clone, Serialize, Deserialize)]
798#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
799pub struct RunListParams {
800 #[serde(skip_serializing_if = "Option::is_none", default)]
802 pub after: Option<String>,
803 #[serde(skip_serializing_if = "Option::is_none", default)]
805 pub limit: Option<i64>,
806 #[serde(skip_serializing_if = "Option::is_none", default)]
808 pub order: Option<RunListParamsOrder>,
809 #[serde(skip_serializing_if = "Option::is_none", default)]
811 pub status: Option<RunListParamsStatus>,
812}
813
814#[derive(Debug, Clone, Serialize, Deserialize)]
816#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
817pub struct RunListResponse {
818 pub id: String,
820 pub created_at: i64,
822 pub data_source: DataSource,
824 pub error: EvalAPIError,
826 pub eval_id: String,
828 #[serde(skip_serializing_if = "Option::is_none", default)]
830 pub metadata: Option<serde_json::Value>,
831 pub model: String,
833 pub name: String,
835 pub object: String,
837 pub per_model_usage: Vec<PerModelUsage>,
839 pub per_testing_criteria_results: Vec<PerTestingCriteriaResult>,
841 pub report_url: String,
843 pub result_counts: ResultCounts,
845 pub status: String,
847}
848
849#[derive(Debug, Clone, Serialize, Deserialize)]
851#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
852pub struct RunRetrieveResponse {
853 pub id: String,
855 pub created_at: i64,
857 pub data_source: DataSource,
859 pub error: EvalAPIError,
861 pub eval_id: String,
863 #[serde(skip_serializing_if = "Option::is_none", default)]
865 pub metadata: Option<serde_json::Value>,
866 pub model: String,
868 pub name: String,
870 pub object: String,
872 pub per_model_usage: Vec<PerModelUsage>,
874 pub per_testing_criteria_results: Vec<PerTestingCriteriaResult>,
876 pub report_url: String,
878 pub result_counts: ResultCounts,
880 pub status: String,
882}
883
884#[derive(Debug, Clone, Serialize, Deserialize)]
885#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
886pub struct EvalCreateParams {
887 pub data_source_config: DataSourceConfig,
889 pub testing_criteria: Vec<TestingCriterion>,
891 #[serde(skip_serializing_if = "Option::is_none", default)]
893 pub metadata: Option<serde_json::Value>,
894 #[serde(skip_serializing_if = "Option::is_none", default)]
896 pub name: Option<String>,
897}
898
899#[derive(Debug, Clone, Serialize, Deserialize)]
901#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
902pub struct DataSourceConfigCustom {
903 pub item_schema: std::collections::HashMap<String, serde_json::Value>,
905 #[serde(rename = "type")]
907 pub type_: String,
908 #[serde(skip_serializing_if = "Option::is_none", default)]
910 pub include_sample_schema: Option<bool>,
911}
912
913#[derive(Debug, Clone, Serialize, Deserialize)]
915#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
916pub struct DataSourceConfigLogs {
917 #[serde(rename = "type")]
919 pub type_: String,
920 #[serde(skip_serializing_if = "Option::is_none", default)]
922 pub metadata: Option<std::collections::HashMap<String, serde_json::Value>>,
923}
924
925#[derive(Debug, Clone, Serialize, Deserialize)]
927#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
928pub struct DataSourceConfigStoredCompletions {
929 #[serde(rename = "type")]
931 pub type_: String,
932 #[serde(skip_serializing_if = "Option::is_none", default)]
934 pub metadata: Option<std::collections::HashMap<String, serde_json::Value>>,
935}
936
937pub type DataSourceConfig = serde_json::Value;
938
939#[derive(Debug, Clone, Serialize, Deserialize)]
940#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
941pub struct TestingCriterionLabelModelInputSimpleInputMessage {
942 pub content: String,
944 pub role: String,
946}
947
948#[derive(Debug, Clone, Serialize, Deserialize)]
950#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
951pub struct TestingCriterionLabelModelInputEvalItemContentOutputText {
952 pub text: String,
954 #[serde(rename = "type")]
956 pub type_: String,
957}
958
959#[derive(Debug, Clone, Serialize, Deserialize)]
961#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
962pub struct TestingCriterionLabelModelInputEvalItemContentInputImage {
963 pub image_url: String,
965 #[serde(rename = "type")]
967 pub type_: String,
968 #[serde(skip_serializing_if = "Option::is_none", default)]
970 pub detail: Option<String>,
971}
972
973pub type TestingCriterionLabelModelInputEvalItemContent = serde_json::Value;
974
975#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
976#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
977#[non_exhaustive]
978pub enum TestingCriterionLabelModelInputEvalItemRole {
979 #[serde(rename = "user")]
980 User,
981 #[serde(rename = "assistant")]
982 Assistant,
983 #[serde(rename = "system")]
984 System,
985 #[serde(rename = "developer")]
986 Developer,
987}
988
989#[derive(Debug, Clone, Serialize, Deserialize)]
991#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
992pub struct TestingCriterionLabelModelInputEvalItem {
993 pub content: TestingCriterionLabelModelInputEvalItemContent,
995 pub role: TestingCriterionLabelModelInputEvalItemRole,
997 #[serde(rename = "type", skip_serializing_if = "Option::is_none", default)]
999 pub type_: Option<String>,
1000}
1001
1002pub type TestingCriterionLabelModelInput = serde_json::Value;
1003
1004#[derive(Debug, Clone, Serialize, Deserialize)]
1006#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
1007pub struct TestingCriterionLabelModel {
1008 pub input: Vec<TestingCriterionLabelModelInput>,
1010 pub labels: serde_json::Value,
1012 pub model: String,
1014 pub name: String,
1016 pub passing_labels: serde_json::Value,
1018 #[serde(rename = "type")]
1020 pub type_: String,
1021}
1022
1023pub type TestingCriterion = serde_json::Value;
1024
1025#[derive(Debug, Clone, Serialize, Deserialize)]
1027#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
1028pub struct EvalCreateResponse {
1029 pub id: String,
1031 pub created_at: i64,
1033 pub data_source_config: DataSourceConfig,
1035 #[serde(skip_serializing_if = "Option::is_none", default)]
1037 pub metadata: Option<serde_json::Value>,
1038 pub name: String,
1040 pub object: String,
1042 pub testing_criteria: Vec<TestingCriterion>,
1044}
1045
1046#[derive(Debug, Clone, Serialize, Deserialize)]
1048#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
1049pub struct EvalCustomDataSourceConfig {
1050 #[serde(rename = "schema")]
1052 pub schema_: std::collections::HashMap<String, serde_json::Value>,
1053 #[serde(rename = "type")]
1055 pub type_: String,
1056}
1057
1058#[derive(Debug, Clone, Serialize, Deserialize)]
1059#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
1060pub struct EvalDeleteResponse {
1061 pub deleted: bool,
1062 pub eval_id: String,
1063 pub object: String,
1064}
1065
1066#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1067#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
1068#[non_exhaustive]
1069pub enum EvalListParamsOrder {
1070 #[serde(rename = "asc")]
1071 Asc,
1072 #[serde(rename = "desc")]
1073 Desc,
1074}
1075
1076#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1077#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
1078#[non_exhaustive]
1079pub enum EvalListParamsOrderBy {
1080 #[serde(rename = "created_at")]
1081 CreatedAt,
1082 #[serde(rename = "updated_at")]
1083 UpdatedAt,
1084}
1085
1086#[derive(Debug, Clone, Serialize, Deserialize)]
1087#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
1088pub struct EvalListParams {
1089 #[serde(skip_serializing_if = "Option::is_none", default)]
1091 pub after: Option<String>,
1092 #[serde(skip_serializing_if = "Option::is_none", default)]
1094 pub limit: Option<i64>,
1095 #[serde(skip_serializing_if = "Option::is_none", default)]
1097 pub order: Option<EvalListParamsOrder>,
1098 #[serde(skip_serializing_if = "Option::is_none", default)]
1100 pub order_by: Option<EvalListParamsOrderBy>,
1101}
1102
1103#[derive(Debug, Clone, Serialize, Deserialize)]
1105#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
1106pub struct EvalListResponse {
1107 pub id: String,
1109 pub created_at: i64,
1111 pub data_source_config: DataSourceConfig,
1113 #[serde(skip_serializing_if = "Option::is_none", default)]
1115 pub metadata: Option<serde_json::Value>,
1116 pub name: String,
1118 pub object: String,
1120 pub testing_criteria: Vec<TestingCriterion>,
1122}
1123
1124#[derive(Debug, Clone, Serialize, Deserialize)]
1126#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
1127pub struct EvalRetrieveResponse {
1128 pub id: String,
1130 pub created_at: i64,
1132 pub data_source_config: DataSourceConfig,
1134 #[serde(skip_serializing_if = "Option::is_none", default)]
1136 pub metadata: Option<serde_json::Value>,
1137 pub name: String,
1139 pub object: String,
1141 pub testing_criteria: Vec<TestingCriterion>,
1143}
1144
1145#[derive(Debug, Clone, Serialize, Deserialize)]
1147#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
1148pub struct EvalStoredCompletionsDataSourceConfig {
1149 #[serde(rename = "schema")]
1151 pub schema_: std::collections::HashMap<String, serde_json::Value>,
1152 #[serde(rename = "type")]
1154 pub type_: String,
1155 #[serde(skip_serializing_if = "Option::is_none", default)]
1157 pub metadata: Option<serde_json::Value>,
1158}
1159
1160#[derive(Debug, Clone, Serialize, Deserialize)]
1161#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
1162pub struct EvalUpdateParams {
1163 #[serde(skip_serializing_if = "Option::is_none", default)]
1165 pub metadata: Option<serde_json::Value>,
1166 #[serde(skip_serializing_if = "Option::is_none", default)]
1168 pub name: Option<String>,
1169}
1170
1171#[derive(Debug, Clone, Serialize, Deserialize)]
1173#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
1174pub struct EvalUpdateResponse {
1175 pub id: String,
1177 pub created_at: i64,
1179 pub data_source_config: DataSourceConfig,
1181 #[serde(skip_serializing_if = "Option::is_none", default)]
1183 pub metadata: Option<serde_json::Value>,
1184 pub name: String,
1186 pub object: String,
1188 pub testing_criteria: Vec<TestingCriterion>,
1190}