1use serde::{Deserialize, Serialize};
4use serde_json::Value;
5
6use crate::{answer::Answers, question::Questions, state::State};
7
8#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
24#[serde(transparent)]
25pub struct TraceConfig(Value);
26
27impl TraceConfig {
28 #[must_use]
30 pub fn new(value: Value) -> Self {
31 TraceConfig(value)
32 }
33
34 #[must_use]
36 pub fn value(&self) -> &Value {
37 &self.0
38 }
39}
40
41#[derive(Debug, Serialize)]
48pub(crate) struct DecisionRequest<'a> {
49 pub model: &'a str,
50 pub state: &'a State,
51 pub questions: &'a Questions,
52 #[serde(skip_serializing_if = "Option::is_none")]
53 pub session_id: Option<&'a str>,
54 #[serde(skip_serializing_if = "Option::is_none")]
55 pub user: Option<&'a str>,
56 #[serde(skip_serializing_if = "Option::is_none")]
57 pub trace: Option<&'a TraceConfig>,
58}
59
60#[derive(Debug, Clone, Copy, PartialEq, Deserialize)]
62pub struct Usage {
63 pub input_tokens: u32,
65 pub output_tokens: u32,
67 #[serde(default)]
69 pub cost: Option<f64>,
70}
71
72#[derive(Debug, Deserialize)]
74pub struct Response {
75 pub model: String,
77 pub answers: Answers,
79 pub usage: Usage,
81 #[serde(default)]
83 pub id: Option<String>,
84 #[serde(default)]
86 pub provider: Option<String>,
87}
88
89#[derive(Debug, Clone, PartialEq)]
96pub struct ResponseMeta {
97 pub id: Option<String>,
99 pub model: String,
101 pub provider: Option<String>,
103 pub usage: Usage,
105 pub latency: std::time::Duration,
107}
108
109impl ResponseMeta {
110 pub(crate) fn from_response(response: &Response, latency: std::time::Duration) -> Self {
112 ResponseMeta {
113 id: response.id.clone(),
114 model: response.model.clone(),
115 provider: response.provider.clone(),
116 usage: response.usage,
117 latency,
118 }
119 }
120}
121
122#[cfg(test)]
123mod tests {
124 use super::*;
125
126 #[test]
127 fn test_should_deserialize_full_response() {
128 let body = r#"{
129 "model": "typesafe/jev-1.13",
130 "id": "req_123",
131 "provider": "openrouter",
132 "usage": {"input_tokens": 100, "output_tokens": 5, "cost": 0.001},
133 "answers": {"refund": {"type": "noul", "noul": 0.9}}
134 }"#;
135 let response: Response = serde_json::from_str(body).unwrap();
136 assert_eq!(response.model, "typesafe/jev-1.13");
137 assert_eq!(response.id, Some("req_123".to_string()));
138 assert_eq!(response.usage.input_tokens, 100);
139 assert_eq!(response.answers.noul("refund").unwrap(), 0.9);
140 }
141
142 #[test]
143 fn test_should_default_optional_response_fields_when_absent() {
144 let body = r#"{
145 "model": "jev-1.13",
146 "usage": {"input_tokens": 1, "output_tokens": 1},
147 "answers": {}
148 }"#;
149 let response: Response = serde_json::from_str(body).unwrap();
150 assert_eq!(response.id, None);
151 assert_eq!(response.provider, None);
152 assert_eq!(response.usage.cost, None);
153 }
154
155 #[test]
156 fn test_should_wrap_trace_config_transparently() {
157 let trace = TraceConfig::new(serde_json::json!({"sampled": true}));
158 let encoded = serde_json::to_value(&trace).unwrap();
159 assert_eq!(encoded, serde_json::json!({"sampled": true}));
160 }
161
162 #[test]
163 fn test_should_skip_none_optional_request_fields() {
164 let questions = Questions::builder()
165 .noul("refund", "Is this a refund?")
166 .build()
167 .unwrap();
168 let state: State = "hi".into();
169 let req = DecisionRequest {
170 model: "jev-1.13",
171 state: &state,
172 questions: &questions,
173 session_id: None,
174 user: None,
175 trace: None,
176 };
177 let json = serde_json::to_value(&req).unwrap();
178 assert!(json.get("session_id").is_none());
179 assert!(json.get("user").is_none());
180 assert!(json.get("trace").is_none());
181 }
182
183 #[test]
184 fn test_should_build_response_meta_from_response() {
185 let body = r#"{
186 "model": "jev-1.13",
187 "usage": {"input_tokens": 1, "output_tokens": 1},
188 "answers": {}
189 }"#;
190 let response: Response = serde_json::from_str(body).unwrap();
191 let meta = ResponseMeta::from_response(&response, std::time::Duration::from_millis(42));
192 assert_eq!(meta.model, "jev-1.13");
193 assert_eq!(meta.latency, std::time::Duration::from_millis(42));
194 }
195}