ci(release): v0.5.0

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

.github/workflows/test.yml

@@ -22,7 +22,7 @@ jobs:
         env:
           MISTRAL_API_KEY: ${{ secrets.MISTRAL_API_KEY }}
       - name: Upload tests coverage
-        uses: codecov/codecov-action@v3
+        uses: codecov/codecov-action@v4
         with:
           fail_ci_if_error: true
           token: ${{ secrets.CODECOV_TOKEN }}

CHANGELOG.md

@@ -1,3 +1,11 @@
+## [0.5.0](https://github.com/ivangabriele/mistralai-client-rs/compare/v0.4.0...v) (2024-03-04)
+
+
+### Features
+
+* add client.embeddings_async() method ([3c22891](https://github.com/ivangabriele/mistralai-client-rs/commit/3c228914f78b0edd4a592091265b88d0bc55568b))
+* add client.list_models_async() method ([b69f7c6](https://github.com/ivangabriele/mistralai-client-rs/commit/b69f7c617c15dd63abb61d004636512916d766bb))
+
 ## [0.4.0](https://github.com/ivangabriele/mistralai-client-rs/compare/v0.3.0...v) (2024-03-04)
 
 

Cargo.toml

@@ -2,7 +2,7 @@
 name = "mistralai-client"
 description = "Mistral AI API client library for Rust (unofficial)."
 license = "Apache-2.0"
-version = "0.4.0"
+version = "0.5.0"
 
 edition = "2021"
 rust-version = "1.76.0"
@@ -15,8 +15,7 @@ readme = "README.md"
 repository = "https://github.com/ivangabriele/mistralai-client-rs"
 
 [dependencies]
-minreq = { version = "2.11.0", features = ["https-rustls", "json-using-serde"] }
+reqwest = { version = "0.11.24", features = ["json", "blocking"] }
-reqwest = { version = "0.11.24", features = ["json"] }
 serde = { version = "1.0.197", features = ["derive"] }
 serde_json = "1.0.114"
 thiserror = "1.0.57"

README.md

@@ -31,9 +31,9 @@ Rust client for the Mistral AI API.
 - [x] Chat without streaming (async)
 - [ ] Chat with streaming
 - [x] Embedding
-- [ ] Embedding (async)
+- [x] Embedding (async)
 - [x] List models
-- [ ] List models (async)
+- [x] List models (async)
 - [ ] Function Calling
 - [ ] Function Calling (async)
 
@@ -122,7 +122,7 @@ async fn main() {
         ..Default::default()
     };
 
-    let result = client.chat(model, messages, Some(options)).await.unwrap();
+    let result = client.chat_async(model, messages, Some(options)).await.unwrap();
     println!("Assistant: {}", result.choices[0].message.content);
     // => "Assistant: Tower. [...]"
 }
@@ -156,7 +156,26 @@ fn main() {
 
 ### Embeddings (async)
 
-_In progress._
+```rs
+use mistralai_client::v1::{client::Client, constants::EmbedModel};
+
+#[tokio::main]
+async fn main() {
+    // This example suppose you have set the `MISTRAL_API_KEY` environment variable.
+  let client: Client = Client::new(None, None, None, None).unwrap();
+
+  let model = EmbedModel::MistralEmbed;
+  let input = vec!["Embed this sentence.", "As well as this one."]
+      .iter()
+      .map(|s| s.to_string())
+      .collect();
+  let options = None;
+
+  let response = client.embeddings_async(model, input, options).await.unwrap();
+  println!("Embeddings: {:?}", response.data);
+  // => "Embeddings: [{...}, {...}]"
+}
+```
 
 ### List models
 
@@ -175,4 +194,16 @@ fn main() {
 
 ### List models (async)
 
-_In progress._
+```rs
+use mistralai_client::v1::client::Client;
+
+#[tokio::main]
+async fn main() {
+    // This example suppose you have set the `MISTRAL_API_KEY` environment variable.
+    let client = Client::new(None, None, None, None).await.unwrap();
+
+    let result = client.list_models_async().unwrap();
+    println!("First Model ID: {:?}", result.data[0].id);
+    // => "First Model ID: open-mistral-7b"
+}
+```

src/v1/client.rs

@@ -1,6 +1,5 @@
 use crate::v1::error::ApiError;
-use minreq::Response;
+use reqwest::Error as ReqwestError;
-use reqwest::{Client as ReqwestClient, Error as ReqwestError};
 
 use crate::v1::{
     chat_completion::{
@@ -42,78 +41,6 @@ impl Client {
         })
     }
 
-    pub fn build_request(&self, request: minreq::Request) -> minreq::Request {
-        let authorization = format!("Bearer {}", self.api_key);
-        let user_agent = format!(
-            "ivangabriele/mistralai-client-rs/{}",
-            env!("CARGO_PKG_VERSION")
-        );
-
-        let request = request
-            .with_header("Authorization", authorization)
-            .with_header("Accept", "application/json")
-            .with_header("Content-Type", "application/json")
-            .with_header("User-Agent", user_agent);
-
-        request
-    }
-
-    pub fn get_sync(&self, path: &str) -> Result<Response, ApiError> {
-        let url = format!("{}{}", self.endpoint, path);
-        let request = self.build_request(minreq::get(url));
-
-        let result = request.send();
-        match result {
-            Ok(response) => {
-                print!("{:?}", response.as_str().unwrap());
-
-                if (200..=299).contains(&response.status_code) {
-                    Ok(response)
-                } else {
-                    Err(ApiError {
-                        message: format!(
-                            "{}: {}",
-                            response.status_code,
-                            response.as_str().unwrap()
-                        ),
-                    })
-                }
-            }
-            Err(error) => Err(self.new_minreq_error(error)),
-        }
-    }
-
-    pub fn post_sync<T: serde::ser::Serialize + std::fmt::Debug>(
-        &self,
-        path: &str,
-        params: &T,
-    ) -> Result<Response, ApiError> {
-        // print!("{:?}", params);
-
-        let url = format!("{}{}", self.endpoint, path);
-        let request = self.build_request(minreq::post(url));
-
-        let result = request.with_json(params).unwrap().send();
-        match result {
-            Ok(response) => {
-                print!("{:?}", response.as_str().unwrap());
-
-                if (200..=299).contains(&response.status_code) {
-                    Ok(response)
-                } else {
-                    Err(ApiError {
-                        message: format!(
-                            "{}: {}",
-                            response.status_code,
-                            response.as_str().unwrap()
-                        ),
-                    })
-                }
-            }
-            Err(error) => Err(self.new_minreq_error(error)),
-        }
-    }
-
     pub fn chat(
         &self,
         model: Model,
@@ -126,7 +53,7 @@ impl Client {
         let result = response.json::<ChatCompletionResponse>();
         match result {
             Ok(response) => Ok(response),
-            Err(error) => Err(self.new_minreq_error(error)),
+            Err(error) => Err(self.to_api_error(error)),
         }
     }
 
@@ -137,31 +64,12 @@ impl Client {
         options: Option<ChatCompletionParams>,
     ) -> Result<ChatCompletionResponse, ApiError> {
         let request = ChatCompletionRequest::new(model, messages, options);
-        let client = ReqwestClient::new();
 
-        let response = client
+        let response = self.post_async("/chat/completions", &request).await?;
-            .post(format!("{}{}", self.endpoint, "/chat/completions"))
+        let result = response.json::<ChatCompletionResponse>().await;
-            .json(&request)
+        match result {
-            .bearer_auth(&self.api_key)
+            Ok(response) => Ok(response),
-            .header(
+            Err(error) => Err(self.to_api_error(error)),
-                "User-Agent",
-                format!("mistralai-client-rs/{}", env!("CARGO_PKG_VERSION")),
-            )
-            .send()
-            .await
-            .map_err(|e| self.new_reqwest_error(e))?;
-
-        if response.status().is_success() {
-            response
-                .json::<ChatCompletionResponse>()
-                .await
-                .map_err(|e| self.new_reqwest_error(e))
-        } else {
-            let status = response.status();
-            let text = response.text().await.unwrap_or_default();
-            Err(ApiError {
-                message: format!("{}: {}", status, text),
-            })
         }
     }
 
@@ -177,7 +85,23 @@ impl Client {
         let result = response.json::<EmbeddingResponse>();
         match result {
             Ok(response) => Ok(response),
-            Err(error) => Err(self.new_minreq_error(error)),
+            Err(error) => Err(self.to_api_error(error)),
+        }
+    }
+
+    pub async fn embeddings_async(
+        &self,
+        model: EmbedModel,
+        input: Vec<String>,
+        options: Option<EmbeddingRequestOptions>,
+    ) -> Result<EmbeddingResponse, ApiError> {
+        let request = EmbeddingRequest::new(model, input, options);
+
+        let response = self.post_async("/embeddings", &request).await?;
+        let result = response.json::<EmbeddingResponse>().await;
+        match result {
+            Ok(response) => Ok(response),
+            Err(error) => Err(self.to_api_error(error)),
         }
     }
 
@@ -186,17 +110,160 @@ impl Client {
         let result = response.json::<ModelListResponse>();
         match result {
             Ok(response) => Ok(response),
-            Err(error) => Err(self.new_minreq_error(error)),
+            Err(error) => Err(self.to_api_error(error)),
         }
     }
 
-    fn new_minreq_error(&self, err: minreq::Error) -> ApiError {
+    pub async fn list_models_async(&self) -> Result<ModelListResponse, ApiError> {
-        ApiError {
+        let response = self.get_async("/models").await?;
-            message: err.to_string(),
+        let result = response.json::<ModelListResponse>().await;
+        match result {
+            Ok(response) => Ok(response),
+            Err(error) => Err(self.to_api_error(error)),
         }
     }
 
-    fn new_reqwest_error(&self, err: ReqwestError) -> ApiError {
+    fn build_request_sync(
+        &self,
+        request: reqwest::blocking::RequestBuilder,
+    ) -> reqwest::blocking::RequestBuilder {
+        let user_agent = format!(
+            "ivangabriele/mistralai-client-rs/{}",
+            env!("CARGO_PKG_VERSION")
+        );
+
+        let request_builder = request
+            .bearer_auth(&self.api_key)
+            .header("Accept", "application/json")
+            .header("Content-Type", "application/json")
+            .header("User-Agent", user_agent);
+
+        request_builder
+    }
+
+    fn build_request_async(&self, request: reqwest::RequestBuilder) -> reqwest::RequestBuilder {
+        let user_agent = format!(
+            "ivangabriele/mistralai-client-rs/{}",
+            env!("CARGO_PKG_VERSION")
+        );
+
+        let request_builder = request
+            .bearer_auth(&self.api_key)
+            .header("Accept", "application/json")
+            .header("Content-Type", "application/json")
+            .header("User-Agent", user_agent);
+
+        request_builder
+    }
+
+    fn get_sync(&self, path: &str) -> Result<reqwest::blocking::Response, ApiError> {
+        let client_sync = reqwest::blocking::Client::new();
+        let url = format!("{}{}", self.endpoint, path);
+        let request = self.build_request_sync(client_sync.get(url));
+
+        let result = request.send();
+        match result {
+            Ok(response) => {
+                if response.status().is_success() {
+                    Ok(response)
+                } else {
+                    let status = response.status();
+                    let text = response.text().unwrap();
+                    Err(ApiError {
+                        message: format!("{}: {}", status, text),
+                    })
+                }
+            }
+            Err(error) => Err(ApiError {
+                message: error.to_string(),
+            }),
+        }
+    }
+
+    async fn get_async(&self, path: &str) -> Result<reqwest::Response, ApiError> {
+        let reqwest_client = reqwest::Client::new();
+        let url = format!("{}{}", self.endpoint, path);
+        let request_builder = reqwest_client.get(url);
+        let request = self.build_request_async(request_builder);
+
+        let result = request.send().await.map_err(|e| self.to_api_error(e));
+        match result {
+            Ok(response) => {
+                if response.status().is_success() {
+                    Ok(response)
+                } else {
+                    let status = response.status();
+                    let text = response.text().await.unwrap_or_default();
+                    Err(ApiError {
+                        message: format!("{}: {}", status, text),
+                    })
+                }
+            }
+            Err(error) => Err(ApiError {
+                message: error.to_string(),
+            }),
+        }
+    }
+
+    fn post_sync<T: serde::ser::Serialize + std::fmt::Debug>(
+        &self,
+        path: &str,
+        params: &T,
+    ) -> Result<reqwest::blocking::Response, ApiError> {
+        let reqwest_client = reqwest::blocking::Client::new();
+        let url = format!("{}{}", self.endpoint, path);
+        let request_builder = reqwest_client.post(url).json(params);
+        let request = self.build_request_sync(request_builder);
+
+        let result = request.send();
+        match result {
+            Ok(response) => {
+                if response.status().is_success() {
+                    Ok(response)
+                } else {
+                    let status = response.status();
+                    let text = response.text().unwrap_or_default();
+                    Err(ApiError {
+                        message: format!("{}: {}", status, text),
+                    })
+                }
+            }
+            Err(error) => Err(ApiError {
+                message: error.to_string(),
+            }),
+        }
+    }
+
+    async fn post_async<T: serde::ser::Serialize + std::fmt::Debug>(
+        &self,
+        path: &str,
+        params: &T,
+    ) -> Result<reqwest::Response, ApiError> {
+        let reqwest_client = reqwest::Client::new();
+        let url = format!("{}{}", self.endpoint, path);
+        let request_builder = reqwest_client.post(url).json(params);
+        let request = self.build_request_async(request_builder);
+
+        let result = request.send().await.map_err(|e| self.to_api_error(e));
+        match result {
+            Ok(response) => {
+                if response.status().is_success() {
+                    Ok(response)
+                } else {
+                    let status = response.status();
+                    let text = response.text().await.unwrap_or_default();
+                    Err(ApiError {
+                        message: format!("{}: {}", status, text),
+                    })
+                }
+            }
+            Err(error) => Err(ApiError {
+                message: error.to_string(),
+            }),
+        }
+    }
+
+    fn to_api_error(&self, err: ReqwestError) -> ApiError {
         ApiError {
             message: err.to_string(),
         }

src/v1/error.rs

@@ -16,4 +16,6 @@ impl Error for ApiError {}
 pub enum ClientError {
     #[error("You must either set the `MISTRAL_API_KEY` environment variable or specify it in `Client::new(api_key, ...).")]
     ApiKeyError,
+    #[error("Failed to read the response text.")]
+    ReadResponseTextError,
 }

tests/v1_client_embeddings_async_test.rs

@@ -0,0 +1,29 @@
+use jrest::expect;
+use mistralai_client::v1::{client::Client, constants::EmbedModel};
+
+#[tokio::test]
+async fn test_client_embeddings_async() {
+    let client: Client = Client::new(None, None, None, None).unwrap();
+
+    let model = EmbedModel::MistralEmbed;
+    let input = vec!["Embed this sentence.", "As well as this one."]
+        .iter()
+        .map(|s| s.to_string())
+        .collect();
+    let options = None;
+
+    let response = client
+        .embeddings_async(model, input, options)
+        .await
+        .unwrap();
+
+    expect!(response.model).to_be(EmbedModel::MistralEmbed);
+    expect!(response.object).to_be("list".to_string());
+    expect!(response.data.len()).to_be(2);
+    expect!(response.data[0].index).to_be(0);
+    expect!(response.data[0].object.clone()).to_be("embedding".to_string());
+    expect!(response.data[0].embedding.len()).to_be_greater_than(0);
+    expect!(response.usage.prompt_tokens).to_be_greater_than(0);
+    expect!(response.usage.completion_tokens).to_be(0);
+    expect!(response.usage.total_tokens).to_be_greater_than(0);
+}

tests/v1_client_list_models_async_test.rs

@@ -0,0 +1,20 @@
+use jrest::expect;
+use mistralai_client::v1::client::Client;
+
+#[tokio::test]
+async fn test_client_list_models_async() {
+    let client = Client::new(None, None, None, None).unwrap();
+
+    let response = client.list_models_async().await.unwrap();
+
+    expect!(response.object).to_be("list".to_string());
+    expect!(response.data.len()).to_be_greater_than(0);
+
+    // let open_mistral_7b_data_item = response
+    //     .data
+    //     .iter()
+    //     .find(|item| item.id == "open-mistral-7b")
+    //     .unwrap();
+
+    // expect!(open_mistral_7b_data_item.id).to_be("open-mistral-7b".to_string());
+}