async-openai 0.34.0

Rust library for OpenAI
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

use serde::{Deserialize, Serialize};

use crate::types::evals::EvalItem;
use crate::types::graders::ReasoningEffort;

/// String check operation.
#[derive(Debug, Deserialize, Serialize, Clone, Copy, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum GraderStringCheckOperation {
    /// Equal.
    Eq,
    /// Not equal.
    Ne,
    /// Like.
    Like,
    /// Case-insensitive like.
    Ilike,
}

/// String check grader.
#[derive(Debug, Deserialize, Serialize, Clone, PartialEq)]
pub struct GraderStringCheck {
    /// The name of the grader.
    pub name: String,
    /// The input text. This may include template strings.
    pub input: String,
    /// The reference text. This may include template strings.
    pub reference: String,
    /// The string check operation to perform. One of `eq`, `ne`, `like`, or `ilike`.
    pub operation: GraderStringCheckOperation,
}

/// Text similarity grader.
#[derive(Debug, Deserialize, Serialize, Clone, PartialEq)]
pub struct GraderTextSimilarity {
    /// The name of the grader.
    pub name: String,
    /// The text being graded.
    pub input: String,
    /// The text being graded against.
    pub reference: String,
    /// The evaluation metric to use.
    pub evaluation_metric: GraderTextSimilarityEvaluationMetric,
}

/// Text similarity metric.
#[derive(Debug, Deserialize, Serialize, Clone, Copy, PartialEq)]
#[serde(rename_all = "snake_case")]
pub enum GraderTextSimilarityEvaluationMetric {
    Cosine,
    FuzzyMatch,
    Bleu,
    Gleu,
    Meteor,
    Rouge1,
    Rouge2,
    Rouge3,
    Rouge4,
    Rouge5,
    RougeL,
}

/// Python grader.
#[derive(Debug, Deserialize, Serialize, Clone, PartialEq)]
pub struct GraderPython {
    /// The name of the grader.
    pub name: String,
    /// The source code of the python script.
    pub source: String,
    /// The image tag to use for the python script.
    pub image_tag: Option<String>,
}

/// Score model grader.
#[derive(Debug, Deserialize, Serialize, Clone, PartialEq)]
pub struct GraderScoreModel {
    /// The name of the grader.
    pub name: String,
    /// The model to use for the evaluation.
    pub model: String,
    /// A list of chat messages forming the prompt or context.
    pub input: Vec<EvalItem>,

    /// Optional sampling parameters.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sampling_params: Option<GraderScoreModelSamplingParams>,
    /// The range of the score. Defaults to [0, 1].
    #[serde(skip_serializing_if = "Option::is_none")]
    pub range: Option<Vec<f64>>,
}

#[derive(Debug, Deserialize, Serialize, Clone, PartialEq)]
pub struct GraderScoreModelSamplingParams {
    /// A seed value to initialize the randomness, during sampling.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub seed: Option<i32>,
    /// An alternative to temperature for nucleus sampling; 1.0 includes all tokens.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub top_p: Option<f64>,
    /// A higher temperature increases randomness in the outputs.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub temperature: Option<f64>,
    /// The maximum number of tokens the grader model may generate in its response.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_completion_tokens: Option<i32>,
    /// Optional reasoning effort parameter.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reasoning_effort: Option<ReasoningEffort>,
}

#[derive(Debug, Deserialize, Serialize, Clone, PartialEq)]
pub struct GraderLabelModel {
    /// The name of the grader.
    pub name: String,
    /// The model to use for the evaluation. Must support structured outputs.
    pub model: String,
    /// A list of chat messages forming the prompt or context.
    pub input: Vec<EvalItem>,
    /// The labels to classify to each item in the evaluation.
    pub labels: Vec<String>,
    /// The labels that indicate a passing result. Must be a subset of labels.
    pub passing_labels: Vec<String>,
}

#[derive(Debug, Deserialize, Serialize, Clone, PartialEq)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum Graders {
    StringCheck(GraderStringCheck),
    TextSimilarity(GraderTextSimilarity),
    Python(GraderPython),
    ScoreModel(GraderScoreModel),
    LabelModel(GraderLabelModel),
}

#[derive(Debug, Deserialize, Serialize, Clone, PartialEq)]
pub struct GraderMulti {
    /// The name of the grader.
    pub name: String,
    pub graders: Graders,
    /// A formula to calculate the output based on grader results.
    pub calculate_output: String,
}