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 pub text: String,
594 #[serde(rename = "type")]
596 pub type_: String,
597}
598
599#[derive(Debug, Clone, Serialize, Deserialize)]
601#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
602pub struct DataSourceCreateEvalResponsesRunDataSourceInputMessagesTemplateTemplateEvalItemContentInputImage {
603 pub image_url: String,
605 #[serde(rename = "type")]
607 pub type_: String,
608 #[serde(skip_serializing_if = "Option::is_none", default)]
610 pub detail: Option<String>,
611}
612
613pub type DataSourceCreateEvalResponsesRunDataSourceInputMessagesTemplateTemplateEvalItemContent = serde_json::Value;
614
615#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
616#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
617#[non_exhaustive]
618pub enum DataSourceCreateEvalResponsesRunDataSourceInputMessagesTemplateTemplateEvalItemRole {
619 #[serde(rename = "user")]
620 User,
621 #[serde(rename = "assistant")]
622 Assistant,
623 #[serde(rename = "system")]
624 System,
625 #[serde(rename = "developer")]
626 Developer,
627}
628
629#[derive(Debug, Clone, Serialize, Deserialize)]
631#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
632pub struct DataSourceCreateEvalResponsesRunDataSourceInputMessagesTemplateTemplateEvalItem {
633 pub content: DataSourceCreateEvalResponsesRunDataSourceInputMessagesTemplateTemplateEvalItemContent,
635 pub role: DataSourceCreateEvalResponsesRunDataSourceInputMessagesTemplateTemplateEvalItemRole,
637 #[serde(rename = "type", skip_serializing_if = "Option::is_none", default)]
639 pub type_: Option<String>,
640}
641
642pub type DataSourceCreateEvalResponsesRunDataSourceInputMessagesTemplateTemplate = serde_json::Value;
643
644#[derive(Debug, Clone, Serialize, Deserialize)]
645#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
646pub struct DataSourceCreateEvalResponsesRunDataSourceInputMessagesTemplate {
647 pub template: Vec<DataSourceCreateEvalResponsesRunDataSourceInputMessagesTemplateTemplate>,
649 #[serde(rename = "type")]
651 pub type_: String,
652}
653
654#[derive(Debug, Clone, Serialize, Deserialize)]
655#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
656pub struct DataSourceCreateEvalResponsesRunDataSourceInputMessagesItemReference {
657 pub item_reference: String,
659 #[serde(rename = "type")]
661 pub type_: String,
662}
663
664pub type DataSourceCreateEvalResponsesRunDataSourceInputMessages = serde_json::Value;
665
666#[derive(Debug, Clone, Serialize, Deserialize)]
668#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
669pub struct DataSourceCreateEvalResponsesRunDataSourceSamplingParamsText {
670 #[serde(skip_serializing_if = "Option::is_none", default)]
672 pub format: Option<serde_json::Value>,
673}
674
675#[derive(Debug, Clone, Serialize, Deserialize)]
676#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
677pub struct DataSourceCreateEvalResponsesRunDataSourceSamplingParams {
678 #[serde(skip_serializing_if = "Option::is_none", default)]
680 pub max_completion_tokens: Option<i64>,
681 #[serde(skip_serializing_if = "Option::is_none", default)]
683 pub reasoning_effort: Option<serde_json::Value>,
684 #[serde(skip_serializing_if = "Option::is_none", default)]
686 pub seed: Option<i64>,
687 #[serde(skip_serializing_if = "Option::is_none", default)]
689 pub temperature: Option<f64>,
690 #[serde(skip_serializing_if = "Option::is_none", default)]
692 pub text: Option<DataSourceCreateEvalResponsesRunDataSourceSamplingParamsText>,
693 #[serde(skip_serializing_if = "Option::is_none", default)]
695 pub tools: Option<Vec<serde_json::Value>>,
696 #[serde(skip_serializing_if = "Option::is_none", default)]
698 pub top_p: Option<f64>,
699}
700
701#[derive(Debug, Clone, Serialize, Deserialize)]
703#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
704pub struct DataSourceCreateEvalResponsesRunDataSource {
705 pub source: DataSourceCreateEvalResponsesRunDataSourceSource,
707 #[serde(rename = "type")]
709 pub type_: String,
710 #[serde(skip_serializing_if = "Option::is_none", default)]
712 pub input_messages: Option<DataSourceCreateEvalResponsesRunDataSourceInputMessages>,
713 #[serde(skip_serializing_if = "Option::is_none", default)]
715 pub model: Option<String>,
716 #[serde(skip_serializing_if = "Option::is_none", default)]
717 pub sampling_params: Option<DataSourceCreateEvalResponsesRunDataSourceSamplingParams>,
718}
719
720#[derive(Debug, Clone, Serialize, Deserialize)]
722#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
723pub struct RunCreateResponse {
724 pub id: String,
726 pub created_at: i64,
728 pub data_source: DataSource,
730 pub error: EvalAPIError,
732 pub eval_id: String,
734 #[serde(skip_serializing_if = "Option::is_none", default)]
736 pub metadata: Option<serde_json::Value>,
737 pub model: String,
739 pub name: String,
741 pub object: String,
743 pub per_model_usage: Vec<PerModelUsage>,
745 pub per_testing_criteria_results: Vec<PerTestingCriteriaResult>,
747 pub report_url: String,
749 pub result_counts: ResultCounts,
751 pub status: String,
753}
754
755#[derive(Debug, Clone, Serialize, Deserialize)]
756#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
757pub struct RunDeleteResponse {
758 #[serde(skip_serializing_if = "Option::is_none", default)]
759 pub deleted: Option<bool>,
760 #[serde(skip_serializing_if = "Option::is_none", default)]
761 pub object: Option<String>,
762 #[serde(skip_serializing_if = "Option::is_none", default)]
763 pub run_id: Option<String>,
764}
765
766#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
767#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
768#[non_exhaustive]
769pub enum RunListParamsOrder {
770 #[serde(rename = "asc")]
771 Asc,
772 #[serde(rename = "desc")]
773 Desc,
774}
775
776#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
777#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
778#[non_exhaustive]
779pub enum RunListParamsStatus {
780 #[serde(rename = "queued")]
781 Queued,
782 #[serde(rename = "in_progress")]
783 InProgress,
784 #[serde(rename = "completed")]
785 Completed,
786 #[serde(rename = "canceled")]
787 Canceled,
788 #[serde(rename = "failed")]
789 Failed,
790}
791
792#[derive(Debug, Clone, Serialize, Deserialize)]
793#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
794pub struct RunListParams {
795 #[serde(skip_serializing_if = "Option::is_none", default)]
797 pub after: Option<String>,
798 #[serde(skip_serializing_if = "Option::is_none", default)]
800 pub limit: Option<i64>,
801 #[serde(skip_serializing_if = "Option::is_none", default)]
803 pub order: Option<RunListParamsOrder>,
804 #[serde(skip_serializing_if = "Option::is_none", default)]
806 pub status: Option<RunListParamsStatus>,
807}
808
809#[derive(Debug, Clone, Serialize, Deserialize)]
811#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
812pub struct RunListResponse {
813 pub id: String,
815 pub created_at: i64,
817 pub data_source: DataSource,
819 pub error: EvalAPIError,
821 pub eval_id: String,
823 #[serde(skip_serializing_if = "Option::is_none", default)]
825 pub metadata: Option<serde_json::Value>,
826 pub model: String,
828 pub name: String,
830 pub object: String,
832 pub per_model_usage: Vec<PerModelUsage>,
834 pub per_testing_criteria_results: Vec<PerTestingCriteriaResult>,
836 pub report_url: String,
838 pub result_counts: ResultCounts,
840 pub status: String,
842}
843
844#[derive(Debug, Clone, Serialize, Deserialize)]
846#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
847pub struct RunRetrieveResponse {
848 pub id: String,
850 pub created_at: i64,
852 pub data_source: DataSource,
854 pub error: EvalAPIError,
856 pub eval_id: String,
858 #[serde(skip_serializing_if = "Option::is_none", default)]
860 pub metadata: Option<serde_json::Value>,
861 pub model: String,
863 pub name: String,
865 pub object: String,
867 pub per_model_usage: Vec<PerModelUsage>,
869 pub per_testing_criteria_results: Vec<PerTestingCriteriaResult>,
871 pub report_url: String,
873 pub result_counts: ResultCounts,
875 pub status: String,
877}
878
879#[derive(Debug, Clone, Serialize, Deserialize)]
880#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
881pub struct EvalCreateParams {
882 pub data_source_config: DataSourceConfig,
884 pub testing_criteria: Vec<TestingCriterion>,
886 #[serde(skip_serializing_if = "Option::is_none", default)]
888 pub metadata: Option<serde_json::Value>,
889 #[serde(skip_serializing_if = "Option::is_none", default)]
891 pub name: Option<String>,
892}
893
894#[derive(Debug, Clone, Serialize, Deserialize)]
896#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
897pub struct DataSourceConfigCustom {
898 pub item_schema: std::collections::HashMap<String, serde_json::Value>,
900 #[serde(rename = "type")]
902 pub type_: String,
903 #[serde(skip_serializing_if = "Option::is_none", default)]
905 pub include_sample_schema: Option<bool>,
906}
907
908#[derive(Debug, Clone, Serialize, Deserialize)]
910#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
911pub struct DataSourceConfigLogs {
912 #[serde(rename = "type")]
914 pub type_: String,
915 #[serde(skip_serializing_if = "Option::is_none", default)]
917 pub metadata: Option<std::collections::HashMap<String, serde_json::Value>>,
918}
919
920#[derive(Debug, Clone, Serialize, Deserialize)]
922#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
923pub struct DataSourceConfigStoredCompletions {
924 #[serde(rename = "type")]
926 pub type_: String,
927 #[serde(skip_serializing_if = "Option::is_none", default)]
929 pub metadata: Option<std::collections::HashMap<String, serde_json::Value>>,
930}
931
932pub type DataSourceConfig = serde_json::Value;
933
934#[derive(Debug, Clone, Serialize, Deserialize)]
935#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
936pub struct TestingCriterionLabelModelInputSimpleInputMessage {
937 pub content: String,
939 pub role: String,
941}
942
943#[derive(Debug, Clone, Serialize, Deserialize)]
945#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
946pub struct TestingCriterionLabelModelInputEvalItemContentOutputText {
947 pub text: String,
949 #[serde(rename = "type")]
951 pub type_: String,
952}
953
954#[derive(Debug, Clone, Serialize, Deserialize)]
956#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
957pub struct TestingCriterionLabelModelInputEvalItemContentInputImage {
958 pub image_url: String,
960 #[serde(rename = "type")]
962 pub type_: String,
963 #[serde(skip_serializing_if = "Option::is_none", default)]
965 pub detail: Option<String>,
966}
967
968pub type TestingCriterionLabelModelInputEvalItemContent = serde_json::Value;
969
970#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
971#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
972#[non_exhaustive]
973pub enum TestingCriterionLabelModelInputEvalItemRole {
974 #[serde(rename = "user")]
975 User,
976 #[serde(rename = "assistant")]
977 Assistant,
978 #[serde(rename = "system")]
979 System,
980 #[serde(rename = "developer")]
981 Developer,
982}
983
984#[derive(Debug, Clone, Serialize, Deserialize)]
986#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
987pub struct TestingCriterionLabelModelInputEvalItem {
988 pub content: TestingCriterionLabelModelInputEvalItemContent,
990 pub role: TestingCriterionLabelModelInputEvalItemRole,
992 #[serde(rename = "type", skip_serializing_if = "Option::is_none", default)]
994 pub type_: Option<String>,
995}
996
997pub type TestingCriterionLabelModelInput = serde_json::Value;
998
999#[derive(Debug, Clone, Serialize, Deserialize)]
1001#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
1002pub struct TestingCriterionLabelModel {
1003 pub input: Vec<TestingCriterionLabelModelInput>,
1005 pub labels: serde_json::Value,
1007 pub model: String,
1009 pub name: String,
1011 pub passing_labels: serde_json::Value,
1013 #[serde(rename = "type")]
1015 pub type_: String,
1016}
1017
1018pub type TestingCriterion = serde_json::Value;
1019
1020#[derive(Debug, Clone, Serialize, Deserialize)]
1022#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
1023pub struct EvalCreateResponse {
1024 pub id: String,
1026 pub created_at: i64,
1028 pub data_source_config: DataSourceConfig,
1030 #[serde(skip_serializing_if = "Option::is_none", default)]
1032 pub metadata: Option<serde_json::Value>,
1033 pub name: String,
1035 pub object: String,
1037 pub testing_criteria: Vec<TestingCriterion>,
1039}
1040
1041#[derive(Debug, Clone, Serialize, Deserialize)]
1043#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
1044pub struct EvalCustomDataSourceConfig {
1045 #[serde(rename = "schema")]
1047 pub schema_: std::collections::HashMap<String, serde_json::Value>,
1048 #[serde(rename = "type")]
1050 pub type_: String,
1051}
1052
1053#[derive(Debug, Clone, Serialize, Deserialize)]
1054#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
1055pub struct EvalDeleteResponse {
1056 pub deleted: bool,
1057 pub eval_id: String,
1058 pub object: String,
1059}
1060
1061#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1062#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
1063#[non_exhaustive]
1064pub enum EvalListParamsOrder {
1065 #[serde(rename = "asc")]
1066 Asc,
1067 #[serde(rename = "desc")]
1068 Desc,
1069}
1070
1071#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1072#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
1073#[non_exhaustive]
1074pub enum EvalListParamsOrderBy {
1075 #[serde(rename = "created_at")]
1076 CreatedAt,
1077 #[serde(rename = "updated_at")]
1078 UpdatedAt,
1079}
1080
1081#[derive(Debug, Clone, Serialize, Deserialize)]
1082#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
1083pub struct EvalListParams {
1084 #[serde(skip_serializing_if = "Option::is_none", default)]
1086 pub after: Option<String>,
1087 #[serde(skip_serializing_if = "Option::is_none", default)]
1089 pub limit: Option<i64>,
1090 #[serde(skip_serializing_if = "Option::is_none", default)]
1092 pub order: Option<EvalListParamsOrder>,
1093 #[serde(skip_serializing_if = "Option::is_none", default)]
1095 pub order_by: Option<EvalListParamsOrderBy>,
1096}
1097
1098#[derive(Debug, Clone, Serialize, Deserialize)]
1100#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
1101pub struct EvalListResponse {
1102 pub id: String,
1104 pub created_at: i64,
1106 pub data_source_config: DataSourceConfig,
1108 #[serde(skip_serializing_if = "Option::is_none", default)]
1110 pub metadata: Option<serde_json::Value>,
1111 pub name: String,
1113 pub object: String,
1115 pub testing_criteria: Vec<TestingCriterion>,
1117}
1118
1119#[derive(Debug, Clone, Serialize, Deserialize)]
1121#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
1122pub struct EvalRetrieveResponse {
1123 pub id: String,
1125 pub created_at: i64,
1127 pub data_source_config: DataSourceConfig,
1129 #[serde(skip_serializing_if = "Option::is_none", default)]
1131 pub metadata: Option<serde_json::Value>,
1132 pub name: String,
1134 pub object: String,
1136 pub testing_criteria: Vec<TestingCriterion>,
1138}
1139
1140#[derive(Debug, Clone, Serialize, Deserialize)]
1142#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
1143pub struct EvalStoredCompletionsDataSourceConfig {
1144 #[serde(rename = "schema")]
1146 pub schema_: std::collections::HashMap<String, serde_json::Value>,
1147 #[serde(rename = "type")]
1149 pub type_: String,
1150 #[serde(skip_serializing_if = "Option::is_none", default)]
1152 pub metadata: Option<serde_json::Value>,
1153}
1154
1155#[derive(Debug, Clone, Serialize, Deserialize)]
1156#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
1157pub struct EvalUpdateParams {
1158 #[serde(skip_serializing_if = "Option::is_none", default)]
1160 pub metadata: Option<serde_json::Value>,
1161 #[serde(skip_serializing_if = "Option::is_none", default)]
1163 pub name: Option<String>,
1164}
1165
1166#[derive(Debug, Clone, Serialize, Deserialize)]
1168#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
1169pub struct EvalUpdateResponse {
1170 pub id: String,
1172 pub created_at: i64,
1174 pub data_source_config: DataSourceConfig,
1176 #[serde(skip_serializing_if = "Option::is_none", default)]
1178 pub metadata: Option<serde_json::Value>,
1179 pub name: String,
1181 pub object: String,
1183 pub testing_criteria: Vec<TestingCriterion>,
1185}