1use std::convert::Infallible;
11
12use super::Whole;
13use crate::embeddings::Embedding as Vector;
14use crate::error::ProviderError;
15use crate::telemetry::{GenAiOperation, SpanBuilder, SpanCombinator};
16use crate::wire::{Call, Capabilities, Fold, Free, Operation, Reply};
17
18#[derive(Debug, Clone, PartialEq)]
24pub struct RerankRequest {
25 pub query: String,
27 pub documents: Vec<String>,
29}
30
31macro_rules! modality_operation {
33 (
34 $(#[$doc:meta])*
35 $op:ident {
36 request: $request:ty,
37 response: $response:ty,
38 telemetry: $telemetry:ident,
39 fold: $fold:ty,
40 seed: $seed:expr,
41 }
42 ) => {
43 $(#[$doc])*
44 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
45 pub struct $op;
46
47 impl Operation for $op {
48 type Request = $request;
49 type Event = Infallible;
50 type End = $response;
51 type Response = $response;
52 type Fold = Traced<Self, $fold>;
53 type Emit = Free;
54
55 fn fold(request: &Self::Request, call: &mut Call<'_>) -> Self::Fold {
56 let telemetry = call
57 .wire
58 .telemetry
59 .map_or(GenAiOperation::$telemetry, |telemetry| telemetry(call.mode));
60 debug_assert!(!telemetry.is_completion());
61 let span = SpanBuilder::new(
62 call.wire.name,
63 call.wire.model.unwrap_or_default(),
64 telemetry,
65 )
66 .build();
67 call.instrument(span.clone());
68 #[allow(clippy::redundant_closure_call)]
69 let inner = ($seed)(request, &*call);
70 Traced {
71 inner,
72 span,
73 record: |span, response| {
74 span.record_response(
75 response.response_id.as_deref(),
76 response.model.as_deref(),
77 &response.usage,
78 )
79 },
80 }
81 }
82 }
83 };
84}
85
86pub struct Traced<Op: Operation, F> {
88 inner: F,
89 span: tracing::Span,
90 record: fn(&tracing::Span, &Op::Response),
91}
92
93impl<Op, F> Fold<Op> for Traced<Op, F>
94where
95 Op: Operation,
96 F: Fold<Op>,
97{
98 fn absorb(&mut self, event: &Op::Event) -> Result<(), ProviderError> {
99 self.inner.absorb(event)
100 }
101
102 fn finish(self, end: Op::End, reply: Reply) -> Result<Op::Response, ProviderError> {
103 let response = self.inner.finish(end, reply)?;
104 (self.record)(&self.span, &response);
105 Ok(response)
106 }
107}
108
109pub(crate) trait Stamp {
111 fn stamp(&mut self, reply: &Reply);
114}
115
116macro_rules! stamp {
117 ($($response:ty),*) => {$(
118 impl Stamp for $response {
119 fn stamp(&mut self, reply: &Reply) {
120 use crate::provider_response::reported;
121 self.provider.clone_from(&reply.provider);
122 self.provider_request_id = reported(reply.provider_request_id.clone());
123 self.raw.clone_from(&reply.raw);
124 self.model = reported(self.model.take());
125 self.response_id = reported(self.response_id.take());
126 }
127 }
128 )*};
129}
130
131stamp!(
132 crate::embeddings::EmbeddingResponse,
133 crate::embeddings::ImageEmbeddingResponse,
134 crate::rerank::RerankResponse,
135 crate::transcription::TranscriptionResponse
136);
137#[cfg(feature = "image")]
138stamp!(crate::image_generation::ImageGenerationResponse);
139#[cfg(feature = "audio")]
140stamp!(crate::audio_generation::AudioGenerationResponse);
141
142modality_operation!(
143 Embedding {
145 request: Vec<String>,
146 response: crate::embeddings::EmbeddingResponse,
147 telemetry: Embeddings,
148 fold: Embedded,
149 seed: |texts: &Vec<String>, call: &Call<'_>| Embedded::over(texts.clone(), call),
150 }
151);
152
153modality_operation!(
154 ImageEmbedding {
156 request: Vec<Vec<u8>>,
157 response: crate::embeddings::ImageEmbeddingResponse,
158 telemetry: Embeddings,
159 fold: Embedded,
160 seed: |images: &Vec<Vec<u8>>, call: &Call<'_>| Embedded::over(
161 images.iter().map(|bytes| crate::embeddings::image_document(bytes)).collect(),
162 call,
163 ),
164 }
165);
166
167modality_operation!(
168 Rerank {
170 request: RerankRequest,
171 response: crate::rerank::RerankResponse,
172 telemetry: Rerank,
173 fold: Whole<Self>,
174 seed: |_: &_, _: &Call<'_>| Whole::stamping(<crate::rerank::RerankResponse as Stamp>::stamp),
175 }
176);
177
178modality_operation!(
179 Transcription {
181 request: crate::transcription::TranscriptionRequest,
182 response: crate::transcription::TranscriptionResponse,
183 telemetry: Transcription,
184 fold: Whole<Self>,
185 seed: |_: &_, _: &Call<'_>| Whole::stamping(<crate::transcription::TranscriptionResponse as Stamp>::stamp),
186 }
187);
188
189#[cfg(feature = "image")]
190modality_operation!(
191 ImageGeneration {
193 request: crate::image_generation::ImageGenerationRequest,
194 response: crate::image_generation::ImageGenerationResponse,
195 telemetry: ImageGeneration,
196 fold: Whole<Self>,
197 seed: |_: &_, _: &Call<'_>| Whole::stamping(<crate::image_generation::ImageGenerationResponse as Stamp>::stamp),
198 }
199);
200
201#[cfg(feature = "audio")]
202modality_operation!(
203 AudioGeneration {
205 request: crate::audio_generation::AudioGenerationRequest,
206 response: crate::audio_generation::AudioGenerationResponse,
207 telemetry: AudioGeneration,
208 fold: Whole<Self>,
209 seed: |_: &_, _: &Call<'_>| Whole::stamping(<crate::audio_generation::AudioGenerationResponse as Stamp>::stamp),
210 }
211);
212
213pub struct Embedded {
217 documents: Vec<String>,
218 provider: String,
220 capabilities: Capabilities,
221}
222
223impl Embedded {
224 pub fn over(documents: Vec<String>, call: &Call<'_>) -> Self {
227 Self {
228 documents,
229 provider: call.wire.name.to_owned(),
230 capabilities: call.wire.capabilities,
231 }
232 }
233
234 fn zipped(self, vectors: Vec<Vector>) -> Result<Vec<Vector>, ProviderError> {
236 self.capabilities.honour_declaration(
237 &self.provider,
238 vectors.iter().map(|vector| vector.vec.len()),
239 )?;
240 if vectors.len() != self.documents.len() {
241 return Err(ProviderError::Response(format!(
242 "provider returned {} embeddings for {} documents",
243 vectors.len(),
244 self.documents.len()
245 )));
246 }
247 Ok(self
248 .documents
249 .into_iter()
250 .zip(vectors)
251 .map(|(document, vector)| Vector {
252 document,
253 vec: vector.vec,
254 })
255 .collect())
256 }
257}
258
259impl Fold<Embedding> for Embedded {
260 fn absorb(&mut self, event: &Infallible) -> Result<(), ProviderError> {
261 match *event {}
262 }
263
264 fn finish(
265 self,
266 mut response: crate::embeddings::EmbeddingResponse,
267 reply: Reply,
268 ) -> Result<crate::embeddings::EmbeddingResponse, ProviderError> {
269 response.embeddings = self.zipped(std::mem::take(&mut response.embeddings))?;
270 response.stamp(&reply);
271 Ok(response)
272 }
273}
274
275impl Fold<ImageEmbedding> for Embedded {
276 fn absorb(&mut self, event: &Infallible) -> Result<(), ProviderError> {
277 match *event {}
278 }
279
280 fn finish(
281 self,
282 mut response: crate::embeddings::ImageEmbeddingResponse,
283 reply: Reply,
284 ) -> Result<crate::embeddings::ImageEmbeddingResponse, ProviderError> {
285 response.embeddings = self.zipped(std::mem::take(&mut response.embeddings))?;
286 response.stamp(&reply);
287 Ok(response)
288 }
289}
290
291#[cfg(test)]
292mod tests;