feat: RequestOptions

Author: 64bit

async-openai/Cargo.toml

@@ -50,6 +50,7 @@ derive_builder = "0.20.2"
 secrecy = { version = "0.10.3", features = ["serde"] }
 bytes = "1.9.0"
 eventsource-stream = "0.2.3"
+serde_urlencoded = "0.7.1"
 tokio-tungstenite = { version = "0.26.1", optional = true, default-features = false }
 hmac = { version = "0.12", optional = true, default-features = false}
 sha2 = { version = "0.10", optional = true, default-features = false }

async-openai/src/admin_api_keys.rs

@@ -6,19 +6,23 @@ use crate::{
     types::admin::api_keys::{
         AdminApiKey, AdminApiKeyDeleteResponse, ApiKeyList, CreateAdminApiKeyRequest,
     },
-    Client,
+    Client, RequestOptions,
 };
 
 /// Admin API keys enable Organization Owners to programmatically manage various aspects of their
 /// organization, including users, projects, and API keys. These keys provide administrative capabilities,
 /// allowing you to automate organization management tasks.
 pub struct AdminAPIKeys<'c, C: Config> {
     client: &'c Client<C>,
+    pub(crate) request_options: RequestOptions,
 }
 
 impl<'c, C: Config> AdminAPIKeys<'c, C> {
     pub fn new(client: &'c Client<C>) -> Self {
-        Self { client }
+        Self {
+            client,
+            request_options: RequestOptions::new(),
+        }
     }
 
     /// List all organization and project API keys.
@@ -28,7 +32,11 @@ impl<'c, C: Config> AdminAPIKeys<'c, C> {
         Q: Serialize + ?Sized,
     {
         self.client
-            .get_with_query("/organization/admin_api_keys", &query)
+            .get_with_query(
+                "/organization/admin_api_keys",
+                &query,
+                &self.request_options,
+            )
             .await
     }
 
@@ -38,23 +46,33 @@ impl<'c, C: Config> AdminAPIKeys<'c, C> {
         request: CreateAdminApiKeyRequest,
     ) -> Result<AdminApiKey, OpenAIError> {
         self.client
-            .post("/organization/admin_api_keys", request)
+            .post(
+                "/organization/admin_api_keys",
+                request,
+                &self.request_options,
+            )
             .await
     }
 
     /// Retrieve a single organization API key.
     #[crate::byot(T0 = std::fmt::Display, R = serde::de::DeserializeOwned)]
     pub async fn retrieve(&self, key_id: &str) -> Result<AdminApiKey, OpenAIError> {
         self.client
-            .get(format!("/organization/admin_api_keys/{key_id}").as_str())
+            .get(
+                format!("/organization/admin_api_keys/{key_id}").as_str(),
+                &self.request_options,
+            )
             .await
     }
 
     /// Delete an organization admin API key.
     #[crate::byot(T0 = std::fmt::Display, R = serde::de::DeserializeOwned)]
     pub async fn delete(&self, key_id: &str) -> Result<AdminApiKeyDeleteResponse, OpenAIError> {
         self.client
-            .delete(format!("/organization/admin_api_keys/{key_id}").as_str())
+            .delete(
+                format!("/organization/admin_api_keys/{key_id}").as_str(),
+                &self.request_options,
+            )
             .await
     }
 }

async-openai/src/assistants.rs

@@ -7,19 +7,23 @@ use crate::{
         AssistantObject, CreateAssistantRequest, DeleteAssistantResponse, ListAssistantsResponse,
         ModifyAssistantRequest,
     },
-    Client,
+    Client, RequestOptions,
 };
 
 /// Build assistants that can call models and use tools to perform tasks.
 ///
 /// [Get started with the Assistants API](https://platform.openai.com/docs/assistants)
 pub struct Assistants<'c, C: Config> {
     client: &'c Client<C>,
+    pub(crate) request_options: RequestOptions,
 }
 
 impl<'c, C: Config> Assistants<'c, C> {
     pub fn new(client: &'c Client<C>) -> Self {
-        Self { client }
+        Self {
+            client,
+            request_options: RequestOptions::new(),
+        }
     }
 
     /// Create an assistant with a model and instructions.
@@ -28,14 +32,14 @@ impl<'c, C: Config> Assistants<'c, C> {
         &self,
         request: CreateAssistantRequest,
     ) -> Result<AssistantObject, OpenAIError> {
-        self.client.post("/assistants", request).await
+        self.client.post("/assistants", request, &self.request_options).await
     }
 
     /// Retrieves an assistant.
     #[crate::byot(T0 = std::fmt::Display, R = serde::de::DeserializeOwned)]
     pub async fn retrieve(&self, assistant_id: &str) -> Result<AssistantObject, OpenAIError> {
         self.client
-            .get(&format!("/assistants/{assistant_id}"))
+            .get(&format!("/assistants/{assistant_id}"), &self.request_options)
             .await
     }
 
@@ -47,15 +51,15 @@ impl<'c, C: Config> Assistants<'c, C> {
         request: ModifyAssistantRequest,
     ) -> Result<AssistantObject, OpenAIError> {
         self.client
-            .post(&format!("/assistants/{assistant_id}"), request)
+            .post(&format!("/assistants/{assistant_id}"), request, &self.request_options)
             .await
     }
 
     /// Delete an assistant.
     #[crate::byot(T0 = std::fmt::Display, R = serde::de::DeserializeOwned)]
     pub async fn delete(&self, assistant_id: &str) -> Result<DeleteAssistantResponse, OpenAIError> {
         self.client
-            .delete(&format!("/assistants/{assistant_id}"))
+            .delete(&format!("/assistants/{assistant_id}"), &self.request_options)
             .await
     }
 
@@ -65,6 +69,6 @@ impl<'c, C: Config> Assistants<'c, C> {
     where
         Q: Serialize + ?Sized,
     {
-        self.client.get_with_query("/assistants", &query).await
+        self.client.get_with_query("/assistants", &query, &self.request_options).await
     }
 }

async-openai/src/audio.rs

@@ -1,14 +1,18 @@
-use crate::{config::Config, Client, Speech, Transcriptions, Translations};
+use crate::{config::Config, Client, RequestOptions, Speech, Transcriptions, Translations};
 
 /// Turn audio into text or text into audio.
 /// Related guide: [Speech to text](https://platform.openai.com/docs/guides/speech-to-text)
 pub struct Audio<'c, C: Config> {
     client: &'c Client<C>,
+    pub(crate) request_options: RequestOptions,
 }
 
 impl<'c, C: Config> Audio<'c, C> {
     pub fn new(client: &'c Client<C>) -> Self {
-        Self { client }
+        Self {
+            client,
+            request_options: RequestOptions::new(),
+        }
     }
 
     /// APIs in Speech group.

async-openai/src/audit_logs.rs

@@ -1,19 +1,23 @@
 use serde::Serialize;
 
 use crate::{
-    config::Config, error::OpenAIError, types::admin::audit_logs::ListAuditLogsResponse, Client,
+    config::Config, error::OpenAIError, types::admin::audit_logs::ListAuditLogsResponse, Client, RequestOptions,
 };
 
 /// Logs of user actions and configuration changes within this organization.
 /// To log events, you must activate logging in the [Organization Settings](https://platform.openai.com/settings/organization/general).
 /// Once activated, for security reasons, logging cannot be deactivated.
 pub struct AuditLogs<'c, C: Config> {
     client: &'c Client<C>,
+    pub(crate) request_options: RequestOptions,
 }
 
 impl<'c, C: Config> AuditLogs<'c, C> {
     pub fn new(client: &'c Client<C>) -> Self {
-        Self { client }
+        Self {
+            client,
+            request_options: RequestOptions::new(),
+        }
     }
 
     /// List user actions and configuration changes within this organization.
@@ -23,7 +27,7 @@ impl<'c, C: Config> AuditLogs<'c, C> {
         Q: Serialize + ?Sized,
     {
         self.client
-            .get_with_query("/organization/audit_logs", &query)
+            .get_with_query("/organization/audit_logs", &query, &self.request_options)
             .await
     }
 }

async-openai/src/batches.rs

@@ -4,25 +4,29 @@ use crate::{
     config::Config,
     error::OpenAIError,
     types::batches::{Batch, BatchRequest, ListBatchesResponse},
-    Client,
+    Client, RequestOptions,
 };
 
 /// Create large batches of API requests for asynchronous processing. The Batch API returns completions within 24 hours for a 50% discount.
 ///
 /// Related guide: [Batch](https://platform.openai.com/docs/guides/batch)
 pub struct Batches<'c, C: Config> {
     client: &'c Client<C>,
+    pub(crate) request_options: RequestOptions,
 }
 
 impl<'c, C: Config> Batches<'c, C> {
     pub fn new(client: &'c Client<C>) -> Self {
-        Self { client }
+        Self {
+            client,
+            request_options: RequestOptions::new(),
+        }
     }
 
     /// Creates and executes a batch from an uploaded file of requests
     #[crate::byot(T0 = serde::Serialize, R = serde::de::DeserializeOwned)]
     pub async fn create(&self, request: BatchRequest) -> Result<Batch, OpenAIError> {
-        self.client.post("/batches", request).await
+        self.client.post("/batches", request, &self.request_options).await
     }
 
     /// List your organization's batches.
@@ -31,13 +35,13 @@ impl<'c, C: Config> Batches<'c, C> {
     where
         Q: Serialize + ?Sized,
     {
-        self.client.get_with_query("/batches", &query).await
+        self.client.get_with_query("/batches", &query, &self.request_options).await
     }
 
     /// Retrieves a batch.
     #[crate::byot(T0 = std::fmt::Display, R = serde::de::DeserializeOwned)]
     pub async fn retrieve(&self, batch_id: &str) -> Result<Batch, OpenAIError> {
-        self.client.get(&format!("/batches/{batch_id}")).await
+        self.client.get(&format!("/batches/{batch_id}"), &self.request_options).await
     }
 
     /// Cancels an in-progress batch. The batch will be in status `cancelling` for up to 10 minutes, before changing to `cancelled`, where it will have partial results (if any) available in the output file.
@@ -47,6 +51,7 @@ impl<'c, C: Config> Batches<'c, C> {
             .post(
                 &format!("/batches/{batch_id}/cancel"),
                 serde_json::json!({}),
+                &self.request_options,
             )
             .await
     }

async-openai/src/certificates.rs

@@ -7,18 +7,22 @@ use crate::{
         Certificate, DeleteCertificateResponse, ListCertificatesResponse, ModifyCertificateRequest,
         ToggleCertificatesRequest, UploadCertificateRequest,
     },
-    Client,
+    Client, RequestOptions,
 };
 
 /// Certificates enable Mutual TLS (mTLS) authentication for your organization.
 /// Manage certificates at the organization level.
 pub struct Certificates<'c, C: Config> {
     client: &'c Client<C>,
+    pub(crate) request_options: RequestOptions,
 }
 
 impl<'c, C: Config> Certificates<'c, C> {
     pub fn new(client: &'c Client<C>) -> Self {
-        Self { client }
+        Self {
+            client,
+            request_options: RequestOptions::new(),
+        }
     }
 
     // Organization-level certificate operations
@@ -33,7 +37,7 @@ impl<'c, C: Config> Certificates<'c, C> {
         Q: Serialize + ?Sized,
     {
         self.client
-            .get_with_query("/organization/certificates", &query)
+            .get_with_query("/organization/certificates", &query, &self.request_options)
             .await
     }
 
@@ -44,7 +48,7 @@ impl<'c, C: Config> Certificates<'c, C> {
         request: UploadCertificateRequest,
     ) -> Result<Certificate, OpenAIError> {
         self.client
-            .post("/organization/certificates", request)
+            .post("/organization/certificates", request, &self.request_options)
             .await
     }
 
@@ -55,7 +59,7 @@ impl<'c, C: Config> Certificates<'c, C> {
         request: ToggleCertificatesRequest,
     ) -> Result<ListCertificatesResponse, OpenAIError> {
         self.client
-            .post("/organization/certificates/activate", request)
+            .post("/organization/certificates/activate", request, &self.request_options)
             .await
     }
 
@@ -66,15 +70,15 @@ impl<'c, C: Config> Certificates<'c, C> {
         request: ToggleCertificatesRequest,
     ) -> Result<ListCertificatesResponse, OpenAIError> {
         self.client
-            .post("/organization/certificates/deactivate", request)
+            .post("/organization/certificates/deactivate", request, &self.request_options)
             .await
     }
 
     /// Retrieve a single certificate.
     #[crate::byot(T0 = std::fmt::Display, R = serde::de::DeserializeOwned)]
     pub async fn retrieve(&self, certificate_id: &str) -> Result<Certificate, OpenAIError> {
         self.client
-            .get(format!("/organization/certificates/{certificate_id}").as_str())
+            .get(format!("/organization/certificates/{certificate_id}").as_str(), &self.request_options)
             .await
     }
 
@@ -91,6 +95,7 @@ impl<'c, C: Config> Certificates<'c, C> {
             .get_with_query(
                 format!("/organization/certificates/{certificate_id}").as_str(),
                 query,
+                &self.request_options,
             )
             .await
     }
@@ -106,6 +111,7 @@ impl<'c, C: Config> Certificates<'c, C> {
             .post(
                 format!("/organization/certificates/{certificate_id}").as_str(),
                 request,
+                &self.request_options,
             )
             .await
     }
@@ -118,7 +124,7 @@ impl<'c, C: Config> Certificates<'c, C> {
         certificate_id: &str,
     ) -> Result<DeleteCertificateResponse, OpenAIError> {
         self.client
-            .delete(format!("/organization/certificates/{certificate_id}").as_str())
+            .delete(format!("/organization/certificates/{certificate_id}").as_str(), &self.request_options)
             .await
     }
 }