#![allow(clippy::too_many_arguments)]
use crate::builders::{Builder, ChatCompletionBuilder};
use crate::config::Config;
use crate::errors::Result;
use crate::interceptor::{
AfterResponseContext, BeforeRequestContext, ErrorContext, InterceptorChain,
};
use crate::responses::ChatCompletionResponseWrapper;
use crate::semantic_conventions::operation_names;
use crate::time::Instant;
use crate::Error;
use openai_client_base::apis::chat_api;
use openai_client_base::apis::configuration::Configuration;
use openai_client_base::apis::Error as ApiError;
use openai_client_base::models::CreateChatCompletionRequest;
use std::sync::Arc;
#[cfg(not(target_family = "wasm"))]
use std::time::Duration;
use timvw_rust_runtime::retry::{openai_insufficient_quota, RetryLayer, RetryPolicy};
use timvw_rust_runtime::{Client as HttpClient, ReqwestService};
macro_rules! impl_interceptor_helpers {
($client_type:ty) => {
impl<T: Default + crate::MaybeSend + crate::MaybeSync> $client_type {
async fn call_before_request(
&self,
operation: &str,
model: &str,
request_json: &str,
state: &mut T,
) -> Result<()> {
if !self.client.interceptors.is_empty() {
let mut ctx = BeforeRequestContext {
operation,
model,
request_json,
state,
};
if let Err(e) = self.client.interceptors.before_request(&mut ctx).await {
let error_ctx = ErrorContext {
operation,
model: Some(model),
request_json: Some(request_json),
error: &e,
state: Some(state),
};
self.client.interceptors.on_error(&error_ctx).await;
return Err(e);
}
}
Ok(())
}
async fn handle_api_error<E>(
&self,
error: openai_client_base::apis::Error<E>,
operation: &str,
model: &str,
request_json: &str,
state: &T,
) -> Error {
let error = map_api_error(error);
if !self.client.interceptors.is_empty() {
let error_ctx = ErrorContext {
operation,
model: Some(model),
request_json: Some(request_json),
error: &error,
state: Some(state),
};
self.client.interceptors.on_error(&error_ctx).await;
}
error
}
async fn call_after_response<R>(
&self,
response: &R,
operation: &str,
model: &str,
request_json: &str,
state: &T,
duration: std::time::Duration,
input_tokens: Option<i64>,
output_tokens: Option<i64>,
) where
R: serde::Serialize + Sync,
{
if !self.client.interceptors.is_empty() {
let response_json = serde_json::to_string(response).unwrap_or_default();
let ctx = AfterResponseContext {
operation,
model,
request_json,
response_json: &response_json,
duration,
input_tokens,
output_tokens,
state,
};
if let Err(e) = self.client.interceptors.after_response(&ctx).await {
tracing::warn!("Interceptor after_response failed: {}", e);
}
}
}
}
};
}
mod assistants;
mod audio;
mod batch;
mod completions;
mod embeddings;
mod files;
mod fine_tuning;
mod headers;
mod images;
mod large_upload;
mod media;
mod models;
mod moderations;
mod raw;
mod responses;
mod threads;
mod uploads;
mod usage;
mod vector_stores;
pub use assistants::AssistantsClient;
pub use audio::AudioClient;
pub use batch::BatchClient;
pub use completions::CompletionsClient;
pub use embeddings::EmbeddingsClient;
pub use files::FilesClient;
pub use fine_tuning::FineTuningClient;
pub use images::ImagesClient;
pub use large_upload::{LargeUpload, DEFAULT_UPLOAD_CONCURRENCY, MAX_UPLOAD_PART_SIZE};
pub use models::ModelsClient;
pub use moderations::ModerationsClient;
pub use responses::ResponsesClient;
pub use threads::ThreadsClient;
pub use uploads::UploadsClient;
pub use usage::UsageClient;
pub use vector_stores::VectorStoresClient;
pub struct ClientBuilder<T = ()> {
config: Arc<Config>,
http: HttpClient,
base_configuration: Configuration,
interceptors: InterceptorChain<T>,
}
#[derive(Clone)]
pub struct Client<T = ()> {
config: Arc<Config>,
http: HttpClient,
base_configuration: Configuration,
interceptors: Arc<InterceptorChain<T>>,
}
impl<T> std::fmt::Debug for Client<T> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Client")
.field("config", &self.config)
.field("http", &"<HttpClient>")
.field("base_configuration", &"<Configuration>")
.field("interceptors", &"<InterceptorChain>")
.finish()
}
}
impl ClientBuilder {
pub fn new(config: Config) -> Result<Self> {
#[cfg_attr(target_family = "wasm", allow(clippy::option_if_let_else))]
let mut http_client = if let Some(client) = config.http_client() {
client.clone()
} else {
#[cfg(target_family = "wasm")]
let reqwest_client = reqwest::Client::new();
#[cfg(not(target_family = "wasm"))]
let reqwest_client = reqwest::Client::builder()
.timeout(Duration::from_secs(120)) .user_agent(format!("openai-ergonomic/{}", env!("CARGO_PKG_VERSION")))
.build()
.map_err(|e| Error::Config(format!("failed to build the HTTP client: {e}")))?;
let max_retries = usize::try_from(config.max_retries()).unwrap_or(usize::MAX);
HttpClient::from_service(ReqwestService::new(reqwest_client)).layer(
RetryLayer::new(RetryPolicy::new(max_retries))
.permanent_429(openai_insufficient_quota),
)
};
let provider = config.provider();
if let Some(auth) = config.auth_provider() {
http_client = http_client.layer(
crate::auth::AuthLayer::from_shared(auth.clone()).scope(provider.api_base())?,
);
}
http_client =
http_client.layer(provider.layer_with(headers::organization_headers(&config)?)?);
let mut base_configuration = Configuration::new();
base_configuration.client = http_client.clone();
base_configuration.user_agent =
Some(format!("openai-ergonomic/{}", env!("CARGO_PKG_VERSION")));
base_configuration.bearer_access_token = None;
base_configuration.base_path = provider.api_base().to_string();
Ok(Self {
config: Arc::new(config),
http: http_client,
base_configuration,
interceptors: InterceptorChain::new(),
})
}
#[cfg(not(target_family = "wasm"))]
pub fn from_env() -> Result<Self> {
Self::new(Config::from_env()?)
}
}
impl<T> ClientBuilder<T> {
#[must_use]
pub fn with_interceptor<U, I>(self, interceptor: I) -> ClientBuilder<U>
where
I: crate::interceptor::Interceptor<U> + 'static,
{
let mut new_chain = InterceptorChain::new();
new_chain.add(interceptor);
ClientBuilder {
config: self.config,
http: self.http,
base_configuration: self.base_configuration,
interceptors: new_chain,
}
}
#[must_use]
pub fn add_interceptor<I>(mut self, interceptor: I) -> Self
where
I: crate::interceptor::Interceptor<T> + 'static,
{
self.interceptors.add(interceptor);
self
}
#[must_use]
pub fn build(self) -> Client<T> {
Client {
config: self.config,
http: self.http,
base_configuration: self.base_configuration,
interceptors: Arc::new(self.interceptors),
}
}
}
impl Client {
pub fn builder(config: Config) -> Result<ClientBuilder> {
ClientBuilder::new(config)
}
#[cfg(not(target_family = "wasm"))]
pub fn from_env() -> Result<ClientBuilder> {
ClientBuilder::from_env()
}
}
impl<T> Client<T> {
pub fn config(&self) -> &Config {
&self.config
}
pub fn http_client(&self) -> &HttpClient {
&self.http
}
}
impl<T: Default + crate::MaybeSend + crate::MaybeSync> Client<T> {
async fn call_before_request(
&self,
operation: &str,
model: &str,
request_json: &str,
state: &mut T,
) -> Result<()> {
if !self.interceptors.is_empty() {
let mut ctx = BeforeRequestContext {
operation,
model,
request_json,
state,
};
if let Err(e) = self.interceptors.before_request(&mut ctx).await {
let error_ctx = ErrorContext {
operation,
model: Some(model),
request_json: Some(request_json),
error: &e,
state: Some(state),
};
self.interceptors.on_error(&error_ctx).await;
return Err(e);
}
}
Ok(())
}
async fn handle_api_error<E>(
&self,
error: openai_client_base::apis::Error<E>,
operation: &str,
model: &str,
request_json: &str,
state: &T,
) -> Error {
let error = map_api_error(error);
if !self.interceptors.is_empty() {
let error_ctx = ErrorContext {
operation,
model: Some(model),
request_json: Some(request_json),
error: &error,
state: Some(state),
};
self.interceptors.on_error(&error_ctx).await;
}
error
}
async fn call_after_response<R>(
&self,
response: &R,
operation: &str,
model: &str,
request_json: &str,
state: &T,
duration: std::time::Duration,
input_tokens: Option<i64>,
output_tokens: Option<i64>,
) where
R: serde::Serialize + Sync,
{
if !self.interceptors.is_empty() {
let response_json = serde_json::to_string(response).unwrap_or_default();
let ctx = AfterResponseContext {
operation,
model,
request_json,
response_json: &response_json,
duration,
input_tokens,
output_tokens,
state,
};
if let Err(e) = self.interceptors.after_response(&ctx).await {
tracing::warn!("Interceptor after_response failed: {}", e);
}
}
}
}
impl<T: Default + crate::MaybeSend + crate::MaybeSync + 'static> Client<T> {
pub fn chat(&self) -> ChatCompletionBuilder {
let model = self
.config
.default_model()
.unwrap_or(crate::config::DEFAULT_MODEL);
ChatCompletionBuilder::new(model)
}
pub fn chat_simple(&self, message: impl Into<String>) -> ChatCompletionBuilder {
self.chat().user(message)
}
pub fn chat_with_system(
&self,
system: impl Into<String>,
user: impl Into<String>,
) -> ChatCompletionBuilder {
self.chat().system(system).user(user)
}
pub async fn execute_chat(
&self,
request: CreateChatCompletionRequest,
) -> Result<ChatCompletionResponseWrapper> {
let mut state = T::default();
let operation = operation_names::CHAT;
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 chat_api::create_chat_completion()
.configuration(&self.base_configuration)
.create_chat_completion_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,
response.usage.as_ref().map(|u| u.prompt_tokens),
response.usage.as_ref().map(|u| u.completion_tokens),
)
.await;
Ok(ChatCompletionResponseWrapper::new(response))
}
pub async fn send_chat(
&self,
builder: ChatCompletionBuilder,
) -> Result<ChatCompletionResponseWrapper> {
let request = builder.build()?;
self.execute_chat(request).await
}
pub async fn send_chat_stream(
&self,
builder: ChatCompletionBuilder,
) -> Result<crate::streaming::BoxedChatStream> {
self.send_chat_stream_with_completion(builder)
.await
.map(|(stream, _completion)| stream)
}
pub async fn send_chat_stream_with_completion(
&self,
mut builder: ChatCompletionBuilder,
) -> Result<(
crate::streaming::BoxedChatStream,
crate::streaming::StreamCompletion,
)> {
builder = builder.stream(true);
let mut request = builder.build()?;
request.stream = Some(Some(true));
self.execute_chat_stream(request, crate::semantic_conventions::operation_names::CHAT)
.await
}
async fn execute_chat_stream(
&self,
request: CreateChatCompletionRequest,
operation: &str,
) -> Result<(
crate::streaming::BoxedChatStream,
crate::streaming::StreamCompletion,
)> {
let request_json = serde_json::to_string(&request).unwrap_or_else(|_| "{}".to_string());
let model = request.model.clone();
let mut state = T::default();
if !self.interceptors.is_empty() {
let mut ctx = crate::interceptor::BeforeRequestContext {
operation,
model: &model,
request_json: &request_json,
state: &mut state,
};
self.interceptors.before_request(&mut ctx).await?;
}
let response = self
.send_event_stream_request(http::Method::POST, "/chat/completions", &request)
.await?;
let stream = crate::streaming::ChatCompletionStream::new(response);
let (intercepted, completion) = crate::streaming::InterceptedStream::new_with_completion(
stream,
std::sync::Arc::clone(&self.interceptors),
operation.to_string(),
model,
request_json,
state,
)?;
Ok((Box::pin(intercepted), completion))
}
}
impl<T: Default + crate::MaybeSend + crate::MaybeSync> Client<T> {
#[must_use]
pub fn assistants(&self) -> AssistantsClient<'_, T> {
AssistantsClient { client: self }
}
#[must_use]
pub fn audio(&self) -> AudioClient<'_, T> {
AudioClient { client: self }
}
#[must_use]
pub fn embeddings(&self) -> EmbeddingsClient<'_, T> {
EmbeddingsClient { client: self }
}
#[must_use]
pub fn images(&self) -> ImagesClient<'_, T> {
ImagesClient { client: self }
}
#[must_use]
pub fn files(&self) -> FilesClient<'_, T> {
FilesClient { client: self }
}
#[must_use]
pub fn fine_tuning(&self) -> FineTuningClient<'_, T> {
FineTuningClient { client: self }
}
#[must_use]
pub fn batch(&self) -> BatchClient<'_, T> {
BatchClient { client: self }
}
#[must_use]
pub fn vector_stores(&self) -> VectorStoresClient<'_, T> {
VectorStoresClient { client: self }
}
#[must_use]
pub fn moderations(&self) -> ModerationsClient<'_, T> {
ModerationsClient { client: self }
}
#[must_use]
pub fn threads(&self) -> ThreadsClient<'_, T> {
ThreadsClient { client: self }
}
#[must_use]
pub fn uploads(&self) -> UploadsClient<'_, T> {
UploadsClient { client: self }
}
#[must_use]
pub fn models(&self) -> ModelsClient<'_, T> {
ModelsClient { client: self }
}
#[must_use]
pub fn completions(&self) -> CompletionsClient<'_, T> {
CompletionsClient { client: self }
}
#[must_use]
pub fn usage(&self) -> UsageClient<'_, T> {
UsageClient { client: self }
}
}
fn map_api_error<T>(error: ApiError<T>) -> Error {
match error {
ApiError::Http(err) => Error::Http(err),
ApiError::Serde(err) => Error::Json(err),
ApiError::ResponseError(response) => {
let (error_type, error_code) = raw::openai_error_details(&response.content);
Error::Api {
status: response.status.as_u16(),
message: response.content,
error_type,
error_code,
}
}
}
}
#[cfg(test)]
mod tests {
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
use super::*;
use openai_client_base::apis::{Error as BaseError, ResponseContent};
#[test]
fn map_api_error_keeps_the_openai_error_type_and_code() {
let response = ResponseContent {
status: http::StatusCode::TOO_MANY_REQUESTS,
content: r#"{"error":{"message":"slow down","type":"requests","code":"rate_limit_exceeded"}}"#
.to_string(),
headers: http::HeaderMap::new(),
entity: Option::<()>::None,
};
let error = map_api_error(BaseError::ResponseError(Box::new(response)));
assert!(error.is_rate_limit());
assert!(matches!(
error,
Error::Api { error_type: Some(t), error_code: Some(c), .. }
if t == "requests" && c == "rate_limit_exceeded"
));
}
#[test]
fn map_api_error_converts_response() {
let response = ResponseContent {
status: http::StatusCode::BAD_REQUEST,
content: "bad request".to_string(),
headers: http::HeaderMap::new(),
entity: Option::<()>::None,
};
let error = map_api_error(BaseError::ResponseError(Box::new(response)));
match error {
Error::Api {
status, message, ..
} => {
assert_eq!(status, 400);
assert!(message.contains("bad request"));
}
other => panic!("expected API error, got {other:?}"),
}
}
#[test]
fn test_moderation_builder_creation() {
use crate::builders::moderations::ModerationBuilder;
let builder = ModerationBuilder::new("Test content");
let request = builder.build().unwrap();
assert_eq!(request.input, "Test content".into());
assert!(request.model.is_none());
}
#[test]
fn test_moderation_builder_with_model() {
use crate::builders::moderations::ModerationBuilder;
let builder = ModerationBuilder::new("Test content").model("text-moderation-stable");
let request = builder.build().unwrap();
assert_eq!(request.input, "Test content".into());
assert_eq!(request.model, Some("text-moderation-stable".to_string()));
}
#[test]
fn test_moderation_builder_array_input() {
use crate::builders::moderations::ModerationBuilder;
let inputs = vec!["First text".to_string(), "Second text".to_string()];
let builder = ModerationBuilder::new_array(inputs);
let request = builder.build().unwrap();
assert_eq!(
serde_json::to_value(&request.input).unwrap(),
serde_json::json!(["First text", "Second text"])
);
}
#[test]
fn test_file_upload_builder_creation() {
use crate::builders::files::{FilePurpose, FileUploadBuilder};
let content = b"test content".to_vec();
let builder = FileUploadBuilder::new("test.txt", FilePurpose::Assistants, content.clone());
assert_eq!(builder.filename(), "test.txt");
assert_eq!(builder.content(), Some(content.as_slice()));
assert_eq!(builder.content_size(), Some(content.len() as u64));
assert!(!builder.is_empty());
}
#[test]
fn test_file_upload_builder_from_text() {
use crate::builders::files::{FilePurpose, FileUploadBuilder};
let builder =
FileUploadBuilder::from_text("hello.txt", FilePurpose::FineTune, "Hello, world!");
assert_eq!(builder.filename(), "hello.txt");
assert_eq!(
builder.content_as_string(),
Some("Hello, world!".to_string())
);
assert!(!builder.is_empty());
}
#[test]
fn test_file_list_builder() {
use crate::builders::files::{FileListBuilder, FileOrder, FilePurpose};
let builder = FileListBuilder::new()
.purpose(FilePurpose::Assistants)
.limit(10)
.order(FileOrder::Desc);
assert!(builder.purpose_ref().is_some());
assert_eq!(builder.limit_ref(), Some(10));
assert!(builder.order_ref().is_some());
}
#[test]
fn test_file_retrieval_builder() {
use crate::builders::files::FileRetrievalBuilder;
let builder = FileRetrievalBuilder::new("file-123");
assert_eq!(builder.file_id(), "file-123");
}
#[test]
fn test_file_delete_builder() {
use crate::builders::files::FileDeleteBuilder;
let builder = FileDeleteBuilder::new("file-456");
assert_eq!(builder.file_id(), "file-456");
}
#[test]
fn test_file_purpose_display() {
use crate::builders::files::FilePurpose;
assert_eq!(FilePurpose::FineTune.to_string(), "fine-tune");
assert_eq!(FilePurpose::Assistants.to_string(), "assistants");
assert_eq!(FilePurpose::Vision.to_string(), "vision");
assert_eq!(FilePurpose::Batch.to_string(), "batch");
}
#[test]
fn test_vector_store_builder_basic() {
use crate::builders::vector_stores::VectorStoreBuilder;
let builder = VectorStoreBuilder::new()
.name("Test Store")
.add_file("file-1")
.metadata("key", "value");
assert_eq!(builder.name_ref(), Some("Test Store"));
assert_eq!(builder.file_count(), 1);
assert!(builder.has_files());
assert_eq!(builder.metadata_ref().len(), 1);
}
#[test]
fn test_vector_store_builder_with_expiration() {
use crate::builders::vector_stores::VectorStoreBuilder;
let builder = VectorStoreBuilder::new()
.name("Temp Store")
.expires_after_days(30);
assert_eq!(builder.name_ref(), Some("Temp Store"));
assert!(builder.expires_after_ref().is_some());
assert_eq!(builder.expires_after_ref().unwrap().days, 30);
}
#[test]
fn test_vector_store_builder_multiple_files() {
use crate::builders::vector_stores::VectorStoreBuilder;
let files = vec!["file-1".to_string(), "file-2".to_string()];
let builder = VectorStoreBuilder::new()
.name("Multi-File Store")
.file_ids(files.clone());
assert_eq!(builder.file_ids_ref(), files.as_slice());
assert_eq!(builder.file_count(), 2);
}
#[test]
fn test_vector_store_file_builder() {
use crate::builders::vector_stores::VectorStoreFileBuilder;
let builder = VectorStoreFileBuilder::new("vs-123", "file-456");
assert_eq!(builder.vector_store_id(), "vs-123");
assert_eq!(builder.file_id(), "file-456");
}
#[test]
fn test_vector_store_search_builder() {
use crate::builders::vector_stores::VectorStoreSearchBuilder;
let builder = VectorStoreSearchBuilder::new("vs-123", "test query")
.limit(10)
.filter("category", "docs");
assert_eq!(builder.vector_store_id(), "vs-123");
assert_eq!(builder.query(), "test query");
assert_eq!(builder.limit_ref(), Some(10));
assert_eq!(builder.filter_ref().len(), 1);
}
#[test]
fn test_vector_store_search_builder_default() {
use crate::builders::vector_stores::VectorStoreSearchBuilder;
let builder = VectorStoreSearchBuilder::new("vs-123", "query");
assert!(builder.limit_ref().is_none());
assert!(builder.filter_ref().is_empty());
}
}