1use std::future::Future;
4use std::sync::Arc;
5use std::time::Duration;
6
7use crate::error::Error;
8use crate::models::ModelList;
9use crate::request::Request;
10use crate::response::Response;
11
12pub trait Transport: Send + Sync {
22 fn evaluate(
24 &self,
25 request: &Request,
26 ) -> impl Future<Output = Result<Reply<Response>, Error>> + Send;
27
28 fn list_models(&self) -> impl Future<Output = Result<Reply<ModelList>, Error>> + Send;
30}
31
32impl<T: Transport + ?Sized> Transport for &T {
33 fn evaluate(
34 &self,
35 request: &Request,
36 ) -> impl Future<Output = Result<Reply<Response>, Error>> + Send {
37 (**self).evaluate(request)
38 }
39
40 fn list_models(&self) -> impl Future<Output = Result<Reply<ModelList>, Error>> + Send {
41 (**self).list_models()
42 }
43}
44
45impl<T: Transport + ?Sized> Transport for Arc<T> {
46 fn evaluate(
47 &self,
48 request: &Request,
49 ) -> impl Future<Output = Result<Reply<Response>, Error>> + Send {
50 (**self).evaluate(request)
51 }
52
53 fn list_models(&self) -> impl Future<Output = Result<Reply<ModelList>, Error>> + Send {
54 (**self).list_models()
55 }
56}
57
58#[derive(Clone, Debug, PartialEq)]
60#[non_exhaustive]
61pub struct Reply<T> {
62 pub body: T,
64 pub meta: ReplyMeta,
66 pub raw_body: Option<String>,
75}
76
77impl<T> Reply<T> {
78 #[must_use]
80 pub const fn new(body: T, meta: ReplyMeta) -> Self {
81 Self {
82 body,
83 meta,
84 raw_body: None,
85 }
86 }
87
88 #[must_use]
90 pub fn with_raw_body(mut self, raw_body: impl Into<String>) -> Self {
91 self.raw_body = Some(raw_body.into());
92 self
93 }
94}
95
96#[derive(Clone, Debug, Default, PartialEq, Eq)]
98#[non_exhaustive]
99pub struct ReplyMeta {
100 pub request_id: Option<String>,
103 pub latency: Duration,
106 pub attempts: u32,
108}
109
110impl ReplyMeta {
111 #[must_use]
113 pub const fn new(request_id: Option<String>, latency: Duration, attempts: u32) -> Self {
114 Self {
115 request_id,
116 latency,
117 attempts,
118 }
119 }
120}
121
122#[cfg(test)]
123mod tests {
124 use std::future::{Future, ready};
125 use std::sync::Arc;
126 use std::time::Duration;
127
128 use indexmap::IndexMap;
129
130 use super::{Reply, ReplyMeta, Transport};
131 use crate::{Error, ModelCard, ModelList, Request, Response, Usage};
132
133 struct Canned;
135
136 impl Transport for Canned {
137 fn evaluate(
138 &self,
139 request: &Request,
140 ) -> impl Future<Output = Result<Reply<Response>, Error>> + Send {
141 let body = Response::new(request.model.clone(), IndexMap::new(), Usage::new(1, 0));
142 let meta = ReplyMeta::new(Some("req_fake".into()), Duration::ZERO, 1);
143 ready(Ok(Reply::new(body, meta)))
144 }
145
146 fn list_models(&self) -> impl Future<Output = Result<Reply<ModelList>, Error>> + Send {
147 let models = ModelList::new(vec![ModelCard::new("jev-latest")]);
148 ready(Ok(Reply::new(models, ReplyMeta::default())))
149 }
150 }
151
152 async fn model_names(transport: impl Transport) -> Vec<String> {
153 let reply = transport.list_models().await.unwrap();
154 reply
155 .body
156 .models
157 .into_iter()
158 .map(|model| model.name)
159 .collect()
160 }
161
162 fn assert_send<T: Send>(value: T) -> T {
164 value
165 }
166
167 #[tokio::test]
168 async fn a_fake_a_reference_and_an_arc_are_all_transports() {
169 let shared = Arc::new(Canned);
170
171 assert_eq!(model_names(Canned).await, ["jev-latest"]);
172 assert_eq!(model_names(&Canned).await, ["jev-latest"]);
173 assert_eq!(model_names(Arc::clone(&shared)).await, ["jev-latest"]);
174
175 let request = Request::new("s", "jev-1.13.0");
176 let reply = assert_send(shared.evaluate(&request)).await.unwrap();
177 assert_eq!(reply.body.model, "jev-1.13.0");
178 assert_eq!(reply.meta.request_id.as_deref(), Some("req_fake"));
179 }
180}