diff --git a/Cargo.toml b/Cargo.toml
index 433f32af..c0601e7f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,7 +1,7 @@
[workspace]
-members = [ "async-openai", "async-openai-*", "examples/*" ]
+members = [ "clia-async-openai", "async-openai", "async-openai-*", "examples/*" ]
# Only check / build main crates by default (check all with `--workspace`)
-default-members = ["async-openai", "async-openai-*"]
+default-members = ["clia-async-openai", "async-openai", "async-openai-*"]
resolver = "2"
[workspace.package]
diff --git a/clia-async-openai/Cargo.toml b/clia-async-openai/Cargo.toml
new file mode 100644
index 00000000..253cbe0a
--- /dev/null
+++ b/clia-async-openai/Cargo.toml
@@ -0,0 +1,65 @@
+[package]
+name = "clia-async-openai"
+version = "0.28.0"
+authors = ["Himanshu Neema"]
+categories = ["api-bindings", "web-programming", "asynchronous"]
+keywords = ["openai", "async", "openapi", "ai"]
+description = "Rust library for OpenAI (with rustls)"
+edition = "2021"
+rust-version = { workspace = true }
+license = "MIT"
+readme = "README.md"
+homepage = "https://github.com/64bit/async-openai"
+repository = "https://github.com/clia-mod/async-openai"
+
+[features]
+default = ["rustls-webpki-roots"]
+# Enable rustls for TLS support
+rustls = ["reqwest/rustls-tls-native-roots"]
+# Enable rustls and webpki-roots
+rustls-webpki-roots = ["reqwest/rustls-tls-webpki-roots"]
+# Enable native-tls for TLS support
+native-tls = ["reqwest/native-tls"]
+# Remove dependency on OpenSSL
+native-tls-vendored = ["reqwest/native-tls-vendored"]
+realtime = ["dep:tokio-tungstenite"]
+# Bring your own types
+byot = []
+
+[dependencies]
+async-openai-macros = { path = "../async-openai-macros", version = "0.1.0" }
+backoff = { version = "0.4.0", features = ["tokio"] }
+base64 = "0.22.1"
+futures = "0.3.31"
+rand = "0.8.5"
+reqwest = { version = "0.12.12", features = [
+ "json",
+ "stream",
+ "multipart",
+ "rustls-tls"
+], default-features = false }
+reqwest-eventsource = "0.6.0"
+serde = { version = "1.0.217", features = ["derive", "rc"] }
+serde_json = "1.0.135"
+thiserror = "2.0.11"
+tokio = { version = "1.43.0", features = ["fs", "macros"] }
+tokio-stream = "0.1.17"
+tokio-util = { version = "0.7.13", features = ["codec", "io-util"] }
+tracing = "0.1.41"
+derive_builder = "0.20.2"
+secrecy = { version = "0.10.3", features = ["serde"] }
+bytes = "1.9.0"
+eventsource-stream = "0.2.3"
+tokio-tungstenite = { version = "0.26.1", optional = true, default-features = false }
+
+[dev-dependencies]
+tokio-test = "0.4.4"
+serde_json = "1.0"
+
+[[test]]
+name = "bring-your-own-type"
+required-features = ["byot"]
+
+[package.metadata.docs.rs]
+all-features = true
+rustdoc-args = ["--cfg", "docsrs"]
diff --git a/clia-async-openai/README.md b/clia-async-openai/README.md
new file mode 100644
index 00000000..cd2abd5b
--- /dev/null
+++ b/clia-async-openai/README.md
@@ -0,0 +1,169 @@
+
+ async-openai
+ Async Rust library for OpenAI
+
+
+
+## Overview
+
+`async-openai` is an unofficial Rust library for OpenAI.
+
+- It's based on [OpenAI OpenAPI spec](https://github.com/openai/openai-openapi)
+- Current features:
+ - [x] Assistants (v2)
+ - [x] Audio
+ - [x] Batch
+ - [x] Chat
+ - [x] Completions (Legacy)
+ - [x] Embeddings
+ - [x] Files
+ - [x] Fine-Tuning
+ - [x] Images
+ - [x] Models
+ - [x] Moderations
+ - [x] Organizations | Administration (partially implemented)
+ - [x] Realtime (Beta) (partially implemented)
+ - [x] Uploads
+- Bring your own custom types for Request or Response objects.
+- SSE streaming on available APIs
+- Requests (except SSE streaming) including form submissions are retried with exponential backoff when [rate limited](https://platform.openai.com/docs/guides/rate-limits).
+- Ergonomic builder pattern for all request objects.
+- Microsoft Azure OpenAI Service (only for APIs matching OpenAI spec)
+
+## Usage
+
+The library reads [API key](https://platform.openai.com/account/api-keys) from the environment variable `OPENAI_API_KEY`.
+
+```bash
+# On macOS/Linux
+export OPENAI_API_KEY='sk-...'
+```
+
+```powershell
+# On Windows Powershell
+$Env:OPENAI_API_KEY='sk-...'
+```
+
+- Visit [examples](https://github.com/64bit/async-openai/tree/main/examples) directory on how to use `async-openai`.
+- Visit [docs.rs/async-openai](https://docs.rs/async-openai) for docs.
+
+## Realtime API
+
+Only types for Realtime API are implemented, and can be enabled with feature flag `realtime`.
+These types were written before OpenAI released official specs.
+
+## Image Generation Example
+
+```rust
+use async_openai::{
+ types::{CreateImageRequestArgs, ImageSize, ImageResponseFormat},
+ Client,
+};
+use std::error::Error;
+
+#[tokio::main]
+async fn main() -> Result<(), Box> {
+ // create client, reads OPENAI_API_KEY environment variable for API key.
+ let client = Client::new();
+
+ let request = CreateImageRequestArgs::default()
+ .prompt("cats on sofa and carpet in living room")
+ .n(2)
+ .response_format(ImageResponseFormat::Url)
+ .size(ImageSize::S256x256)
+ .user("async-openai")
+ .build()?;
+
+ let response = client.images().create(request).await?;
+
+ // Download and save images to ./data directory.
+ // Each url is downloaded and saved in dedicated Tokio task.
+ // Directory is created if it doesn't exist.
+ let paths = response.save("./data").await?;
+
+ paths
+ .iter()
+ .for_each(|path| println!("Image file path: {}", path.display()));
+
+ Ok(())
+}
+```
+
+
+
+
+
+
Scaled up for README, actual size 256x256
+
(&self, query: &Q) -> Result
+ where
+ Q: Serialize + ?Sized,
+ {
+ self.client.get_with_query("/assistants", &query).await
+ }
+}
diff --git a/clia-async-openai/src/audio.rs b/clia-async-openai/src/audio.rs
new file mode 100644
index 00000000..1ee4631d
--- /dev/null
+++ b/clia-async-openai/src/audio.rs
@@ -0,0 +1,111 @@
+use bytes::Bytes;
+
+use crate::{
+ config::Config,
+ error::OpenAIError,
+ types::{
+ CreateSpeechRequest, CreateSpeechResponse, CreateTranscriptionRequest,
+ CreateTranscriptionResponseJson, CreateTranscriptionResponseVerboseJson,
+ CreateTranslationRequest, CreateTranslationResponseJson,
+ CreateTranslationResponseVerboseJson,
+ },
+ Client,
+};
+
+/// 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,
+}
+
+impl<'c, C: Config> Audio<'c, C> {
+ pub fn new(client: &'c Client) -> Self {
+ Self { client }
+ }
+
+ /// Transcribes audio into the input language.
+ #[crate::byot(
+ T0 = Clone,
+ R = serde::de::DeserializeOwned,
+ where_clause = "reqwest::multipart::Form: crate::traits::AsyncTryFrom",
+ )]
+ pub async fn transcribe(
+ &self,
+ request: CreateTranscriptionRequest,
+ ) -> Result {
+ self.client
+ .post_form("/audio/transcriptions", request)
+ .await
+ }
+
+ /// Transcribes audio into the input language.
+ #[crate::byot(
+ T0 = Clone,
+ R = serde::de::DeserializeOwned,
+ where_clause = "reqwest::multipart::Form: crate::traits::AsyncTryFrom",
+ )]
+ pub async fn transcribe_verbose_json(
+ &self,
+ request: CreateTranscriptionRequest,
+ ) -> Result {
+ self.client
+ .post_form("/audio/transcriptions", request)
+ .await
+ }
+
+ /// Transcribes audio into the input language.
+ pub async fn transcribe_raw(
+ &self,
+ request: CreateTranscriptionRequest,
+ ) -> Result {
+ self.client
+ .post_form_raw("/audio/transcriptions", request)
+ .await
+ }
+
+ /// Translates audio into English.
+ #[crate::byot(
+ T0 = Clone,
+ R = serde::de::DeserializeOwned,
+ where_clause = "reqwest::multipart::Form: crate::traits::AsyncTryFrom",
+ )]
+ pub async fn translate(
+ &self,
+ request: CreateTranslationRequest,
+ ) -> Result {
+ self.client.post_form("/audio/translations", request).await
+ }
+
+ /// Translates audio into English.
+ #[crate::byot(
+ T0 = Clone,
+ R = serde::de::DeserializeOwned,
+ where_clause = "reqwest::multipart::Form: crate::traits::AsyncTryFrom",
+ )]
+ pub async fn translate_verbose_json(
+ &self,
+ request: CreateTranslationRequest,
+ ) -> Result {
+ self.client.post_form("/audio/translations", request).await
+ }
+
+ /// Transcribes audio into the input language.
+ pub async fn translate_raw(
+ &self,
+ request: CreateTranslationRequest,
+ ) -> Result {
+ self.client
+ .post_form_raw("/audio/translations", request)
+ .await
+ }
+
+ /// Generates audio from the input text.
+ pub async fn speech(
+ &self,
+ request: CreateSpeechRequest,
+ ) -> Result {
+ let bytes = self.client.post_raw("/audio/speech", request).await?;
+
+ Ok(CreateSpeechResponse { bytes })
+ }
+}
diff --git a/clia-async-openai/src/audit_logs.rs b/clia-async-openai/src/audit_logs.rs
new file mode 100644
index 00000000..753c318b
--- /dev/null
+++ b/clia-async-openai/src/audit_logs.rs
@@ -0,0 +1,27 @@
+use serde::Serialize;
+
+use crate::{config::Config, error::OpenAIError, types::ListAuditLogsResponse, Client};
+
+/// 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,
+}
+
+impl<'c, C: Config> AuditLogs<'c, C> {
+ pub fn new(client: &'c Client) -> Self {
+ Self { client }
+ }
+
+ /// List user actions and configuration changes within this organization.
+ #[crate::byot(T0 = serde::Serialize, R = serde::de::DeserializeOwned)]
+ pub async fn get(&self, query: &Q) -> Result
+ where
+ Q: Serialize + ?Sized,
+ {
+ self.client
+ .get_with_query("/organization/audit_logs", &query)
+ .await
+ }
+}
diff --git a/clia-async-openai/src/batches.rs b/clia-async-openai/src/batches.rs
new file mode 100644
index 00000000..57910490
--- /dev/null
+++ b/clia-async-openai/src/batches.rs
@@ -0,0 +1,53 @@
+use serde::Serialize;
+
+use crate::{
+ config::Config,
+ error::OpenAIError,
+ types::{Batch, BatchRequest, ListBatchesResponse},
+ Client,
+};
+
+/// 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,
+}
+
+impl<'c, C: Config> Batches<'c, C> {
+ pub fn new(client: &'c Client) -> Self {
+ Self { client }
+ }
+
+ /// 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 {
+ self.client.post("/batches", request).await
+ }
+
+ /// List your organization's batches.
+ #[crate::byot(T0 = serde::Serialize, R = serde::de::DeserializeOwned)]
+ pub async fn list(&self, query: &Q) -> Result
+ where
+ Q: Serialize + ?Sized,
+ {
+ self.client.get_with_query("/batches", &query).await
+ }
+
+ /// Retrieves a batch.
+ #[crate::byot(T0 = std::fmt::Display, R = serde::de::DeserializeOwned)]
+ pub async fn retrieve(&self, batch_id: &str) -> Result {
+ self.client.get(&format!("/batches/{batch_id}")).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.
+ #[crate::byot(T0 = std::fmt::Display, R = serde::de::DeserializeOwned)]
+ pub async fn cancel(&self, batch_id: &str) -> Result {
+ self.client
+ .post(
+ &format!("/batches/{batch_id}/cancel"),
+ serde_json::json!({}),
+ )
+ .await
+ }
+}
diff --git a/clia-async-openai/src/chat.rs b/clia-async-openai/src/chat.rs
new file mode 100644
index 00000000..28c89f9d
--- /dev/null
+++ b/clia-async-openai/src/chat.rs
@@ -0,0 +1,88 @@
+use crate::{
+ config::Config,
+ error::OpenAIError,
+ types::{
+ ChatCompletionResponseStream, CreateChatCompletionRequest, CreateChatCompletionResponse,
+ },
+ Client,
+};
+
+/// Given a list of messages comprising a conversation, the model will return a response.
+///
+/// Related guide: [Chat completions](https://platform.openai.com//docs/guides/text-generation)
+pub struct Chat<'c, C: Config> {
+ client: &'c Client,
+}
+
+impl<'c, C: Config> Chat<'c, C> {
+ pub fn new(client: &'c Client) -> Self {
+ Self { client }
+ }
+
+ /// Creates a model response for the given chat conversation. Learn more in
+ /// the
+ ///
+ /// [text generation](https://platform.openai.com/docs/guides/text-generation),
+ /// [vision](https://platform.openai.com/docs/guides/vision),
+ ///
+ /// and [audio](https://platform.openai.com/docs/guides/audio) guides.
+ ///
+ ///
+ /// Parameter support can differ depending on the model used to generate the
+ /// response, particularly for newer reasoning models. Parameters that are
+ /// only supported for reasoning models are noted below. For the current state
+ /// of unsupported parameters in reasoning models,
+ ///
+ /// [refer to the reasoning guide](https://platform.openai.com/docs/guides/reasoning).
+ ///
+ /// byot: You must ensure "stream: false" in serialized `request`
+ #[crate::byot(
+ T0 = serde::Serialize,
+ R = serde::de::DeserializeOwned
+ )]
+ pub async fn create(
+ &self,
+ request: CreateChatCompletionRequest,
+ ) -> Result {
+ #[cfg(not(feature = "byot"))]
+ {
+ if request.stream.is_some() && request.stream.unwrap() {
+ return Err(OpenAIError::InvalidArgument(
+ "When stream is true, use Chat::create_stream".into(),
+ ));
+ }
+ }
+ self.client.post("/chat/completions", request).await
+ }
+
+ /// Creates a completion for the chat message
+ ///
+ /// partial message deltas will be sent, like in ChatGPT. Tokens will be sent as data-only [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format) as they become available, with the stream terminated by a `data: [DONE]` message.
+ ///
+ /// [ChatCompletionResponseStream] is a parsed SSE stream until a \[DONE\] is received from server.
+ ///
+ /// byot: You must ensure "stream: true" in serialized `request`
+ #[crate::byot(
+ T0 = serde::Serialize,
+ R = serde::de::DeserializeOwned,
+ stream = "true",
+ where_clause = "R: std::marker::Send + 'static"
+ )]
+ #[allow(unused_mut)]
+ pub async fn create_stream(
+ &self,
+ mut request: CreateChatCompletionRequest,
+ ) -> Result {
+ #[cfg(not(feature = "byot"))]
+ {
+ if request.stream.is_some() && !request.stream.unwrap() {
+ return Err(OpenAIError::InvalidArgument(
+ "When stream is false, use Chat::create".into(),
+ ));
+ }
+
+ request.stream = Some(true);
+ }
+ Ok(self.client.post_stream("/chat/completions", request).await)
+ }
+}
diff --git a/clia-async-openai/src/client.rs b/clia-async-openai/src/client.rs
new file mode 100644
index 00000000..11046817
--- /dev/null
+++ b/clia-async-openai/src/client.rs
@@ -0,0 +1,546 @@
+use std::pin::Pin;
+
+use bytes::Bytes;
+use futures::{stream::StreamExt, Stream};
+use reqwest::multipart::Form;
+use reqwest_eventsource::{Event, EventSource, RequestBuilderExt};
+use serde::{de::DeserializeOwned, Serialize};
+
+use crate::{
+ config::{Config, OpenAIConfig},
+ error::{map_deserialization_error, OpenAIError, WrappedError},
+ file::Files,
+ image::Images,
+ moderation::Moderations,
+ traits::AsyncTryFrom,
+ Assistants, Audio, AuditLogs, Batches, Chat, Completions, Embeddings, FineTuning, Invites,
+ Models, Projects, Threads, Uploads, Users, VectorStores,
+};
+
+#[derive(Debug, Clone, Default)]
+/// Client is a container for config, backoff and http_client
+/// used to make API calls.
+pub struct Client {
+ http_client: reqwest::Client,
+ config: C,
+ backoff: backoff::ExponentialBackoff,
+}
+
+impl Client {
+ /// Client with default [OpenAIConfig]
+ pub fn new() -> Self {
+ Self::default()
+ }
+}
+
+impl Client {
+ /// Create client with a custom HTTP client, OpenAI config, and backoff.
+ pub fn build(
+ http_client: reqwest::Client,
+ config: C,
+ backoff: backoff::ExponentialBackoff,
+ ) -> Self {
+ Self {
+ http_client,
+ config,
+ backoff,
+ }
+ }
+
+ /// Create client with [OpenAIConfig] or [crate::config::AzureConfig]
+ pub fn with_config(config: C) -> Self {
+ Self {
+ http_client: reqwest::Client::new(),
+ config,
+ backoff: Default::default(),
+ }
+ }
+
+ /// Provide your own [client] to make HTTP requests with.
+ ///
+ /// [client]: reqwest::Client
+ pub fn with_http_client(mut self, http_client: reqwest::Client) -> Self {
+ self.http_client = http_client;
+ self
+ }
+
+ /// Exponential backoff for retrying [rate limited](https://platform.openai.com/docs/guides/rate-limits) requests.
+ pub fn with_backoff(mut self, backoff: backoff::ExponentialBackoff) -> Self {
+ self.backoff = backoff;
+ self
+ }
+
+ // API groups
+
+ /// To call [Models] group related APIs using this client.
+ pub fn models(&self) -> Models {
+ Models::new(self)
+ }
+
+ /// To call [Completions] group related APIs using this client.
+ pub fn completions(&self) -> Completions {
+ Completions::new(self)
+ }
+
+ /// To call [Chat] group related APIs using this client.
+ pub fn chat(&self) -> Chat {
+ Chat::new(self)
+ }
+
+ /// To call [Images] group related APIs using this client.
+ pub fn images(&self) -> Images {
+ Images::new(self)
+ }
+
+ /// To call [Moderations] group related APIs using this client.
+ pub fn moderations(&self) -> Moderations {
+ Moderations::new(self)
+ }
+
+ /// To call [Files] group related APIs using this client.
+ pub fn files(&self) -> Files {
+ Files::new(self)
+ }
+
+ /// To call [Uploads] group related APIs using this client.
+ pub fn uploads(&self) -> Uploads {
+ Uploads::new(self)
+ }
+
+ /// To call [FineTuning] group related APIs using this client.
+ pub fn fine_tuning(&self) -> FineTuning {
+ FineTuning::new(self)
+ }
+
+ /// To call [Embeddings] group related APIs using this client.
+ pub fn embeddings(&self) -> Embeddings {
+ Embeddings::new(self)
+ }
+
+ /// To call [Audio] group related APIs using this client.
+ pub fn audio(&self) -> Audio {
+ Audio::new(self)
+ }
+
+ /// To call [Assistants] group related APIs using this client.
+ pub fn assistants(&self) -> Assistants {
+ Assistants::new(self)
+ }
+
+ /// To call [Threads] group related APIs using this client.
+ pub fn threads(&self) -> Threads {
+ Threads::new(self)
+ }
+
+ /// To call [VectorStores] group related APIs using this client.
+ pub fn vector_stores(&self) -> VectorStores {
+ VectorStores::new(self)
+ }
+
+ /// To call [Batches] group related APIs using this client.
+ pub fn batches(&self) -> Batches {
+ Batches::new(self)
+ }
+
+ /// To call [AuditLogs] group related APIs using this client.
+ pub fn audit_logs(&self) -> AuditLogs {
+ AuditLogs::new(self)
+ }
+
+ /// To call [Invites] group related APIs using this client.
+ pub fn invites(&self) -> Invites {
+ Invites::new(self)
+ }
+
+ /// To call [Users] group related APIs using this client.
+ pub fn users(&self) -> Users {
+ Users::new(self)
+ }
+
+ /// To call [Projects] group related APIs using this client.
+ pub fn projects(&self) -> Projects {
+ Projects::new(self)
+ }
+
+ pub fn config(&self) -> &C {
+ &self.config
+ }
+
+ /// Make a GET request to {path} and deserialize the response body
+ pub(crate) async fn get(&self, path: &str) -> Result
+ where
+ O: DeserializeOwned,
+ {
+ let request_maker = || async {
+ Ok(self
+ .http_client
+ .get(self.config.url(path))
+ .query(&self.config.query())
+ .headers(self.config.headers())
+ .build()?)
+ };
+
+ self.execute(request_maker).await
+ }
+
+ /// Make a GET request to {path} with given Query and deserialize the response body
+ pub(crate) async fn get_with_query(&self, path: &str, query: &Q) -> Result
+ where
+ O: DeserializeOwned,
+ Q: Serialize + ?Sized,
+ {
+ let request_maker = || async {
+ Ok(self
+ .http_client
+ .get(self.config.url(path))
+ .query(&self.config.query())
+ .query(query)
+ .headers(self.config.headers())
+ .build()?)
+ };
+
+ self.execute(request_maker).await
+ }
+
+ /// Make a DELETE request to {path} and deserialize the response body
+ pub(crate) async fn delete(&self, path: &str) -> Result
+ where
+ O: DeserializeOwned,
+ {
+ let request_maker = || async {
+ Ok(self
+ .http_client
+ .delete(self.config.url(path))
+ .query(&self.config.query())
+ .headers(self.config.headers())
+ .build()?)
+ };
+
+ self.execute(request_maker).await
+ }
+
+ /// Make a GET request to {path} and return the response body
+ pub(crate) async fn get_raw(&self, path: &str) -> Result {
+ let request_maker = || async {
+ Ok(self
+ .http_client
+ .get(self.config.url(path))
+ .query(&self.config.query())
+ .headers(self.config.headers())
+ .build()?)
+ };
+
+ self.execute_raw(request_maker).await
+ }
+
+ /// Make a POST request to {path} and return the response body
+ pub(crate) async fn post_raw(&self, path: &str, request: I) -> Result
+ where
+ I: Serialize,
+ {
+ let request_maker = || async {
+ Ok(self
+ .http_client
+ .post(self.config.url(path))
+ .query(&self.config.query())
+ .headers(self.config.headers())
+ .json(&request)
+ .build()?)
+ };
+
+ self.execute_raw(request_maker).await
+ }
+
+ /// Make a POST request to {path} and deserialize the response body
+ pub(crate) async fn post(&self, path: &str, request: I) -> Result
+ where
+ I: Serialize,
+ O: DeserializeOwned,
+ {
+ let request_maker = || async {
+ Ok(self
+ .http_client
+ .post(self.config.url(path))
+ .query(&self.config.query())
+ .headers(self.config.headers())
+ .json(&request)
+ .build()?)
+ };
+
+ self.execute(request_maker).await
+ }
+
+ /// POST a form at {path} and return the response body
+ pub(crate) async fn post_form_raw(&self, path: &str, form: F) -> Result
+ where
+ Form: AsyncTryFrom,
+ F: Clone,
+ {
+ let request_maker = || async {
+ Ok(self
+ .http_client
+ .post(self.config.url(path))
+ .query(&self.config.query())
+ .headers(self.config.headers())
+ .multipart(
+
+
+ 
+