use super::{map_api_error, Client};
use crate::builders::embeddings::EmbeddingsBuilder;
use crate::builders::Builder;
use crate::errors::Result;
use crate::interceptor::{AfterResponseContext, BeforeRequestContext, ErrorContext};
use crate::semantic_conventions::operation_names;
use crate::time::Instant;
use crate::Error;
use openai_client_base::apis::embeddings_api;
use openai_client_base::models::CreateEmbeddingResponse;
#[derive(Debug, Clone, Copy)]
#[allow(dead_code)]
pub struct EmbeddingsClient<'a, T = ()> {
pub(super) client: &'a Client<T>,
}
impl_interceptor_helpers!(EmbeddingsClient<'_, T>);
impl<T: Default + crate::MaybeSend + crate::MaybeSync> EmbeddingsClient<'_, T> {
#[must_use]
pub fn builder(&self, model: impl Into<String>) -> EmbeddingsBuilder {
EmbeddingsBuilder::new(model)
}
#[must_use]
pub fn text(&self, model: impl Into<String>, input: impl Into<String>) -> EmbeddingsBuilder {
self.builder(model).input_text(input)
}
#[must_use]
pub fn tokens<I>(&self, model: impl Into<String>, tokens: I) -> EmbeddingsBuilder
where
I: IntoIterator<Item = i64>,
{
self.builder(model).input_tokens(tokens)
}
pub async fn create(&self, builder: EmbeddingsBuilder) -> Result<CreateEmbeddingResponse> {
let request = builder.build()?;
let mut state = T::default();
let operation = operation_names::EMBEDDINGS;
let model = request.model.clone();
let request_json = serde_json::to_string(&request).unwrap_or_default();
self.call_before_request(operation, &model, &request_json, &mut state)
.await?;
let start_time = Instant::now();
let response = match embeddings_api::create_embedding()
.configuration(&self.client.base_configuration)
.create_embedding_request(&request)
.call()
.await
{
Ok(resp) => resp,
Err(e) => {
let error = self
.handle_api_error(e, operation, &model, &request_json, &state)
.await;
return Err(error);
}
};
let duration = start_time.elapsed();
self.call_after_response(
&response,
operation,
&model,
&request_json,
&state,
duration,
Some(response.usage.prompt_tokens),
Some(response.usage.total_tokens),
)
.await;
Ok(response)
}
}