fix(deps): update rust crate thiserror to v2

.cargo/config.toml

@@ -1,2 +0,0 @@
-[registries.sunbeam]
-index = "sparse+https://src.sunbeam.pt/api/packages/studio/cargo/"

.env.example

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

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,34 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ""
+labels: "bug"
+assignees: ""
+---
+
+**Describe the bug**
+
+...
+
+**Reproduction**
+
+Steps to reproduce the behavior:
+
+1. ...
+2. ...
+
+**Expected behavior**
+
+...
+
+**Screenshots**
+
+If applicable, add screenshots to help explain your problem.
+
+**Version**
+
+If applicable, what version did you use?
+
+**Environment**
+
+If applicable, add relevant information about your config and environment here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,19 @@
+---
+name: Feature request
+about: Suggest a new idea for the project.
+title: ""
+labels: "enhancement"
+assignees: ""
+---
+
+**Is your feature request related to some problems?**
+
+- _Ex. I'm always frustrated when..._
+
+**What are the solutions you'd like?**
+
+- _Ex. A new option to..._
+
+**Anything else?**
+
+- ...

.github/pull_request_template.md

@@ -0,0 +1,8 @@
+## Description
+
+A clear and concise description of what your pull request is about.
+
+## Checklist
+
+- [ ] I updated the documentation accordingly. Or I don't need to.
+- [ ] I updated the tests accordingly. Or I don't need to.

.github/renovate.json

@@ -0,0 +1,3 @@
+{
+  "extends": ["github>ivangabriele/renovate-config"]
+}

.github/workflows/test.yml

@@ -0,0 +1,59 @@
+name: Test
+
+on:
+  pull_request:
+  push:
+
+jobs:
+  test:
+    name: Test
+    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: Install cargo-llvm-cov
+        uses: taiki-e/install-action@cargo-llvm-cov
+      - name: Run tests (with coverage)
+        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@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 }}
+
+  test_examples:
+    name: Test Examples
+    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 examples
+        run: make test-examples
+        env:
+          MISTRAL_API_KEY: ${{ secrets.MISTRAL_API_KEY }}

.gitignore

@@ -23,4 +23,3 @@ Cargo.lock
 /cobertura.xml
 
 .env
-.envrc

CHANGELOG.md

@@ -1,37 +1,3 @@
-# Changelog
-
-## [1.0.0](https://src.sunbeam.pt/studio/mistralai-client-rs) (2026-03-20)
-
-Forked from [ivangabriele/mistralai-client-rs](https://github.com/ivangabriele/mistralai-client-rs) v0.14.0 and updated to the latest Mistral AI API.
-
-### ⚠ BREAKING CHANGES
-
-* `Model` is now a string-based struct with constructor methods instead of a closed enum
-* `EmbedModel` is removed — use `Model::mistral_embed()` instead
-* `Tool::new()` parameters now accept `serde_json::Value` (JSON Schema) instead of limited enum types
-* `ChatParams.temperature` is now `Option<f32>` instead of `f32`
-* Stream delta `content` is now `Option<String>`
-
-### Features
-
-* Add all current Mistral models (Large 3, Small 4, Medium 3.1, Magistral, Codestral, Devstral, Pixtral, Voxtral, Ministral)
-* Add FIM (fill-in-the-middle) completions endpoint
-* Add Files API (upload, list, get, delete, download URL)
-* Add Fine-tuning jobs API (create, list, get, cancel, start)
-* Add Batch jobs API (create, list, get, cancel)
-* Add OCR endpoint (document text extraction)
-* Add Audio transcription endpoint
-* Add Moderations and Classifications endpoints
-* Add Agent completions endpoint
-* Add new chat fields: frequency_penalty, presence_penalty, stop, n, min_tokens, parallel_tool_calls, reasoning_effort, json_schema response format
-* Add embedding fields: output_dimension, output_dtype
-* Add tool call IDs and Required tool choice variant
-* Add model get and delete endpoints
-
----
-
-## Upstream Changelog (pre-fork)
-
 ## [0.14.0](https://github.com/ivangabriele/mistralai-client-rs/compare/v0.13.0...v) (2024-08-27)
 
 ### Features

CONTRIBUTING.md

@@ -1,277 +1,77 @@
-# Contributing to mistralai-client-rs
+# Contribute
 
-Thank you for your interest in contributing! We're excited to work with you.
-
-This document provides guidelines for contributing to the project. Following these guidelines helps maintain code quality and makes the review process smoother for everyone.
-
-## Table of Contents
-
-- [Code of Conduct](#code-of-conduct)
 - [Getting Started](#getting-started)
-- [Development Environment Setup](#development-environment-setup)
-- [How to Contribute](#how-to-contribute)
-- [Coding Standards](#coding-standards)
-- [Testing](#testing)
-- [Pull Request Process](#pull-request-process)
-- [Reporting Bugs](#reporting-bugs)
-- [Suggesting Features](#suggesting-features)
-- [AI Usage Policy](#ai-usage-policy)
-- [Questions?](#questions)
-
-## Code of Conduct
-
-This project adheres to the [Contributor Covenant Code of Conduct](CODE_OF_CONDUCT.md). By participating, you are expected to uphold this code. Please report unacceptable behavior to the project maintainers.
-
-## Getting Started
-
-1. **Fork the repository** on Gitea
-2. **Clone your fork** locally
-3. **Set up your development environment** (see below)
-4. **Create a branch** for your changes
-5. **Make your changes** with clear commit messages
-6. **Test your changes** thoroughly
-7. **Submit a pull request**
-
-## Development Environment Setup
-
-### Prerequisites
-
-- **Rust** 2024 edition or later (install via [rustup](https://rustup.rs/))
-- **Git** for version control
-
-### Initial Setup
-
-```bash
-# Clone your fork
-git clone git@src.sunbeam.pt:studio/mistralai-client-rs.git
-cd mistralai-client-rs
-
-# Build the project
-cargo build
-
-# Run tests (requires MISTRAL_API_KEY)
-cargo test
-```
-
-### Useful Commands
-
-```bash
-# Check code without building
-cargo check
-
-# Run clippy for linting
-cargo clippy
-
-# Format code
-cargo fmt
-
-# Run tests with output
-cargo test -- --nocapture
-
-# Build documentation
-cargo doc --open
-```
-
-### Environment Variables with `.envrc`
-
-This project uses [direnv](https://direnv.net/) for managing environment variables.
-
-#### Setup
-
-1. **Install direnv** (if not already installed):
-   ```bash
-   # macOS
-   brew install direnv
-
-   # Add to your shell profile (~/.zshrc or ~/.bashrc)
-   eval "$(direnv hook zsh)"  # or bash
-   ```
-
-2. **Create `.envrc` file** in the project root:
-   ```bash
-   # The .envrc file is already gitignored for security
-   export MISTRAL_API_KEY=your_api_key_here
-   ```
-
-3. **Allow direnv** to load the file:
-   ```bash
-   direnv allow .
-   ```
-
-## How to Contribute
-
-### Types of Contributions
-
-We welcome many types of contributions:
-
-- **Bug fixes** - Fix issues and improve stability
-- **Features** - Implement new functionality (discuss first in an issue)
-- **Documentation** - Improve or add documentation
-- **Examples** - Create new examples or demos
-- **Tests** - Add test coverage
-- **Performance** - Optimize existing code
-- **Refactoring** - Improve code quality
-
-### Before You Start
-
-For **bug fixes and small improvements**, feel free to open a PR directly.
-
-For **new features or significant changes**:
-1. **Open an issue first** to discuss the proposal
-2. Wait for maintainer feedback before investing significant time
-3. Reference the issue in your PR
-
-This helps ensure your work aligns with project direction and avoids duplicate effort.
-
-## Coding Standards
-
-### Rust Style
-
-- Follow the [Rust API Guidelines](https://rust-lang.github.io/api-guidelines/)
-- Use `cargo fmt` to format code (run before committing)
-- Address all `cargo clippy` warnings
-- Use meaningful variable and function names
-- Add doc comments (`///`) for public APIs
-
-### Code Organization
-
-- Keep modules focused and cohesive
-- Prefer composition over inheritance
-- Use Rust's type system to enforce invariants
-- Avoid unnecessary `unsafe` code
-
-### Documentation
-
-- Add doc comments for all public types, traits, and functions
-- Include examples in doc comments when helpful
-- Keep README.md in sync with current capabilities
-
-### Commit Messages
-
-This repository follows the [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/) specification.
-
-Write clear, descriptive commit messages:
-
-```
-feat: add batch jobs API
-
-fix: handle empty tool_calls in streaming response
-
-refactor!: replace Model enum with string-based type
-
-BREAKING CHANGE: Model is now a struct, not an enum.
-```
-
-## Testing
-
-### Running Tests
-
-```bash
-# Run all tests (requires MISTRAL_API_KEY)
-cargo test
-
-# Run specific test
-cargo test test_client_chat
-
-# Run tests with output
-cargo test -- --nocapture
-```
-
-### Writing Tests
-
-- Add unit tests in the same file as the code (in a `mod tests` block)
-- Add integration tests in `tests/` directory
-- Test edge cases and error conditions
-- Keep tests focused and readable
-- Use descriptive test names
-
-### Test Coverage
-
-Tests hit the live Mistral API, so a valid `MISTRAL_API_KEY` is required. The tests use small, cheap models and consume minimal tokens.
-
-## Pull Request Process
-
-### Before Submitting
-
-1. **Update your branch** with latest upstream changes
-   ```bash
-   git fetch origin
-   git rebase origin/main
-   ```
-
-2. **Run the test suite** and ensure all tests pass
-   ```bash
-   cargo test
-   ```
-
-3. **Run clippy** and fix any warnings
-   ```bash
-   cargo clippy
-   ```
-
-4. **Format your code**
-   ```bash
-   cargo fmt
-   ```
-
-5. **Update documentation** if you changed APIs or behavior
-
-### Submitting Your PR
-
-1. **Push to your fork**
-2. **Open a pull request** on Gitea
-3. **Fill out the PR description** with what changed and why
-4. **Request review** from maintainers
-
-### During Review
-
-- Be responsive to feedback
-- Make requested changes promptly
-- Push updates to the same branch
-- Be patient - maintainers are volunteers with limited time
-
-## Reporting Bugs
-
-### Before Reporting
-
-1. **Check existing issues** to avoid duplicates
-2. **Verify it's a bug** and not expected behavior
-3. **Test on the latest version** from main branch
-
-### Bug Report Template
-
-When opening a bug report, please include:
-
-- **Description** - What went wrong?
-- **Expected behavior** - What should have happened?
-- **Actual behavior** - What actually happened?
-- **Steps to reproduce** - Minimal steps to reproduce the issue
-- **Environment**:
-  - OS version
-  - Rust version (`rustc --version`)
-  - Crate version or commit hash
-- **Logs/Stack traces** - Error messages or relevant log output
-
-## Suggesting Features
-
-We welcome feature suggestions! When suggesting a feature, please include:
-
-- **Problem statement** - What problem does this solve?
-- **Proposed solution** - How would this feature work?
-- **Alternatives considered** - What other approaches did you think about?
-- **Use cases** - Real-world scenarios where this helps
-
-## AI Usage Policy
-
-- AI tools (Copilot, ChatGPT, etc.) are allowed for productivity
-- You must understand and be accountable for all code you submit
-- Humans make all architectural decisions, not AI
-- When in doubt, ask yourself: "Can I maintain and debug this?"
-
-## Questions?
-
-Open an issue on the repository for any questions about contributing.
+  - [Requirements](#requirements)
+  - [First setup](#first-setup)
+  - [Optional requirements](#optional-requirements)
+- [Local Development](#local-development)
+  - [Test](#test)
+- [Documentation](#documentation)
+  - [Readme](#readme)
+- [Code of Conduct](#code-of-conduct)
+- [Commit Message Format](#commit-message-format)
 
 ---
 
-Thank you for contributing! Your effort helps make this library better for everyone.
+## Getting Started
+
+### Requirements
+
+- [Rust](https://www.rust-lang.org/tools/install): v1
+
+### First setup
+
+> [!IMPORTANT]  
+> If you're under **Windows**, you nust run all CLI commands under a Linux shell-like terminal (i.e.: WSL or Git Bash).
+
+Then run:
+
+```sh
+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-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`.
+
+## Local Development
+
+### Test
+
+```sh
+make test
+```
+
+or
+
+```sh
+make test-watch
+```
+
+## Documentation
+
+### Readme
+
+> [!IMPORTANT]
+> Do not edit the `README.md` file directly. It is generated from the `README.template.md` file.
+
+1. Edit the `README.template.md` file.
+2. Run `make readme` to generate/update the `README.md` file.
+
+## Code of Conduct
+
+Help us keep this project open and inclusive. Please read and follow our [Code of Conduct](./CODE_OF_CONDUCT.md).
+
+## Commit Message Format
+
+This repository follow the [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/) specification.

Cargo.toml

@@ -2,31 +2,31 @@
 name = "mistralai-client"
 description = "Mistral AI API client library for Rust (unofficial)."
 license = "Apache-2.0"
-version = "1.2.0"
+version = "0.14.0"
 
 edition = "2021"
 rust-version = "1.76.0"
 
-authors = ["Sunbeam Studios <hello@sunbeam.pt>"]
+authors = ["Ivan Gabriele <ivan.gabriele@protonmail.com>"]
 categories = ["api-bindings"]
-homepage = "https://sunbeam.pt"
+homepage = "https://github.com/ivangabriele/mistralai-client-rs#readme"
 keywords = ["mistral", "mistralai", "client", "api", "llm"]
 readme = "README.md"
-repository = "https://src.sunbeam.pt/studio/mistralai-client-rs"
-publish = ["sunbeam"]
+repository = "https://github.com/ivangabriele/mistralai-client-rs"
 
 [dependencies]
-async-stream = "0.3"
-async-trait = "0.1"
-env_logger = "0.11"
-futures = "0.3"
-log = "0.4"
-reqwest = { version = "0.12", features = ["json", "blocking", "stream", "multipart"] }
-serde = { version = "1", features = ["derive"] }
-serde_json = "1"
-thiserror = "2"
-tokio = { version = "1", features = ["full"] }
-tokio-stream = "0.1"
+async-stream = "0.3.5"
+async-trait = "0.1.77"
+env_logger = "0.11.3"
+futures = "0.3.30"
+log = "0.4.21"
+reqwest = { version = "0.12.0", features = ["json", "blocking", "stream"] }
+serde = { version = "1.0.197", features = ["derive"] }
+serde_json = "1.0.114"
+strum = "0.26.1"
+thiserror = "2.0.0"
+tokio = { version = "1.36.0", features = ["full"] }
+tokio-stream = "0.1.14"
 
 [dev-dependencies]
-jrest = "0.2"
+jrest = "0.2.3"

Makefile

@@ -0,0 +1,72 @@
+SHELL := /bin/bash
+
+.PHONY: doc readme 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
+	npx conventional-changelog-cli -p conventionalcommits -i ./CHANGELOG.md -s
+	git add .
+	git commit -m "docs(changelog): update"
+	git push origin HEAD
+	cargo release $(1) --execute
+	git push origin HEAD --tags
+endef
+
+doc:
+	cargo doc
+	open ./target/doc/mistralai_client/index.html
+
+readme:
+	@echo "Generating README.md from template..."
+	@> README.md # Clear README.md content before starting
+	@while IFS= read -r line || [[ -n "$$line" ]]; do \
+		if [[ $$line == *"<CODE>"* && $$line == *"</CODE>"* ]]; then \
+			example_path=$$(echo $$line | sed -n 's/.*<CODE>\(.*\)<\/CODE>.*/\1/p'); \
+			if [ -f $$example_path ]; then \
+				echo '```rs' >> README.md; \
+				cat $$example_path >> README.md; \
+				echo '```' >> README.md; \
+			else \
+				echo "Error: Example $$example_path not found." >&2; \
+			fi; \
+		else \
+			echo "$$line" >> README.md; \
+		fi; \
+	done < README.template.md
+	@echo "README.md has been generated."
+
+release-patch:
+	$(call RELEASE_TEMPLATE,patch)
+release-minor:
+	$(call RELEASE_TEMPLATE,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-examples:
+	@$(source_env_if_not_ci) && \
+	for example in $$(ls examples/*.rs | sed 's/examples\/\(.*\)\.rs/\1/'); do \
+		echo "Running $$example"; \
+		cargo run --example $$example; \
+	done
+test-watch:
+	@source ./.env && \
+	cargo watch -x "test -- --nocapture"

README.md

@@ -1,40 +1,87 @@
 # Mistral AI Rust Client
 
-Rust client for the [Mistral AI API](https://docs.mistral.ai/api/).
+[![Crates.io Package](https://img.shields.io/crates/v/mistralai-client?style=for-the-badge)](https://crates.io/crates/mistralai-client)
+[![Docs.rs Documentation](https://img.shields.io/docsrs/mistralai-client/latest?style=for-the-badge)](https://docs.rs/mistralai-client/latest/mistralai-client)
+[![Test Workflow Status](https://img.shields.io/github/actions/workflow/status/ivangabriele/mistralai-client-rs/test.yml?label=CI&style=for-the-badge)](https://github.com/ivangabriele/mistralai-client-rs/actions?query=branch%3Amain+workflow%3ATest++)
+[![Code Coverage](https://img.shields.io/codecov/c/github/ivangabriele/mistralai-client-rs/main?label=Cov&style=for-the-badge)](https://app.codecov.io/github/ivangabriele/mistralai-client-rs)
+
+Rust client for the Mistral AI API.
+
+> [!IMPORTANT]  
+> While we are in v0, minor versions may introduce breaking changes.  
+> Please, refer to the [CHANGELOG.md](./CHANGELOG.md) for more information.
+
+---
+
+- [Supported APIs](#supported-apis)
+- [Installation](#installation)
+  - [Mistral API Key](#mistral-api-key)
+    - [As an environment variable](#as-an-environment-variable)
+    - [As a client argument](#as-a-client-argument)
+- [Usage](#usage)
+  - [Chat](#chat)
+  - [Chat (async)](#chat-async)
+  - [Chat with streaming (async)](#chat-with-streaming-async)
+  - [Chat with Function Calling](#chat-with-function-calling)
+  - [Chat with Function Calling (async)](#chat-with-function-calling-async)
+  - [Embeddings](#embeddings)
+  - [Embeddings (async)](#embeddings-async)
+  - [List models](#list-models)
+  - [List models (async)](#list-models-async)
+- [Contributing](#contributing)
+
+---
 
 ## Supported APIs
 
-- [x] Chat completions (sync, async, streaming)
-- [x] Function calling / tool use
-- [x] FIM (fill-in-the-middle) code completions
-- [x] Embeddings (sync, async)
-- [x] Models (list, get, delete)
-- [x] Files (upload, list, get, delete, download URL)
-- [x] Fine-tuning jobs (create, list, get, cancel, start)
-- [x] Batch jobs (create, list, get, cancel)
-- [x] OCR (document text extraction)
-- [x] Audio transcription
-- [x] Moderations & classifications
-- [x] Agent completions
+- [x] Chat without streaming
+- [x] Chat without streaming (async)
+- [x] Chat with streaming
+- [x] Embedding
+- [x] Embedding (async)
+- [x] List models
+- [x] List models (async)
+- [x] Function Calling
+- [x] Function Calling (async)
 
 ## Installation
 
+You can install the library in your project using:
+
 ```sh
 cargo add mistralai-client
 ```
 
-### API Key
+### Mistral API Key
 
-Get your key at <https://console.mistral.ai/api-keys>.
+You can get your Mistral API Key there: <https://docs.mistral.ai/#api-access>.
+
+#### As an environment variable
+
+Just set the `MISTRAL_API_KEY` environment variable.
 
 ```rs
 use mistralai_client::v1::client::Client;
 
-// From MISTRAL_API_KEY environment variable:
-let client = Client::new(None, None, None, None).unwrap();
+fn main() {
+    let client = Client::new(None, None, None, None);
+}
+```
 
-// Or pass directly:
-let client = Client::new(Some("your_api_key".to_string()), None, None, None).unwrap();
+```sh
+MISTRAL_API_KEY=your_api_key cargo run
+```
+
+#### As a client argument
+
+```rs
+use mistralai_client::v1::client::Client;
+
+fn main() {
+    let api_key = "your_api_key";
+
+    let client = Client::new(Some(api_key), None, None, None).unwrap();
+}
 ```
 
 ## Usage
@@ -43,23 +90,30 @@ let client = Client::new(Some("your_api_key".to_string()), None, None, None).unw
 
 ```rs
 use mistralai_client::v1::{
-    chat::{ChatMessage, ChatParams},
+    chat::{ChatMessage, ChatMessageRole, ChatParams},
     client::Client,
     constants::Model,
 };
 
 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::mistral_small_latest();
-    let messages = vec![ChatMessage::new_user_message("What is the Eiffel Tower?")];
+    let model = Model::OpenMistral7b;
+    let messages = vec![ChatMessage {
+        role: ChatMessageRole::User,
+        content: "Just guess the next word: \"Eiffel ...\"?".to_string(),
+        tool_calls: None,
+    }];
     let options = ChatParams {
-        temperature: Some(0.7),
+        temperature: 0.0,
+        random_seed: Some(42),
         ..Default::default()
     };
 
     let result = client.chat(model, messages, Some(options)).unwrap();
-    println!("{}", result.choices[0].message.content);
+    println!("Assistant: {}", result.choices[0].message.content);
+    // => "Assistant: Tower. The Eiffel Tower is a famous landmark in Paris, France."
 }
 ```
 
@@ -67,29 +121,46 @@ fn main() {
 
 ```rs
 use mistralai_client::v1::{
-    chat::{ChatMessage, ChatParams},
+    chat::{ChatMessage, ChatMessageRole, ChatParams},
     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::mistral_small_latest();
-    let messages = vec![ChatMessage::new_user_message("What is the Eiffel Tower?")];
+    let model = Model::OpenMistral7b;
+    let messages = vec![ChatMessage {
+        role: ChatMessageRole::User,
+        content: "Just guess the next word: \"Eiffel ...\"?".to_string(),
+        tool_calls: None,
+    }];
+    let options = ChatParams {
+        temperature: 0.0,
+        random_seed: Some(42),
+        ..Default::default()
+    };
 
-    let result = client.chat_async(model, messages, None).await.unwrap();
-    println!("{}", result.choices[0].message.content);
+    let result = client
+        .chat_async(model, messages, Some(options))
+        .await
+        .unwrap();
+    println!(
+        "{:?}: {}",
+        result.choices[0].message.role, result.choices[0].message.content
+    );
+    // => "Assistant: Tower. The Eiffel Tower is a famous landmark in Paris, France."
 }
 ```
 
-### Chat with streaming
+### Chat with streaming (async)
 
 ```rs
 use futures::stream::StreamExt;
 use mistralai_client::v1::{
-    chat::{ChatMessage, ChatParams},
+    chat::{ChatMessage, ChatMessageRole, ChatParams},
     client::Client,
     constants::Model,
 };
@@ -97,111 +168,244 @@ use std::io::{self, Write};
 
 #[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::mistral_small_latest();
-    let messages = vec![ChatMessage::new_user_message("Tell me a short story.")];
+    let model = Model::OpenMistral7b;
+    let messages = vec![ChatMessage {
+        role: ChatMessageRole::User,
+        content: "Tell me a short happy story.".to_string(),
+        tool_calls: None,
+    }];
+    let options = ChatParams {
+        temperature: 0.0,
+        random_seed: Some(42),
+        ..Default::default()
+    };
 
-    let stream = client.chat_stream(model, messages, None).await.unwrap();
-    stream
+    let stream_result = client
+        .chat_stream(model, messages, Some(options))
+        .await
+        .unwrap();
+    stream_result
         .for_each(|chunk_result| async {
             match chunk_result {
                 Ok(chunks) => chunks.iter().for_each(|chunk| {
-                    if let Some(content) = &chunk.choices[0].delta.content {
-                        print!("{}", content);
-                        io::stdout().flush().unwrap();
-                    }
+                    print!("{}", chunk.choices[0].delta.content);
+                    io::stdout().flush().unwrap();
+                    // => "Once upon a time, [...]"
                 }),
-                Err(error) => eprintln!("Error: {:?}", error),
+                Err(error) => {
+                    eprintln!("Error processing chunk: {:?}", error)
+                }
             }
         })
         .await;
-    println!();
+    print!("\n") // To persist the last chunk output.
 }
 ```
 
-### Function calling
+### Chat with Function Calling
 
 ```rs
 use mistralai_client::v1::{
-    chat::{ChatMessage, ChatParams},
+    chat::{ChatMessage, ChatMessageRole, ChatParams},
     client::Client,
     constants::Model,
-    tool::{Function, Tool, ToolChoice},
+    tool::{Function, Tool, ToolChoice, ToolFunctionParameter, ToolFunctionParameterType},
 };
 use serde::Deserialize;
 use std::any::Any;
 
 #[derive(Debug, Deserialize)]
-struct GetWeatherArgs { city: String }
+struct GetCityTemperatureArguments {
+    city: String,
+}
 
-struct GetWeatherFunction;
+struct GetCityTemperatureFunction;
 #[async_trait::async_trait]
-impl Function for GetWeatherFunction {
+impl Function for GetCityTemperatureFunction {
     async fn execute(&self, arguments: String) -> Box<dyn Any + Send> {
-        let args: GetWeatherArgs = serde_json::from_str(&arguments).unwrap();
-        Box::new(format!("20°C in {}", args.city))
+        // Deserialize arguments, perform the logic, and return the result
+        let GetCityTemperatureArguments { city } = serde_json::from_str(&arguments).unwrap();
+
+        let temperature = match city.as_str() {
+            "Paris" => "20°C",
+            _ => "Unknown city",
+        };
+
+        Box::new(temperature.to_string())
     }
 }
 
 fn main() {
     let tools = vec![Tool::new(
-        "get_weather".to_string(),
-        "Get the weather in a city.".to_string(),
-        serde_json::json!({
-            "type": "object",
-            "properties": {
-                "city": { "type": "string", "description": "City name" }
-            },
-            "required": ["city"]
-        }),
+        "get_city_temperature".to_string(),
+        "Get the current temperature in a city.".to_string(),
+        vec![ToolFunctionParameter::new(
+            "city".to_string(),
+            "The name of the city.".to_string(),
+            ToolFunctionParameterType::String,
+        )],
     )];
 
+    // This example suppose you have set the `MISTRAL_API_KEY` environment variable.
     let mut client = Client::new(None, None, None, None).unwrap();
-    client.register_function("get_weather".to_string(), Box::new(GetWeatherFunction));
+    client.register_function(
+        "get_city_temperature".to_string(),
+        Box::new(GetCityTemperatureFunction),
+    );
 
-    let messages = vec![ChatMessage::new_user_message("What's the weather in Paris?")];
+    let model = Model::MistralSmallLatest;
+    let messages = vec![ChatMessage {
+        role: ChatMessageRole::User,
+        content: "What's the temperature in Paris?".to_string(),
+        tool_calls: None,
+    }];
     let options = ChatParams {
+        temperature: 0.0,
+        random_seed: Some(42),
         tool_choice: Some(ToolChoice::Auto),
         tools: Some(tools),
         ..Default::default()
     };
 
-    client.chat(Model::mistral_small_latest(), messages, Some(options)).unwrap();
-    let result = client.get_last_function_call_result().unwrap().downcast::<String>().unwrap();
-    println!("{}", result);
+    client.chat(model, messages, Some(options)).unwrap();
+    let temperature = client
+        .get_last_function_call_result()
+        .unwrap()
+        .downcast::<String>()
+        .unwrap();
+    println!("The temperature in Paris is: {}.", temperature);
+    // => "The temperature in Paris is: 20°C."
 }
 ```
 
-### FIM (code completion)
+### Chat with Function Calling (async)
 
 ```rs
-use mistralai_client::v1::{client::Client, constants::Model, fim::FimParams};
+use mistralai_client::v1::{
+    chat::{ChatMessage, ChatMessageRole, ChatParams},
+    client::Client,
+    constants::Model,
+    tool::{Function, Tool, ToolChoice, ToolFunctionParameter, ToolFunctionParameterType},
+};
+use serde::Deserialize;
+use std::any::Any;
 
-fn main() {
-    let client = Client::new(None, None, None, None).unwrap();
+#[derive(Debug, Deserialize)]
+struct GetCityTemperatureArguments {
+    city: String,
+}
 
-    let options = FimParams {
-        suffix: Some("\n    return result".to_string()),
+struct GetCityTemperatureFunction;
+#[async_trait::async_trait]
+impl Function for GetCityTemperatureFunction {
+    async fn execute(&self, arguments: String) -> Box<dyn Any + Send> {
+        // Deserialize arguments, perform the logic, and return the result
+        let GetCityTemperatureArguments { city } = serde_json::from_str(&arguments).unwrap();
+
+        let temperature = match city.as_str() {
+            "Paris" => "20°C",
+            _ => "Unknown city",
+        };
+
+        Box::new(temperature.to_string())
+    }
+}
+
+#[tokio::main]
+async fn main() {
+    let tools = vec![Tool::new(
+        "get_city_temperature".to_string(),
+        "Get the current temperature in a city.".to_string(),
+        vec![ToolFunctionParameter::new(
+            "city".to_string(),
+            "The name of the city.".to_string(),
+            ToolFunctionParameterType::String,
+        )],
+    )];
+
+    // This example suppose you have set the `MISTRAL_API_KEY` environment variable.
+    let mut client = Client::new(None, None, None, None).unwrap();
+    client.register_function(
+        "get_city_temperature".to_string(),
+        Box::new(GetCityTemperatureFunction),
+    );
+
+    let model = Model::MistralSmallLatest;
+    let messages = vec![ChatMessage {
+        role: ChatMessageRole::User,
+        content: "What's the temperature in Paris?".to_string(),
+        tool_calls: None,
+    }];
+    let options = ChatParams {
+        temperature: 0.0,
+        random_seed: Some(42),
+        tool_choice: Some(ToolChoice::Auto),
+        tools: Some(tools),
         ..Default::default()
     };
 
-    let result = client.fim(Model::codestral_latest(), "def fibonacci(".to_string(), Some(options)).unwrap();
-    println!("{}", result.choices[0].message.content);
+    client
+        .chat_async(model, messages, Some(options))
+        .await
+        .unwrap();
+    let temperature = client
+        .get_last_function_call_result()
+        .unwrap()
+        .downcast::<String>()
+        .unwrap();
+    println!("The temperature in Paris is: {}.", temperature);
+    // => "The temperature in Paris is: 20°C."
 }
 ```
 
 ### Embeddings
 
 ```rs
-use mistralai_client::v1::{client::Client, constants::Model};
+use mistralai_client::v1::{client::Client, constants::EmbedModel};
 
 fn main() {
-    let client = Client::new(None, None, None, None).unwrap();
+    // This example suppose you have set the `MISTRAL_API_KEY` environment variable.
+    let client: Client = Client::new(None, None, None, None).unwrap();
 
-    let input = vec!["Hello world".to_string(), "Goodbye world".to_string()];
-    let response = client.embeddings(Model::mistral_embed(), input, None).unwrap();
-    println!("Dimensions: {}", response.data[0].embedding.len());
+    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!("First Embedding: {:?}", response.data[0]);
+    // => "First Embedding: {...}"
+}
+```
+
+### 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!("First Embedding: {:?}", response.data[0]);
+    // => "First Embedding: {...}"
 }
 ```
 
@@ -211,62 +415,31 @@ fn main() {
 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).unwrap();
 
-    let models = client.list_models().unwrap();
-    for model in &models.data {
-        println!("{}", model.id);
-    }
+    let result = client.list_models().unwrap();
+    println!("First Model ID: {:?}", result.data[0].id);
+    // => "First Model ID: open-mistral-7b"
 }
 ```
 
-### OCR
+### List models (async)
 
 ```rs
-use mistralai_client::v1::{
-    client::Client,
-    constants::Model,
-    ocr::{OcrDocument, OcrRequest},
-};
+use mistralai_client::v1::client::Client;
 
-fn main() {
+#[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 request = OcrRequest {
-        model: Model::mistral_ocr_latest(),
-        document: OcrDocument::from_url("https://example.com/document.pdf"),
-        pages: Some(vec![0]),
-        table_format: None,
-        include_image_base64: None,
-        image_limit: None,
-    };
-
-    let response = client.ocr(&request).unwrap();
-    println!("{}", response.pages[0].markdown);
+    let result = client.list_models_async().await.unwrap();
+    println!("First Model ID: {:?}", result.data[0].id);
+    // => "First Model ID: open-mistral-7b"
 }
 ```
 
-## Available Models
+## Contributing
 
-Use `Model::new("any-model-id")` for any model, or use the built-in constructors:
-
-| Constructor | Model ID |
-|---|---|
-| `Model::mistral_large_latest()` | `mistral-large-latest` |
-| `Model::mistral_medium_latest()` | `mistral-medium-latest` |
-| `Model::mistral_small_latest()` | `mistral-small-latest` |
-| `Model::mistral_small_4()` | `mistral-small-4-0-26-03` |
-| `Model::codestral_latest()` | `codestral-latest` |
-| `Model::magistral_medium_latest()` | `magistral-medium-latest` |
-| `Model::magistral_small_latest()` | `magistral-small-latest` |
-| `Model::mistral_embed()` | `mistral-embed` |
-| `Model::mistral_ocr_latest()` | `mistral-ocr-latest` |
-| `Model::mistral_moderation_latest()` | `mistral-moderation-26-03` |
-| `Model::pixtral_large()` | `pixtral-large-2411` |
-| `Model::voxtral_mini_transcribe()` | `voxtral-mini-transcribe-2-26-02` |
-
-See `constants.rs` for the full list.
-
-## License
-
-Apache-2.0
+Please read [CONTRIBUTING.md](./CONTRIBUTING.md) for details on how to contribute to this library.

README.template.md

@@ -0,0 +1,127 @@
+# Mistral AI Rust Client
+
+[![Crates.io Package](https://img.shields.io/crates/v/mistralai-client?style=for-the-badge)](https://crates.io/crates/mistralai-client)
+[![Docs.rs Documentation](https://img.shields.io/docsrs/mistralai-client/latest?style=for-the-badge)](https://docs.rs/mistralai-client/latest/mistralai-client)
+[![Test Workflow Status](https://img.shields.io/github/actions/workflow/status/ivangabriele/mistralai-client-rs/test.yml?label=CI&style=for-the-badge)](https://github.com/ivangabriele/mistralai-client-rs/actions?query=branch%3Amain+workflow%3ATest++)
+[![Code Coverage](https://img.shields.io/codecov/c/github/ivangabriele/mistralai-client-rs/main?label=Cov&style=for-the-badge)](https://app.codecov.io/github/ivangabriele/mistralai-client-rs)
+
+Rust client for the Mistral AI API.
+
+> [!IMPORTANT]  
+> While we are in v0, minor versions may introduce breaking changes.  
+> Please, refer to the [CHANGELOG.md](./CHANGELOG.md) for more information.
+
+---
+
+- [Supported APIs](#supported-apis)
+- [Installation](#installation)
+  - [Mistral API Key](#mistral-api-key)
+    - [As an environment variable](#as-an-environment-variable)
+    - [As a client argument](#as-a-client-argument)
+- [Usage](#usage)
+  - [Chat](#chat)
+  - [Chat (async)](#chat-async)
+  - [Chat with streaming (async)](#chat-with-streaming-async)
+  - [Chat with Function Calling](#chat-with-function-calling)
+  - [Chat with Function Calling (async)](#chat-with-function-calling-async)
+  - [Embeddings](#embeddings)
+  - [Embeddings (async)](#embeddings-async)
+  - [List models](#list-models)
+  - [List models (async)](#list-models-async)
+- [Contributing](#contributing)
+
+---
+
+## Supported APIs
+
+- [x] Chat without streaming
+- [x] Chat without streaming (async)
+- [x] Chat with streaming
+- [x] Embedding
+- [x] Embedding (async)
+- [x] List models
+- [x] List models (async)
+- [x] Function Calling
+- [x] Function Calling (async)
+
+## Installation
+
+You can install the library in your project using:
+
+```sh
+cargo add mistralai-client
+```
+
+### Mistral API Key
+
+You can get your Mistral API Key there: <https://docs.mistral.ai/#api-access>.
+
+#### As an environment variable
+
+Just set the `MISTRAL_API_KEY` environment variable.
+
+```rs
+use mistralai_client::v1::client::Client;
+
+fn main() {
+    let client = Client::new(None, None, None, None);
+}
+```
+
+```sh
+MISTRAL_API_KEY=your_api_key cargo run
+```
+
+#### As a client argument
+
+```rs
+use mistralai_client::v1::client::Client;
+
+fn main() {
+    let api_key = "your_api_key";
+
+    let client = Client::new(Some(api_key), None, None, None).unwrap();
+}
+```
+
+## Usage
+
+### Chat
+
+<CODE>examples/chat.rs</CODE>
+
+### Chat (async)
+
+<CODE>examples/chat_async.rs</CODE>
+
+### Chat with streaming (async)
+
+<CODE>examples/chat_with_streaming.rs</CODE>
+
+### Chat with Function Calling
+
+<CODE>examples/chat_with_function_calling.rs</CODE>
+
+### Chat with Function Calling (async)
+
+<CODE>examples/chat_with_function_calling_async.rs</CODE>
+
+### Embeddings
+
+<CODE>examples/embeddings.rs</CODE>
+
+### Embeddings (async)
+
+<CODE>examples/embeddings_async.rs</CODE>
+
+### List models
+
+<CODE>examples/list_models.rs</CODE>
+
+### List models (async)
+
+<CODE>examples/list_models_async.rs</CODE>
+
+## Contributing
+
+Please read [CONTRIBUTING.md](./CONTRIBUTING.md) for details on how to contribute to this library.

examples/chat.rs

@@ -1,5 +1,5 @@
 use mistralai_client::v1::{
-    chat::{ChatMessage, ChatParams},
+    chat::{ChatMessage, ChatMessageRole, ChatParams},
     client::Client,
     constants::Model,
 };
@@ -8,12 +8,14 @@ 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::mistral_small_latest();
-    let messages = vec![ChatMessage::new_user_message(
-        "Just guess the next word: \"Eiffel ...\"?",
-    )];
+    let model = Model::OpenMistral7b;
+    let messages = vec![ChatMessage {
+        role: ChatMessageRole::User,
+        content: "Just guess the next word: \"Eiffel ...\"?".to_string(),
+        tool_calls: None,
+    }];
     let options = ChatParams {
-        temperature: Some(0.0),
+        temperature: 0.0,
         random_seed: Some(42),
         ..Default::default()
     };

examples/chat_async.rs

@@ -1,5 +1,5 @@
 use mistralai_client::v1::{
-    chat::{ChatMessage, ChatParams},
+    chat::{ChatMessage, ChatMessageRole, ChatParams},
     client::Client,
     constants::Model,
 };
@@ -9,12 +9,14 @@ 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::mistral_small_latest();
-    let messages = vec![ChatMessage::new_user_message(
-        "Just guess the next word: \"Eiffel ...\"?",
-    )];
+    let model = Model::OpenMistral7b;
+    let messages = vec![ChatMessage {
+        role: ChatMessageRole::User,
+        content: "Just guess the next word: \"Eiffel ...\"?".to_string(),
+        tool_calls: None,
+    }];
     let options = ChatParams {
-        temperature: Some(0.0),
+        temperature: 0.0,
         random_seed: Some(42),
         ..Default::default()
     };
@@ -27,4 +29,5 @@ async fn main() {
         "{:?}: {}",
         result.choices[0].message.role, result.choices[0].message.content
     );
+    // => "Assistant: Tower. The Eiffel Tower is a famous landmark in Paris, France."
 }

examples/chat_with_function_calling.rs

@@ -1,8 +1,8 @@
 use mistralai_client::v1::{
-    chat::{ChatMessage, ChatParams},
+    chat::{ChatMessage, ChatMessageRole, ChatParams},
     client::Client,
     constants::Model,
-    tool::{Function, Tool, ToolChoice},
+    tool::{Function, Tool, ToolChoice, ToolFunctionParameter, ToolFunctionParameterType},
 };
 use serde::Deserialize;
 use std::any::Any;
@@ -16,6 +16,7 @@ struct GetCityTemperatureFunction;
 #[async_trait::async_trait]
 impl Function for GetCityTemperatureFunction {
     async fn execute(&self, arguments: String) -> Box<dyn Any + Send> {
+        // Deserialize arguments, perform the logic, and return the result
         let GetCityTemperatureArguments { city } = serde_json::from_str(&arguments).unwrap();
 
         let temperature = match city.as_str() {
@@ -31,16 +32,11 @@ fn main() {
     let tools = vec![Tool::new(
         "get_city_temperature".to_string(),
         "Get the current temperature in a city.".to_string(),
-        serde_json::json!({
-            "type": "object",
-            "properties": {
-                "city": {
-                    "type": "string",
-                    "description": "The name of the city."
-                }
-            },
-            "required": ["city"]
-        }),
+        vec![ToolFunctionParameter::new(
+            "city".to_string(),
+            "The name of the city.".to_string(),
+            ToolFunctionParameterType::String,
+        )],
     )];
 
     // This example suppose you have set the `MISTRAL_API_KEY` environment variable.
@@ -50,12 +46,14 @@ fn main() {
         Box::new(GetCityTemperatureFunction),
     );
 
-    let model = Model::mistral_small_latest();
-    let messages = vec![ChatMessage::new_user_message(
-        "What's the temperature in Paris?",
-    )];
+    let model = Model::MistralSmallLatest;
+    let messages = vec![ChatMessage {
+        role: ChatMessageRole::User,
+        content: "What's the temperature in Paris?".to_string(),
+        tool_calls: None,
+    }];
     let options = ChatParams {
-        temperature: Some(0.0),
+        temperature: 0.0,
         random_seed: Some(42),
         tool_choice: Some(ToolChoice::Auto),
         tools: Some(tools),

examples/chat_with_function_calling_async.rs

@@ -1,8 +1,8 @@
 use mistralai_client::v1::{
-    chat::{ChatMessage, ChatParams},
+    chat::{ChatMessage, ChatMessageRole, ChatParams},
     client::Client,
     constants::Model,
-    tool::{Function, Tool, ToolChoice},
+    tool::{Function, Tool, ToolChoice, ToolFunctionParameter, ToolFunctionParameterType},
 };
 use serde::Deserialize;
 use std::any::Any;
@@ -16,6 +16,7 @@ struct GetCityTemperatureFunction;
 #[async_trait::async_trait]
 impl Function for GetCityTemperatureFunction {
     async fn execute(&self, arguments: String) -> Box<dyn Any + Send> {
+        // Deserialize arguments, perform the logic, and return the result
         let GetCityTemperatureArguments { city } = serde_json::from_str(&arguments).unwrap();
 
         let temperature = match city.as_str() {
@@ -32,16 +33,11 @@ async fn main() {
     let tools = vec![Tool::new(
         "get_city_temperature".to_string(),
         "Get the current temperature in a city.".to_string(),
-        serde_json::json!({
-            "type": "object",
-            "properties": {
-                "city": {
-                    "type": "string",
-                    "description": "The name of the city."
-                }
-            },
-            "required": ["city"]
-        }),
+        vec![ToolFunctionParameter::new(
+            "city".to_string(),
+            "The name of the city.".to_string(),
+            ToolFunctionParameterType::String,
+        )],
     )];
 
     // This example suppose you have set the `MISTRAL_API_KEY` environment variable.
@@ -51,12 +47,14 @@ async fn main() {
         Box::new(GetCityTemperatureFunction),
     );
 
-    let model = Model::mistral_small_latest();
-    let messages = vec![ChatMessage::new_user_message(
-        "What's the temperature in Paris?",
-    )];
+    let model = Model::MistralSmallLatest;
+    let messages = vec![ChatMessage {
+        role: ChatMessageRole::User,
+        content: "What's the temperature in Paris?".to_string(),
+        tool_calls: None,
+    }];
     let options = ChatParams {
-        temperature: Some(0.0),
+        temperature: 0.0,
         random_seed: Some(42),
         tool_choice: Some(ToolChoice::Auto),
         tools: Some(tools),

examples/chat_with_streaming.rs

@@ -1,6 +1,6 @@
 use futures::stream::StreamExt;
 use mistralai_client::v1::{
-    chat::{ChatMessage, ChatParams},
+    chat::{ChatMessage, ChatMessageRole, ChatParams},
     client::Client,
     constants::Model,
 };
@@ -11,10 +11,14 @@ 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::mistral_small_latest();
-    let messages = vec![ChatMessage::new_user_message("Tell me a short happy story.")];
+    let model = Model::OpenMistral7b;
+    let messages = vec![ChatMessage {
+        role: ChatMessageRole::User,
+        content: "Tell me a short happy story.".to_string(),
+        tool_calls: None,
+    }];
     let options = ChatParams {
-        temperature: Some(0.0),
+        temperature: 0.0,
         random_seed: Some(42),
         ..Default::default()
     };
@@ -27,10 +31,9 @@ async fn main() {
         .for_each(|chunk_result| async {
             match chunk_result {
                 Ok(chunks) => chunks.iter().for_each(|chunk| {
-                    if let Some(content) = &chunk.choices[0].delta.content {
-                        print!("{}", content);
-                        io::stdout().flush().unwrap();
-                    }
+                    print!("{}", chunk.choices[0].delta.content);
+                    io::stdout().flush().unwrap();
+                    // => "Once upon a time, [...]"
                 }),
                 Err(error) => {
                     eprintln!("Error processing chunk: {:?}", error)
@@ -38,5 +41,5 @@ async fn main() {
             }
         })
         .await;
-    println!();
+    print!("\n") // To persist the last chunk output.
 }

examples/embeddings.rs

@@ -1,10 +1,10 @@
-use mistralai_client::v1::{client::Client, constants::Model};
+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 = Model::mistral_embed();
+    let model = EmbedModel::MistralEmbed;
     let input = vec!["Embed this sentence.", "As well as this one."]
         .iter()
         .map(|s| s.to_string())
@@ -13,4 +13,5 @@ fn main() {
 
     let response = client.embeddings(model, input, options).unwrap();
     println!("First Embedding: {:?}", response.data[0]);
+    // => "First Embedding: {...}"
 }

examples/embeddings_async.rs

@@ -1,11 +1,11 @@
-use mistralai_client::v1::{client::Client, constants::Model};
+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 = Model::mistral_embed();
+    let model = EmbedModel::MistralEmbed;
     let input = vec!["Embed this sentence.", "As well as this one."]
         .iter()
         .map(|s| s.to_string())
@@ -17,4 +17,5 @@ async fn main() {
         .await
         .unwrap();
     println!("First Embedding: {:?}", response.data[0]);
+    // => "First Embedding: {...}"
 }

examples/fim.rs

@@ -1,21 +0,0 @@
-use mistralai_client::v1::{
-    client::Client,
-    constants::Model,
-    fim::FimParams,
-};
-
-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::codestral_latest();
-    let prompt = "def fibonacci(n):".to_string();
-    let options = FimParams {
-        suffix: Some("\n    return result".to_string()),
-        temperature: Some(0.0),
-        ..Default::default()
-    };
-
-    let response = client.fim(model, prompt, Some(options)).unwrap();
-    println!("Completion: {}", response.choices[0].message.content);
-}

examples/ocr.rs

@@ -1,25 +0,0 @@
-use mistralai_client::v1::{
-    client::Client,
-    constants::Model,
-    ocr::{OcrDocument, OcrRequest},
-};
-
-fn main() {
-    // This example suppose you have set the `MISTRAL_API_KEY` environment variable.
-    let client = Client::new(None, None, None, None).unwrap();
-
-    let request = OcrRequest {
-        model: Model::mistral_ocr_latest(),
-        document: OcrDocument::from_url("https://arxiv.org/pdf/2201.04234"),
-        pages: Some(vec![0]),
-        table_format: None,
-        include_image_base64: None,
-        image_limit: None,
-    };
-
-    let response = client.ocr(&request).unwrap();
-    for page in &response.pages {
-        println!("--- Page {} ---", page.index);
-        println!("{}", &page.markdown[..200.min(page.markdown.len())]);
-    }
-}

justfile

@@ -1,27 +0,0 @@
-check:
-    cargo check --all-targets
-
-doc:
-    cargo doc --open
-
-fmt:
-    cargo fmt
-
-lint:
-    cargo clippy --all-targets
-
-publish:
-    cargo publish --registry sunbeam
-
-test:
-    cargo test --no-fail-fast
-
-test-cover:
-    cargo llvm-cov
-
-test-examples:
-    #!/usr/bin/env bash
-    for example in $(ls examples/*.rs | sed 's/examples\/\(.*\)\.rs/\1/'); do
-        echo "Running $example"
-        cargo run --example "$example"
-    done

src/lib.rs

@@ -1,7 +1,4 @@
-//! Rust client for the [Mistral AI API](https://docs.mistral.ai/api/).
-//!
-//! Supports chat completions, embeddings, FIM, files, fine-tuning, batch jobs,
-//! OCR, audio transcription, moderations, classifications, and agent completions.
+//! This crate provides a easy bindings and types for MistralAI's API.
 
-/// The v1 module contains types and methods for all `/v1/` API endpoints.
+/// The v1 module contains the types and methods for the v1 API endpoints.
 pub mod v1;

src/v1/agents.rs

@@ -1,283 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use crate::v1::{chat, common, constants, tool};
-
-// =============================================================================
-// Agent Completions (existing — POST /v1/agents/completions)
-// =============================================================================
-
-#[derive(Debug)]
-pub struct AgentCompletionParams {
-    pub max_tokens: Option<u32>,
-    pub min_tokens: Option<u32>,
-    pub temperature: Option<f32>,
-    pub top_p: Option<f32>,
-    pub random_seed: Option<u32>,
-    pub stop: Option<Vec<String>>,
-    pub response_format: Option<chat::ResponseFormat>,
-    pub tools: Option<Vec<tool::Tool>>,
-    pub tool_choice: Option<tool::ToolChoice>,
-}
-impl Default for AgentCompletionParams {
-    fn default() -> Self {
-        Self {
-            max_tokens: None,
-            min_tokens: None,
-            temperature: None,
-            top_p: None,
-            random_seed: None,
-            stop: None,
-            response_format: None,
-            tools: None,
-            tool_choice: None,
-        }
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct AgentCompletionRequest {
-    pub agent_id: String,
-    pub messages: Vec<chat::ChatMessage>,
-    pub stream: bool,
-
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub max_tokens: Option<u32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub min_tokens: Option<u32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub temperature: Option<f32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    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 stop: Option<Vec<String>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub response_format: Option<chat::ResponseFormat>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub tools: Option<Vec<tool::Tool>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub tool_choice: Option<tool::ToolChoice>,
-}
-impl AgentCompletionRequest {
-    pub fn new(
-        agent_id: String,
-        messages: Vec<chat::ChatMessage>,
-        stream: bool,
-        options: Option<AgentCompletionParams>,
-    ) -> Self {
-        let opts = options.unwrap_or_default();
-
-        Self {
-            agent_id,
-            messages,
-            stream,
-            max_tokens: opts.max_tokens,
-            min_tokens: opts.min_tokens,
-            temperature: opts.temperature,
-            top_p: opts.top_p,
-            random_seed: opts.random_seed,
-            stop: opts.stop,
-            response_format: opts.response_format,
-            tools: opts.tools,
-            tool_choice: opts.tool_choice,
-        }
-    }
-}
-
-// Agent completion response (same shape as chat completions)
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct AgentCompletionResponse {
-    pub id: String,
-    pub object: String,
-    pub created: u64,
-    pub model: constants::Model,
-    pub choices: Vec<chat::ChatResponseChoice>,
-    pub usage: common::ResponseUsage,
-}
-
-// =============================================================================
-// Agents API — CRUD (Beta)
-// POST/GET/PATCH/DELETE /v1/agents
-// =============================================================================
-
-// -----------------------------------------------------------------------------
-// Tool types for agents
-
-/// A function tool definition for an agent.
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct FunctionTool {
-    pub function: tool::ToolFunction,
-}
-
-/// Tool types available to agents.
-#[derive(Clone, Debug, Serialize, Deserialize)]
-#[serde(tag = "type")]
-pub enum AgentTool {
-    #[serde(rename = "function")]
-    Function(FunctionTool),
-    #[serde(rename = "web_search")]
-    WebSearch {},
-    #[serde(rename = "web_search_premium")]
-    WebSearchPremium {},
-    #[serde(rename = "code_interpreter")]
-    CodeInterpreter {},
-    #[serde(rename = "image_generation")]
-    ImageGeneration {},
-    #[serde(rename = "document_library")]
-    DocumentLibrary {},
-}
-
-impl AgentTool {
-    /// Create a function tool from name, description, and JSON Schema parameters.
-    pub fn function(name: String, description: String, parameters: serde_json::Value) -> Self {
-        Self::Function(FunctionTool {
-            function: tool::ToolFunction {
-                name,
-                description,
-                parameters,
-            },
-        })
-    }
-
-    pub fn web_search() -> Self {
-        Self::WebSearch {}
-    }
-
-    pub fn code_interpreter() -> Self {
-        Self::CodeInterpreter {}
-    }
-
-    pub fn image_generation() -> Self {
-        Self::ImageGeneration {}
-    }
-
-    pub fn document_library() -> Self {
-        Self::DocumentLibrary {}
-    }
-}
-
-// -----------------------------------------------------------------------------
-// Completion args (subset of chat params allowed for agents)
-
-#[derive(Clone, Debug, Default, Serialize, Deserialize)]
-pub struct CompletionArgs {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub temperature: Option<f32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub top_p: Option<f32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub max_tokens: Option<u32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub min_tokens: Option<u32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub random_seed: Option<u32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub stop: Option<Vec<String>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub frequency_penalty: Option<f32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub presence_penalty: Option<f32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub response_format: Option<chat::ResponseFormat>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub tool_choice: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub prediction: Option<serde_json::Value>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub reasoning_effort: Option<String>,
-}
-
-// -----------------------------------------------------------------------------
-// Create agent request
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct CreateAgentRequest {
-    pub model: String,
-    pub name: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub description: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub instructions: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub tools: Option<Vec<AgentTool>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub handoffs: Option<Vec<String>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub completion_args: Option<CompletionArgs>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub metadata: Option<serde_json::Value>,
-}
-
-// -----------------------------------------------------------------------------
-// Update agent request
-
-#[derive(Clone, Debug, Default, Serialize, Deserialize)]
-pub struct UpdateAgentRequest {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub model: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub name: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub description: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub instructions: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub tools: Option<Vec<AgentTool>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub handoffs: Option<Vec<String>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub completion_args: Option<CompletionArgs>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub metadata: Option<serde_json::Value>,
-}
-
-// -----------------------------------------------------------------------------
-// Agent response
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct Agent {
-    pub id: String,
-    pub object: String,
-    pub name: String,
-    pub model: String,
-    pub created_at: String,
-    pub updated_at: String,
-    #[serde(default)]
-    pub version: u64,
-    #[serde(default)]
-    pub versions: Vec<u64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub description: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub instructions: Option<String>,
-    #[serde(default)]
-    pub tools: Vec<AgentTool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub handoffs: Option<Vec<String>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub completion_args: Option<CompletionArgs>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub metadata: Option<serde_json::Value>,
-    #[serde(default)]
-    pub deployment_chat: bool,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub source: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub version_message: Option<String>,
-    #[serde(default)]
-    pub guardrails: Vec<serde_json::Value>,
-}
-
-/// List agents response. The API returns a raw JSON array of agents.
-#[derive(Clone, Debug, Deserialize, Serialize)]
-#[serde(transparent)]
-pub struct AgentListResponse {
-    pub data: Vec<Agent>,
-}
-
-/// Delete agent response. The API returns 204 No Content on success.
-#[derive(Clone, Debug)]
-pub struct AgentDeleteResponse {
-    pub deleted: bool,
-}

src/v1/audio.rs

@@ -1,78 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use crate::v1::constants;
-
-// -----------------------------------------------------------------------------
-// Request (multipart form, but we define the params struct)
-
-#[derive(Debug)]
-pub struct AudioTranscriptionParams {
-    pub model: constants::Model,
-    pub language: Option<String>,
-    pub temperature: Option<f32>,
-    pub diarize: Option<bool>,
-    pub timestamp_granularities: Option<Vec<TimestampGranularity>>,
-}
-impl Default for AudioTranscriptionParams {
-    fn default() -> Self {
-        Self {
-            model: constants::Model::voxtral_mini_transcribe(),
-            language: None,
-            temperature: None,
-            diarize: None,
-            timestamp_granularities: None,
-        }
-    }
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "lowercase")]
-pub enum TimestampGranularity {
-    Segment,
-    Word,
-}
-
-// -----------------------------------------------------------------------------
-// Response
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct AudioTranscriptionResponse {
-    pub text: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub model: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub language: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub segments: Option<Vec<TranscriptionSegment>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub words: Option<Vec<TranscriptionWord>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub usage: Option<AudioUsage>,
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct TranscriptionSegment {
-    pub id: u32,
-    pub start: f32,
-    pub end: f32,
-    pub text: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub speaker: Option<String>,
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct TranscriptionWord {
-    pub word: String,
-    pub start: f32,
-    pub end: f32,
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct AudioUsage {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub prompt_audio_seconds: Option<f32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub prompt_tokens: Option<u32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub total_tokens: Option<u32>,
-}

src/v1/batch.rs

@@ -1,53 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use crate::v1::constants;
-
-// -----------------------------------------------------------------------------
-// Request
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct BatchJobRequest {
-    pub input_files: Vec<String>,
-    pub model: constants::Model,
-    pub endpoint: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub metadata: Option<serde_json::Value>,
-}
-
-// -----------------------------------------------------------------------------
-// Response
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct BatchJobResponse {
-    pub id: String,
-    pub object: String,
-    pub model: constants::Model,
-    pub endpoint: String,
-    pub input_files: Vec<String>,
-    pub status: String,
-    pub created_at: u64,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub completed_at: Option<u64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_file: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub error_file: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub metadata: Option<serde_json::Value>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub total_requests: Option<u64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub completed_requests: Option<u64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub succeeded_requests: Option<u64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub failed_requests: Option<u64>,
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct BatchJobListResponse {
-    pub data: Vec<BatchJobResponse>,
-    pub object: String,
-    #[serde(default)]
-    pub total: u32,
-}

src/v1/chat.rs

@@ -2,161 +2,35 @@ use serde::{Deserialize, Serialize};
 
 use crate::v1::{common, constants, tool};
 
-// -----------------------------------------------------------------------------
-// Content parts (multimodal)
-
-/// A single part of a multimodal message.
-#[derive(Clone, Debug, Deserialize, Serialize)]
-#[serde(tag = "type")]
-pub enum ContentPart {
-    #[serde(rename = "text")]
-    Text { text: String },
-    #[serde(rename = "image_url")]
-    ImageUrl {
-        image_url: ImageUrl,
-    },
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct ImageUrl {
-    pub url: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub detail: Option<String>,
-}
-
-/// Message content: either a plain text string or multimodal content parts.
-///
-/// Serializes as a JSON string for text, or a JSON array for parts.
-/// All existing `new_*_message()` constructors produce `Text` variants,
-/// so existing code continues to work unchanged.
-#[derive(Clone, Debug, Deserialize, Serialize)]
-#[serde(untagged)]
-pub enum ChatMessageContent {
-    Text(String),
-    Parts(Vec<ContentPart>),
-}
-
-impl ChatMessageContent {
-    /// Extract the text content. For multimodal messages, concatenates all text parts.
-    pub fn text(&self) -> String {
-        match self {
-            Self::Text(s) => s.clone(),
-            Self::Parts(parts) => parts
-                .iter()
-                .filter_map(|p| match p {
-                    ContentPart::Text { text } => Some(text.as_str()),
-                    _ => None,
-                })
-                .collect::<Vec<_>>()
-                .join(""),
-        }
-    }
-
-    /// Returns the content as a string slice if it is a plain text message.
-    pub fn as_text(&self) -> Option<&str> {
-        match self {
-            Self::Text(s) => Some(s),
-            Self::Parts(_) => None,
-        }
-    }
-
-    /// Returns true if this is a multimodal message with image parts.
-    pub fn has_images(&self) -> bool {
-        match self {
-            Self::Text(_) => false,
-            Self::Parts(parts) => parts.iter().any(|p| matches!(p, ContentPart::ImageUrl { .. })),
-        }
-    }
-}
-
-impl std::fmt::Display for ChatMessageContent {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.text())
-    }
-}
-
-impl From<String> for ChatMessageContent {
-    fn from(s: String) -> Self {
-        Self::Text(s)
-    }
-}
-
-impl From<&str> for ChatMessageContent {
-    fn from(s: &str) -> Self {
-        Self::Text(s.to_string())
-    }
-}
-
 // -----------------------------------------------------------------------------
 // Definitions
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct ChatMessage {
     pub role: ChatMessageRole,
-    pub content: ChatMessageContent,
+    pub content: String,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub tool_calls: Option<Vec<tool::ToolCall>>,
-    /// Tool call ID, required when role is Tool.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub tool_call_id: Option<String>,
-    /// Function name, used when role is Tool.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub name: Option<String>,
 }
 impl ChatMessage {
-    pub fn new_system_message(content: &str) -> Self {
-        Self {
-            role: ChatMessageRole::System,
-            content: ChatMessageContent::Text(content.to_string()),
-            tool_calls: None,
-            tool_call_id: None,
-            name: None,
-        }
-    }
-
     pub fn new_assistant_message(content: &str, tool_calls: Option<Vec<tool::ToolCall>>) -> Self {
         Self {
             role: ChatMessageRole::Assistant,
-            content: ChatMessageContent::Text(content.to_string()),
+            content: content.to_string(),
             tool_calls,
-            tool_call_id: None,
-            name: None,
         }
     }
 
     pub fn new_user_message(content: &str) -> Self {
         Self {
             role: ChatMessageRole::User,
-            content: ChatMessageContent::Text(content.to_string()),
+            content: content.to_string(),
             tool_calls: None,
-            tool_call_id: None,
-            name: None,
-        }
-    }
-
-    /// Create a user message with mixed text and image content.
-    pub fn new_user_message_with_images(parts: Vec<ContentPart>) -> Self {
-        Self {
-            role: ChatMessageRole::User,
-            content: ChatMessageContent::Parts(parts),
-            tool_calls: None,
-            tool_call_id: None,
-            name: None,
-        }
-    }
-
-    pub fn new_tool_message(content: &str, tool_call_id: &str, name: Option<&str>) -> Self {
-        Self {
-            role: ChatMessageRole::Tool,
-            content: ChatMessageContent::Text(content.to_string()),
-            tool_calls: None,
-            tool_call_id: Some(tool_call_id.to_string()),
-            name: name.map(|n| n.to_string()),
         }
     }
 }
 
-/// See the [chat completions API](https://docs.mistral.ai/api/#tag/chat/operation/chat_completion_v1_chat_completions_post).
+/// See the [Mistral AI API documentation](https://docs.mistral.ai/capabilities/completion/#chat-messages) for more information.
 #[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
 pub enum ChatMessageRole {
     #[serde(rename = "system")]
@@ -170,32 +44,17 @@ pub enum ChatMessageRole {
 }
 
 /// The format that the model must output.
+///
+/// See the [API documentation](https://docs.mistral.ai/api/#operation/createChatCompletion) for more information.
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct ResponseFormat {
     #[serde(rename = "type")]
     pub type_: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub json_schema: Option<serde_json::Value>,
 }
 impl ResponseFormat {
-    pub fn text() -> Self {
-        Self {
-            type_: "text".to_string(),
-            json_schema: None,
-        }
-    }
-
     pub fn json_object() -> Self {
         Self {
             type_: "json_object".to_string(),
-            json_schema: None,
-        }
-    }
-
-    pub fn json_schema(schema: serde_json::Value) -> Self {
-        Self {
-            type_: "json_schema".to_string(),
-            json_schema: Some(schema),
         }
     }
 }
@@ -204,83 +63,91 @@ impl ResponseFormat {
 // Request
 
 /// The parameters for the chat request.
+///
+/// See the [API documentation](https://docs.mistral.ai/api/#operation/createChatCompletion) for more information.
 #[derive(Clone, Debug)]
 pub struct ChatParams {
+    /// The maximum number of tokens to generate in the completion.
+    ///
+    /// Defaults to `None`.
     pub max_tokens: Option<u32>,
-    pub min_tokens: Option<u32>,
+    /// The seed to use for random sampling. If set, different calls will generate deterministic results.
+    ///
+    /// Defaults to `None`.
     pub random_seed: Option<u32>,
+    /// The format that the model must output.
+    ///
+    /// Defaults to `None`.
     pub response_format: Option<ResponseFormat>,
+    /// Whether to inject a safety prompt before all conversations.
+    ///
+    /// Defaults to `false`.
     pub safe_prompt: bool,
-    pub temperature: Option<f32>,
+    /// What sampling temperature to use, between `Some(0.0)` and `Some(1.0)`.
+    ///
+    /// Defaults to `0.7`.
+    pub temperature: f32,
+    /// Specifies if/how functions are called.
+    ///
+    /// Defaults to `None`.
     pub tool_choice: Option<tool::ToolChoice>,
+    /// A list of available tools for the model.
+    ///
+    /// Defaults to `None`.
     pub tools: Option<Vec<tool::Tool>>,
-    pub top_p: Option<f32>,
-    pub stop: Option<Vec<String>>,
-    pub n: Option<u32>,
-    pub frequency_penalty: Option<f32>,
-    pub presence_penalty: Option<f32>,
-    pub parallel_tool_calls: Option<bool>,
-    /// For reasoning models (Magistral). "high" or "none".
-    pub reasoning_effort: Option<String>,
+    /// Nucleus sampling, where the model considers the results of the tokens with `top_p` probability mass.
+    ///
+    /// Defaults to `1.0`.
+    pub top_p: f32,
 }
 impl Default for ChatParams {
     fn default() -> Self {
         Self {
             max_tokens: None,
-            min_tokens: None,
             random_seed: None,
             safe_prompt: false,
             response_format: None,
-            temperature: None,
+            temperature: 0.7,
             tool_choice: None,
             tools: None,
-            top_p: None,
-            stop: None,
-            n: None,
-            frequency_penalty: None,
-            presence_penalty: None,
-            parallel_tool_calls: None,
-            reasoning_effort: None,
+            top_p: 1.0,
+        }
+    }
+}
+impl ChatParams {
+    pub fn json_default() -> Self {
+        Self {
+            max_tokens: None,
+            random_seed: None,
+            safe_prompt: false,
+            response_format: None,
+            temperature: 0.7,
+            tool_choice: None,
+            tools: None,
+            top_p: 1.0,
         }
     }
 }
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct ChatRequest {
-    pub model: constants::Model,
     pub messages: Vec<ChatMessage>,
-    pub stream: bool,
+    pub model: constants::Model,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     pub max_tokens: Option<u32>,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub min_tokens: Option<u32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub random_seed: Option<u32>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub response_format: Option<ResponseFormat>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub safe_prompt: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub temperature: Option<f32>,
+    pub safe_prompt: bool,
+    pub stream: bool,
+    pub temperature: f32,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub tool_choice: Option<tool::ToolChoice>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub tools: Option<Vec<tool::Tool>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub top_p: Option<f32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub stop: Option<Vec<String>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub n: Option<u32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub frequency_penalty: Option<f32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub presence_penalty: Option<f32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub parallel_tool_calls: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub reasoning_effort: Option<String>,
+    pub top_p: f32,
 }
 impl ChatRequest {
     pub fn new(
@@ -289,28 +156,30 @@ impl ChatRequest {
         stream: bool,
         options: Option<ChatParams>,
     ) -> Self {
-        let opts = options.unwrap_or_default();
-        let safe_prompt = if opts.safe_prompt { Some(true) } else { None };
+        let ChatParams {
+            max_tokens,
+            random_seed,
+            safe_prompt,
+            temperature,
+            tool_choice,
+            tools,
+            top_p,
+            response_format,
+        } = options.unwrap_or_default();
 
         Self {
-            model,
             messages,
-            stream,
-            max_tokens: opts.max_tokens,
-            min_tokens: opts.min_tokens,
-            random_seed: opts.random_seed,
+            model,
+
+            max_tokens,
+            random_seed,
             safe_prompt,
-            temperature: opts.temperature,
-            tool_choice: opts.tool_choice,
-            tools: opts.tools,
-            top_p: opts.top_p,
-            response_format: opts.response_format,
-            stop: opts.stop,
-            n: opts.n,
-            frequency_penalty: opts.frequency_penalty,
-            presence_penalty: opts.presence_penalty,
-            parallel_tool_calls: opts.parallel_tool_calls,
-            reasoning_effort: opts.reasoning_effort,
+            stream,
+            temperature,
+            tool_choice,
+            tools,
+            top_p,
+            response_format,
         }
     }
 }
@@ -323,7 +192,7 @@ pub struct ChatResponse {
     pub id: String,
     pub object: String,
     /// Unix timestamp (in seconds).
-    pub created: u64,
+    pub created: u32,
     pub model: constants::Model,
     pub choices: Vec<ChatResponseChoice>,
     pub usage: common::ResponseUsage,
@@ -334,21 +203,14 @@ pub struct ChatResponseChoice {
     pub index: u32,
     pub message: ChatMessage,
     pub finish_reason: ChatResponseChoiceFinishReason,
-    /// Reasoning content returned by Magistral models.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub reasoning: Option<String>,
+    // TODO Check this prop (seen in API responses but undocumented).
+    // pub logprobs: ???
 }
 
 #[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
 pub enum ChatResponseChoiceFinishReason {
     #[serde(rename = "stop")]
     Stop,
-    #[serde(rename = "length")]
-    Length,
     #[serde(rename = "tool_calls")]
     ToolCalls,
-    #[serde(rename = "model_length")]
-    ModelLength,
-    #[serde(rename = "error")]
-    Error,
 }

src/v1/chat_stream.rs

@@ -1,7 +1,7 @@
 use serde::{Deserialize, Serialize};
 use serde_json::from_str;
 
-use crate::v1::{chat, common, constants, error, tool};
+use crate::v1::{chat, common, constants, error};
 
 // -----------------------------------------------------------------------------
 // Response
@@ -11,11 +11,12 @@ pub struct ChatStreamChunk {
     pub id: String,
     pub object: String,
     /// Unix timestamp (in seconds).
-    pub created: u64,
+    pub created: u32,
     pub model: constants::Model,
     pub choices: Vec<ChatStreamChunkChoice>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub usage: Option<common::ResponseUsage>,
+    // TODO Check this prop (seen in API responses but undocumented).
+    // pub logprobs: ???,
 }
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
@@ -23,15 +24,14 @@ pub struct ChatStreamChunkChoice {
     pub index: u32,
     pub delta: ChatStreamChunkChoiceDelta,
     pub finish_reason: Option<String>,
+    // TODO Check this prop (seen in API responses but undocumented).
+    // pub logprobs: ???,
 }
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct ChatStreamChunkChoiceDelta {
     pub role: Option<chat::ChatMessageRole>,
-    #[serde(default)]
-    pub content: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub tool_calls: Option<Vec<tool::ToolCall>>,
+    pub content: String,
 }
 
 /// Extracts serialized chunks from a stream message.
@@ -47,6 +47,7 @@ pub fn get_chunk_from_stream_message_line(
         return Ok(Some(vec![]));
     }
 
+    // Attempt to deserialize the JSON string into ChatStreamChunk
     match from_str::<ChatStreamChunk>(chunk_as_json) {
         Ok(chunk) => Ok(Some(vec![chunk])),
         Err(e) => Err(error::ApiError {

src/v1/common.rs

@@ -3,7 +3,6 @@ use serde::{Deserialize, Serialize};
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct ResponseUsage {
     pub prompt_tokens: u32,
-    #[serde(default)]
     pub completion_tokens: u32,
     pub total_tokens: u32,
 }

src/v1/constants.rs

@@ -1,131 +1,35 @@
-use std::fmt;
-
 use serde::{Deserialize, Serialize};
 
 pub const API_URL_BASE: &str = "https://api.mistral.ai/v1";
 
-/// A Mistral AI model identifier.
-///
-/// Use the associated constants for known models, or construct with `Model::new()` for any model string.
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
-#[serde(transparent)]
-pub struct Model(pub String);
-
-impl Model {
-    pub fn new(id: impl Into<String>) -> Self {
-        Self(id.into())
-    }
-
-    // Flagship / Premier
-    pub fn mistral_large_latest() -> Self {
-        Self::new("mistral-large-latest")
-    }
-    pub fn mistral_large_3() -> Self {
-        Self::new("mistral-large-3-25-12")
-    }
-    pub fn mistral_medium_latest() -> Self {
-        Self::new("mistral-medium-latest")
-    }
-    pub fn mistral_medium_3_1() -> Self {
-        Self::new("mistral-medium-3-1-25-08")
-    }
-    pub fn mistral_small_latest() -> Self {
-        Self::new("mistral-small-latest")
-    }
-    pub fn mistral_small_4() -> Self {
-        Self::new("mistral-small-4-0-26-03")
-    }
-    pub fn mistral_small_3_2() -> Self {
-        Self::new("mistral-small-3-2-25-06")
-    }
-
-    // Ministral
-    pub fn ministral_3_14b() -> Self {
-        Self::new("ministral-3-14b-25-12")
-    }
-    pub fn ministral_3_8b() -> Self {
-        Self::new("ministral-3-8b-25-12")
-    }
-    pub fn ministral_3_3b() -> Self {
-        Self::new("ministral-3-3b-25-12")
-    }
-
-    // Reasoning
-    pub fn magistral_medium_latest() -> Self {
-        Self::new("magistral-medium-latest")
-    }
-    pub fn magistral_small_latest() -> Self {
-        Self::new("magistral-small-latest")
-    }
-
-    // Code
-    pub fn codestral_latest() -> Self {
-        Self::new("codestral-latest")
-    }
-    pub fn codestral_2508() -> Self {
-        Self::new("codestral-2508")
-    }
-    pub fn codestral_embed() -> Self {
-        Self::new("codestral-embed-25-05")
-    }
-    pub fn devstral_2() -> Self {
-        Self::new("devstral-2-25-12")
-    }
-    pub fn devstral_small_2() -> Self {
-        Self::new("devstral-small-2-25-12")
-    }
-
-    // Multimodal / Vision
-    pub fn pixtral_large() -> Self {
-        Self::new("pixtral-large-2411")
-    }
-
-    // Audio
-    pub fn voxtral_mini_transcribe() -> Self {
-        Self::new("voxtral-mini-transcribe-2-26-02")
-    }
-    pub fn voxtral_small() -> Self {
-        Self::new("voxtral-small-25-07")
-    }
-    pub fn voxtral_mini() -> Self {
-        Self::new("voxtral-mini-25-07")
-    }
-
-    // Legacy (kept for backward compatibility)
-    pub fn open_mistral_nemo() -> Self {
-        Self::new("open-mistral-nemo")
-    }
-
-    // Embedding
-    pub fn mistral_embed() -> Self {
-        Self::new("mistral-embed")
-    }
-
-    // Moderation
-    pub fn mistral_moderation_latest() -> Self {
-        Self::new("mistral-moderation-26-03")
-    }
-
-    // OCR
-    pub fn mistral_ocr_latest() -> Self {
-        Self::new("mistral-ocr-latest")
-    }
+#[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
+pub enum Model {
+    #[serde(rename = "open-mistral-7b")]
+    OpenMistral7b,
+    #[serde(rename = "open-mixtral-8x7b")]
+    OpenMixtral8x7b,
+    #[serde(rename = "open-mixtral-8x22b")]
+    OpenMixtral8x22b,
+    #[serde(rename = "open-mistral-nemo", alias = "open-mistral-nemo-2407")]
+    OpenMistralNemo,
+    #[serde(rename = "mistral-tiny")]
+    MistralTiny,
+    #[serde(rename = "mistral-small-latest", alias = "mistral-small-2402")]
+    MistralSmallLatest,
+    #[serde(rename = "mistral-medium-latest", alias = "mistral-medium-2312")]
+    MistralMediumLatest,
+    #[serde(rename = "mistral-large-latest", alias = "mistral-large-2407")]
+    MistralLargeLatest,
+    #[serde(rename = "mistral-large-2402")]
+    MistralLarge,
+    #[serde(rename = "codestral-latest", alias = "codestral-2405")]
+    CodestralLatest,
+    #[serde(rename = "open-codestral-mamba")]
+    CodestralMamba,
 }
 
-impl fmt::Display for Model {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.0)
-    }
-}
-
-impl From<&str> for Model {
-    fn from(s: &str) -> Self {
-        Self(s.to_string())
-    }
-}
-
-impl From<String> for Model {
-    fn from(s: String) -> Self {
-        Self(s)
-    }
+#[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
+pub enum EmbedModel {
+    #[serde(rename = "mistral-embed")]
+    MistralEmbed,
 }

src/v1/conversation_stream.rs

@@ -1,395 +0,0 @@
-//! Streaming support for the Conversations API.
-//!
-//! When `stream: true` is set on a conversation request, the API returns
-//! Server-Sent Events (SSE). Each event has an `event:` type line and a
-//! `data:` JSON payload, discriminated by the `type` field.
-//!
-//! Event types:
-//! - `conversation.response.started` — generation began
-//! - `message.output.delta` — partial assistant text
-//! - `function.call.delta` — a function call (tool call)
-//! - `conversation.response.done` — generation complete (has usage)
-//! - `conversation.response.error` — error during generation
-
-use serde::{Deserialize, Serialize};
-
-use crate::v1::{conversations, error};
-
-// ── SSE event types ────────────────────────────────────────────────────
-
-/// A streaming event from the Conversations API.
-/// The `type` field discriminates the variant.
-#[derive(Clone, Debug, Deserialize, Serialize)]
-#[serde(tag = "type")]
-pub enum ConversationEvent {
-    /// Generation started.
-    #[serde(rename = "conversation.response.started")]
-    ResponseStarted {
-        #[serde(default)]
-        created_at: Option<String>,
-    },
-
-    /// Partial assistant text output.
-    #[serde(rename = "message.output.delta")]
-    MessageOutput {
-        id: String,
-        content: serde_json::Value, // string or array of chunks
-        #[serde(default)]
-        role: String,
-        #[serde(default)]
-        output_index: u32,
-        #[serde(default)]
-        content_index: u32,
-        #[serde(default)]
-        model: Option<String>,
-    },
-
-    /// A function call from the model.
-    #[serde(rename = "function.call.delta")]
-    FunctionCall {
-        id: String,
-        name: String,
-        tool_call_id: String,
-        arguments: String,
-        #[serde(default)]
-        output_index: u32,
-        #[serde(default)]
-        model: Option<String>,
-        #[serde(default)]
-        confirmation_status: Option<String>,
-    },
-
-    /// Generation complete — includes token usage.
-    #[serde(rename = "conversation.response.done")]
-    ResponseDone {
-        usage: conversations::ConversationUsageInfo,
-        #[serde(default)]
-        created_at: Option<String>,
-    },
-
-    /// Error during generation.
-    #[serde(rename = "conversation.response.error")]
-    ResponseError {
-        message: String,
-        code: i32,
-        #[serde(default)]
-        created_at: Option<String>,
-    },
-
-    /// Tool execution started (server-side).
-    #[serde(rename = "tool.execution.started")]
-    ToolExecutionStarted {
-        #[serde(flatten)]
-        extra: serde_json::Value,
-    },
-
-    /// Tool execution delta (server-side).
-    #[serde(rename = "tool.execution.delta")]
-    ToolExecutionDelta {
-        #[serde(flatten)]
-        extra: serde_json::Value,
-    },
-
-    /// Tool execution done (server-side).
-    #[serde(rename = "tool.execution.done")]
-    ToolExecutionDone {
-        #[serde(flatten)]
-        extra: serde_json::Value,
-    },
-
-    /// Agent handoff started.
-    #[serde(rename = "agent.handoff.started")]
-    AgentHandoffStarted {
-        #[serde(flatten)]
-        extra: serde_json::Value,
-    },
-
-    /// Agent handoff done.
-    #[serde(rename = "agent.handoff.done")]
-    AgentHandoffDone {
-        #[serde(flatten)]
-        extra: serde_json::Value,
-    },
-}
-
-impl ConversationEvent {
-    /// Extract text content from a MessageOutput event.
-    pub fn text_delta(&self) -> Option<String> {
-        match self {
-            ConversationEvent::MessageOutput { content, .. } => {
-                // content can be a string or an array of chunks
-                if let Some(s) = content.as_str() {
-                    Some(s.to_string())
-                } else if let Some(arr) = content.as_array() {
-                    // Array of chunks — extract text from TextChunk items
-                    let mut text = String::new();
-                    for chunk in arr {
-                        if let Some(t) = chunk.get("text").and_then(|v| v.as_str()) {
-                            text.push_str(t);
-                        }
-                    }
-                    if text.is_empty() { None } else { Some(text) }
-                } else {
-                    None
-                }
-            }
-            _ => None,
-        }
-    }
-}
-
-// ── SSE parsing ────────────────────────────────────────────────────────
-
-/// Parse a single SSE `data:` line into a conversation event.
-///
-/// Returns:
-/// - `Ok(Some(event))` — parsed event
-/// - `Ok(None)` — `[DONE]` signal or empty/comment line
-/// - `Err(e)` — parse error
-pub fn parse_sse_line(line: &str) -> Result<Option<ConversationEvent>, error::ApiError> {
-    let line = line.trim();
-
-    if line.is_empty() || line.starts_with(':') || line.starts_with("event:") {
-        return Ok(None);
-    }
-
-    if line == "data: [DONE]" || line == "[DONE]" {
-        return Ok(None);
-    }
-
-    // SSE data lines start with "data: "
-    let json = match line.strip_prefix("data: ") {
-        Some(j) => j.trim(),
-        None => return Ok(None), // not a data line
-    };
-    if json.is_empty() {
-        return Ok(None);
-    }
-
-    serde_json::from_str::<ConversationEvent>(json).map(Some).map_err(|e| {
-        error::ApiError {
-            message: format!("Failed to parse conversation stream event: {e}\nRaw: {json}"),
-        }
-    })
-}
-
-/// Accumulate streaming events into a final `ConversationResponse`.
-pub fn accumulate(
-    conversation_id: &str,
-    events: &[ConversationEvent],
-) -> conversations::ConversationResponse {
-    let mut full_text = String::new();
-    let mut function_calls = Vec::new();
-    let mut usage = conversations::ConversationUsageInfo {
-        prompt_tokens: 0,
-        completion_tokens: 0,
-        total_tokens: 0,
-    };
-
-    for event in events {
-        match event {
-            ConversationEvent::MessageOutput { content, .. } => {
-                if let Some(s) = content.as_str() {
-                    full_text.push_str(s);
-                } else if let Some(arr) = content.as_array() {
-                    for chunk in arr {
-                        if let Some(t) = chunk.get("text").and_then(|v| v.as_str()) {
-                            full_text.push_str(t);
-                        }
-                    }
-                }
-            }
-            ConversationEvent::FunctionCall {
-                id, name, tool_call_id, arguments, ..
-            } => {
-                function_calls.push(conversations::ConversationEntry::FunctionCall(
-                    conversations::FunctionCallEntry {
-                        name: name.clone(),
-                        arguments: arguments.clone(),
-                        id: Some(id.clone()),
-                        object: None,
-                        tool_call_id: Some(tool_call_id.clone()),
-                        created_at: None,
-                        completed_at: None,
-                    },
-                ));
-            }
-            ConversationEvent::ResponseDone { usage: u, .. } => {
-                usage = u.clone();
-            }
-            _ => {}
-        }
-    }
-
-    let mut outputs = Vec::new();
-    if !full_text.is_empty() {
-        outputs.push(conversations::ConversationEntry::MessageOutput(
-            conversations::MessageOutputEntry {
-                role: "assistant".into(),
-                content: crate::v1::chat::ChatMessageContent::Text(full_text),
-                id: None,
-                object: None,
-                model: None,
-                created_at: None,
-                completed_at: None,
-            },
-        ));
-    }
-    outputs.extend(function_calls);
-
-    conversations::ConversationResponse {
-        conversation_id: conversation_id.to_string(),
-        outputs,
-        usage,
-        object: "conversation.response".into(),
-        guardrails: None,
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_parse_done() {
-        assert!(parse_sse_line("data: [DONE]").unwrap().is_none());
-    }
-
-    #[test]
-    fn test_parse_empty() {
-        assert!(parse_sse_line("").unwrap().is_none());
-        assert!(parse_sse_line("  ").unwrap().is_none());
-    }
-
-    #[test]
-    fn test_parse_comment() {
-        assert!(parse_sse_line(": keep-alive").unwrap().is_none());
-    }
-
-    #[test]
-    fn test_parse_response_started() {
-        let line = r#"data: {"type":"conversation.response.started","created_at":"2026-03-24T12:00:00Z"}"#;
-        let event = parse_sse_line(line).unwrap().unwrap();
-        assert!(matches!(event, ConversationEvent::ResponseStarted { .. }));
-    }
-
-    #[test]
-    fn test_parse_message_output_string() {
-        let line = r#"data: {"type":"message.output.delta","id":"msg-1","content":"hello ","role":"assistant"}"#;
-        let event = parse_sse_line(line).unwrap().unwrap();
-        assert_eq!(event.text_delta(), Some("hello ".into()));
-    }
-
-    #[test]
-    fn test_parse_message_output_chunks() {
-        let line = r#"data: {"type":"message.output.delta","id":"msg-1","content":[{"type":"text","text":"world"}],"role":"assistant"}"#;
-        let event = parse_sse_line(line).unwrap().unwrap();
-        assert_eq!(event.text_delta(), Some("world".into()));
-    }
-
-    #[test]
-    fn test_parse_function_call() {
-        let line = r#"data: {"type":"function.call.delta","id":"fc-1","name":"search_web","tool_call_id":"tc-1","arguments":"{\"query\":\"test\"}"}"#;
-        let event = parse_sse_line(line).unwrap().unwrap();
-        match event {
-            ConversationEvent::FunctionCall { name, arguments, tool_call_id, .. } => {
-                assert_eq!(name, "search_web");
-                assert_eq!(tool_call_id, "tc-1");
-                assert!(arguments.contains("test"));
-            }
-            _ => panic!("Expected FunctionCall"),
-        }
-    }
-
-    #[test]
-    fn test_parse_response_done() {
-        let line = r#"data: {"type":"conversation.response.done","usage":{"prompt_tokens":100,"completion_tokens":50,"total_tokens":150}}"#;
-        let event = parse_sse_line(line).unwrap().unwrap();
-        match event {
-            ConversationEvent::ResponseDone { usage, .. } => {
-                assert_eq!(usage.prompt_tokens, 100);
-                assert_eq!(usage.completion_tokens, 50);
-                assert_eq!(usage.total_tokens, 150);
-            }
-            _ => panic!("Expected ResponseDone"),
-        }
-    }
-
-    #[test]
-    fn test_parse_response_error() {
-        let line = r#"data: {"type":"conversation.response.error","message":"rate limited","code":429}"#;
-        let event = parse_sse_line(line).unwrap().unwrap();
-        match event {
-            ConversationEvent::ResponseError { message, code, .. } => {
-                assert_eq!(message, "rate limited");
-                assert_eq!(code, 429);
-            }
-            _ => panic!("Expected ResponseError"),
-        }
-    }
-
-    #[test]
-    fn test_accumulate() {
-        let events = vec![
-            ConversationEvent::ResponseStarted { created_at: None },
-            ConversationEvent::MessageOutput {
-                id: "m1".into(),
-                content: serde_json::json!("hello "),
-                role: "assistant".into(),
-                output_index: 0,
-                content_index: 0,
-                model: None,
-            },
-            ConversationEvent::MessageOutput {
-                id: "m1".into(),
-                content: serde_json::json!("world"),
-                role: "assistant".into(),
-                output_index: 0,
-                content_index: 0,
-                model: None,
-            },
-            ConversationEvent::ResponseDone {
-                usage: conversations::ConversationUsageInfo {
-                    prompt_tokens: 10,
-                    completion_tokens: 5,
-                    total_tokens: 15,
-                },
-                created_at: None,
-            },
-        ];
-
-        let resp = accumulate("conv-1", &events);
-        assert_eq!(resp.conversation_id, "conv-1");
-        assert_eq!(resp.assistant_text(), Some("hello world".into()));
-        assert_eq!(resp.usage.total_tokens, 15);
-    }
-
-    #[test]
-    fn test_accumulate_with_function_calls() {
-        let events = vec![
-            ConversationEvent::FunctionCall {
-                id: "fc-1".into(),
-                name: "search".into(),
-                tool_call_id: "tc-1".into(),
-                arguments: r#"{"q":"test"}"#.into(),
-                output_index: 0,
-                model: None,
-                confirmation_status: None,
-            },
-            ConversationEvent::ResponseDone {
-                usage: conversations::ConversationUsageInfo {
-                    prompt_tokens: 20,
-                    completion_tokens: 10,
-                    total_tokens: 30,
-                },
-                created_at: None,
-            },
-        ];
-
-        let resp = accumulate("conv-2", &events);
-        assert!(resp.assistant_text().is_none());
-        let calls = resp.function_calls();
-        assert_eq!(calls.len(), 1);
-        assert_eq!(calls[0].name, "search");
-    }
-}

src/v1/conversations.rs

@@ -1,377 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use crate::v1::{agents, chat};
-
-// =============================================================================
-// Conversations API (Beta)
-// POST/GET/DELETE /v1/conversations
-// =============================================================================
-
-// -----------------------------------------------------------------------------
-// Conversation entries (inputs and outputs)
-// All entries share common fields: id, object, type, created_at, completed_at
-
-/// Input entry — a message sent to the conversation.
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct MessageInputEntry {
-    pub role: String,
-    pub content: chat::ChatMessageContent,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub prefix: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub id: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub object: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub created_at: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub completed_at: Option<String>,
-}
-
-/// Output entry — an assistant message produced by the model.
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct MessageOutputEntry {
-    pub role: String,
-    pub content: chat::ChatMessageContent,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub id: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub object: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub model: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub created_at: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub completed_at: Option<String>,
-}
-
-/// A function call requested by the model.
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct FunctionCallEntry {
-    pub name: String,
-    pub arguments: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub id: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub object: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub tool_call_id: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub created_at: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub completed_at: Option<String>,
-}
-
-/// Result of a function call, sent back to the conversation.
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct FunctionResultEntry {
-    pub tool_call_id: String,
-    pub result: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub id: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub object: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub created_at: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub completed_at: Option<String>,
-}
-
-/// A built-in tool execution (web_search, code_interpreter, etc.).
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct ToolExecutionEntry {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub tool_name: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub id: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub object: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub created_at: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub completed_at: Option<String>,
-    #[serde(flatten)]
-    pub extra: serde_json::Value,
-}
-
-/// Agent handoff entry — transfer between agents.
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct AgentHandoffEntry {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub previous_agent_id: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub next_agent_id: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub id: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub object: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub created_at: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub completed_at: Option<String>,
-}
-
-/// Union of all conversation entry types.
-#[derive(Clone, Debug, Serialize, Deserialize)]
-#[serde(tag = "type")]
-pub enum ConversationEntry {
-    #[serde(rename = "message.input")]
-    MessageInput(MessageInputEntry),
-    #[serde(rename = "message.output")]
-    MessageOutput(MessageOutputEntry),
-    #[serde(rename = "function.call")]
-    FunctionCall(FunctionCallEntry),
-    #[serde(rename = "function.result")]
-    FunctionResult(FunctionResultEntry),
-    #[serde(rename = "tool.execution")]
-    ToolExecution(ToolExecutionEntry),
-    #[serde(rename = "agent.handoff")]
-    AgentHandoff(AgentHandoffEntry),
-}
-
-// -----------------------------------------------------------------------------
-// Conversation inputs (flexible: string or array of entries)
-
-/// Conversation input: either a plain string or structured entry array.
-#[derive(Clone, Debug, Serialize, Deserialize)]
-#[serde(untagged)]
-pub enum ConversationInput {
-    Text(String),
-    Entries(Vec<ConversationEntry>),
-}
-
-impl From<&str> for ConversationInput {
-    fn from(s: &str) -> Self {
-        Self::Text(s.to_string())
-    }
-}
-
-impl From<String> for ConversationInput {
-    fn from(s: String) -> Self {
-        Self::Text(s)
-    }
-}
-
-impl From<Vec<ConversationEntry>> for ConversationInput {
-    fn from(entries: Vec<ConversationEntry>) -> Self {
-        Self::Entries(entries)
-    }
-}
-
-// -----------------------------------------------------------------------------
-// Handoff execution mode
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
-pub enum HandoffExecution {
-    #[serde(rename = "server")]
-    Server,
-    #[serde(rename = "client")]
-    Client,
-}
-
-impl Default for HandoffExecution {
-    fn default() -> Self {
-        Self::Server
-    }
-}
-
-// -----------------------------------------------------------------------------
-// Create conversation request (POST /v1/conversations)
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct CreateConversationRequest {
-    pub inputs: ConversationInput,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub model: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub agent_id: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub agent_version: Option<serde_json::Value>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub name: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub description: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub instructions: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub completion_args: Option<agents::CompletionArgs>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub tools: Option<Vec<agents::AgentTool>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub handoff_execution: Option<HandoffExecution>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub metadata: Option<serde_json::Value>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub store: Option<bool>,
-    #[serde(default)]
-    pub stream: bool,
-}
-
-// -----------------------------------------------------------------------------
-// Append to conversation request (POST /v1/conversations/{id})
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct AppendConversationRequest {
-    pub inputs: ConversationInput,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub completion_args: Option<agents::CompletionArgs>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub handoff_execution: Option<HandoffExecution>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub store: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub tool_confirmations: Option<Vec<ToolCallConfirmation>>,
-    #[serde(default)]
-    pub stream: bool,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct ToolCallConfirmation {
-    pub tool_call_id: String,
-    pub result: String,
-}
-
-// -----------------------------------------------------------------------------
-// Restart conversation request (POST /v1/conversations/{id}/restart)
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct RestartConversationRequest {
-    pub from_entry_id: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub inputs: Option<ConversationInput>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub completion_args: Option<agents::CompletionArgs>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub agent_version: Option<serde_json::Value>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub handoff_execution: Option<HandoffExecution>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub metadata: Option<serde_json::Value>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub store: Option<bool>,
-    #[serde(default)]
-    pub stream: bool,
-}
-
-// -----------------------------------------------------------------------------
-// Conversation response (returned by create, append, restart)
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct ConversationUsageInfo {
-    #[serde(default)]
-    pub prompt_tokens: u32,
-    #[serde(default)]
-    pub completion_tokens: u32,
-    #[serde(default)]
-    pub total_tokens: u32,
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct ConversationResponse {
-    pub conversation_id: String,
-    pub outputs: Vec<ConversationEntry>,
-    pub usage: ConversationUsageInfo,
-    #[serde(default)]
-    pub object: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub guardrails: Option<serde_json::Value>,
-}
-
-impl ConversationResponse {
-    /// Extract the assistant's text response from the outputs, if any.
-    pub fn assistant_text(&self) -> Option<String> {
-        for entry in &self.outputs {
-            if let ConversationEntry::MessageOutput(msg) = entry {
-                return Some(msg.content.text());
-            }
-        }
-        None
-    }
-
-    /// Extract all function call entries from the outputs.
-    pub fn function_calls(&self) -> Vec<&FunctionCallEntry> {
-        self.outputs
-            .iter()
-            .filter_map(|e| match e {
-                ConversationEntry::FunctionCall(fc) => Some(fc),
-                _ => None,
-            })
-            .collect()
-    }
-
-    /// Check if any outputs are agent handoff entries.
-    pub fn has_handoff(&self) -> bool {
-        self.outputs
-            .iter()
-            .any(|e| matches!(e, ConversationEntry::AgentHandoff(_)))
-    }
-}
-
-// -----------------------------------------------------------------------------
-// Conversation history response (GET /v1/conversations/{id}/history)
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct ConversationHistoryResponse {
-    pub conversation_id: String,
-    pub entries: Vec<ConversationEntry>,
-    #[serde(default)]
-    pub object: String,
-}
-
-// -----------------------------------------------------------------------------
-// Conversation messages response (GET /v1/conversations/{id}/messages)
-// Note: may have same shape as history; keeping separate for API clarity
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct ConversationMessagesResponse {
-    pub conversation_id: String,
-    #[serde(alias = "messages", alias = "entries")]
-    pub messages: Vec<ConversationEntry>,
-    #[serde(default)]
-    pub object: String,
-}
-
-// -----------------------------------------------------------------------------
-// Conversation info (GET /v1/conversations/{id})
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct Conversation {
-    pub id: String,
-    #[serde(default)]
-    pub object: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub agent_id: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub model: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub name: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub description: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub instructions: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub created_at: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub updated_at: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub completion_args: Option<agents::CompletionArgs>,
-    #[serde(default)]
-    pub tools: Vec<agents::AgentTool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub guardrails: Option<serde_json::Value>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub metadata: Option<serde_json::Value>,
-}
-
-/// List conversations response. API returns a raw JSON array.
-#[derive(Clone, Debug, Deserialize, Serialize)]
-#[serde(transparent)]
-pub struct ConversationListResponse {
-    pub data: Vec<Conversation>,
-}
-
-/// Delete conversation response. API returns 204 No Content.
-#[derive(Clone, Debug)]
-pub struct ConversationDeleteResponse {
-    pub deleted: bool,
-}

src/v1/embedding.rs

@@ -8,63 +8,42 @@ use crate::v1::{common, constants};
 #[derive(Debug)]
 pub struct EmbeddingRequestOptions {
     pub encoding_format: Option<EmbeddingRequestEncodingFormat>,
-    pub output_dimension: Option<u32>,
-    pub output_dtype: Option<EmbeddingOutputDtype>,
 }
 impl Default for EmbeddingRequestOptions {
     fn default() -> Self {
         Self {
             encoding_format: None,
-            output_dimension: None,
-            output_dtype: None,
         }
     }
 }
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct EmbeddingRequest {
-    pub model: constants::Model,
+    pub model: constants::EmbedModel,
     pub input: Vec<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub encoding_format: Option<EmbeddingRequestEncodingFormat>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_dimension: Option<u32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub output_dtype: Option<EmbeddingOutputDtype>,
 }
 impl EmbeddingRequest {
     pub fn new(
-        model: constants::Model,
+        model: constants::EmbedModel,
         input: Vec<String>,
         options: Option<EmbeddingRequestOptions>,
     ) -> Self {
-        let opts = options.unwrap_or_default();
+        let EmbeddingRequestOptions { encoding_format } = options.unwrap_or_default();
 
         Self {
             model,
             input,
-            encoding_format: opts.encoding_format,
-            output_dimension: opts.output_dimension,
-            output_dtype: opts.output_dtype,
+            encoding_format,
         }
     }
 }
 
 #[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
-#[serde(rename_all = "lowercase")]
+#[allow(non_camel_case_types)]
 pub enum EmbeddingRequestEncodingFormat {
-    Float,
-    Base64,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
-#[serde(rename_all = "lowercase")]
-pub enum EmbeddingOutputDtype {
-    Float,
-    Int8,
-    Uint8,
-    Binary,
-    Ubinary,
+    float,
 }
 
 // -----------------------------------------------------------------------------
@@ -72,8 +51,9 @@ pub enum EmbeddingOutputDtype {
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct EmbeddingResponse {
+    pub id: String,
     pub object: String,
-    pub model: constants::Model,
+    pub model: constants::EmbedModel,
     pub data: Vec<EmbeddingResponseDataItem>,
     pub usage: common::ResponseUsage,
 }

src/v1/files.rs

@@ -1,55 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-// -----------------------------------------------------------------------------
-// Request
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "kebab-case")]
-pub enum FilePurpose {
-    FineTune,
-    Batch,
-    Ocr,
-}
-
-// -----------------------------------------------------------------------------
-// Response
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct FileListResponse {
-    pub data: Vec<FileObject>,
-    pub object: String,
-    #[serde(default)]
-    pub total: u32,
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct FileObject {
-    pub id: String,
-    pub object: String,
-    pub bytes: u64,
-    pub created_at: u64,
-    pub filename: String,
-    pub purpose: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub sample_type: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub source: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub num_lines: Option<u64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub mimetype: Option<String>,
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct FileDeleteResponse {
-    pub id: String,
-    pub object: String,
-    pub deleted: bool,
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct FileUrlResponse {
-    pub url: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub expires_at: Option<u64>,
-}

src/v1/fim.rs

@@ -1,101 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use crate::v1::{common, constants};
-
-// -----------------------------------------------------------------------------
-// Request
-
-#[derive(Debug)]
-pub struct FimParams {
-    pub suffix: Option<String>,
-    pub max_tokens: Option<u32>,
-    pub min_tokens: Option<u32>,
-    pub temperature: Option<f32>,
-    pub top_p: Option<f32>,
-    pub stop: Option<Vec<String>>,
-    pub random_seed: Option<u32>,
-}
-impl Default for FimParams {
-    fn default() -> Self {
-        Self {
-            suffix: None,
-            max_tokens: None,
-            min_tokens: None,
-            temperature: None,
-            top_p: None,
-            stop: None,
-            random_seed: None,
-        }
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct FimRequest {
-    pub model: constants::Model,
-    pub prompt: String,
-    pub stream: bool,
-
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub suffix: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub max_tokens: Option<u32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub min_tokens: Option<u32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub temperature: Option<f32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub top_p: Option<f32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub stop: Option<Vec<String>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub random_seed: Option<u32>,
-}
-impl FimRequest {
-    pub fn new(
-        model: constants::Model,
-        prompt: String,
-        stream: bool,
-        options: Option<FimParams>,
-    ) -> Self {
-        let opts = options.unwrap_or_default();
-
-        Self {
-            model,
-            prompt,
-            stream,
-            suffix: opts.suffix,
-            max_tokens: opts.max_tokens,
-            min_tokens: opts.min_tokens,
-            temperature: opts.temperature,
-            top_p: opts.top_p,
-            stop: opts.stop,
-            random_seed: opts.random_seed,
-        }
-    }
-}
-
-// -----------------------------------------------------------------------------
-// Response
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct FimResponse {
-    pub id: String,
-    pub object: String,
-    pub created: u64,
-    pub model: constants::Model,
-    pub choices: Vec<FimResponseChoice>,
-    pub usage: common::ResponseUsage,
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct FimResponseChoice {
-    pub index: u32,
-    pub message: FimResponseMessage,
-    pub finish_reason: String,
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct FimResponseMessage {
-    pub role: String,
-    pub content: String,
-}

src/v1/fine_tuning.rs

@@ -1,101 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use crate::v1::constants;
-
-// -----------------------------------------------------------------------------
-// Request
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct FineTuningJobRequest {
-    pub model: constants::Model,
-    pub training_files: Vec<TrainingFile>,
-
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub validation_files: Option<Vec<String>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub hyperparameters: Option<Hyperparameters>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub suffix: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub auto_start: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub job_type: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub integrations: Option<Vec<Integration>>,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct TrainingFile {
-    pub file_id: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub weight: Option<f32>,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct Hyperparameters {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub learning_rate: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub training_steps: Option<u32>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub warmup_fraction: Option<f64>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub epochs: Option<f64>,
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct Integration {
-    pub r#type: String,
-    pub project: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub name: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub api_key: Option<String>,
-}
-
-// -----------------------------------------------------------------------------
-// Response
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct FineTuningJobResponse {
-    pub id: String,
-    pub object: String,
-    pub model: constants::Model,
-    pub status: FineTuningJobStatus,
-    pub created_at: u64,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub modified_at: Option<u64>,
-    pub training_files: Vec<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub validation_files: Option<Vec<String>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub hyperparameters: Option<Hyperparameters>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub fine_tuned_model: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub suffix: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub integrations: Option<Vec<Integration>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub trained_tokens: Option<u64>,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
-#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
-pub enum FineTuningJobStatus {
-    Queued,
-    Running,
-    Success,
-    Failed,
-    TimeoutExceeded,
-    CancellationRequested,
-    Cancelled,
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct FineTuningJobListResponse {
-    pub data: Vec<FineTuningJobResponse>,
-    pub object: String,
-    #[serde(default)]
-    pub total: u32,
-}

src/v1/mod.rs

@@ -1,20 +1,10 @@
-pub mod agents;
-pub mod audio;
-pub mod batch;
 pub mod chat;
 pub mod chat_stream;
 pub mod client;
 pub mod common;
 pub mod constants;
-pub mod conversation_stream;
-pub mod conversations;
 pub mod embedding;
 pub mod error;
-pub mod files;
-pub mod fim;
-pub mod fine_tuning;
 pub mod model_list;
-pub mod moderation;
-pub mod ocr;
 pub mod tool;
 pub mod utils;

src/v1/model_list.rs

@@ -9,50 +9,29 @@ pub struct ModelListResponse {
     pub data: Vec<ModelListData>,
 }
 
-/// See the [models API](https://docs.mistral.ai/api/#tag/models/operation/list_models_v1_models_get).
+/// See: https://docs.mistral.ai/api/#tag/models
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct ModelListData {
     pub id: String,
     pub object: String,
     /// Unix timestamp (in seconds).
-    pub created: u64,
+    pub created: u32,
     pub owned_by: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub root: Option<String>,
-    #[serde(default)]
     pub archived: bool,
-    #[serde(default)]
-    pub name: Option<String>,
-    #[serde(default)]
-    pub description: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub capabilities: Option<ModelListDataCapabilities>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub max_context_length: Option<u32>,
-    #[serde(default)]
+    pub name: String,
+    pub description: String,
+    pub capabilities: ModelListDataCapabilies,
+    pub max_context_length: u32,
     pub aliases: Vec<String>,
     /// ISO 8601 date (`YYYY-MM-DDTHH:MM:SSZ`).
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub deprecation: Option<String>,
 }
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct ModelListDataCapabilities {
-    #[serde(default)]
+pub struct ModelListDataCapabilies {
     pub completion_chat: bool,
-    #[serde(default)]
     pub completion_fim: bool,
-    #[serde(default)]
     pub function_calling: bool,
-    #[serde(default)]
     pub fine_tuning: bool,
-    #[serde(default)]
-    pub vision: bool,
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct ModelDeleteResponse {
-    pub id: String,
-    pub object: String,
-    pub deleted: bool,
 }

src/v1/moderation.rs

@@ -1,70 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use crate::v1::constants;
-
-// -----------------------------------------------------------------------------
-// Request
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct ModerationRequest {
-    pub model: constants::Model,
-    pub input: Vec<String>,
-}
-impl ModerationRequest {
-    pub fn new(model: constants::Model, input: Vec<String>) -> Self {
-        Self { model, input }
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct ChatModerationRequest {
-    pub model: constants::Model,
-    pub input: Vec<ChatModerationInput>,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct ChatModerationInput {
-    pub role: String,
-    pub content: String,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct ClassificationRequest {
-    pub model: constants::Model,
-    pub input: Vec<String>,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct ChatClassificationRequest {
-    pub model: constants::Model,
-    pub input: Vec<ChatModerationInput>,
-}
-
-// -----------------------------------------------------------------------------
-// Response
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct ModerationResponse {
-    pub id: String,
-    pub model: constants::Model,
-    pub results: Vec<ModerationResult>,
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct ModerationResult {
-    pub categories: serde_json::Value,
-    pub category_scores: serde_json::Value,
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct ClassificationResponse {
-    pub id: String,
-    pub model: constants::Model,
-    pub results: Vec<ClassificationResult>,
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct ClassificationResult {
-    pub categories: serde_json::Value,
-    pub category_scores: serde_json::Value,
-}

src/v1/ocr.rs

@@ -1,96 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-use crate::v1::constants;
-
-// -----------------------------------------------------------------------------
-// Request
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct OcrRequest {
-    pub model: constants::Model,
-    pub document: OcrDocument,
-
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub pages: Option<Vec<u32>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub table_format: Option<OcrTableFormat>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub include_image_base64: Option<bool>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub image_limit: Option<u32>,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct OcrDocument {
-    #[serde(rename = "type")]
-    pub type_: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub document_url: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub file_id: Option<String>,
-}
-impl OcrDocument {
-    pub fn from_url(url: &str) -> Self {
-        Self {
-            type_: "document_url".to_string(),
-            document_url: Some(url.to_string()),
-            file_id: None,
-        }
-    }
-
-    pub fn from_file_id(file_id: &str) -> Self {
-        Self {
-            type_: "file_id".to_string(),
-            document_url: None,
-            file_id: Some(file_id.to_string()),
-        }
-    }
-}
-
-#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
-#[serde(rename_all = "lowercase")]
-pub enum OcrTableFormat {
-    Markdown,
-    Html,
-}
-
-// -----------------------------------------------------------------------------
-// Response
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct OcrResponse {
-    pub pages: Vec<OcrPage>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub usage_info: Option<OcrUsageInfo>,
-    pub model: constants::Model,
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct OcrPage {
-    pub index: u32,
-    pub markdown: String,
-    #[serde(default)]
-    pub images: Vec<OcrImage>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub dimensions: Option<OcrPageDimensions>,
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct OcrImage {
-    pub id: String,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub image_base64: Option<String>,
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct OcrPageDimensions {
-    pub width: f32,
-    pub height: f32,
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-pub struct OcrUsageInfo {
-    pub pages_processed: u32,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub doc_size_bytes: Option<u64>,
-}

src/v1/tool.rs

@@ -1,16 +1,12 @@
 use async_trait::async_trait;
 use serde::{Deserialize, Serialize};
-use std::{any::Any, fmt::Debug};
+use std::{any::Any, collections::HashMap, fmt::Debug};
 
 // -----------------------------------------------------------------------------
 // Definitions
 
 #[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
 pub struct ToolCall {
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub id: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub r#type: Option<String>,
     pub function: ToolCallFunction,
 }
 
@@ -26,12 +22,31 @@ pub struct Tool {
     pub function: ToolFunction,
 }
 impl Tool {
-    /// Create a tool with a JSON Schema parameters object.
     pub fn new(
         function_name: String,
         function_description: String,
-        parameters: serde_json::Value,
+        function_parameters: Vec<ToolFunctionParameter>,
     ) -> Self {
+        let properties: HashMap<String, ToolFunctionParameterProperty> = function_parameters
+            .into_iter()
+            .map(|param| {
+                (
+                    param.name,
+                    ToolFunctionParameterProperty {
+                        r#type: param.r#type,
+                        description: param.description,
+                    },
+                )
+            })
+            .collect();
+        let property_names = properties.keys().cloned().collect();
+
+        let parameters = ToolFunctionParameters {
+            r#type: ToolFunctionParametersType::Object,
+            properties,
+            required: property_names,
+        };
+
         Self {
             r#type: ToolType::Function,
             function: ToolFunction {
@@ -48,9 +63,50 @@ impl Tool {
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct ToolFunction {
-    pub name: String,
-    pub description: String,
-    pub parameters: serde_json::Value,
+    name: String,
+    description: String,
+    parameters: ToolFunctionParameters,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct ToolFunctionParameter {
+    name: String,
+    description: String,
+    r#type: ToolFunctionParameterType,
+}
+impl ToolFunctionParameter {
+    pub fn new(name: String, description: String, r#type: ToolFunctionParameterType) -> Self {
+        Self {
+            name,
+            r#type,
+            description,
+        }
+    }
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct ToolFunctionParameters {
+    r#type: ToolFunctionParametersType,
+    properties: HashMap<String, ToolFunctionParameterProperty>,
+    required: Vec<String>,
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct ToolFunctionParameterProperty {
+    r#type: ToolFunctionParameterType,
+    description: String,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
+pub enum ToolFunctionParametersType {
+    #[serde(rename = "object")]
+    Object,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
+pub enum ToolFunctionParameterType {
+    #[serde(rename = "string")]
+    String,
 }
 
 #[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)]
@@ -71,9 +127,6 @@ pub enum ToolChoice {
     /// The model won't call a function and will generate a message instead.
     #[serde(rename = "none")]
     None,
-    /// The model must call at least one tool.
-    #[serde(rename = "required")]
-    Required,
 }
 
 // -----------------------------------------------------------------------------

tests/v1_agents_api_test.rs

@@ -1,372 +0,0 @@
-use mistralai_client::v1::{
-    agents::*,
-    client::Client,
-};
-
-mod setup;
-
-fn make_client() -> Client {
-    Client::new(None, None, None, None).unwrap()
-}
-
-// ---------------------------------------------------------------------------
-// Sync tests
-// ---------------------------------------------------------------------------
-
-#[test]
-fn test_create_and_delete_agent() {
-    setup::setup();
-    let client = make_client();
-
-    let req = CreateAgentRequest {
-        model: "mistral-medium-latest".to_string(),
-        name: "test-create-delete".to_string(),
-        description: Some("Integration test agent".to_string()),
-        instructions: Some("You are a test agent. Respond briefly.".to_string()),
-        tools: None,
-        handoffs: None,
-        completion_args: None,
-        metadata: None,
-    };
-
-    let agent = client.create_agent(&req).unwrap();
-    assert!(!agent.id.is_empty());
-    assert_eq!(agent.name, "test-create-delete");
-    assert_eq!(agent.model, "mistral-medium-latest");
-    assert_eq!(agent.object, "agent");
-    // Version starts at 0 in the API
-    assert!(agent.description.as_deref() == Some("Integration test agent"));
-    assert!(agent.instructions.as_deref() == Some("You are a test agent. Respond briefly."));
-
-    // Cleanup
-    let del = client.delete_agent(&agent.id).unwrap();
-    assert!(del.deleted);
-}
-
-#[test]
-fn test_create_agent_with_tools() {
-    setup::setup();
-    let client = make_client();
-
-    let req = CreateAgentRequest {
-        model: "mistral-medium-latest".to_string(),
-        name: "test-agent-tools".to_string(),
-        description: None,
-        instructions: Some("You can search.".to_string()),
-        tools: Some(vec![
-            AgentTool::function(
-                "search".to_string(),
-                "Search for things".to_string(),
-                serde_json::json!({
-                    "type": "object",
-                    "properties": {
-                        "query": {"type": "string", "description": "Search query"}
-                    },
-                    "required": ["query"]
-                }),
-            ),
-            AgentTool::web_search(),
-        ]),
-        handoffs: None,
-        completion_args: Some(CompletionArgs {
-            temperature: Some(0.3),
-            ..Default::default()
-        }),
-        metadata: None,
-    };
-
-    let agent = client.create_agent(&req).unwrap();
-    assert_eq!(agent.tools.len(), 2);
-    assert!(matches!(&agent.tools[0], AgentTool::Function(_)));
-    assert!(matches!(&agent.tools[1], AgentTool::WebSearch {}));
-
-    // Verify completion_args round-tripped
-    let args = agent.completion_args.as_ref().unwrap();
-    assert!((args.temperature.unwrap() - 0.3).abs() < 0.01);
-
-    client.delete_agent(&agent.id).unwrap();
-}
-
-#[test]
-fn test_get_agent() {
-    setup::setup();
-    let client = make_client();
-
-    let req = CreateAgentRequest {
-        model: "mistral-medium-latest".to_string(),
-        name: "test-get-agent".to_string(),
-        description: Some("Get test".to_string()),
-        instructions: None,
-        tools: None,
-        handoffs: None,
-        completion_args: None,
-        metadata: None,
-    };
-
-    let created = client.create_agent(&req).unwrap();
-    let fetched = client.get_agent(&created.id).unwrap();
-
-    assert_eq!(fetched.id, created.id);
-    assert_eq!(fetched.name, "test-get-agent");
-    assert_eq!(fetched.model, "mistral-medium-latest");
-    assert_eq!(fetched.description.as_deref(), Some("Get test"));
-
-    client.delete_agent(&created.id).unwrap();
-}
-
-#[test]
-fn test_update_agent() {
-    setup::setup();
-    let client = make_client();
-
-    let req = CreateAgentRequest {
-        model: "mistral-medium-latest".to_string(),
-        name: "test-update-agent".to_string(),
-        description: Some("Before update".to_string()),
-        instructions: Some("Original instructions".to_string()),
-        tools: None,
-        handoffs: None,
-        completion_args: None,
-        metadata: None,
-    };
-
-    let created = client.create_agent(&req).unwrap();
-
-    let update = UpdateAgentRequest {
-        name: Some("test-update-agent-renamed".to_string()),
-        description: Some("After update".to_string()),
-        instructions: Some("Updated instructions".to_string()),
-        ..Default::default()
-    };
-
-    let updated = client.update_agent(&created.id, &update).unwrap();
-    assert_eq!(updated.id, created.id);
-    assert_eq!(updated.name, "test-update-agent-renamed");
-    assert_eq!(updated.description.as_deref(), Some("After update"));
-    assert_eq!(updated.instructions.as_deref(), Some("Updated instructions"));
-    // Version should have incremented
-    assert!(updated.version >= created.version);
-
-    client.delete_agent(&created.id).unwrap();
-}
-
-#[test]
-fn test_list_agents() {
-    setup::setup();
-    let client = make_client();
-
-    // Create two agents
-    let req1 = CreateAgentRequest {
-        model: "mistral-medium-latest".to_string(),
-        name: "test-list-agent-1".to_string(),
-        description: None,
-        instructions: None,
-        tools: None,
-        handoffs: None,
-        completion_args: None,
-        metadata: None,
-    };
-    let req2 = CreateAgentRequest {
-        model: "mistral-medium-latest".to_string(),
-        name: "test-list-agent-2".to_string(),
-        description: None,
-        instructions: None,
-        tools: None,
-        handoffs: None,
-        completion_args: None,
-        metadata: None,
-    };
-
-    let a1 = client.create_agent(&req1).unwrap();
-    let a2 = client.create_agent(&req2).unwrap();
-
-    let list = client.list_agents().unwrap();
-    assert!(list.data.len() >= 2);
-
-    // Our two agents should be in the list
-    let ids: Vec<&str> = list.data.iter().map(|a| a.id.as_str()).collect();
-    assert!(ids.contains(&a1.id.as_str()));
-    assert!(ids.contains(&a2.id.as_str()));
-
-    // Cleanup
-    client.delete_agent(&a1.id).unwrap();
-    client.delete_agent(&a2.id).unwrap();
-}
-
-// ---------------------------------------------------------------------------
-// Async tests
-// ---------------------------------------------------------------------------
-
-#[tokio::test]
-async fn test_create_and_delete_agent_async() {
-    setup::setup();
-    let client = make_client();
-
-    let req = CreateAgentRequest {
-        model: "mistral-medium-latest".to_string(),
-        name: "test-async-create-delete".to_string(),
-        description: Some("Async integration test".to_string()),
-        instructions: Some("Respond briefly.".to_string()),
-        tools: None,
-        handoffs: None,
-        completion_args: None,
-        metadata: None,
-    };
-
-    let agent = client.create_agent_async(&req).await.unwrap();
-    assert!(!agent.id.is_empty());
-    assert_eq!(agent.name, "test-async-create-delete");
-    assert_eq!(agent.object, "agent");
-
-    let del = client.delete_agent_async(&agent.id).await.unwrap();
-    assert!(del.deleted);
-}
-
-#[tokio::test]
-async fn test_get_agent_async() {
-    setup::setup();
-    let client = make_client();
-
-    let req = CreateAgentRequest {
-        model: "mistral-medium-latest".to_string(),
-        name: "test-async-get".to_string(),
-        description: None,
-        instructions: None,
-        tools: None,
-        handoffs: None,
-        completion_args: None,
-        metadata: None,
-    };
-
-    let created = client.create_agent_async(&req).await.unwrap();
-    let fetched = client.get_agent_async(&created.id).await.unwrap();
-    assert_eq!(fetched.id, created.id);
-    assert_eq!(fetched.name, "test-async-get");
-
-    client.delete_agent_async(&created.id).await.unwrap();
-}
-
-#[tokio::test]
-async fn test_update_agent_async() {
-    setup::setup();
-    let client = make_client();
-
-    let req = CreateAgentRequest {
-        model: "mistral-medium-latest".to_string(),
-        name: "test-async-update".to_string(),
-        description: Some("Before".to_string()),
-        instructions: None,
-        tools: None,
-        handoffs: None,
-        completion_args: None,
-        metadata: None,
-    };
-
-    let created = client.create_agent_async(&req).await.unwrap();
-
-    let update = UpdateAgentRequest {
-        description: Some("After".to_string()),
-        ..Default::default()
-    };
-    let updated = client.update_agent_async(&created.id, &update).await.unwrap();
-    assert_eq!(updated.description.as_deref(), Some("After"));
-
-    client.delete_agent_async(&created.id).await.unwrap();
-}
-
-#[tokio::test]
-async fn test_list_agents_async() {
-    setup::setup();
-    let client = make_client();
-
-    let req = CreateAgentRequest {
-        model: "mistral-medium-latest".to_string(),
-        name: "test-async-list".to_string(),
-        description: None,
-        instructions: None,
-        tools: None,
-        handoffs: None,
-        completion_args: None,
-        metadata: None,
-    };
-
-    let agent = client.create_agent_async(&req).await.unwrap();
-    let list = client.list_agents_async().await.unwrap();
-    assert!(list.data.iter().any(|a| a.id == agent.id));
-
-    client.delete_agent_async(&agent.id).await.unwrap();
-}
-
-#[test]
-fn test_create_agent_with_handoffs() {
-    setup::setup();
-    let client = make_client();
-
-    // Create a target agent first
-    let target_req = CreateAgentRequest {
-        model: "mistral-medium-latest".to_string(),
-        name: "test-handoff-target".to_string(),
-        description: Some("Target agent for handoff".to_string()),
-        instructions: Some("You handle math questions.".to_string()),
-        tools: None,
-        handoffs: None,
-        completion_args: None,
-        metadata: None,
-    };
-    let target = client.create_agent(&target_req).unwrap();
-
-    // Create orchestrator with handoff to target
-    let orch_req = CreateAgentRequest {
-        model: "mistral-medium-latest".to_string(),
-        name: "test-handoff-orchestrator".to_string(),
-        description: Some("Orchestrator with handoffs".to_string()),
-        instructions: Some("Delegate math questions.".to_string()),
-        tools: None,
-        handoffs: Some(vec![target.id.clone()]),
-        completion_args: None,
-        metadata: None,
-    };
-    let orch = client.create_agent(&orch_req).unwrap();
-    assert_eq!(orch.handoffs.as_ref().unwrap().len(), 1);
-    assert_eq!(orch.handoffs.as_ref().unwrap()[0], target.id);
-
-    // Cleanup
-    client.delete_agent(&orch.id).unwrap();
-    client.delete_agent(&target.id).unwrap();
-}
-
-#[test]
-fn test_agent_completion_with_created_agent() {
-    setup::setup();
-    let client = make_client();
-
-    let req = CreateAgentRequest {
-        model: "mistral-medium-latest".to_string(),
-        name: "test-completion-agent".to_string(),
-        description: None,
-        instructions: Some("Always respond with exactly the word 'pong'.".to_string()),
-        tools: None,
-        handoffs: None,
-        completion_args: Some(CompletionArgs {
-            temperature: Some(0.0),
-            ..Default::default()
-        }),
-        metadata: None,
-    };
-
-    let agent = client.create_agent(&req).unwrap();
-
-    // Use the existing agent_completion method with the created agent
-    use mistralai_client::v1::chat::ChatMessage;
-    let messages = vec![ChatMessage::new_user_message("ping")];
-    let response = client
-        .agent_completion(agent.id.clone(), messages, None)
-        .unwrap();
-
-    assert!(!response.choices.is_empty());
-    let text = response.choices[0].message.content.text().to_lowercase();
-    assert!(text.contains("pong"), "Expected 'pong', got: {text}");
-    assert!(response.usage.total_tokens > 0);
-
-    client.delete_agent(&agent.id).unwrap();
-}

tests/v1_agents_types_test.rs

@@ -1,119 +0,0 @@
-use mistralai_client::v1::agents::*;
-
-#[test]
-fn test_create_agent_request_serialization() {
-    let req = CreateAgentRequest {
-        model: "mistral-medium-latest".to_string(),
-        name: "sol-orchestrator".to_string(),
-        description: Some("Virtual librarian".to_string()),
-        instructions: Some("You are Sol.".to_string()),
-        tools: Some(vec![AgentTool::web_search()]),
-        handoffs: Some(vec!["agent_abc123".to_string()]),
-        completion_args: Some(CompletionArgs {
-            temperature: Some(0.3),
-            ..Default::default()
-        }),
-        metadata: None,
-    };
-
-    let json = serde_json::to_value(&req).unwrap();
-    assert_eq!(json["model"], "mistral-medium-latest");
-    assert_eq!(json["name"], "sol-orchestrator");
-    assert_eq!(json["tools"][0]["type"], "web_search");
-    assert_eq!(json["handoffs"][0], "agent_abc123");
-    assert!(json["completion_args"]["temperature"].as_f64().unwrap() - 0.3 < 0.001);
-}
-
-#[test]
-fn test_agent_response_deserialization() {
-    let json = serde_json::json!({
-        "id": "ag_abc123",
-        "object": "agent",
-        "name": "sol-orchestrator",
-        "model": "mistral-medium-latest",
-        "created_at": "2026-03-21T10:00:00Z",
-        "updated_at": "2026-03-21T10:00:00Z",
-        "version": 1,
-        "versions": [1],
-        "description": "Virtual librarian",
-        "instructions": "You are Sol.",
-        "tools": [
-            {"type": "function", "function": {"name": "search", "description": "Search", "parameters": {}}},
-            {"type": "web_search"},
-            {"type": "code_interpreter"}
-        ],
-        "handoffs": ["ag_def456"],
-        "completion_args": {"temperature": 0.3, "response_format": {"type": "text"}}
-    });
-
-    let agent: Agent = serde_json::from_value(json).unwrap();
-    assert_eq!(agent.id, "ag_abc123");
-    assert_eq!(agent.name, "sol-orchestrator");
-    assert_eq!(agent.version, 1);
-    assert_eq!(agent.tools.len(), 3);
-    assert!(matches!(&agent.tools[0], AgentTool::Function(_)));
-    assert!(matches!(&agent.tools[1], AgentTool::WebSearch {}));
-    assert!(matches!(&agent.tools[2], AgentTool::CodeInterpreter {}));
-    assert_eq!(agent.handoffs.as_ref().unwrap()[0], "ag_def456");
-}
-
-#[test]
-fn test_agent_tool_function_constructor() {
-    let tool = AgentTool::function(
-        "search_archive".to_string(),
-        "Search messages".to_string(),
-        serde_json::json!({"type": "object", "properties": {"query": {"type": "string"}}}),
-    );
-
-    let json = serde_json::to_value(&tool).unwrap();
-    assert_eq!(json["type"], "function");
-    assert_eq!(json["function"]["name"], "search_archive");
-}
-
-#[test]
-fn test_completion_args_default_skips_none() {
-    let args = CompletionArgs::default();
-    let json = serde_json::to_value(&args).unwrap();
-    // All fields are None, so the JSON object should be empty
-    assert_eq!(json, serde_json::json!({}));
-}
-
-#[test]
-fn test_agent_delete_response() {
-    // AgentDeleteResponse is not deserialized from JSON — the API returns 204 No Content.
-    // The client constructs it directly.
-    let resp = AgentDeleteResponse { deleted: true };
-    assert!(resp.deleted);
-}
-
-#[test]
-fn test_agent_list_response() {
-    // API returns a raw JSON array (no wrapper object)
-    let json = serde_json::json!([
-        {
-            "id": "ag_1",
-            "object": "agent",
-            "name": "agent-1",
-            "model": "mistral-medium-latest",
-            "created_at": "2026-03-21T10:00:00Z",
-            "updated_at": "2026-03-21T10:00:00Z",
-            "version": 0,
-            "tools": []
-        }
-    ]);
-    let resp: AgentListResponse = serde_json::from_value(json).unwrap();
-    assert_eq!(resp.data.len(), 1);
-    assert_eq!(resp.data[0].name, "agent-1");
-}
-
-#[test]
-fn test_update_agent_partial() {
-    let req = UpdateAgentRequest {
-        instructions: Some("New instructions".to_string()),
-        ..Default::default()
-    };
-    let json = serde_json::to_value(&req).unwrap();
-    assert_eq!(json["instructions"], "New instructions");
-    assert!(json.get("model").is_none());
-    assert!(json.get("name").is_none());
-}

tests/v1_chat_multimodal_api_test.rs

@@ -1,156 +0,0 @@
-use mistralai_client::v1::{
-    chat::{
-        ChatMessage, ChatParams, ChatResponseChoiceFinishReason, ContentPart, ImageUrl,
-    },
-    client::Client,
-    constants::Model,
-};
-
-mod setup;
-
-fn make_client() -> Client {
-    Client::new(None, None, None, None).unwrap()
-}
-
-#[test]
-fn test_multimodal_chat_with_image_url() {
-    setup::setup();
-    let client = make_client();
-
-    // Use a small, publicly accessible image
-    let msg = ChatMessage::new_user_message_with_images(vec![
-        ContentPart::Text {
-            text: "Describe this image in one sentence.".to_string(),
-        },
-        ContentPart::ImageUrl {
-            image_url: ImageUrl {
-                url: "https://picsum.photos/id/237/200/300".to_string(),
-                detail: None,
-            },
-        },
-    ]);
-
-    let model = Model::new("pixtral-large-latest".to_string());
-    let options = ChatParams {
-        max_tokens: Some(100),
-        temperature: Some(0.0),
-        ..Default::default()
-    };
-
-    let response = client.chat(model, vec![msg], Some(options)).unwrap();
-
-    assert_eq!(
-        response.choices[0].finish_reason,
-        ChatResponseChoiceFinishReason::Stop
-    );
-    let text = response.choices[0].message.content.text();
-    assert!(!text.is_empty(), "Expected non-empty description");
-    assert!(response.usage.total_tokens > 0);
-}
-
-#[tokio::test]
-async fn test_multimodal_chat_with_image_url_async() {
-    setup::setup();
-    let client = make_client();
-
-    let msg = ChatMessage::new_user_message_with_images(vec![
-        ContentPart::Text {
-            text: "What colors do you see in this image? Reply in one sentence.".to_string(),
-        },
-        ContentPart::ImageUrl {
-            image_url: ImageUrl {
-                url: "https://picsum.photos/id/237/200/300".to_string(),
-                detail: None,
-            },
-        },
-    ]);
-
-    let model = Model::new("pixtral-large-latest".to_string());
-    let options = ChatParams {
-        max_tokens: Some(100),
-        temperature: Some(0.0),
-        ..Default::default()
-    };
-
-    let response = client
-        .chat_async(model, vec![msg], Some(options))
-        .await
-        .unwrap();
-
-    let text = response.choices[0].message.content.text();
-    assert!(!text.is_empty(), "Expected non-empty description");
-    assert!(response.usage.total_tokens > 0);
-}
-
-#[test]
-fn test_mixed_text_and_image_messages() {
-    setup::setup();
-    let client = make_client();
-
-    // First message: just text
-    let msg1 = ChatMessage::new_user_message("I'm going to show you an image next.");
-
-    // Second message: text + image
-    let msg2 = ChatMessage::new_user_message_with_images(vec![
-        ContentPart::Text {
-            text: "Here it is. What do you see?".to_string(),
-        },
-        ContentPart::ImageUrl {
-            image_url: ImageUrl {
-                url: "https://picsum.photos/id/237/200/300".to_string(),
-                detail: None,
-            },
-        },
-    ]);
-
-    let model = Model::new("pixtral-large-latest".to_string());
-    let options = ChatParams {
-        max_tokens: Some(100),
-        temperature: Some(0.0),
-        ..Default::default()
-    };
-
-    let response = client.chat(model, vec![msg1, msg2], Some(options)).unwrap();
-    let text = response.choices[0].message.content.text();
-    assert!(!text.is_empty());
-}
-
-#[test]
-fn test_text_only_message_still_works() {
-    setup::setup();
-    let client = make_client();
-
-    // Verify that text-only messages (the common case) still work fine
-    // with the new ChatMessageContent type
-    let msg = ChatMessage::new_user_message("What is 7 + 8?");
-    let model = Model::mistral_small_latest();
-    let options = ChatParams {
-        temperature: Some(0.0),
-        max_tokens: Some(50),
-        ..Default::default()
-    };
-
-    let response = client.chat(model, vec![msg], Some(options)).unwrap();
-    let text = response.choices[0].message.content.text();
-    assert!(text.contains("15"), "Expected '15', got: {text}");
-}
-
-#[test]
-fn test_reasoning_field_presence() {
-    setup::setup();
-    let client = make_client();
-
-    // Normal model should not have reasoning
-    let msg = ChatMessage::new_user_message("What is 2 + 2?");
-    let model = Model::mistral_small_latest();
-    let options = ChatParams {
-        temperature: Some(0.0),
-        max_tokens: Some(50),
-        ..Default::default()
-    };
-
-    let response = client.chat(model, vec![msg], Some(options)).unwrap();
-    // reasoning is None for non-Magistral models (or it might just be absent)
-    // This test verifies the field deserializes correctly either way
-    let _ = response.choices[0].reasoning.as_ref();
-}

tests/v1_chat_multimodal_test.rs

@@ -1,204 +0,0 @@
-use mistralai_client::v1::chat::*;
-
-#[test]
-fn test_content_part_text_serialization() {
-    let part = ContentPart::Text {
-        text: "hello".to_string(),
-    };
-    let json = serde_json::to_value(&part).unwrap();
-    assert_eq!(json["type"], "text");
-    assert_eq!(json["text"], "hello");
-}
-
-#[test]
-fn test_content_part_image_url_serialization() {
-    let part = ContentPart::ImageUrl {
-        image_url: ImageUrl {
-            url: "https://example.com/image.png".to_string(),
-            detail: Some("high".to_string()),
-        },
-    };
-    let json = serde_json::to_value(&part).unwrap();
-    assert_eq!(json["type"], "image_url");
-    assert_eq!(json["image_url"]["url"], "https://example.com/image.png");
-    assert_eq!(json["image_url"]["detail"], "high");
-}
-
-#[test]
-fn test_content_part_image_url_no_detail() {
-    let part = ContentPart::ImageUrl {
-        image_url: ImageUrl {
-            url: "data:image/png;base64,abc123".to_string(),
-            detail: None,
-        },
-    };
-    let json = serde_json::to_value(&part).unwrap();
-    assert_eq!(json["type"], "image_url");
-    assert!(json["image_url"].get("detail").is_none());
-}
-
-#[test]
-fn test_chat_message_content_text() {
-    let content = ChatMessageContent::Text("hello world".to_string());
-    assert_eq!(content.text(), "hello world");
-    assert_eq!(content.as_text(), Some("hello world"));
-    assert!(!content.has_images());
-    assert_eq!(content.to_string(), "hello world");
-}
-
-#[test]
-fn test_chat_message_content_parts() {
-    let content = ChatMessageContent::Parts(vec![
-        ContentPart::Text {
-            text: "What is this? ".to_string(),
-        },
-        ContentPart::ImageUrl {
-            image_url: ImageUrl {
-                url: "https://example.com/cat.jpg".to_string(),
-                detail: None,
-            },
-        },
-    ]);
-
-    assert_eq!(content.text(), "What is this? ");
-    assert!(content.as_text().is_none());
-    assert!(content.has_images());
-}
-
-#[test]
-fn test_chat_message_content_text_serialization() {
-    let content = ChatMessageContent::Text("hello".to_string());
-    let json = serde_json::to_value(&content).unwrap();
-    assert_eq!(json, serde_json::json!("hello"));
-}
-
-#[test]
-fn test_chat_message_content_parts_serialization() {
-    let content = ChatMessageContent::Parts(vec![ContentPart::Text {
-        text: "hello".to_string(),
-    }]);
-    let json = serde_json::to_value(&content).unwrap();
-    assert!(json.is_array());
-    assert_eq!(json[0]["type"], "text");
-}
-
-#[test]
-fn test_chat_message_content_text_deserialization() {
-    let content: ChatMessageContent = serde_json::from_value(serde_json::json!("hello")).unwrap();
-    assert_eq!(content.text(), "hello");
-}
-
-#[test]
-fn test_chat_message_content_parts_deserialization() {
-    let content: ChatMessageContent = serde_json::from_value(serde_json::json!([
-        {"type": "text", "text": "describe this"},
-        {"type": "image_url", "image_url": {"url": "https://example.com/img.jpg"}}
-    ]))
-    .unwrap();
-    assert_eq!(content.text(), "describe this");
-    assert!(content.has_images());
-}
-
-#[test]
-fn test_new_user_message_text_content() {
-    let msg = ChatMessage::new_user_message("hello");
-    let json = serde_json::to_value(&msg).unwrap();
-    assert_eq!(json["role"], "user");
-    assert_eq!(json["content"], "hello");
-}
-
-#[test]
-fn test_new_user_message_with_images() {
-    let msg = ChatMessage::new_user_message_with_images(vec![
-        ContentPart::Text {
-            text: "What is this?".to_string(),
-        },
-        ContentPart::ImageUrl {
-            image_url: ImageUrl {
-                url: "data:image/png;base64,abc123".to_string(),
-                detail: None,
-            },
-        },
-    ]);
-
-    let json = serde_json::to_value(&msg).unwrap();
-    assert_eq!(json["role"], "user");
-    assert!(json["content"].is_array());
-    assert_eq!(json["content"][0]["type"], "text");
-    assert_eq!(json["content"][1]["type"], "image_url");
-}
-
-#[test]
-fn test_chat_message_content_from_str() {
-    let content: ChatMessageContent = "test".into();
-    assert_eq!(content.text(), "test");
-}
-
-#[test]
-fn test_chat_message_content_from_string() {
-    let content: ChatMessageContent = String::from("test").into();
-    assert_eq!(content.text(), "test");
-}
-
-#[test]
-fn test_chat_response_choice_with_reasoning() {
-    let json = serde_json::json!({
-        "index": 0,
-        "message": {
-            "role": "assistant",
-            "content": "The answer is 42."
-        },
-        "finish_reason": "stop",
-        "reasoning": "Let me think about this step by step..."
-    });
-
-    let choice: ChatResponseChoice = serde_json::from_value(json).unwrap();
-    assert_eq!(choice.reasoning.as_deref(), Some("Let me think about this step by step..."));
-    assert_eq!(choice.message.content.text(), "The answer is 42.");
-}
-
-#[test]
-fn test_chat_response_choice_without_reasoning() {
-    let json = serde_json::json!({
-        "index": 0,
-        "message": {
-            "role": "assistant",
-            "content": "Hello"
-        },
-        "finish_reason": "stop"
-    });
-
-    let choice: ChatResponseChoice = serde_json::from_value(json).unwrap();
-    assert!(choice.reasoning.is_none());
-}
-
-#[test]
-fn test_full_chat_response_roundtrip() {
-    let json = serde_json::json!({
-        "id": "chat-abc123",
-        "object": "chat.completion",
-        "created": 1711000000,
-        "model": "mistral-medium-latest",
-        "choices": [{
-            "index": 0,
-            "message": {
-                "role": "assistant",
-                "content": "Hi there!"
-            },
-            "finish_reason": "stop"
-        }],
-        "usage": {
-            "prompt_tokens": 10,
-            "completion_tokens": 5,
-            "total_tokens": 15
-        }
-    });
-
-    let resp: ChatResponse = serde_json::from_value(json).unwrap();
-    assert_eq!(resp.choices[0].message.content.text(), "Hi there!");
-    assert_eq!(resp.usage.total_tokens, 15);
-
-    // Re-serialize and verify
-    let re_json = serde_json::to_value(&resp).unwrap();
-    assert_eq!(re_json["choices"][0]["message"]["content"], "Hi there!");
-}

tests/v1_client_chat_async_test.rs

@@ -3,7 +3,7 @@ use mistralai_client::v1::{
     chat::{ChatMessage, ChatMessageRole, ChatParams, ChatResponseChoiceFinishReason},
     client::Client,
     constants::Model,
-    tool::{Tool, ToolChoice},
+    tool::{Tool, ToolChoice, ToolFunctionParameter, ToolFunctionParameterType},
 };
 
 mod setup;
@@ -14,12 +14,12 @@ async fn test_client_chat_async() {
 
     let client = Client::new(None, None, None, None).unwrap();
 
-    let model = Model::mistral_small_latest();
+    let model = Model::OpenMistral7b;
     let messages = vec![ChatMessage::new_user_message(
         "Guess the next word: \"Eiffel ...\"?",
     )];
     let options = ChatParams {
-        temperature: Some(0.0),
+        temperature: 0.0,
         random_seed: Some(42),
         ..Default::default()
     };
@@ -29,6 +29,7 @@ async fn test_client_chat_async() {
         .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);
@@ -39,7 +40,7 @@ async fn test_client_chat_async() {
     expect!(response.choices[0]
         .message
         .content
-        .text()
+        .clone()
         .contains("Tower"))
     .to_be(true);
 
@@ -55,26 +56,21 @@ async fn test_client_chat_async_with_function_calling() {
     let tools = vec![Tool::new(
         "get_city_temperature".to_string(),
         "Get the current temperature in a city.".to_string(),
-        serde_json::json!({
-            "type": "object",
-            "properties": {
-                "city": {
-                    "type": "string",
-                    "description": "The name of the city."
-                }
-            },
-            "required": ["city"]
-        }),
+        vec![ToolFunctionParameter::new(
+            "city".to_string(),
+            "The name of the city.".to_string(),
+            ToolFunctionParameterType::String,
+        )],
     )];
 
     let client = Client::new(None, None, None, None).unwrap();
 
-    let model = Model::mistral_small_latest();
+    let model = Model::MistralSmallLatest;
     let messages = vec![ChatMessage::new_user_message(
         "What's the current temperature in Paris?",
     )];
     let options = ChatParams {
-        temperature: Some(0.0),
+        temperature: 0.0,
         random_seed: Some(42),
         tool_choice: Some(ToolChoice::Any),
         tools: Some(tools),
@@ -86,6 +82,7 @@ async fn test_client_chat_async_with_function_calling() {
         .await
         .unwrap();
 
+    expect!(response.model).to_be(Model::MistralSmallLatest);
     expect!(response.object).to_be("chat.completion".to_string());
 
     expect!(response.choices.len()).to_be(1);
@@ -94,6 +91,13 @@ async fn test_client_chat_async_with_function_calling() {
         .to_be(ChatResponseChoiceFinishReason::ToolCalls);
 
     expect!(response.choices[0].message.role.clone()).to_be(ChatMessageRole::Assistant);
+    expect!(response.choices[0].message.content.clone()).to_be("".to_string());
+    // expect!(response.choices[0].message.tool_calls.clone()).to_be(Some(vec![ToolCall {
+    //     function: ToolCallFunction {
+    //         name: "get_city_temperature".to_string(),
+    //         arguments: "{\"city\": \"Paris\"}".to_string(),
+    //     },
+    // }]));
 
     expect!(response.usage.prompt_tokens).to_be_greater_than(0);
     expect!(response.usage.completion_tokens).to_be_greater_than(0);

tests/v1_client_chat_stream_test.rs

@@ -1,18 +1,16 @@
-// Streaming tests require a live API key and are not run in CI.
-// Uncomment to test locally.
-
 // use futures::stream::StreamExt;
+// use jrest::expect;
 // use mistralai_client::v1::{
-//     chat::{ChatMessage, ChatParams},
+//     chat_completion::{ChatParams, 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::mistral_small_latest();
+
+//     let model = Model::OpenMistral7b;
 //     let messages = vec![ChatMessage::new_user_message(
 //         "Just guess the next word: \"Eiffel ...\"?",
 //     )];
@@ -21,24 +19,22 @@
 //         random_seed: Some(42),
 //         ..Default::default()
 //     };
-//
-//     let stream = client
-//         .chat_stream(model, messages, Some(options))
-//         .await
-//         .expect("Failed to create stream.");
-//
-//     stream
-//         .for_each(|chunk_result| async {
-//             match chunk_result {
-//                 Ok(chunks) => {
-//                     for chunk in &chunks {
-//                         if let Some(content) = &chunk.choices[0].delta.content {
-//                             print!("{}", content);
-//                         }
-//                     }
+
+//     let stream_result = client.chat_stream(model, messages, Some(options)).await;
+//     let mut stream = stream_result.expect("Failed to create stream.");
+//     while let Some(maybe_chunk_result) = stream.next().await {
+//         match maybe_chunk_result {
+//             Some(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(error) => eprintln!("Error: {:?}", error),
 //             }
-//         })
-//         .await;
+//             Some(Err(error)) => eprintln!("Error processing chunk: {:?}", error),
+//             None => (),
+//         }
+//     }
 // }

tests/v1_client_chat_test.rs

@@ -3,7 +3,7 @@ use mistralai_client::v1::{
     chat::{ChatMessage, ChatMessageRole, ChatParams, ChatResponseChoiceFinishReason},
     client::Client,
     constants::Model,
-    tool::{Tool, ToolChoice},
+    tool::{Tool, ToolChoice, ToolFunctionParameter, ToolFunctionParameterType},
 };
 
 mod setup;
@@ -14,18 +14,19 @@ fn test_client_chat() {
 
     let client = Client::new(None, None, None, None).unwrap();
 
-    let model = Model::mistral_small_latest();
+    let model = Model::OpenMistral7b;
     let messages = vec![ChatMessage::new_user_message(
         "Guess the next word: \"Eiffel ...\"?",
     )];
     let options = ChatParams {
-        temperature: Some(0.0),
+        temperature: 0.0,
         random_seed: Some(42),
         ..Default::default()
     };
 
     let response = client.chat(model, messages, Some(options)).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);
@@ -33,7 +34,7 @@ fn test_client_chat() {
     expect!(response.choices[0]
         .message
         .content
-        .text()
+        .clone()
         .contains("Tower"))
     .to_be(true);
     expect!(response.choices[0].finish_reason.clone()).to_be(ChatResponseChoiceFinishReason::Stop);
@@ -49,26 +50,21 @@ fn test_client_chat_with_function_calling() {
     let tools = vec![Tool::new(
         "get_city_temperature".to_string(),
         "Get the current temperature in a city.".to_string(),
-        serde_json::json!({
-            "type": "object",
-            "properties": {
-                "city": {
-                    "type": "string",
-                    "description": "The name of the city."
-                }
-            },
-            "required": ["city"]
-        }),
+        vec![ToolFunctionParameter::new(
+            "city".to_string(),
+            "The name of the city.".to_string(),
+            ToolFunctionParameterType::String,
+        )],
     )];
 
     let client = Client::new(None, None, None, None).unwrap();
 
-    let model = Model::mistral_small_latest();
+    let model = Model::MistralSmallLatest;
     let messages = vec![ChatMessage::new_user_message(
         "What's the current temperature in Paris?",
     )];
     let options = ChatParams {
-        temperature: Some(0.0),
+        temperature: 0.0,
         random_seed: Some(42),
         tool_choice: Some(ToolChoice::Auto),
         tools: Some(tools),
@@ -77,10 +73,12 @@ fn test_client_chat_with_function_calling() {
 
     let response = client.chat(model, messages, Some(options)).unwrap();
 
+    expect!(response.model).to_be(Model::MistralSmallLatest);
     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("".to_string());
     expect!(response.choices[0].finish_reason.clone())
         .to_be(ChatResponseChoiceFinishReason::ToolCalls);
     expect!(response.usage.prompt_tokens).to_be_greater_than(0);

tests/v1_client_embeddings_async_test.rs

@@ -1,11 +1,11 @@
 use jrest::expect;
-use mistralai_client::v1::{client::Client, constants::Model};
+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 = Model::mistral_embed();
+    let model = EmbedModel::MistralEmbed;
     let input = vec!["Embed this sentence.", "As well as this one."]
         .iter()
         .map(|s| s.to_string())
@@ -17,6 +17,7 @@ async fn test_client_embeddings_async() {
         .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);

tests/v1_client_embeddings_test.rs

@@ -1,11 +1,11 @@
 use jrest::expect;
-use mistralai_client::v1::{client::Client, constants::Model};
+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 = Model::mistral_embed();
+    let model = EmbedModel::MistralEmbed;
     let input = vec!["Embed this sentence.", "As well as this one."]
         .iter()
         .map(|s| s.to_string())
@@ -14,6 +14,7 @@ fn test_client_embeddings() {
 
     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);

tests/v1_constants_test.rs

@@ -6,19 +6,26 @@ use mistralai_client::v1::{
 };
 
 #[test]
-fn test_model_constants() {
+fn test_model_constant() {
     let models = vec![
-        Model::mistral_small_latest(),
-        Model::mistral_large_latest(),
-        Model::open_mistral_nemo(),
-        Model::codestral_latest(),
+        Model::OpenMistral7b,
+        Model::OpenMixtral8x7b,
+        Model::OpenMixtral8x22b,
+        Model::OpenMistralNemo,
+        Model::MistralTiny,
+        Model::MistralSmallLatest,
+        Model::MistralMediumLatest,
+        Model::MistralLargeLatest,
+        Model::MistralLarge,
+        Model::CodestralLatest,
+        Model::CodestralMamba,
     ];
 
     let client = Client::new(None, None, None, None).unwrap();
 
     let messages = vec![ChatMessage::new_user_message("A number between 0 and 100?")];
     let options = ChatParams {
-        temperature: Some(0.0),
+        temperature: 0.0,
         random_seed: Some(42),
         ..Default::default()
     };
@@ -32,6 +39,6 @@ fn test_model_constants() {
         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.content.text().len()).to_be_greater_than(0);
+        expect!(response.choices[0].message.content.len()).to_be_greater_than(0);
     }
 }

tests/v1_conversation_stream_test.rs

@@ -1,183 +0,0 @@
-use futures::StreamExt;
-use mistralai_client::v1::{
-    client::Client,
-    conversation_stream::ConversationEvent,
-    conversations::*,
-};
-
-mod setup;
-
-fn make_client() -> Client {
-    Client::new(None, None, None, None).unwrap()
-}
-
-#[tokio::test]
-async fn test_create_conversation_stream() {
-    setup::setup();
-    let client = make_client();
-
-    let req = CreateConversationRequest {
-        inputs: ConversationInput::Text("What is 2 + 2? Answer in one word.".to_string()),
-        model: Some("mistral-medium-latest".to_string()),
-        agent_id: None,
-        agent_version: None,
-        name: None,
-        description: None,
-        instructions: Some("Respond concisely.".to_string()),
-        completion_args: None,
-        tools: None,
-        handoff_execution: None,
-        metadata: None,
-        store: Some(true),
-        stream: true,
-    };
-
-    let stream = client.create_conversation_stream_async(&req).await.unwrap();
-    tokio::pin!(stream);
-
-    let mut saw_started = false;
-    let mut saw_output = false;
-    let mut saw_done = false;
-    let mut full_text = String::new();
-    let mut conversation_id = String::new();
-    let mut usage_tokens = 0u32;
-
-    while let Some(result) = stream.next().await {
-        let event = result.unwrap();
-        match &event {
-            ConversationEvent::ResponseStarted { .. } => {
-                saw_started = true;
-            }
-            ConversationEvent::MessageOutput { .. } => {
-                saw_output = true;
-                if let Some(delta) = event.text_delta() {
-                    full_text.push_str(&delta);
-                }
-            }
-            ConversationEvent::ResponseDone { usage, .. } => {
-                saw_done = true;
-                usage_tokens = usage.total_tokens;
-            }
-            _ => {}
-        }
-    }
-
-    assert!(saw_started, "Should receive ResponseStarted event");
-    assert!(saw_output, "Should receive at least one MessageOutput event");
-    assert!(saw_done, "Should receive ResponseDone event");
-    assert!(!full_text.is_empty(), "Should accumulate text from deltas");
-    assert!(usage_tokens > 0, "Should have token usage");
-
-    // Accumulate and verify
-    // (we can't accumulate from the consumed stream, but we verified the pieces above)
-}
-
-#[tokio::test]
-async fn test_append_conversation_stream() {
-    setup::setup();
-    let client = make_client();
-
-    // Create conversation (non-streaming) first
-    let create_req = CreateConversationRequest {
-        inputs: ConversationInput::Text("Remember: the secret word is BANANA.".to_string()),
-        model: Some("mistral-medium-latest".to_string()),
-        agent_id: None,
-        agent_version: None,
-        name: None,
-        description: None,
-        instructions: Some("Keep responses short.".to_string()),
-        completion_args: None,
-        tools: None,
-        handoff_execution: None,
-        metadata: None,
-        store: Some(true),
-        stream: false,
-    };
-    let created = client.create_conversation_async(&create_req).await.unwrap();
-
-    // Append with streaming
-    let append_req = AppendConversationRequest {
-        inputs: ConversationInput::Text("What is the secret word?".to_string()),
-        completion_args: None,
-        handoff_execution: None,
-        store: Some(true),
-        tool_confirmations: None,
-        stream: true,
-    };
-
-    let stream = client
-        .append_conversation_stream_async(&created.conversation_id, &append_req)
-        .await
-        .unwrap();
-    tokio::pin!(stream);
-
-    let mut events = Vec::new();
-    while let Some(result) = stream.next().await {
-        events.push(result.unwrap());
-    }
-
-    // Should have started + output(s) + done
-    assert!(
-        events.iter().any(|e| matches!(e, ConversationEvent::ResponseStarted { .. })),
-        "Should have ResponseStarted"
-    );
-    assert!(
-        events.iter().any(|e| matches!(e, ConversationEvent::ResponseDone { .. })),
-        "Should have ResponseDone"
-    );
-
-    // Accumulate and check the text
-    let resp = mistralai_client::v1::conversation_stream::accumulate(
-        &created.conversation_id,
-        &events,
-    );
-    let text = resp.assistant_text().unwrap_or_default().to_uppercase();
-    assert!(text.contains("BANANA"), "Should recall the secret word, got: {text}");
-
-    // Cleanup
-    client.delete_conversation_async(&created.conversation_id).await.unwrap();
-}
-
-#[tokio::test]
-async fn test_stream_accumulate_matches_non_stream() {
-    setup::setup();
-    let client = make_client();
-
-    let question = "What is the capital of Japan? One word.";
-
-    // Non-streaming
-    let req = CreateConversationRequest {
-        inputs: ConversationInput::Text(question.to_string()),
-        model: Some("mistral-medium-latest".to_string()),
-        agent_id: None,
-        agent_version: None,
-        name: None,
-        description: None,
-        instructions: Some("Answer in exactly one word.".to_string()),
-        completion_args: None,
-        tools: None,
-        handoff_execution: None,
-        metadata: None,
-        store: Some(false),
-        stream: false,
-    };
-    let non_stream = client.create_conversation_async(&req).await.unwrap();
-    let non_stream_text = non_stream.assistant_text().unwrap_or_default().to_lowercase();
-
-    // Streaming
-    let mut stream_req = req.clone();
-    stream_req.stream = true;
-    let stream = client.create_conversation_stream_async(&stream_req).await.unwrap();
-    tokio::pin!(stream);
-
-    let mut events = Vec::new();
-    while let Some(result) = stream.next().await {
-        events.push(result.unwrap());
-    }
-    let accumulated = mistralai_client::v1::conversation_stream::accumulate("", &events);
-    let stream_text = accumulated.assistant_text().unwrap_or_default().to_lowercase();
-
-    // Both should contain "tokyo"
-    assert!(non_stream_text.contains("tokyo"), "Non-stream should say Tokyo: {non_stream_text}");
-    assert!(stream_text.contains("tokyo"), "Stream should say Tokyo: {stream_text}");
-}

tests/v1_conversations_api_test.rs

@@ -1,642 +0,0 @@
-use mistralai_client::v1::{
-    agents::*,
-    client::Client,
-    conversations::*,
-};
-
-mod setup;
-
-fn make_client() -> Client {
-    Client::new(None, None, None, None).unwrap()
-}
-
-/// Helper: create a disposable agent for conversation tests (sync).
-fn create_test_agent(client: &Client, name: &str) -> Agent {
-    let req = make_agent_request(name);
-    client.create_agent(&req).unwrap()
-}
-
-/// Helper: create a disposable agent for conversation tests (async).
-async fn create_test_agent_async(client: &Client, name: &str) -> Agent {
-    let req = make_agent_request(name);
-    client.create_agent_async(&req).await.unwrap()
-}
-
-fn make_agent_request(name: &str) -> CreateAgentRequest {
-    CreateAgentRequest {
-        model: "mistral-medium-latest".to_string(),
-        name: name.to_string(),
-        description: Some("Conversation test agent".to_string()),
-        instructions: Some("You are a helpful test agent. Keep responses short.".to_string()),
-        tools: None,
-        handoffs: None,
-        completion_args: Some(CompletionArgs {
-            temperature: Some(0.0),
-            ..Default::default()
-        }),
-        metadata: None,
-    }
-}
-
-// ---------------------------------------------------------------------------
-// Sync tests
-// ---------------------------------------------------------------------------
-
-#[test]
-fn test_create_conversation_with_agent() {
-    setup::setup();
-    let client = make_client();
-    let agent = create_test_agent(&client, "conv-test-create");
-
-    let req = CreateConversationRequest {
-        inputs: ConversationInput::Text("What is 2 + 2?".to_string()),
-        model: None,
-        agent_id: Some(agent.id.clone()),
-        agent_version: None,
-        name: None,
-        description: None,
-        instructions: None,
-        completion_args: None,
-        tools: None,
-        handoff_execution: None,
-        metadata: None,
-        store: None,
-        stream: false,
-    };
-
-    let response = client.create_conversation(&req).unwrap();
-    assert!(!response.conversation_id.is_empty());
-    assert_eq!(response.object, "conversation.response");
-    assert!(!response.outputs.is_empty());
-    assert!(response.usage.total_tokens > 0);
-
-    // Should have an assistant response
-    let text = response.assistant_text();
-    assert!(text.is_some(), "Expected assistant text in outputs");
-    assert!(text.unwrap().contains('4'), "Expected answer containing '4'");
-
-    // Cleanup
-    client.delete_conversation(&response.conversation_id).unwrap();
-    client.delete_agent(&agent.id).unwrap();
-}
-
-#[test]
-fn test_create_conversation_without_agent() {
-    setup::setup();
-    let client = make_client();
-
-    let req = CreateConversationRequest {
-        inputs: ConversationInput::Text("Say hello.".to_string()),
-        model: Some("mistral-medium-latest".to_string()),
-        agent_id: None,
-        agent_version: None,
-        name: None,
-        description: None,
-        instructions: Some("Always respond with exactly 'hello'.".to_string()),
-        completion_args: Some(CompletionArgs {
-            temperature: Some(0.0),
-            ..Default::default()
-        }),
-        tools: None,
-        handoff_execution: None,
-        metadata: None,
-        store: None,
-        stream: false,
-    };
-
-    let response = client.create_conversation(&req).unwrap();
-    assert!(!response.conversation_id.is_empty());
-    let text = response.assistant_text().unwrap().to_lowercase();
-    assert!(text.contains("hello"), "Expected 'hello', got: {text}");
-
-    client.delete_conversation(&response.conversation_id).unwrap();
-}
-
-#[test]
-fn test_append_to_conversation() {
-    setup::setup();
-    let client = make_client();
-    let agent = create_test_agent(&client, "conv-test-append");
-
-    // Create conversation
-    let create_req = CreateConversationRequest {
-        inputs: ConversationInput::Text("Remember the number 42.".to_string()),
-        model: None,
-        agent_id: Some(agent.id.clone()),
-        agent_version: None,
-        name: None,
-        description: None,
-        instructions: None,
-        completion_args: None,
-        tools: None,
-        handoff_execution: None,
-        metadata: None,
-        store: None,
-        stream: false,
-    };
-    let created = client.create_conversation(&create_req).unwrap();
-
-    // Append follow-up
-    let append_req = AppendConversationRequest {
-        inputs: ConversationInput::Text("What number did I ask you to remember?".to_string()),
-        completion_args: None,
-        handoff_execution: None,
-        store: None,
-        tool_confirmations: None,
-        stream: false,
-    };
-    let appended = client
-        .append_conversation(&created.conversation_id, &append_req)
-        .unwrap();
-
-    assert_eq!(appended.conversation_id, created.conversation_id);
-    assert!(!appended.outputs.is_empty());
-    let text = appended.assistant_text().unwrap();
-    assert!(text.contains("42"), "Expected '42' in response, got: {text}");
-    assert!(appended.usage.total_tokens > 0);
-
-    client.delete_conversation(&created.conversation_id).unwrap();
-    client.delete_agent(&agent.id).unwrap();
-}
-
-#[test]
-fn test_get_conversation_info() {
-    setup::setup();
-    let client = make_client();
-    let agent = create_test_agent(&client, "conv-test-get-info");
-
-    let create_req = CreateConversationRequest {
-        inputs: ConversationInput::Text("Hello.".to_string()),
-        model: None,
-        agent_id: Some(agent.id.clone()),
-        agent_version: None,
-        name: None,
-        description: None,
-        instructions: None,
-        completion_args: None,
-        tools: None,
-        handoff_execution: None,
-        metadata: None,
-        store: None,
-        stream: false,
-    };
-    let created = client.create_conversation(&create_req).unwrap();
-
-    let info = client.get_conversation(&created.conversation_id).unwrap();
-    assert_eq!(info.id, created.conversation_id);
-    assert_eq!(info.agent_id.as_deref(), Some(agent.id.as_str()));
-
-    client.delete_conversation(&created.conversation_id).unwrap();
-    client.delete_agent(&agent.id).unwrap();
-}
-
-#[test]
-fn test_get_conversation_history() {
-    setup::setup();
-    let client = make_client();
-    let agent = create_test_agent(&client, "conv-test-history");
-
-    // Create and do two turns
-    let create_req = CreateConversationRequest {
-        inputs: ConversationInput::Text("First message.".to_string()),
-        model: None,
-        agent_id: Some(agent.id.clone()),
-        agent_version: None,
-        name: None,
-        description: None,
-        instructions: None,
-        completion_args: None,
-        tools: None,
-        handoff_execution: None,
-        metadata: None,
-        store: None,
-        stream: false,
-    };
-    let created = client.create_conversation(&create_req).unwrap();
-
-    let append_req = AppendConversationRequest {
-        inputs: ConversationInput::Text("Second message.".to_string()),
-        completion_args: None,
-        handoff_execution: None,
-        store: None,
-        tool_confirmations: None,
-        stream: false,
-    };
-    client
-        .append_conversation(&created.conversation_id, &append_req)
-        .unwrap();
-
-    // Get history — should have at least 4 entries (user, assistant, user, assistant)
-    let history = client
-        .get_conversation_history(&created.conversation_id)
-        .unwrap();
-    assert_eq!(history.conversation_id, created.conversation_id);
-    assert_eq!(history.object, "conversation.history");
-    assert!(
-        history.entries.len() >= 4,
-        "Expected >= 4 history entries, got {}",
-        history.entries.len()
-    );
-
-    // First entry should be a message input
-    assert!(matches!(
-        &history.entries[0],
-        ConversationEntry::MessageInput(_)
-    ));
-
-    client.delete_conversation(&created.conversation_id).unwrap();
-    client.delete_agent(&agent.id).unwrap();
-}
-
-#[test]
-fn test_get_conversation_messages() {
-    setup::setup();
-    let client = make_client();
-    let agent = create_test_agent(&client, "conv-test-messages");
-
-    let create_req = CreateConversationRequest {
-        inputs: ConversationInput::Text("Hello there.".to_string()),
-        model: None,
-        agent_id: Some(agent.id.clone()),
-        agent_version: None,
-        name: None,
-        description: None,
-        instructions: None,
-        completion_args: None,
-        tools: None,
-        handoff_execution: None,
-        metadata: None,
-        store: None,
-        stream: false,
-    };
-    let created = client.create_conversation(&create_req).unwrap();
-
-    let messages = client
-        .get_conversation_messages(&created.conversation_id)
-        .unwrap();
-    assert_eq!(messages.conversation_id, created.conversation_id);
-    assert!(!messages.messages.is_empty());
-
-    client.delete_conversation(&created.conversation_id).unwrap();
-    client.delete_agent(&agent.id).unwrap();
-}
-
-#[test]
-fn test_list_conversations() {
-    setup::setup();
-    let client = make_client();
-
-    let req = CreateConversationRequest {
-        inputs: ConversationInput::Text("List test.".to_string()),
-        model: Some("mistral-medium-latest".to_string()),
-        agent_id: None,
-        agent_version: None,
-        name: None,
-        description: None,
-        instructions: None,
-        completion_args: None,
-        tools: None,
-        handoff_execution: None,
-        metadata: None,
-        store: None,
-        stream: false,
-    };
-    let created = client.create_conversation(&req).unwrap();
-
-    let list = client.list_conversations().unwrap();
-    // API returns raw array (no wrapper object)
-    assert!(list.data.iter().any(|c| c.id == created.conversation_id));
-
-    client.delete_conversation(&created.conversation_id).unwrap();
-}
-
-#[test]
-fn test_delete_conversation() {
-    setup::setup();
-    let client = make_client();
-
-    let req = CreateConversationRequest {
-        inputs: ConversationInput::Text("To be deleted.".to_string()),
-        model: Some("mistral-medium-latest".to_string()),
-        agent_id: None,
-        agent_version: None,
-        name: None,
-        description: None,
-        instructions: None,
-        completion_args: None,
-        tools: None,
-        handoff_execution: None,
-        metadata: None,
-        store: None,
-        stream: false,
-    };
-    let created = client.create_conversation(&req).unwrap();
-
-    let del = client.delete_conversation(&created.conversation_id).unwrap();
-    assert!(del.deleted);
-
-    // Should no longer appear in list
-    let list = client.list_conversations().unwrap();
-    assert!(!list.data.iter().any(|c| c.id == created.conversation_id));
-}
-
-#[test]
-fn test_conversation_with_structured_entries() {
-    setup::setup();
-    let client = make_client();
-
-    use mistralai_client::v1::chat::ChatMessageContent;
-
-    let entries = vec![ConversationEntry::MessageInput(MessageInputEntry {
-        role: "user".to_string(),
-        content: ChatMessageContent::Text("What is the capital of France?".to_string()),
-        prefix: None,
-        id: None,
-        object: None,
-        created_at: None,
-        completed_at: None,
-    })];
-
-    let req = CreateConversationRequest {
-        inputs: ConversationInput::Entries(entries),
-        model: Some("mistral-medium-latest".to_string()),
-        agent_id: None,
-        agent_version: None,
-        name: None,
-        description: None,
-        instructions: Some("Respond in one word.".to_string()),
-        completion_args: Some(CompletionArgs {
-            temperature: Some(0.0),
-            ..Default::default()
-        }),
-        tools: None,
-        handoff_execution: None,
-        metadata: None,
-        store: None,
-        stream: false,
-    };
-
-    let response = client.create_conversation(&req).unwrap();
-    let text = response.assistant_text().unwrap().to_lowercase();
-    assert!(text.contains("paris"), "Expected 'Paris', got: {text}");
-
-    client.delete_conversation(&response.conversation_id).unwrap();
-}
-
-#[test]
-fn test_conversation_with_function_calling() {
-    setup::setup();
-    let client = make_client();
-
-    // Create agent with a function tool
-    let agent_req = CreateAgentRequest {
-        model: "mistral-medium-latest".to_string(),
-        name: "conv-test-function".to_string(),
-        description: None,
-        instructions: Some("When asked about temperature, use the get_temperature tool.".to_string()),
-        tools: Some(vec![AgentTool::function(
-            "get_temperature".to_string(),
-            "Get the current temperature in a city".to_string(),
-            serde_json::json!({
-                "type": "object",
-                "properties": {
-                    "city": {"type": "string", "description": "City name"}
-                },
-                "required": ["city"]
-            }),
-        )]),
-        handoffs: None,
-        completion_args: Some(CompletionArgs {
-            temperature: Some(0.0),
-            ..Default::default()
-        }),
-        metadata: None,
-    };
-    let agent = client.create_agent(&agent_req).unwrap();
-
-    // Create conversation — model should call the function
-    let conv_req = CreateConversationRequest {
-        inputs: ConversationInput::Text("What is the temperature in Paris?".to_string()),
-        model: None,
-        agent_id: Some(agent.id.clone()),
-        agent_version: None,
-        name: None,
-        description: None,
-        instructions: None,
-        completion_args: None,
-        tools: None,
-        handoff_execution: Some(HandoffExecution::Client),
-        metadata: None,
-        store: None,
-        stream: false,
-    };
-    let response = client.create_conversation(&conv_req).unwrap();
-
-    // With client-side execution, we should see function calls in outputs
-    let function_calls = response.function_calls();
-    if !function_calls.is_empty() {
-        assert_eq!(function_calls[0].name, "get_temperature");
-        let args: serde_json::Value =
-            serde_json::from_str(&function_calls[0].arguments).unwrap();
-        assert!(args["city"].as_str().is_some());
-
-        // Send back the function result
-        let tool_call_id = function_calls[0]
-            .tool_call_id
-            .as_deref()
-            .unwrap_or("unknown");
-
-        let result_entries = vec![ConversationEntry::FunctionResult(FunctionResultEntry {
-            tool_call_id: tool_call_id.to_string(),
-            result: "22°C".to_string(),
-            id: None,
-            object: None,
-            created_at: None,
-            completed_at: None,
-        })];
-
-        let append_req = AppendConversationRequest {
-            inputs: ConversationInput::Entries(result_entries),
-            completion_args: None,
-            handoff_execution: None,
-            store: None,
-            tool_confirmations: None,
-            stream: false,
-        };
-        let final_response = client
-            .append_conversation(&response.conversation_id, &append_req)
-            .unwrap();
-
-        // Now we should get an assistant text response
-        let text = final_response.assistant_text();
-        assert!(text.is_some(), "Expected final text after function result");
-        assert!(
-            text.unwrap().contains("22"),
-            "Expected temperature in response"
-        );
-    }
-    // If the API handled it server-side instead, we should still have a response
-    else {
-        assert!(
-            response.assistant_text().is_some(),
-            "Expected either function calls or assistant text"
-        );
-    }
-
-    client.delete_conversation(&response.conversation_id).unwrap();
-    client.delete_agent(&agent.id).unwrap();
-}
-
-// ---------------------------------------------------------------------------
-// Async tests
-// ---------------------------------------------------------------------------
-
-#[tokio::test]
-async fn test_create_conversation_async() {
-    setup::setup();
-    let client = make_client();
-    let agent = create_test_agent_async(&client, "conv-async-create").await;
-
-    let req = CreateConversationRequest {
-        inputs: ConversationInput::Text("Async test: what is 3 + 3?".to_string()),
-        model: None,
-        agent_id: Some(agent.id.clone()),
-        agent_version: None,
-        name: None,
-        description: None,
-        instructions: None,
-        completion_args: None,
-        tools: None,
-        handoff_execution: None,
-        metadata: None,
-        store: None,
-        stream: false,
-    };
-
-    let response = client.create_conversation_async(&req).await.unwrap();
-    assert!(!response.conversation_id.is_empty());
-    let text = response.assistant_text().unwrap();
-    assert!(text.contains('6'), "Expected '6', got: {text}");
-
-    client
-        .delete_conversation_async(&response.conversation_id)
-        .await
-        .unwrap();
-    client.delete_agent_async(&agent.id).await.unwrap();
-}
-
-#[tokio::test]
-async fn test_append_conversation_async() {
-    setup::setup();
-    let client = make_client();
-    let agent = create_test_agent_async(&client, "conv-async-append").await;
-
-    let create_req = CreateConversationRequest {
-        inputs: ConversationInput::Text("My name is Alice.".to_string()),
-        model: None,
-        agent_id: Some(agent.id.clone()),
-        agent_version: None,
-        name: None,
-        description: None,
-        instructions: None,
-        completion_args: None,
-        tools: None,
-        handoff_execution: None,
-        metadata: None,
-        store: None,
-        stream: false,
-    };
-    let created = client.create_conversation_async(&create_req).await.unwrap();
-
-    let append_req = AppendConversationRequest {
-        inputs: ConversationInput::Text("What is my name?".to_string()),
-        completion_args: None,
-        handoff_execution: None,
-        store: None,
-        tool_confirmations: None,
-        stream: false,
-    };
-    let appended = client
-        .append_conversation_async(&created.conversation_id, &append_req)
-        .await
-        .unwrap();
-
-    let text = appended.assistant_text().unwrap();
-    assert!(
-        text.to_lowercase().contains("alice"),
-        "Expected 'Alice' in response, got: {text}"
-    );
-
-    client
-        .delete_conversation_async(&created.conversation_id)
-        .await
-        .unwrap();
-    client.delete_agent_async(&agent.id).await.unwrap();
-}
-
-#[tokio::test]
-async fn test_get_conversation_history_async() {
-    setup::setup();
-    let client = make_client();
-    let agent = create_test_agent_async(&client, "conv-async-history").await;
-
-    let create_req = CreateConversationRequest {
-        inputs: ConversationInput::Text("Hello.".to_string()),
-        model: None,
-        agent_id: Some(agent.id.clone()),
-        agent_version: None,
-        name: None,
-        description: None,
-        instructions: None,
-        completion_args: None,
-        tools: None,
-        handoff_execution: None,
-        metadata: None,
-        store: None,
-        stream: false,
-    };
-    let created = client.create_conversation_async(&create_req).await.unwrap();
-
-    let history = client
-        .get_conversation_history_async(&created.conversation_id)
-        .await
-        .unwrap();
-    assert!(history.entries.len() >= 2); // at least user + assistant
-
-    client
-        .delete_conversation_async(&created.conversation_id)
-        .await
-        .unwrap();
-    client.delete_agent_async(&agent.id).await.unwrap();
-}
-
-#[tokio::test]
-async fn test_list_conversations_async() {
-    setup::setup();
-    let client = make_client();
-
-    let req = CreateConversationRequest {
-        inputs: ConversationInput::Text("Async list test.".to_string()),
-        model: Some("mistral-medium-latest".to_string()),
-        agent_id: None,
-        agent_version: None,
-        name: None,
-        description: None,
-        instructions: None,
-        completion_args: None,
-        tools: None,
-        handoff_execution: None,
-        metadata: None,
-        store: None,
-        stream: false,
-    };
-    let created = client.create_conversation_async(&req).await.unwrap();
-
-    let list = client.list_conversations_async().await.unwrap();
-    assert!(list.data.iter().any(|c| c.id == created.conversation_id));
-
-    client
-        .delete_conversation_async(&created.conversation_id)
-        .await
-        .unwrap();
-}

tests/v1_conversations_types_test.rs

@@ -1,226 +0,0 @@
-use mistralai_client::v1::chat::ChatMessageContent;
-use mistralai_client::v1::conversations::*;
-
-#[test]
-fn test_conversation_input_from_string() {
-    let input: ConversationInput = "hello".into();
-    let json = serde_json::to_value(&input).unwrap();
-    assert_eq!(json, serde_json::json!("hello"));
-}
-
-#[test]
-fn test_conversation_input_from_entries() {
-    let entries = vec![ConversationEntry::MessageInput(MessageInputEntry {
-        role: "user".to_string(),
-        content: ChatMessageContent::Text("hello".to_string()),
-        prefix: None,
-        id: None,
-        object: None,
-        created_at: None,
-        completed_at: None,
-    })];
-    let input: ConversationInput = entries.into();
-    let json = serde_json::to_value(&input).unwrap();
-    assert!(json.is_array());
-    assert_eq!(json[0]["type"], "message.input");
-    assert_eq!(json[0]["content"], "hello");
-}
-
-#[test]
-fn test_create_conversation_request() {
-    let req = CreateConversationRequest {
-        inputs: ConversationInput::Text("What is 2+2?".to_string()),
-        model: None,
-        agent_id: Some("ag_abc123".to_string()),
-        agent_version: None,
-        name: None,
-        description: None,
-        instructions: None,
-        completion_args: None,
-        tools: None,
-        handoff_execution: Some(HandoffExecution::Server),
-        metadata: None,
-        store: None,
-        stream: false,
-    };
-
-    let json = serde_json::to_value(&req).unwrap();
-    assert_eq!(json["inputs"], "What is 2+2?");
-    assert_eq!(json["agent_id"], "ag_abc123");
-    assert_eq!(json["handoff_execution"], "server");
-    assert_eq!(json["stream"], false);
-}
-
-#[test]
-fn test_conversation_response_deserialization() {
-    let json = serde_json::json!({
-        "conversation_id": "conv_abc123",
-        "outputs": [
-            {
-                "type": "message.output",
-                "role": "assistant",
-                "content": "4"
-            }
-        ],
-        "usage": {
-            "prompt_tokens": 10,
-            "completion_tokens": 5,
-            "total_tokens": 15
-        },
-        "object": "conversation.response"
-    });
-
-    let resp: ConversationResponse = serde_json::from_value(json).unwrap();
-    assert_eq!(resp.conversation_id, "conv_abc123");
-    assert_eq!(resp.assistant_text().unwrap(), "4");
-    assert_eq!(resp.usage.total_tokens, 15);
-    assert!(!resp.has_handoff());
-}
-
-#[test]
-fn test_conversation_response_with_function_calls() {
-    let json = serde_json::json!({
-        "conversation_id": "conv_abc123",
-        "outputs": [
-            {
-                "type": "function.call",
-                "name": "search_archive",
-                "arguments": "{\"query\":\"error rate\"}",
-                "tool_call_id": "tc_1"
-            },
-            {
-                "type": "message.output",
-                "role": "assistant",
-                "content": "error rate is 0.3%"
-            }
-        ],
-        "usage": {"prompt_tokens": 20, "completion_tokens": 10, "total_tokens": 30},
-        "object": "conversation.response"
-    });
-
-    let resp: ConversationResponse = serde_json::from_value(json).unwrap();
-    let fc = resp.function_calls();
-    assert_eq!(fc.len(), 1);
-    assert_eq!(fc[0].name, "search_archive");
-    assert_eq!(resp.assistant_text().unwrap(), "error rate is 0.3%");
-}
-
-#[test]
-fn test_conversation_response_with_handoff() {
-    let json = serde_json::json!({
-        "conversation_id": "conv_abc123",
-        "outputs": [
-            {
-                "type": "agent.handoff",
-                "previous_agent_id": "ag_orch",
-                "next_agent_id": "ag_obs"
-            }
-        ],
-        "usage": {"prompt_tokens": 5, "completion_tokens": 0, "total_tokens": 5},
-        "object": "conversation.response"
-    });
-
-    let resp: ConversationResponse = serde_json::from_value(json).unwrap();
-    assert!(resp.has_handoff());
-    assert!(resp.assistant_text().is_none());
-}
-
-#[test]
-fn test_conversation_history_response() {
-    let json = serde_json::json!({
-        "conversation_id": "conv_abc123",
-        "entries": [
-            {"type": "message.input", "role": "user", "content": "hi"},
-            {"type": "message.output", "role": "assistant", "content": "hello"},
-            {"type": "message.input", "role": "user", "content": "search for cats"},
-            {"type": "function.call", "name": "search", "arguments": "{\"q\":\"cats\"}"},
-            {"type": "function.result", "tool_call_id": "tc_1", "result": "found 3 results"},
-            {"type": "message.output", "role": "assistant", "content": "found 3 results about cats"}
-        ],
-        "object": "conversation.history"
-    });
-
-    let resp: ConversationHistoryResponse = serde_json::from_value(json).unwrap();
-    assert_eq!(resp.entries.len(), 6);
-    assert!(matches!(&resp.entries[0], ConversationEntry::MessageInput(_)));
-    assert!(matches!(&resp.entries[3], ConversationEntry::FunctionCall(_)));
-    assert!(matches!(&resp.entries[4], ConversationEntry::FunctionResult(_)));
-}
-
-#[test]
-fn test_append_conversation_request() {
-    let req = AppendConversationRequest {
-        inputs: ConversationInput::Text("follow-up question".to_string()),
-        completion_args: None,
-        handoff_execution: None,
-        store: None,
-        tool_confirmations: None,
-        stream: false,
-    };
-
-    let json = serde_json::to_value(&req).unwrap();
-    assert_eq!(json["inputs"], "follow-up question");
-    assert_eq!(json["stream"], false);
-}
-
-#[test]
-fn test_restart_conversation_request() {
-    let req = RestartConversationRequest {
-        from_entry_id: "entry_3".to_string(),
-        inputs: Some(ConversationInput::Text("different question".to_string())),
-        completion_args: None,
-        agent_version: None,
-        handoff_execution: Some(HandoffExecution::Client),
-        metadata: None,
-        store: None,
-        stream: false,
-    };
-
-    let json = serde_json::to_value(&req).unwrap();
-    assert_eq!(json["from_entry_id"], "entry_3");
-    assert_eq!(json["handoff_execution"], "client");
-}
-
-#[test]
-fn test_tool_call_confirmation() {
-    let req = AppendConversationRequest {
-        inputs: ConversationInput::Entries(vec![ConversationEntry::FunctionResult(
-            FunctionResultEntry {
-                tool_call_id: "tc_1".to_string(),
-                result: "search returned 5 results".to_string(),
-                id: None,
-                object: None,
-                created_at: None,
-                completed_at: None,
-            },
-        )]),
-        completion_args: None,
-        handoff_execution: None,
-        store: None,
-        tool_confirmations: None,
-        stream: false,
-    };
-
-    let json = serde_json::to_value(&req).unwrap();
-    assert_eq!(json["inputs"][0]["type"], "function.result");
-    assert_eq!(json["inputs"][0]["tool_call_id"], "tc_1");
-}
-
-#[test]
-fn test_handoff_execution_default() {
-    assert_eq!(HandoffExecution::default(), HandoffExecution::Server);
-}
-
-#[test]
-fn test_conversation_list_response() {
-    // API returns a raw JSON array
-    let json = serde_json::json!([
-        {"id": "conv_1", "object": "conversation", "agent_id": "ag_1", "created_at": "2026-03-21T00:00:00Z"},
-        {"id": "conv_2", "object": "conversation", "model": "mistral-medium-latest"}
-    ]);
-
-    let resp: ConversationListResponse = serde_json::from_value(json).unwrap();
-    assert_eq!(resp.data.len(), 2);
-    assert_eq!(resp.data[0].agent_id.as_deref(), Some("ag_1"));
-    assert!(resp.data[1].agent_id.is_none());
-}