ci(release): v0.7.0

BREAKING CHANGE:

- Rename `ClientError.ApiKeyError` to `MissingApiKey`.
- Rename `ClientError.ReadResponseTextError` to `ClientError.UnreadableResponseText`.

.env.example

@@ -1,3 +1,3 @@
 # This key is only used for development purposes.
 # You'll only need one if you want to contribute to this library.
-MISTRAL_API_KEY=
+export MISTRAL_API_KEY=

.github/workflows/test.yml

@@ -6,10 +6,6 @@ jobs:
   test:
     name: Test
     runs-on: ubuntu-latest
-    container:
-      image: xd009642/tarpaulin
-      # https://github.com/xd009642/tarpaulin#github-actions
-      options: --security-opt seccomp=unconfined
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -17,12 +13,30 @@ jobs:
         uses: actions-rs/toolchain@v1
         with:
           toolchain: 1.76.0
+      - name: Install cargo-llvm-cov
+        uses: taiki-e/install-action@cargo-llvm-cov
       - name: Run tests (with coverage)
-        run: make test-cover
+        run: cargo llvm-cov --lcov --output-path ./lcov.info
         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
+          files: ./lcov.info
           token: ${{ secrets.CODECOV_TOKEN }}
+
+  test_documentation:
+    name: Test Documentation
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Setup Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: 1.76.0
+      - name: Run documentation tests
+        run: make test-doc
+        env:
+          MISTRAL_API_KEY: ${{ secrets.MISTRAL_API_KEY }}

CHANGELOG.md

@@ -1,16 +1,63 @@
-## [](https://github.com/ivangabriele/mistralai-client-rs/compare/v0.1.0...v) (2024-03-03)
+## [0.7.0](https://github.com/ivangabriele/mistralai-client-rs/compare/v0.6.0...v) (2024-03-05)
 
 
 ### ⚠ BREAKING CHANGES
 
-* Chat completions must now be called directly from client.chat() without building a request in between.
+* - Rename `ClientError.ApiKeyError` to `MissingApiKey`.
+- Rename `ClientError.ReadResponseTextError` to `ClientError.UnreadableResponseText`.
+
+### Bug Fixes
+
+* fix failure when api key as param and not env ([ef5d475](https://github.com/ivangabriele/mistralai-client-rs/commit/ef5d475e2d0e3fe040c44d6adabf7249e9962835))
+
+## [0.6.0](https://github.com/ivangabriele/mistralai-client-rs/compare/v0.5.0...v) (2024-03-04)
+
+
+### ⚠ BREAKING CHANGES
+
+* You can't set the `stream` option for `client.chat*()`.
+
+Either use `client.chat_stream()` if you want to use streams
+or use `client.chat()` / `client.chat_async()` otherwise.
 
 ### Features
 
-* add client.list_models() method ([814b991](https://github.com/ivangabriele/mistralai-client-rs/commit/814b9918b3aca78bfd606b5b9bb470b70ea2a5c6))
-* simplify chat completion call ([7de2b19](https://github.com/ivangabriele/mistralai-client-rs/commit/7de2b19b981f1d65fe5c566fcaf521e4f2a9ced1))
+* add client.chat_stream() method ([4a4219d](https://github.com/ivangabriele/mistralai-client-rs/commit/4a4219d3eaa8f0ae953ee6182b36bf464d1c4a21))
 
-## [](https://github.com/ivangabriele/mistralai-client-rs/compare/v0.1.0...v) (2024-03-03)
+## [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)
+
+
+### ⚠ BREAKING CHANGES
+
+* `Client::new()` now returns a `Result`.
+* `APIError` is renamed to `ApiError`.
+
+### Features
+
+* add client.chat_async() method ([1dd59f6](https://github.com/ivangabriele/mistralai-client-rs/commit/1dd59f67048c10458ab0382af8fdfe4ed21c82fa))
+* add missing api key error ([1deab88](https://github.com/ivangabriele/mistralai-client-rs/commit/1deab88251fc706e0415a5e416ab9aee4b52f6f3))
+* wrap Client::new() return in a Result ([3387618](https://github.com/ivangabriele/mistralai-client-rs/commit/33876183e41340f426aa1dd1b6d8b5c05c8e15b9))
+
+## [0.3.0](https://github.com/ivangabriele/mistralai-client-rs/compare/v0.2.0...v) (2024-03-04)
+
+
+### ⚠ BREAKING CHANGES
+
+* Models are now enforced by `Model` & `EmbedModel` enums.
+
+### Features
+
+* add client.embeddings() method ([f44d951](https://github.com/ivangabriele/mistralai-client-rs/commit/f44d95124767c3a3f14c78c4be3d9c203fac49ad))
+
+## [0.2.0](https://github.com/ivangabriele/mistralai-client-rs/compare/v0.1.0...v) (2024-03-03)
 
 
 ### ⚠ BREAKING CHANGES

CONTRIBUTING.md

@@ -27,11 +27,19 @@ Then run:
 git clone https://github.com/ivangabriele/mistralai-client-rs.git # or your fork
 cd ./mistralai-client-rs
 cargo build
+cp .env.example .env
 ```
 
+Then edit the `.env` file to set your `MISTRAL_API_KEY`.
+
+> [!NOTE]
+> All tests use either the `open-mistral-7b` or `mistral-embed` models and only consume a few dozen tokens.
+> So you would have to run them thousands of times to even reach a single dollar of usage.
+
 ### Optional requirements
 
-- [cargo-watch](https://github.com/watchexec/cargo-watch#install) for `make test-*-watch`.
+- [cargo-llvm-cov](https://github.com/taiki-e/cargo-llvm-cov?tab=readme-ov-file#installation) for `make test-cover`
+- [cargo-watch](https://github.com/watchexec/cargo-watch#install) for `make test-watch`.
 
 ### Test
 
@@ -51,5 +59,4 @@ Help us keep this project open and inclusive. Please read and follow our [Code o
 
 ## Commit Message Format
 
-This repository follow the [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/) specification and
-specificaly the [Angular Commit Message Guidelines](https://github.com/angular/angular/blob/main/CONTRIBUTING.md#commit).
+This repository follow the [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/) specification.

Cargo.toml

@@ -2,7 +2,7 @@
 name = "mistralai-client"
 description = "Mistral AI API client library for Rust (unofficial)."
 license = "Apache-2.0"
-version = "0.2.0"
+version = "0.7.0"
 
 edition = "2021"
 rust-version = "1.76.0"
@@ -15,12 +15,14 @@ readme = "README.md"
 repository = "https://github.com/ivangabriele/mistralai-client-rs"
 
 [dependencies]
-minreq = { version = "2.11.0", features = ["https-rustls", "json-using-serde"] }
+futures = "0.3.30"
+reqwest = { version = "0.11.24", features = ["json", "blocking", "stream"] }
 serde = { version = "1.0.197", features = ["derive"] }
 serde_json = "1.0.114"
+strum = "0.26.1"
+strum_macros = "0.26.1"
 thiserror = "1.0.57"
 tokio = { version = "1.36.0", features = ["full"] }
 
 [dev-dependencies]
-dotenv = "0.15.0"
 jrest = "0.2.3"

Makefile

@@ -1,7 +1,20 @@
+SHELL := /bin/bash
+
 .PHONY: test
 
+define source_env_if_not_ci
+	@if [ -z "$${CI}" ]; then \
+		if [ -f ./.env ]; then \
+			source ./.env; \
+		else \
+			echo "No .env file found"; \
+			exit 1; \
+		fi \
+	fi
+endef
+
 define RELEASE_TEMPLATE
-	conventional-changelog -p conventionalcommits -i CHANGELOG.md -s
+	conventional-changelog -p conventionalcommits -i ./CHANGELOG.md -s
 	git add .
 	git commit -m "docs(changelog): update"
 	git push origin HEAD
@@ -9,12 +22,9 @@ define RELEASE_TEMPLATE
 	git push origin HEAD --tags
 endef
 
-test:
-	cargo test --no-fail-fast
-test-cover:
-	cargo tarpaulin --frozen --no-fail-fast --out Xml --skip-clean
-test-watch:
-	cargo watch -x "test -- --nocapture"
+doc:
+	cargo doc
+	open ./target/doc/mistralai_client/index.html
 
 release-patch:
 	$(call RELEASE_TEMPLATE,patch)
@@ -24,3 +34,12 @@ release-minor:
 
 release-major:
 	$(call RELEASE_TEMPLATE,major)
+
+test:
+	@$(source_env_if_not_ci) && cargo test --no-fail-fast
+test-cover:
+	@$(source_env_if_not_ci) && cargo llvm-cov
+test-doc:
+	@$(source_env_if_not_ci) && cargo test --doc --no-fail-fast
+test-watch:
+	@source ./.env && cargo watch -x "test -- --nocapture"

README.md

@@ -16,19 +16,26 @@ Rust client for the Mistral AI API.
     - [As a client argument](#as-a-client-argument)
 - [Usage](#usage)
   - [Chat without streaming](#chat-without-streaming)
-  - [Chat with streaming](#chat-with-streaming)
+  - [Chat without streaming (async)](#chat-without-streaming-async)
+  - [Chat with streaming (async)](#chat-with-streaming-async)
   - [Embeddings](#embeddings)
+  - [Embeddings (async)](#embeddings-async)
   - [List models](#list-models)
+  - [List models (async)](#list-models-async)
 
 ---
 
 ## Supported APIs
 
 - [x] Chat without streaming
-- [ ] Chat with streaming
-- [ ] Embedding
+- [x] Chat without streaming (async)
+- [x] Chat with streaming
+- [x] Embedding
+- [x] Embedding (async)
 - [x] List models
+- [x] List models (async)
 - [ ] Function Calling
+- [ ] Function Calling (async)
 
 ## Installation
 
@@ -54,7 +61,7 @@ use mistralai_client::v1::client::Client;
 fn main() {
     let api_key = "your_api_key";
 
-    let client = Client::new(Some(api_key), None, None, None);
+    let client = Client::new(Some(api_key), None, None, None).unwrap();
 }
 ```
 
@@ -64,18 +71,18 @@ fn main() {
 
 ```rs
 use mistralai_client::v1::{
-    chat_completion::{ChatCompletionMessage, ChatCompletionMessageRole, ChatCompletionRequestOptions},
+    chat_completion::{ChatCompletionParams, ChatMessage, ChatMessageRole},
     client::Client,
-    constants::OPEN_MISTRAL_7B,
+    constants::Model,
 };
 
 fn main() {
     // This example suppose you have set the `MISTRAL_API_KEY` environment variable.
-    let client = Client::new(None, None, None, None);
+    let client = Client::new(None, None, None, None).unwrap();
 
-    let model = OPEN_MISTRAL_7B.to_string();
-    let messages = vec![ChatCompletionMessage {
-        role: ChatCompletionMessageRole::user,
+    let model = Model::OpenMistral7b;
+    let messages = vec![ChatMessage {
+        role: ChatMessageRole::user,
         content: "Just guess the next word: \"Eiffel ...\"?".to_string(),
     }];
     let options = ChatCompletionRequestOptions {
@@ -90,13 +97,120 @@ fn main() {
 }
 ```
 
-### Chat with streaming
+### Chat without streaming (async)
 
-_In progress._
+```rs
+use mistralai_client::v1::{
+    chat_completion::{ChatCompletionParams, ChatMessage, ChatMessageRole},
+    client::Client,
+    constants::Model,
+};
+
+#[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).unwrap();
+
+    let model = Model::OpenMistral7b;
+    let messages = vec![ChatMessage {
+        role: ChatMessageRole::user,
+        content: "Just guess the next word: \"Eiffel ...\"?".to_string(),
+    }];
+    let options = ChatCompletionRequestOptions {
+        temperature: Some(0.0),
+        random_seed: Some(42),
+        ..Default::default()
+    };
+
+    let result = client.chat_async(model, messages, Some(options)).await.unwrap();
+    println!("Assistant: {}", result.choices[0].message.content);
+    // => "Assistant: Tower. [...]"
+}
+```
+
+### Chat with streaming (async)
+
+```rs
+use futures::stream::StreamExt;
+use mistralai_client::v1::{
+    chat_completion::{ChatCompletionParams, ChatMessage, ChatMessageRole},
+    client::Client,
+    constants::Model,
+};
+
+[#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).unwrap();
+
+    let model = Model::OpenMistral7b;
+    let messages = vec![ChatMessage {
+        role: ChatMessageRole::user,
+        content: "Just guess the next word: \"Eiffel ...\"?".to_string(),
+    }];
+    let options = ChatCompletionParams {
+        temperature: Some(0.0),
+        random_seed: Some(42),
+        ..Default::default()
+    };
+
+    let stream_result = client.chat_stream(model, messages, Some(options)).await;
+    let mut stream = stream_result.expect("Failed to create stream.");
+    while let Some(chunk_result) = stream.next().await {
+        match chunk_result {
+            Ok(chunk) => {
+                println!("Assistant (message chunk): {}", chunk.choices[0].delta.content);
+            }
+            Err(e) => eprintln!("Error processing chunk: {:?}", e),
+        }
+    }
+}
+```
 
 ### Embeddings
 
-_In progress._
+```rs
+use mistralai_client::v1::{client::Client, constants::EmbedModel};
+
+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(model, input, options).unwrap();
+  println!("Embeddings: {:?}", response.data);
+  // => "Embeddings: [{...}, {...}]"
+}
+```
+
+### Embeddings (async)
+
+```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
 
@@ -105,9 +219,25 @@ use mistralai_client::v1::client::Client;
 
 fn main() {
     // This example suppose you have set the `MISTRAL_API_KEY` environment variable.
-    let client = Client::new(None, None, None, None);
+    let client = Client::new(None, None, None, None).unwrap();
 
-    let result = client.list_models(model, messages, Some(options)).unwrap();
+    let result = client.list_models().unwrap();
+    println!("First Model ID: {:?}", result.data[0].id);
+    // => "First Model ID: open-mistral-7b"
+}
+```
+
+### List models (async)
+
+```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"
 }

release.toml

@@ -1 +1,4 @@
+# https://github.com/crate-ci/cargo-release/blob/master/docs/reference.md
 allow-branch = ["main"]
+pre-release-commit-message = "ci(release): v{{version}}"
+pre-release-replacements = [{ file = "CHANGELOG.md", search = "## \\[\\]", replace = "## [{{version}}]" }]

src/lib.rs

@@ -1 +1,4 @@
+//! This crate provides a easy bindings and types for MistralAI's API.
+
+/// The v1 module contains the types and methods for the v1 API endpoints.
 pub mod v1;

src/v1/chat_completion.rs

@@ -1,6 +1,25 @@
 use serde::{Deserialize, Serialize};
 
-use crate::v1::common;
+use crate::v1::{common, constants};
+
+// -----------------------------------------------------------------------------
+// Definitions
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct ChatMessage {
+    pub role: ChatMessageRole,
+    pub content: String,
+}
+
+#[derive(Clone, Debug, strum_macros::Display, Eq, PartialEq, Deserialize, Serialize)]
+#[allow(non_camel_case_types)]
+pub enum ChatMessageRole {
+    assistant,
+    user,
+}
+
+// -----------------------------------------------------------------------------
+// Request
 
 #[derive(Debug)]
 pub struct ChatCompletionParams {
@@ -9,7 +28,6 @@ pub struct ChatCompletionParams {
     pub max_tokens: Option<u32>,
     pub top_p: Option<f32>,
     pub random_seed: Option<u32>,
-    pub stream: Option<bool>,
     pub safe_prompt: Option<bool>,
 }
 impl Default for ChatCompletionParams {
@@ -20,7 +38,6 @@ impl Default for ChatCompletionParams {
             max_tokens: None,
             top_p: None,
             random_seed: None,
-            stream: None,
             safe_prompt: None,
         }
     }
@@ -28,8 +45,8 @@ impl Default for ChatCompletionParams {
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct ChatCompletionRequest {
-    pub messages: Vec<ChatCompletionMessage>,
-    pub model: String,
+    pub messages: Vec<ChatMessage>,
+    pub model: constants::Model,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub tools: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -40,8 +57,7 @@ pub struct ChatCompletionRequest {
     pub top_p: Option<f32>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub random_seed: Option<u32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub stream: Option<bool>,
+    pub stream: bool,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub safe_prompt: Option<bool>,
     // TODO Check this prop (seen in official Python client but not in API doc).
@@ -51,8 +67,9 @@ pub struct ChatCompletionRequest {
 }
 impl ChatCompletionRequest {
     pub fn new(
-        model: String,
-        messages: Vec<ChatCompletionMessage>,
+        model: constants::Model,
+        messages: Vec<ChatMessage>,
+        stream: bool,
         options: Option<ChatCompletionParams>,
     ) -> Self {
         let ChatCompletionParams {
@@ -61,7 +78,6 @@ impl ChatCompletionRequest {
             max_tokens,
             top_p,
             random_seed,
-            stream,
             safe_prompt,
         } = options.unwrap_or_default();
 
@@ -79,35 +95,55 @@ impl ChatCompletionRequest {
     }
 }
 
+// -----------------------------------------------------------------------------
+// Response
+
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct ChatCompletionResponse {
     pub id: String,
     pub object: String,
     /// Unix timestamp (in seconds).
     pub created: u32,
-    pub model: String,
-    pub choices: Vec<ChatCompletionChoice>,
+    pub model: constants::Model,
+    pub choices: Vec<ChatCompletionResponseChoice>,
     pub usage: common::ResponseUsage,
 }
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct ChatCompletionChoice {
+pub struct ChatCompletionResponseChoice {
     pub index: u32,
-    pub message: ChatCompletionMessage,
+    pub message: ChatMessage,
     pub finish_reason: String,
     // TODO Check this prop (seen in API responses but undocumented).
     // pub logprobs: ???
 }
 
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct ChatCompletionMessage {
-    pub role: ChatCompletionMessageRole,
-    pub content: String,
+// -----------------------------------------------------------------------------
+// Stream
+
+#[derive(Debug, Deserialize)]
+pub struct ChatCompletionStreamChunk {
+    pub id: String,
+    pub object: String,
+    /// Unix timestamp (in seconds).
+    pub created: u32,
+    pub model: constants::Model,
+    pub choices: Vec<ChatCompletionStreamChunkChoice>,
+    // TODO Check this prop (seen in API responses but undocumented).
+    // pub usage: ???,
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
-#[allow(non_camel_case_types)]
-pub enum ChatCompletionMessageRole {
-    assistant,
-    user,
+#[derive(Debug, Deserialize)]
+pub struct ChatCompletionStreamChunkChoice {
+    pub index: u32,
+    pub delta: ChatCompletionStreamChunkChoiceDelta,
+    pub finish_reason: Option<String>,
+    // TODO Check this prop (seen in API responses but undocumented).
+    // pub logprobs: ???,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct ChatCompletionStreamChunkChoiceDelta {
+    pub role: Option<ChatMessageRole>,
+    pub content: String,
 }

src/v1/client.rs

@@ -1,14 +1,22 @@
-use crate::v1::error::APIError;
-use minreq::Response;
+use futures::stream::StreamExt;
+use futures::Stream;
+use reqwest::Error as ReqwestError;
+use serde_json::from_str;
+
+use crate::v1::error::ApiError;
 
 use crate::v1::{
     chat_completion::{
-        ChatCompletionMessage, ChatCompletionParams, ChatCompletionRequest, ChatCompletionResponse,
+        ChatCompletionParams, ChatCompletionRequest, ChatCompletionResponse, ChatMessage,
     },
-    constants::API_URL_BASE,
-    list_models::ListModelsResponse,
+    constants::{EmbedModel, Model, API_URL_BASE},
+    embedding::{EmbeddingRequest, EmbeddingRequestOptions, EmbeddingResponse},
+    error::ClientError,
+    model_list::ModelListResponse,
 };
 
+use super::chat_completion::ChatCompletionStreamChunk;
+
 pub struct Client {
     pub api_key: String,
     pub endpoint: String,
@@ -17,145 +25,468 @@ pub struct Client {
 }
 
 impl Client {
+    /// Constructs a new `Client`.
+    ///
+    /// # Arguments
+    ///
+    /// * `api_key`     - An optional API key.
+    ///                   If not provided, the method will try to use the `MISTRAL_API_KEY` environment variable.
+    /// * `endpoint`    - An optional custom API endpoint. Defaults to the official API endpoint if not provided.
+    /// * `max_retries` - Optional maximum number of retries for failed requests. Defaults to `5`.
+    /// * `timeout`     - Optional timeout in seconds for requests. Defaults to `120`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use mistralai_client::v1::client::Client;
+    ///
+    /// let client = Client::new(Some("your_api_key_here".to_string()), None, Some(3), Some(60));
+    /// assert!(client.is_ok());
+    /// ```
+    ///
+    /// # Errors
+    ///
+    /// This method fails whenever neither the `api_key` is provided
+    /// nor the `MISTRAL_API_KEY` environment variable is set.
     pub fn new(
         api_key: Option<String>,
         endpoint: Option<String>,
         max_retries: Option<u32>,
         timeout: Option<u32>,
-    ) -> Self {
-        let api_key = api_key.unwrap_or(std::env::var("MISTRAL_API_KEY").unwrap());
+    ) -> Result<Self, ClientError> {
+        let api_key = match api_key {
+            Some(api_key_from_param) => api_key_from_param,
+            None => std::env::var("MISTRAL_API_KEY").map_err(|_| ClientError::MissingApiKey)?,
+        };
         let endpoint = endpoint.unwrap_or(API_URL_BASE.to_string());
         let max_retries = max_retries.unwrap_or(5);
         let timeout = timeout.unwrap_or(120);
 
-        Self {
+        Ok(Self {
             api_key,
             endpoint,
             max_retries,
             timeout,
+        })
+    }
+
+    /// Synchronously sends a chat completion request and returns the response.
+    ///
+    /// # Arguments
+    ///
+    /// * `model` - The [Model] to use for the chat completion.
+    /// * `messages` - A vector of [ChatMessage] to send as part of the chat.
+    /// * `options` - Optional [ChatCompletionParams] to customize the request.
+    ///
+    /// # Returns
+    ///
+    /// Returns a [Result] containing the `ChatCompletionResponse` if the request is successful,
+    /// or an [ApiError] if there is an error.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use mistralai_client::v1::{
+    ///     chat_completion::{ChatMessage, ChatMessageRole},
+    ///     client::Client,
+    ///     constants::Model,
+    /// };
+    ///
+    /// let client = Client::new(None, None, None, None).unwrap();
+    /// let messages = vec![ChatMessage {
+    ///     role: ChatMessageRole::user,
+    ///     content: "Hello, world!".to_string(),
+    /// }];
+    /// let response = client.chat(Model::OpenMistral7b, messages, None).unwrap();
+    /// println!("{}: {}", response.choices[0].message.role, response.choices[0].message.content);
+    /// ```
+    pub fn chat(
+        &self,
+        model: Model,
+        messages: Vec<ChatMessage>,
+        options: Option<ChatCompletionParams>,
+    ) -> Result<ChatCompletionResponse, ApiError> {
+        let request = ChatCompletionRequest::new(model, messages, false, options);
+
+        let response = self.post_sync("/chat/completions", &request)?;
+        let result = response.json::<ChatCompletionResponse>();
+        match result {
+            Ok(response) => Ok(response),
+            Err(error) => Err(self.to_api_error(error)),
         }
     }
 
-    pub fn build_request(&self, request: minreq::Request) -> minreq::Request {
-        let authorization = format!("Bearer {}", self.api_key);
+    /// Asynchronously sends a chat completion request and returns the response.
+    ///
+    /// # Arguments
+    ///
+    /// * `model` - The [Model] to use for the chat completion.
+    /// * `messages` - A vector of [ChatMessage] to send as part of the chat.
+    /// * `options` - Optional [ChatCompletionParams] to customize the request.
+    ///
+    /// # Returns
+    ///
+    /// Returns a [Result] containing a `Stream` of `ChatCompletionStreamChunk` if the request is successful,
+    /// or an [ApiError] if there is an error.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use mistralai_client::v1::{
+    ///     chat_completion::{ChatMessage, ChatMessageRole},
+    ///     client::Client,
+    ///     constants::Model,
+    /// };
+    ///
+    /// #[tokio::main]
+    /// async fn main() {
+    ///     let client = Client::new(None, None, None, None).unwrap();
+    ///     let messages = vec![ChatMessage {
+    ///         role: ChatMessageRole::user,
+    ///         content: "Hello, world!".to_string(),
+    ///     }];
+    ///     let response = client.chat_async(Model::OpenMistral7b, messages, None).await.unwrap();
+    ///     println!("{}: {}", response.choices[0].message.role, response.choices[0].message.content);
+    /// }
+    /// ```
+    pub async fn chat_async(
+        &self,
+        model: Model,
+        messages: Vec<ChatMessage>,
+        options: Option<ChatCompletionParams>,
+    ) -> Result<ChatCompletionResponse, ApiError> {
+        let request = ChatCompletionRequest::new(model, messages, false, options);
+
+        let response = self.post_async("/chat/completions", &request).await?;
+        let result = response.json::<ChatCompletionResponse>().await;
+        match result {
+            Ok(response) => Ok(response),
+            Err(error) => Err(self.to_api_error(error)),
+        }
+    }
+
+    /// Asynchronously sends a chat completion request and returns a stream of message chunks.
+    ///
+    /// # Arguments
+    ///
+    /// * `model` - The [Model] to use for the chat completion.
+    /// * `messages` - A vector of [ChatMessage] to send as part of the chat.
+    /// * `options` - Optional [ChatCompletionParams] to customize the request.
+    ///
+    /// # Returns
+    ///
+    /// Returns a [Result] containing a `Stream` of `ChatCompletionStreamChunk` if the request is successful,
+    /// or an [ApiError] if there is an error.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use futures::stream::StreamExt;
+    /// use mistralai_client::v1::{
+    ///     chat_completion::{ChatMessage, ChatMessageRole},
+    ///     client::Client,
+    ///     constants::Model,
+    /// };
+    ///
+    /// #[tokio::main]
+    /// async fn main() {
+    ///     let client = Client::new(None, None, None, None).unwrap();
+    ///     let messages = vec![ChatMessage {
+    ///         role: ChatMessageRole::user,
+    ///         content: "Hello, world!".to_string(),
+    ///     }];
+    ///     let mut stream = client.chat_stream(Model::OpenMistral7b, messages, None).await.unwrap();
+    ///     while let Some(chunk_result) = stream.next().await {
+    ///         match chunk_result {
+    ///             Ok(chunk) => {
+    ///                 print!("{}", chunk.choices[0].delta.content);
+    ///             }
+    ///             Err(error) => {
+    ///                 println!("Error: {}", error.message);
+    ///             }
+    ///         }
+    ///     }
+    /// }
+    pub async fn chat_stream(
+        &self,
+        model: Model,
+        messages: Vec<ChatMessage>,
+        options: Option<ChatCompletionParams>,
+    ) -> Result<impl Stream<Item = Result<ChatCompletionStreamChunk, ApiError>>, ApiError> {
+        let request = ChatCompletionRequest::new(model, messages, true, options);
+        let response = self
+            .post_stream("/chat/completions", &request)
+            .await
+            .map_err(|e| ApiError {
+                message: e.to_string(),
+            })?;
+        if !response.status().is_success() {
+            let status = response.status();
+            let text = response.text().await.unwrap_or_default();
+            return Err(ApiError {
+                message: format!("{}: {}", status, text),
+            });
+        }
+
+        let deserialized_stream =
+            response
+                .bytes_stream()
+                .map(|item| -> Result<ChatCompletionStreamChunk, ApiError> {
+                    match item {
+                        Ok(bytes) => {
+                            let text = String::from_utf8(bytes.to_vec()).map_err(|e| ApiError {
+                                message: e.to_string(),
+                            })?;
+                            let text_trimmed = text.trim_start_matches("data: ");
+                            from_str(&text_trimmed).map_err(|e| ApiError {
+                                message: e.to_string(),
+                            })
+                        }
+                        Err(e) => Err(ApiError {
+                            message: e.to_string(),
+                        }),
+                    }
+                });
+
+        Ok(deserialized_stream)
+    }
+
+    pub fn embeddings(
+        &self,
+        model: EmbedModel,
+        input: Vec<String>,
+        options: Option<EmbeddingRequestOptions>,
+    ) -> Result<EmbeddingResponse, ApiError> {
+        let request = EmbeddingRequest::new(model, input, options);
+
+        let response = self.post_sync("/embeddings", &request)?;
+        let result = response.json::<EmbeddingResponse>();
+        match result {
+            Ok(response) => Ok(response),
+            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)),
+        }
+    }
+
+    pub fn list_models(&self) -> Result<ModelListResponse, ApiError> {
+        let response = self.get_sync("/models")?;
+        let result = response.json::<ModelListResponse>();
+        match result {
+            Ok(response) => Ok(response),
+            Err(error) => Err(self.to_api_error(error)),
+        }
+    }
+
+    pub async fn list_models_async(&self) -> Result<ModelListResponse, ApiError> {
+        let response = self.get_async("/models").await?;
+        let result = response.json::<ModelListResponse>().await;
+        match result {
+            Ok(response) => Ok(response),
+            Err(error) => Err(self.to_api_error(error)),
+        }
+    }
+
+    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 = request
-            .with_header("Authorization", authorization)
-            .with_header("Accept", "application/json")
-            .with_header("Content-Type", "application/json")
-            .with_header("User-Agent", user_agent);
+        let request_builder = request
+            .bearer_auth(&self.api_key)
+            .header("Accept", "application/json")
+            .header("Content-Type", "application/json")
+            .header("User-Agent", user_agent);
 
-        request
+        request_builder
     }
 
-    pub fn get(&self, path: &str) -> Result<Response, APIError> {
+    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 build_request_stream(&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", "text/event-stream")
+            .header("Content-Type", "application/json")
+            .header("User-Agent", user_agent);
+
+        request_builder
+    }
+
+    fn get_sync(&self, path: &str) -> Result<reqwest::blocking::Response, ApiError> {
+        let reqwest_client = reqwest::blocking::Client::new();
         let url = format!("{}{}", self.endpoint, path);
-        let request = self.build_request(minreq::get(url));
+        let request = self.build_request_sync(reqwest_client.get(url));
 
         let result = request.send();
         match result {
             Ok(response) => {
-                if (200..=299).contains(&response.status_code) {
+                if response.status().is_success() {
                     Ok(response)
                 } else {
-                    Err(APIError {
-                        message: format!(
-                            "{}: {}",
-                            response.status_code,
-                            response.as_str().unwrap()
-                        ),
+                    let status = response.status();
+                    let text = response.text().unwrap();
+                    Err(ApiError {
+                        message: format!("{}: {}", status, text),
                     })
                 }
             }
-            Err(error) => Err(self.new_error(error)),
+            Err(error) => Err(ApiError {
+                message: error.to_string(),
+            }),
         }
     }
 
-    pub fn post<T: serde::ser::Serialize + std::fmt::Debug>(
+    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;
+        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<Response, APIError> {
-        // print!("{:?}", params);
-
+    ) -> Result<reqwest::blocking::Response, ApiError> {
+        let reqwest_client = reqwest::blocking::Client::new();
         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_error(error)),
-        }
-    }
-
-    pub fn delete(&self, path: &str) -> Result<Response, APIError> {
-        let url = format!("{}{}", self.endpoint, path);
-        let request = self.build_request(minreq::post(url));
+        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 (200..=299).contains(&response.status_code) {
+                if response.status().is_success() {
                     Ok(response)
                 } else {
-                    Err(APIError {
-                        message: format!(
-                            "{}: {}",
-                            response.status_code,
-                            response.as_str().unwrap()
-                        ),
+                    let status = response.status();
+                    let text = response.text().unwrap_or_default();
+                    Err(ApiError {
+                        message: format!("{}: {}", status, text),
                     })
                 }
             }
-            Err(error) => Err(self.new_error(error)),
+            Err(error) => Err(ApiError {
+                message: error.to_string(),
+            }),
         }
     }
 
-    pub fn chat(
+    async fn post_async<T: serde::ser::Serialize + std::fmt::Debug>(
         &self,
-        model: String,
-        messages: Vec<ChatCompletionMessage>,
-        options: Option<ChatCompletionParams>,
-    ) -> Result<ChatCompletionResponse, APIError> {
-        let request = ChatCompletionRequest::new(model, messages, options);
+        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 response = self.post("/chat/completions", &request)?;
-        let result = response.json::<ChatCompletionResponse>();
+        let result = request.send().await;
         match result {
-            Ok(response) => Ok(response),
-            Err(error) => Err(self.new_error(error)),
+            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(),
+            }),
         }
     }
 
-    pub fn list_models(&self) -> Result<ListModelsResponse, APIError> {
-        let response = self.get("/models")?;
-        let result = response.json::<ListModelsResponse>();
+    async fn post_stream<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_stream(request_builder);
+
+        let result = request.send().await;
         match result {
-            Ok(response) => Ok(response),
-            Err(error) => Err(self.new_error(error)),
+            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 new_error(&self, err: minreq::Error) -> APIError {
-        APIError {
+    fn to_api_error(&self, err: ReqwestError) -> ApiError {
+        ApiError {
             message: err.to_string(),
         }
     }

src/v1/constants.rs

@@ -1,7 +1,23 @@
+use serde::{Deserialize, Serialize};
+
 pub const API_URL_BASE: &str = "https://api.mistral.ai/v1";
 
-pub const OPEN_MISTRAL_7B: &str = "open-mistral-7b";
-pub const OPEN_MISTRAL_8X7B: &str = "open-mixtral-8x7b";
-pub const MISTRAL_SMALL_LATEST: &str = "mistral-small-latest";
-pub const MISTRAL_MEDIUM_LATEST: &str = "mistral-medium-latest";
-pub const MISTRAL_LARGE_LATEST: &str = "mistral-large-latest";
+#[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
+pub enum Model {
+    #[serde(rename = "open-mistral-7b")]
+    OpenMistral7b,
+    #[serde(rename = "open-mistral-8x7b")]
+    OpenMistral8x7b,
+    #[serde(rename = "mistral-small-latest")]
+    MistralSmallLatest,
+    #[serde(rename = "mistral-medium-latest")]
+    MistralMediumLatest,
+    #[serde(rename = "mistral-large-latest")]
+    MistralLargeLatest,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
+pub enum EmbedModel {
+    #[serde(rename = "mistral-embed")]
+    MistralEmbed,
+}

src/v1/embedding.rs

@@ -0,0 +1,60 @@
+use serde::{Deserialize, Serialize};
+
+use crate::v1::{common, constants};
+
+#[derive(Debug)]
+pub struct EmbeddingRequestOptions {
+    pub encoding_format: Option<EmbeddingRequestEncodingFormat>,
+}
+impl Default for EmbeddingRequestOptions {
+    fn default() -> Self {
+        Self {
+            encoding_format: None,
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct EmbeddingRequest {
+    pub model: constants::EmbedModel,
+    pub input: Vec<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub encoding_format: Option<EmbeddingRequestEncodingFormat>,
+}
+impl EmbeddingRequest {
+    pub fn new(
+        model: constants::EmbedModel,
+        input: Vec<String>,
+        options: Option<EmbeddingRequestOptions>,
+    ) -> Self {
+        let EmbeddingRequestOptions { encoding_format } = options.unwrap_or_default();
+
+        Self {
+            model,
+            input,
+            encoding_format,
+        }
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
+#[allow(non_camel_case_types)]
+pub enum EmbeddingRequestEncodingFormat {
+    float,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct EmbeddingResponse {
+    pub id: String,
+    pub object: String,
+    pub model: constants::EmbedModel,
+    pub data: Vec<EmbeddingResponseDataItem>,
+    pub usage: common::ResponseUsage,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct EmbeddingResponseDataItem {
+    pub index: u32,
+    pub embedding: Vec<f32>,
+    pub object: String,
+}

src/v1/error.rs

@@ -2,14 +2,20 @@ use std::error::Error;
 use std::fmt;
 
 #[derive(Debug)]
-pub struct APIError {
+pub struct ApiError {
     pub message: String,
 }
-
-impl fmt::Display for APIError {
+impl fmt::Display for ApiError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "APIError: {}", self.message)
+        write!(f, "ApiError: {}", self.message)
     }
 }
+impl Error for ApiError {}
 
-impl Error for APIError {}
+#[derive(Debug, PartialEq, thiserror::Error)]
+pub enum ClientError {
+    #[error("You must either set the `MISTRAL_API_KEY` environment variable or specify it in `Client::new(api_key, ...).")]
+    MissingApiKey,
+    #[error("Failed to read the response text.")]
+    UnreadableResponseText,
+}

src/v1/mod.rs

@@ -2,5 +2,6 @@ pub mod chat_completion;
 pub mod client;
 pub mod common;
 pub mod constants;
+pub mod embedding;
 pub mod error;
-pub mod list_models;
+pub mod model_list;

src/v1/model_list.rs

@@ -1,19 +1,19 @@
 use serde::{Deserialize, Serialize};
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct ListModelsResponse {
+pub struct ModelListResponse {
     pub object: String,
-    pub data: Vec<ListModelsModel>,
+    pub data: Vec<ModelListData>,
 }
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct ListModelsModel {
+pub struct ModelListData {
     pub id: String,
     pub object: String,
     /// Unix timestamp (in seconds).
     pub created: u32,
     pub owned_by: String,
-    pub permission: Vec<ListModelsModelPermission>,
+    pub permission: Vec<ModelListDataPermission>,
     // TODO Check this prop (seen in API responses but undocumented).
     // pub root: ???,
     // TODO Check this prop (seen in API responses but undocumented).
@@ -21,7 +21,7 @@ pub struct ListModelsModel {
 }
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct ListModelsModelPermission {
+pub struct ModelListDataPermission {
     pub id: String,
     pub object: String,
     /// Unix timestamp (in seconds).

tests/v1_client_chat_async_test.rs

@@ -0,0 +1,38 @@
+use jrest::expect;
+use mistralai_client::v1::{
+    chat_completion::{ChatCompletionParams, ChatMessage, ChatMessageRole},
+    client::Client,
+    constants::Model,
+};
+
+#[tokio::test]
+async fn test_client_chat_async() {
+    let client = Client::new(None, None, None, None).unwrap();
+
+    let model = Model::OpenMistral7b;
+    let messages = vec![ChatMessage {
+        role: ChatMessageRole::user,
+        content: "Just guess the next word: \"Eiffel ...\"?".to_string(),
+    }];
+    let options = ChatCompletionParams {
+        temperature: Some(0.0),
+        random_seed: Some(42),
+        ..Default::default()
+    };
+
+    let response = client
+        .chat_async(model, messages, Some(options))
+        .await
+        .unwrap();
+
+    expect!(response.model).to_be(Model::OpenMistral7b);
+    expect!(response.object).to_be("chat.completion".to_string());
+    expect!(response.choices.len()).to_be(1);
+    expect!(response.choices[0].index).to_be(0);
+    expect!(response.choices[0].message.role.clone()).to_be(ChatMessageRole::assistant);
+    expect!(response.choices[0].message.content.clone())
+        .to_be("Tower. The Eiffel Tower is a famous landmark in Paris, France.".to_string());
+    expect!(response.usage.prompt_tokens).to_be_greater_than(0);
+    expect!(response.usage.completion_tokens).to_be_greater_than(0);
+    expect!(response.usage.total_tokens).to_be_greater_than(0);
+}

tests/v1_client_chat_stream_test.rs

@@ -0,0 +1,40 @@
+use futures::stream::StreamExt;
+use jrest::expect;
+use mistralai_client::v1::{
+    chat_completion::{ChatCompletionParams, ChatMessage, ChatMessageRole},
+    client::Client,
+    constants::Model,
+};
+
+#[tokio::test]
+async fn test_client_chat_stream() {
+    let client = Client::new(None, None, None, None).unwrap();
+
+    let model = Model::OpenMistral7b;
+    let messages = vec![ChatMessage {
+        role: ChatMessageRole::user,
+        content: "Just guess the next word: \"Eiffel ...\"?".to_string(),
+    }];
+    let options = ChatCompletionParams {
+        temperature: Some(0.0),
+        random_seed: Some(42),
+        ..Default::default()
+    };
+
+    let stream_result = client.chat_stream(model, messages, Some(options)).await;
+    let mut stream = stream_result.expect("Failed to create stream.");
+    while let Some(chunk_result) = stream.next().await {
+        match chunk_result {
+            Ok(chunk) => {
+                if chunk.choices[0].delta.role == Some(ChatMessageRole::assistant)
+                    || chunk.choices[0].finish_reason == Some("stop".to_string())
+                {
+                    expect!(chunk.choices[0].delta.content.len()).to_be(0);
+                } else {
+                    expect!(chunk.choices[0].delta.content.len()).to_be_greater_than(0);
+                }
+            }
+            Err(e) => eprintln!("Error processing chunk: {:?}", e),
+        }
+    }
+}

tests/v1_client_chat_test.rs

@@ -1,22 +1,17 @@
 use jrest::expect;
 use mistralai_client::v1::{
-    chat_completion::{ChatCompletionMessage, ChatCompletionMessageRole, ChatCompletionParams},
+    chat_completion::{ChatCompletionParams, ChatMessage, ChatMessageRole},
     client::Client,
-    constants::OPEN_MISTRAL_7B,
+    constants::Model,
 };
 
 #[test]
-fn test_chat_completion() {
-    extern crate dotenv;
+fn test_client_chat() {
+    let client = Client::new(None, None, None, None).unwrap();
 
-    use dotenv::dotenv;
-    dotenv().ok();
-
-    let client = Client::new(None, None, None, None);
-
-    let model = OPEN_MISTRAL_7B.to_string();
-    let messages = vec![ChatCompletionMessage {
-        role: ChatCompletionMessageRole::user,
+    let model = Model::OpenMistral7b;
+    let messages = vec![ChatMessage {
+        role: ChatMessageRole::user,
         content: "Just guess the next word: \"Eiffel ...\"?".to_string(),
     }];
     let options = ChatCompletionParams {
@@ -27,14 +22,14 @@ fn test_chat_completion() {
 
     let response = client.chat(model, messages, Some(options)).unwrap();
 
-    expect!(response.model).to_be("open-mistral-7b".to_string());
+    expect!(response.model).to_be(Model::OpenMistral7b);
     expect!(response.object).to_be("chat.completion".to_string());
     expect!(response.choices.len()).to_be(1);
     expect!(response.choices[0].index).to_be(0);
-    expect!(response.choices[0].message.role.clone()).to_be(ChatCompletionMessageRole::assistant);
+    expect!(response.choices[0].message.role.clone()).to_be(ChatMessageRole::assistant);
     expect!(response.choices[0].message.content.clone())
         .to_be("Tower. The Eiffel Tower is a famous landmark in Paris, France.".to_string());
     expect!(response.usage.prompt_tokens).to_be_greater_than(0);
     expect!(response.usage.completion_tokens).to_be_greater_than(0);
-    expect!(response.usage.total_tokens).to_be_greater_than(21);
+    expect!(response.usage.total_tokens).to_be_greater_than(0);
 }

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_embeddings_test.rs

@@ -0,0 +1,26 @@
+use jrest::expect;
+use mistralai_client::v1::{client::Client, constants::EmbedModel};
+
+#[test]
+fn test_client_embeddings() {
+    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(model, input, options).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());
+}

tests/v1_client_list_models_test.rs

@@ -0,0 +1,20 @@
+use jrest::expect;
+use mistralai_client::v1::client::Client;
+
+#[test]
+fn test_client_list_models() {
+    let client = Client::new(None, None, None, None).unwrap();
+
+    let response = client.list_models().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());
+}

tests/v1_client_new_test.rs

@@ -0,0 +1,106 @@
+use jrest::expect;
+use mistralai_client::v1::{client::Client, error::ClientError};
+
+#[test]
+fn test_client_new_with_none_params() {
+    let maybe_original_mistral_api_key = std::env::var("MISTRAL_API_KEY").ok();
+    std::env::remove_var("MISTRAL_API_KEY");
+    std::env::set_var("MISTRAL_API_KEY", "test_api_key_from_env");
+
+    let client = Client::new(None, None, None, None).unwrap();
+
+    expect!(client.api_key).to_be("test_api_key_from_env".to_string());
+    expect!(client.endpoint).to_be("https://api.mistral.ai/v1".to_string());
+    expect!(client.max_retries).to_be(5);
+    expect!(client.timeout).to_be(120);
+
+    match maybe_original_mistral_api_key {
+        Some(original_mistral_api_key) => {
+            std::env::set_var("MISTRAL_API_KEY", original_mistral_api_key)
+        }
+        None => std::env::remove_var("MISTRAL_API_KEY"),
+    }
+}
+
+#[test]
+fn test_client_new_with_all_params() {
+    let maybe_original_mistral_api_key = std::env::var("MISTRAL_API_KEY").ok();
+    std::env::remove_var("MISTRAL_API_KEY");
+
+    let api_key = Some("test_api_key_from_param".to_string());
+    let endpoint = Some("https://example.org".to_string());
+    let max_retries = Some(10);
+    let timeout = Some(20);
+
+    let client = Client::new(
+        api_key.clone(),
+        endpoint.clone(),
+        max_retries.clone(),
+        timeout.clone(),
+    )
+    .unwrap();
+
+    expect!(client.api_key).to_be(api_key.unwrap());
+    expect!(client.endpoint).to_be(endpoint.unwrap());
+    expect!(client.max_retries).to_be(max_retries.unwrap());
+    expect!(client.timeout).to_be(timeout.unwrap());
+
+    match maybe_original_mistral_api_key {
+        Some(original_mistral_api_key) => {
+            std::env::set_var("MISTRAL_API_KEY", original_mistral_api_key)
+        }
+        None => std::env::remove_var("MISTRAL_API_KEY"),
+    }
+}
+
+#[test]
+fn test_client_new_with_api_key_as_both_env_and_param() {
+    let maybe_original_mistral_api_key = std::env::var("MISTRAL_API_KEY").ok();
+    std::env::remove_var("MISTRAL_API_KEY");
+    std::env::set_var("MISTRAL_API_KEY", "test_api_key_from_env");
+
+    let api_key = Some("test_api_key_from_param".to_string());
+    let endpoint = Some("https://example.org".to_string());
+    let max_retries = Some(10);
+    let timeout = Some(20);
+
+    let client = Client::new(
+        api_key.clone(),
+        endpoint.clone(),
+        max_retries.clone(),
+        timeout.clone(),
+    )
+    .unwrap();
+
+    expect!(client.api_key).to_be(api_key.unwrap());
+    expect!(client.endpoint).to_be(endpoint.unwrap());
+    expect!(client.max_retries).to_be(max_retries.unwrap());
+    expect!(client.timeout).to_be(timeout.unwrap());
+
+    match maybe_original_mistral_api_key {
+        Some(original_mistral_api_key) => {
+            std::env::set_var("MISTRAL_API_KEY", original_mistral_api_key)
+        }
+        None => std::env::remove_var("MISTRAL_API_KEY"),
+    }
+}
+
+#[test]
+fn test_client_new_with_missing_api_key() {
+    let maybe_original_mistral_api_key = std::env::var("MISTRAL_API_KEY").ok();
+    std::env::remove_var("MISTRAL_API_KEY");
+
+    let call = || Client::new(None, None, None, None);
+
+    match call() {
+        Ok(_) => panic!("Expected `ClientError::MissingApiKey` but got Ok.`"),
+        Err(error) => assert_eq!(error, ClientError::MissingApiKey),
+    }
+
+    match maybe_original_mistral_api_key {
+        Some(original_mistral_api_key) => {
+            std::env::set_var("MISTRAL_API_KEY", original_mistral_api_key)
+        }
+        None => std::env::remove_var("MISTRAL_API_KEY"),
+    }
+}

tests/v1_client_test.rs

@@ -1,52 +0,0 @@
-use jrest::expect;
-use mistralai_client::v1::client::Client;
-
-#[test]
-fn test_client_new_with_none_params() {
-    let maybe_original_mistral_api_key = std::env::var("MISTRAL_API_KEY").ok();
-    std::env::set_var("MISTRAL_API_KEY", "test_api_key_from_env");
-
-    let client = Client::new(None, None, None, None);
-
-    expect!(client.api_key).to_be("test_api_key_from_env".to_string());
-    expect!(client.endpoint).to_be("https://api.mistral.ai/v1".to_string());
-    expect!(client.max_retries).to_be(5);
-    expect!(client.timeout).to_be(120);
-
-    match maybe_original_mistral_api_key {
-        Some(original_mistral_api_key) => {
-            std::env::set_var("MISTRAL_API_KEY", original_mistral_api_key)
-        }
-        None => std::env::remove_var("MISTRAL_API_KEY"),
-    }
-}
-
-#[test]
-fn test_client_new_with_all_params() {
-    let maybe_original_mistral_api_key = std::env::var("MISTRAL_API_KEY").ok();
-    std::env::set_var("MISTRAL_API_KEY", "test_api_key_from_env");
-
-    let api_key = Some("test_api_key_from_param".to_string());
-    let endpoint = Some("https://example.org".to_string());
-    let max_retries = Some(10);
-    let timeout = Some(20);
-
-    let client = Client::new(
-        api_key.clone(),
-        endpoint.clone(),
-        max_retries.clone(),
-        timeout.clone(),
-    );
-
-    expect!(client.api_key).to_be(api_key.unwrap());
-    expect!(client.endpoint).to_be(endpoint.unwrap());
-    expect!(client.max_retries).to_be(max_retries.unwrap());
-    expect!(client.timeout).to_be(timeout.unwrap());
-
-    match maybe_original_mistral_api_key {
-        Some(original_mistral_api_key) => {
-            std::env::set_var("MISTRAL_API_KEY", original_mistral_api_key)
-        }
-        None => std::env::remove_var("MISTRAL_API_KEY"),
-    }
-}

tests/v1_list_models_test.rs

@@ -1,17 +0,0 @@
-use jrest::expect;
-use mistralai_client::v1::client::Client;
-
-#[test]
-fn test_list_models() {
-    extern crate dotenv;
-
-    use dotenv::dotenv;
-    dotenv().ok();
-
-    let client = Client::new(None, None, None, None);
-
-    let response = client.list_models().unwrap();
-
-    expect!(response.object).to_be("list".to_string());
-    expect!(response.data.len()).to_be_greater_than(0);
-}