1use serde::{Deserialize, Serialize};
6
7#[derive(Debug, Clone, Serialize, Deserialize)]
9#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
10pub struct GraderInputItemOutputText {
11 pub text: String,
13 #[serde(rename = "type")]
15 pub type_: String,
16}
17
18#[derive(Debug, Clone, Serialize, Deserialize)]
20#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
21pub struct GraderInputItemInputImage {
22 pub image_url: String,
24 #[serde(rename = "type")]
26 pub type_: String,
27 #[serde(skip_serializing_if = "Option::is_none", default)]
29 pub detail: Option<String>,
30}
31
32pub type GraderInputItem = serde_json::Value;
33
34pub type GraderInputs = Vec<GraderInputItem>;
35
36#[derive(Debug, Clone, Serialize, Deserialize)]
38#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
39pub struct InputContentOutputText {
40 pub text: String,
42 #[serde(rename = "type")]
44 pub type_: String,
45}
46
47#[derive(Debug, Clone, Serialize, Deserialize)]
49#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
50pub struct InputContentInputImage {
51 pub image_url: String,
53 #[serde(rename = "type")]
55 pub type_: String,
56 #[serde(skip_serializing_if = "Option::is_none", default)]
58 pub detail: Option<String>,
59}
60
61pub type InputContent = serde_json::Value;
62
63#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
64#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
65#[non_exhaustive]
66pub enum InputRole {
67 #[serde(rename = "user")]
68 User,
69 #[serde(rename = "assistant")]
70 Assistant,
71 #[serde(rename = "system")]
72 System,
73 #[serde(rename = "developer")]
74 Developer,
75}
76
77#[derive(Debug, Clone, Serialize, Deserialize)]
79#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
80pub struct Input {
81 pub content: InputContent,
83 pub role: InputRole,
85 #[serde(rename = "type", skip_serializing_if = "Option::is_none", default)]
87 pub type_: Option<String>,
88}
89
90#[derive(Debug, Clone, Serialize, Deserialize)]
92#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
93pub struct LabelModelGrader {
94 pub input: Vec<Input>,
95 pub labels: Vec<String>,
97 pub model: String,
99 pub name: String,
101 pub passing_labels: Vec<String>,
103 #[serde(rename = "type")]
105 pub type_: String,
106}
107
108pub type Graders = serde_json::Value;
109
110#[derive(Debug, Clone, Serialize, Deserialize)]
112#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
113pub struct MultiGrader {
114 pub calculate_output: String,
116 pub graders: Graders,
118 pub name: String,
120 #[serde(rename = "type")]
122 pub type_: String,
123}
124
125#[derive(Debug, Clone, Serialize, Deserialize)]
127#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
128pub struct PythonGrader {
129 pub name: String,
131 pub source: String,
133 #[serde(rename = "type")]
135 pub type_: String,
136 #[serde(skip_serializing_if = "Option::is_none", default)]
138 pub image_tag: Option<String>,
139}
140
141#[derive(Debug, Clone, Serialize, Deserialize)]
143#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
144pub struct SamplingParams {
145 #[serde(skip_serializing_if = "Option::is_none", default)]
147 pub max_completions_tokens: Option<i64>,
148 #[serde(skip_serializing_if = "Option::is_none", default)]
150 pub reasoning_effort: Option<serde_json::Value>,
151 #[serde(skip_serializing_if = "Option::is_none", default)]
153 pub seed: Option<i64>,
154 #[serde(skip_serializing_if = "Option::is_none", default)]
156 pub temperature: Option<f64>,
157 #[serde(skip_serializing_if = "Option::is_none", default)]
159 pub top_p: Option<f64>,
160}
161
162#[derive(Debug, Clone, Serialize, Deserialize)]
164#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
165pub struct ScoreModelGrader {
166 pub input: Vec<Input>,
168 pub model: String,
170 pub name: String,
172 #[serde(rename = "type")]
174 pub type_: String,
175 #[serde(skip_serializing_if = "Option::is_none", default)]
177 pub range: Option<Vec<f64>>,
178 #[serde(skip_serializing_if = "Option::is_none", default)]
180 pub sampling_params: Option<SamplingParams>,
181}
182
183#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
184#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
185#[non_exhaustive]
186pub enum StringCheckGraderOperation {
187 #[serde(rename = "eq")]
188 Eq,
189 #[serde(rename = "ne")]
190 Ne,
191 #[serde(rename = "like")]
192 Like,
193 #[serde(rename = "ilike")]
194 Ilike,
195}
196
197#[derive(Debug, Clone, Serialize, Deserialize)]
199#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
200pub struct StringCheckGrader {
201 pub input: String,
203 pub name: String,
205 pub operation: StringCheckGraderOperation,
207 pub reference: String,
209 #[serde(rename = "type")]
211 pub type_: String,
212}
213
214#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
215#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
216#[non_exhaustive]
217pub enum TextSimilarityGraderEvaluationMetric {
218 #[serde(rename = "cosine")]
219 Cosine,
220 #[serde(rename = "fuzzy_match")]
221 FuzzyMatch,
222 #[serde(rename = "bleu")]
223 Bleu,
224 #[serde(rename = "gleu")]
225 Gleu,
226 #[serde(rename = "meteor")]
227 Meteor,
228 #[serde(rename = "rouge_1")]
229 Rouge1,
230 #[serde(rename = "rouge_2")]
231 Rouge2,
232 #[serde(rename = "rouge_3")]
233 Rouge3,
234 #[serde(rename = "rouge_4")]
235 Rouge4,
236 #[serde(rename = "rouge_5")]
237 Rouge5,
238 #[serde(rename = "rouge_l")]
239 RougeL,
240}
241
242#[derive(Debug, Clone, Serialize, Deserialize)]
244#[cfg_attr(feature = "structured", derive(schemars::JsonSchema))]
245pub struct TextSimilarityGrader {
246 pub evaluation_metric: TextSimilarityGraderEvaluationMetric,
248 pub input: String,
250 pub name: String,
252 pub reference: String,
254 #[serde(rename = "type")]
256 pub type_: String,
257}