Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
use anyhow::{Result, anyhow};
use collections::{BTreeMap, HashMap};
use credentials_provider::CredentialsProvider;
use futures::{FutureExt, Stream, StreamExt, future::BoxFuture};
use gpui::{App, AppContext, AsyncApp, Context, Entity, Global, SharedString, Task};
use http_client::{CustomHeaders, HttpClient};
use language_model::{
ApiKeyConfiguration, ApiKeyState, AuthenticateError, EnvVar, IconOrSvg, LanguageModel,
LanguageModelClient, LanguageModelCompletionError, LanguageModelCompletionEvent,
LanguageModelCompletionStream, LanguageModelId, LanguageModelName, LanguageModelProvider,
LanguageModelProviderId, LanguageModelProviderName, LanguageModelProviderState,
LanguageModelRequest, LanguageModelToolChoice, LanguageModelToolChoiceSupport,
LanguageModelToolResultContent, LanguageModelToolUse, MessageContent, ModelRateLimiters,
PromptCompactionStrategy, ProviderSettingsView, RateLimiter, Role, StopReason, TokenUsage,
env_var, unavailable_error,
};
pub use mistral::{MISTRAL_API_URL, StreamResponse};
pub use settings::MistralAvailableModel as AvailableModel;
use settings::{Settings, SettingsStore};
use std::pin::Pin;
use std::sync::{Arc, LazyLock};
use strum::IntoEnumIterator;
use ui::IconName;
use language_model::util::{fix_streamed_json, parse_tool_arguments};
const PROVIDER_ID: LanguageModelProviderId = LanguageModelProviderId::new("mistral");
const PROVIDER_NAME: LanguageModelProviderName = LanguageModelProviderName::new("Mistral");
const API_KEY_ENV_VAR_NAME: &str = "MISTRAL_API_KEY";
static API_KEY_ENV_VAR: LazyLock<EnvVar> = env_var!(API_KEY_ENV_VAR_NAME);
pub(crate) const RESERVED_HEADER_NAMES: &[&str] = &["x-affinity"];
#[derive(Default, Clone, Debug, PartialEq)]
pub struct MistralSettings {
pub api_url: String,
pub available_models: Vec<AvailableModel>,
pub custom_headers: CustomHeaders,
}
pub struct MistralLanguageModelProvider {
http_client: Arc<dyn HttpClient>,
pub state: Entity<State>,
request_limiters: ModelRateLimiters,
}
pub struct State {
api_key_state: ApiKeyState,
credentials_provider: Arc<dyn CredentialsProvider>,
}
impl State {
fn is_authenticated(&self) -> bool {
self.api_key_state.has_key()
}
fn set_api_key(&mut self, api_key: Option<String>, cx: &mut Context<Self>) -> Task<Result<()>> {
let credentials_provider = self.credentials_provider.clone();
let api_url = MistralLanguageModelProvider::api_url(cx);
self.api_key_state.store(
api_url,
api_key,
|this| &mut this.api_key_state,
credentials_provider,
cx,
)
}
fn authenticate(&mut self, cx: &mut Context<Self>) -> Task<Result<(), AuthenticateError>> {
let credentials_provider = self.credentials_provider.clone();
let api_url = MistralLanguageModelProvider::api_url(cx);
self.api_key_state.load_if_needed(
api_url,
|this| &mut this.api_key_state,
credentials_provider,
cx,
)
}
}
struct GlobalMistralLanguageModelProvider(Arc<MistralLanguageModelProvider>);
impl Global for GlobalMistralLanguageModelProvider {}
impl MistralLanguageModelProvider {
pub fn try_global(cx: &App) -> Option<&Arc<MistralLanguageModelProvider>> {
cx.try_global::<GlobalMistralLanguageModelProvider>()
.map(|this| &this.0)
}
pub fn global(
http_client: Arc<dyn HttpClient>,
credentials_provider: Arc<dyn CredentialsProvider>,
cx: &mut App,
) -> Arc<Self> {
if let Some(this) = cx.try_global::<GlobalMistralLanguageModelProvider>() {
return this.0.clone();
}
let state = cx.new(|cx| {
cx.observe_global::<SettingsStore>(|this: &mut State, cx| {
let credentials_provider = this.credentials_provider.clone();
let api_url = Self::api_url(cx);
this.api_key_state.handle_url_change(
api_url,
|this| &mut this.api_key_state,
credentials_provider,
cx,
);
cx.notify();
})
.detach();
State {
api_key_state: ApiKeyState::new(Self::api_url(cx), (*API_KEY_ENV_VAR).clone()),
credentials_provider,
}
});
let this = Arc::new(Self {
http_client,
state,
request_limiters: ModelRateLimiters::default(),
});
cx.set_global(GlobalMistralLanguageModelProvider(this));
cx.global::<GlobalMistralLanguageModelProvider>().0.clone()
}
/// Every model this provider offers, keyed by id: the built-in models,
/// with settings entries added or overriding built-in ones.
fn mistral_models(&self, cx: &App) -> BTreeMap<String, mistral::Model> {
let mut models = BTreeMap::default();
for model in mistral::Model::iter() {
if !matches!(model, mistral::Model::Custom { .. }) {
models.insert(model.id().to_string(), model);
}
}
for model in &Self::settings(cx).available_models {
models.insert(
model.name.clone(),
mistral::Model::Custom {
name: model.name.clone(),
display_name: model.display_name.clone(),
max_tokens: model.max_tokens,
max_output_tokens: model.max_output_tokens,
max_completion_tokens: model.max_completion_tokens,
supports_tools: model.supports_tools,
supports_images: model.supports_images,
supports_thinking: model.supports_thinking,
},
);
}
models
}
/// The current configuration of `model`, if this provider still offers it.
fn config(
&self,
model: &LanguageModel,
cx: &App,
) -> Result<mistral::Model, LanguageModelCompletionError> {
self.mistral_models(cx)
.remove(model.id.0.as_ref())
.ok_or_else(|| unavailable_error(model))
}
fn stream_mistral_request(
&self,
request_limiter: &RateLimiter,
request: mistral::Request,
affinity: Option<String>,
cx: &AsyncApp,
) -> BoxFuture<
'static,
Result<futures::stream::BoxStream<'static, Result<mistral::StreamResponse>>>,
> {
let http_client = self.http_client.clone();
let (api_key, api_url, extra_headers) = self.state.read_with(cx, |state, cx| {
let api_url = MistralLanguageModelProvider::api_url(cx);
let extra_headers = MistralLanguageModelProvider::settings(cx)
.custom_headers
.clone();
(state.api_key_state.key(&api_url), api_url, extra_headers)
});
let future = request_limiter.stream(async move {
let Some(api_key) = api_key else {
return Err(LanguageModelCompletionError::NoApiKey {
provider: PROVIDER_NAME,
});
};
let request = mistral::stream_completion(
http_client.as_ref(),
&api_url,
&api_key,
request,
affinity,
&extra_headers,
);
let response = request.await?;
Ok(response)
});
async move { Ok(future.await?.boxed()) }.boxed()
}
fn settings(cx: &App) -> &MistralSettings {
&crate::AllLanguageModelSettings::get_global(cx).mistral
}
pub fn api_url(cx: &App) -> SharedString {
let api_url = &Self::settings(cx).api_url;
if api_url.is_empty() {
mistral::MISTRAL_API_URL.into()
} else {
SharedString::new(api_url.as_str())
}
}
}
impl LanguageModelProviderState for MistralLanguageModelProvider {
type ObservableEntity = State;
fn observable_entity(&self) -> Option<Entity<Self::ObservableEntity>> {
Some(self.state.clone())
}
}
impl LanguageModelProvider for MistralLanguageModelProvider {
fn id(&self) -> LanguageModelProviderId {
PROVIDER_ID
}
fn name(&self) -> LanguageModelProviderName {
PROVIDER_NAME
}
fn icon(&self) -> IconOrSvg {
IconOrSvg::Icon(IconName::AiMistral)
}
fn default_model(&self, cx: &App) -> Option<LanguageModel> {
self.mistral_models(cx)
.get(mistral::Model::default().id())
.map(language_model)
}
fn default_fast_model(&self, cx: &App) -> Option<LanguageModel> {
self.mistral_models(cx)
.get(mistral::Model::default_fast().id())
.map(language_model)
}
fn provided_models(&self, cx: &App) -> Vec<LanguageModel> {
self.mistral_models(cx)
.values()
.map(language_model)
.collect()
}
fn is_authenticated(&self, cx: &App) -> bool {
self.state.read(cx).is_authenticated()
}
fn authenticate(&self, cx: &mut App) -> Task<Result<(), AuthenticateError>> {
self.state.update(cx, |state, cx| state.authenticate(cx))
}
fn settings_view(&self, cx: &mut App) -> Option<ProviderSettingsView> {
let state = self.state.read(cx);
Some(ProviderSettingsView::ApiKey(ApiKeyConfiguration::new(
state.api_key_state.has_key(),
state.api_key_state.is_from_env_var(),
state.api_key_state.env_var_name().clone(),
"https://console.mistral.ai/api-keys".into(),
)))
}
fn set_api_key(&self, api_key: Option<String>, cx: &mut App) -> Task<Result<()>> {
self.state
.update(cx, |state, cx| state.set_api_key(api_key, cx))
}
}
impl LanguageModelClient for MistralLanguageModelProvider {
fn stream_completion(
&self,
model: &LanguageModel,
request: LanguageModelRequest,
cx: &AsyncApp,
) -> BoxFuture<'static, Result<LanguageModelCompletionStream, LanguageModelCompletionError>>
{
let config = match cx.update(|cx| self.config(model, cx)) {
Ok(config) => config,
Err(error) => return async move { Err(error) }.boxed(),
};
let request_limiter = self.request_limiters.for_model(&model.id);
let (request, affinity) =
match into_mistral(request, config.clone(), config.max_output_tokens()) {
Ok(request) => request,
Err(error) => return async move { Err(error.into()) }.boxed(),
};
let stream = self.stream_mistral_request(&request_limiter, request, affinity, cx);
let executor = cx.background_executor().clone();
async move {
let stream = stream.await?;
let mapper = MistralEventMapper::new();
Ok(language_model::stream_in_background(
mapper.map_stream(stream).boxed(),
executor,
))
}
.boxed()
}
}
fn language_model(model: &mistral::Model) -> LanguageModel {
let supports_tools = model.supports_tools();
LanguageModel {
supports_tools,
supports_streaming_tools: true,
tool_choice_support: LanguageModelToolChoiceSupport {
auto: supports_tools,
any: supports_tools,
none: supports_tools,
},
prompt_compaction_strategy: PromptCompactionStrategy::PreserveRequestPrefix,
supports_images: model.supports_images(),
supports_thinking: model.supports_thinking(),
supports_disabling_thinking: model.supports_disabling_thinking(),
max_output_tokens: model.max_output_tokens(),
..LanguageModel::new(
LanguageModelId::from(model.id().to_string()),
LanguageModelName::from(model.display_name().to_string()),
PROVIDER_ID,
PROVIDER_NAME,
format!("mistral/{}", model.id()),
model.max_token_count(),
)
}
}
pub fn into_mistral(
request: LanguageModelRequest,
model: mistral::Model,
max_output_tokens: Option<u64>,
) -> Result<(mistral::Request, Option<String>)> {
let max_output_tokens = request.effective_max_output_tokens(max_output_tokens);
if request.contains_custom_tool_input() {
anyhow::bail!("Mistral does not support custom tools");
}
let stream = true;
let mut messages = Vec::new();
for message in &request.messages {
match message.role {
Role::User => {
let mut message_content = mistral::MessageContent::empty();
for content in &message.content {
match content {
MessageContent::Text(text) => {
message_content
.push_part(mistral::MessagePart::Text { text: text.clone() });
}
MessageContent::Image(image_content) => {
if model.supports_images() {
message_content.push_part(mistral::MessagePart::ImageUrl {
image_url: image_content.to_base64_url(),
});
}
}
MessageContent::Thinking { text, .. } => {
if model.supports_thinking() {
message_content.push_part(mistral::MessagePart::Thinking {
thinking: vec![mistral::ThinkingPart::Text {
text: text.clone(),
}],
});
}
}
MessageContent::RedactedThinking(_) => {}
MessageContent::Compaction(_) => {}
MessageContent::ToolUse(_) => {
// Tool use is not supported in User messages for Mistral
}
MessageContent::ToolResult(tool_result) => {
let mut text_parts: Vec<String> = Vec::new();
for part in &tool_result.content {
match part {
LanguageModelToolResultContent::Text(text) => {
text_parts.push(text.to_string());
}
LanguageModelToolResultContent::Image(_) => {
text_parts.push("[Tool responded with an image, but Zed doesn't support these in Mistral models yet]".to_string());
}
}
}
messages.push(mistral::RequestMessage::Tool {
content: text_parts.join("\n"),
tool_call_id: tool_result.tool_use_id.to_string(),
});
}
}
}
if !matches!(message_content, mistral::MessageContent::Plain { ref content } if content.is_empty())
{
messages.push(mistral::RequestMessage::User {
content: message_content,
});
}
}
Role::Assistant => {
for content in &message.content {
match content {
MessageContent::Text(text) if text.is_empty() => {
// Mistral API returns a 400 if there's neither content nor tool_calls
}
MessageContent::Text(text) => {
messages.push(mistral::RequestMessage::Assistant {
content: Some(mistral::MessageContent::Plain {
content: text.clone(),
}),
tool_calls: Vec::new(),
});
}
MessageContent::Thinking { text, .. } => {
if model.supports_thinking() {
messages.push(mistral::RequestMessage::Assistant {
content: Some(mistral::MessageContent::Multipart {
content: vec![mistral::MessagePart::Thinking {
thinking: vec![mistral::ThinkingPart::Text {
text: text.clone(),
}],
}],
}),
tool_calls: Vec::new(),
});
}
}
MessageContent::RedactedThinking(_) => {}
MessageContent::Image(_) => {}
MessageContent::Compaction(_) => {}
MessageContent::ToolUse(tool_use) => {
let input = tool_use.input.as_json().ok_or_else(|| {
anyhow!("Mistral does not support custom tool calls")
})?;
let tool_call = mistral::ToolCall {
id: tool_use.id.to_string(),
content: mistral::ToolCallContent::Function {
function: mistral::FunctionContent {
name: tool_use.name.to_string(),
arguments: serde_json::to_string(input).unwrap_or_default(),
},
},
};
if let Some(mistral::RequestMessage::Assistant { tool_calls, .. }) =
messages.last_mut()
{
tool_calls.push(tool_call);
} else {
messages.push(mistral::RequestMessage::Assistant {
content: None,
tool_calls: vec![tool_call],
});
}
}
MessageContent::ToolResult(_) => {
// Tool results are not supported in Assistant messages
}
}
}
}
Role::System => {
for content in &message.content {
match content {
MessageContent::Text(text) => {
messages.push(mistral::RequestMessage::System {
content: mistral::MessageContent::Plain {
content: text.clone(),
},
});
}
MessageContent::Thinking { text, .. } => {
if model.supports_thinking() {
messages.push(mistral::RequestMessage::System {
content: mistral::MessageContent::Multipart {
content: vec![mistral::MessagePart::Thinking {
thinking: vec![mistral::ThinkingPart::Text {
text: text.clone(),
}],
}],
},
});
}
}
MessageContent::RedactedThinking(_) => {}
MessageContent::Compaction(_) => {}
MessageContent::Image(_)
| MessageContent::ToolUse(_)
| MessageContent::ToolResult(_) => {
// Images and tools are not supported in System messages
}
}
}
}
}
}
Ok((
mistral::Request {
model: model.id().to_string(),
messages,
stream,
stream_options: if stream {
Some(mistral::StreamOptions {
stream_tool_calls: Some(true),
})
} else {
None
},
max_tokens: max_output_tokens,
temperature: request.temperature,
response_format: None,
tool_choice: match request.tool_choice {
Some(LanguageModelToolChoice::Auto) if !request.tools.is_empty() => {
Some(mistral::ToolChoice::Auto)
}
Some(LanguageModelToolChoice::Any) if !request.tools.is_empty() => {
Some(mistral::ToolChoice::Any)
}
Some(LanguageModelToolChoice::None) => Some(mistral::ToolChoice::None),
_ if !request.tools.is_empty() => Some(mistral::ToolChoice::Auto),
_ => None,
},
parallel_tool_calls: if !request.tools.is_empty() {
Some(false)
} else {
None
},
tools: request
.tools
.into_iter()
.map(|tool| {
let input_schema = match tool.input {
language_model::LanguageModelRequestToolInput::Function {
input_schema,
..
} => input_schema,
language_model::LanguageModelRequestToolInput::Custom { .. } => {
return Err(anyhow::anyhow!("Mistral does not support custom tools"));
}
};
Ok(mistral::ToolDefinition::Function {
function: mistral::FunctionDefinition {
name: tool.name,
description: Some(tool.description),
parameters: Some(input_schema),
},
})
})
.collect::<Result<_>>()?,
reasoning_effort: if !model.supports_thinking() {
None
} else if request.thinking_allowed {
Some(mistral::ReasoningEffort::High)
} else if model.supports_disabling_thinking() {
// Explicitly disable thinking rather than relying on the API's
// default.
Some(mistral::ReasoningEffort::None)
} else {
// Models for which thinking can't be disabled will reject
// "none" as the `reasoning_effort` value. Omitting the field is
// the only way to request the API's default effort.
None
},
},
request.thread_id,
))
}
pub struct MistralEventMapper {
tool_calls_by_index: HashMap<usize, RawToolCall>,
}
impl MistralEventMapper {
pub fn new() -> Self {
Self {
tool_calls_by_index: HashMap::default(),
}
}
pub fn map_stream(
mut self,
events: Pin<Box<dyn Send + Stream<Item = Result<StreamResponse>>>>,
) -> impl Stream<Item = Result<LanguageModelCompletionEvent, LanguageModelCompletionError>>
{
events.flat_map(move |event| {
futures::stream::iter(match event {
Ok(event) => self.map_event(event),
Err(error) => vec![Err(LanguageModelCompletionError::from(error))],
})
})
}
pub fn map_event(
&mut self,
event: mistral::StreamResponse,
) -> Vec<Result<LanguageModelCompletionEvent, LanguageModelCompletionError>> {
let Some(choice) = event.choices.first() else {
return vec![Err(LanguageModelCompletionError::from(anyhow!(
"Response contained no choices"
)))];
};
let mut events = Vec::new();
if let Some(content) = choice.delta.content.as_ref() {
match content {
mistral::MessageContentDelta::Text(text) => {
events.push(Ok(LanguageModelCompletionEvent::Text(text.clone())));
}
mistral::MessageContentDelta::Parts(parts) => {
for part in parts {
match part {
mistral::MessagePart::Text { text } => {
events.push(Ok(LanguageModelCompletionEvent::Text(text.clone())));
}
mistral::MessagePart::Thinking { thinking } => {
for tp in thinking.iter().cloned() {
match tp {
mistral::ThinkingPart::Text { text } => {
events.push(Ok(
LanguageModelCompletionEvent::Thinking {
text,
signature: None,
},
));
}
}
}
}
mistral::MessagePart::ImageUrl { .. } => {
// We currently don't emit a separate event for images in responses.
}
}
}
}
}
}
if let Some(tool_calls) = choice.delta.tool_calls.as_ref() {
for tool_call in tool_calls {
let entry = self.tool_calls_by_index.entry(tool_call.index).or_default();
if let Some(tool_id) = tool_call.id.clone()
&& !tool_id.is_empty()
&& tool_id != "null"
{
entry.id = tool_id;
}
if let Some(function) = tool_call.function.as_ref() {
if let Some(name) = function.name.clone()
&& !name.is_empty()
{
entry.name = name;
}
if let Some(arguments) = function.arguments.clone() {
entry.arguments.push_str(&arguments);
}
}
if !entry.id.is_empty() && !entry.name.is_empty() {
if let Ok(input) = serde_json::from_str::<serde_json::Value>(
&fix_streamed_json(&entry.arguments),
) {
events.push(Ok(LanguageModelCompletionEvent::ToolUse(
LanguageModelToolUse {
id: entry.id.clone().into(),
name: entry.name.as_str().into(),
is_input_complete: false,
input: language_model::LanguageModelToolUseInput::Json(input),
raw_input: entry.arguments.clone(),
thought_signature: None,
},
)));
}
}
}
}
if let Some(usage) = event.usage {
events.push(Ok(LanguageModelCompletionEvent::UsageUpdate(TokenUsage {
input_tokens: usage.prompt_tokens,
output_tokens: usage.completion_tokens,
cache_creation_input_tokens: 0,
cache_read_input_tokens: 0,
})));
}
if let Some(finish_reason) = choice.finish_reason.as_deref() {
match finish_reason {
"stop" => {
events.push(Ok(LanguageModelCompletionEvent::Stop(StopReason::EndTurn)));
}
"tool_calls" => {
events.extend(self.process_tool_calls());
events.push(Ok(LanguageModelCompletionEvent::Stop(StopReason::ToolUse)));
}
unexpected => {
log::error!("Unexpected Mistral stop_reason: {unexpected:?}");
events.push(Ok(LanguageModelCompletionEvent::Stop(StopReason::EndTurn)));
}
}
}
events
}
fn process_tool_calls(
&mut self,
) -> Vec<Result<LanguageModelCompletionEvent, LanguageModelCompletionError>> {
let mut results = Vec::new();
for (_, tool_call) in self.tool_calls_by_index.drain() {
if tool_call.id.is_empty() || tool_call.name.is_empty() {
results.push(Err(LanguageModelCompletionError::from(anyhow!(
"Received incomplete tool call: missing id or name"
))));
continue;
}
match parse_tool_arguments(&tool_call.arguments) {
Ok(input) => results.push(Ok(LanguageModelCompletionEvent::ToolUse(
LanguageModelToolUse {
id: tool_call.id.into(),
name: tool_call.name.into(),
is_input_complete: true,
input: language_model::LanguageModelToolUseInput::Json(input),
raw_input: tool_call.arguments,
thought_signature: None,
},
))),
Err(error) => {
results.push(Ok(LanguageModelCompletionEvent::ToolUseJsonParseError {
id: tool_call.id.into(),
tool_name: tool_call.name.into(),
raw_input: tool_call.arguments.into(),
json_parse_error: error.to_string(),
}))
}
}
}
results
}
}
#[derive(Default)]
struct RawToolCall {
id: String,
name: String,
arguments: String,
}
#[cfg(test)]
mod tests {
use super::*;
use language_model::{LanguageModelImage, LanguageModelRequestMessage, MessageContent};
fn tool_call_chunk(
id: Option<&str>,
name: Option<&str>,
arguments: Option<&str>,
finish_reason: Option<&str>,
) -> mistral::StreamResponse {
mistral::StreamResponse {
id: "resp".into(),
object: "chat.completion.chunk".into(),
created: 0,
model: "test".into(),
choices: vec![mistral::StreamChoice {
index: 0,
delta: mistral::StreamDelta {
role: None,
content: None,
tool_calls: if finish_reason.is_some() {
None
} else {
Some(vec![mistral::ToolCallChunk {
index: 0,
id: id.map(Into::into),
function: Some(mistral::FunctionChunk {
name: name.map(Into::into),
arguments: arguments.map(Into::into),
}),
}])
},
},
finish_reason: finish_reason.map(Into::into),
}],
usage: None,
}
}
#[test]
fn test_streaming_tool_call_ignores_null_id() {
// Mistral's streaming API sometimes sends `"id": "null"` in continuation chunks.
let mut mapper = MistralEventMapper::new();
mapper.map_event(tool_call_chunk(
Some("real_id_123"),
Some("read_file"),
Some("{\"path\":"),
None,
));
mapper.map_event(tool_call_chunk(
Some("null"),
None,
Some("\"a.txt\"}"),
None,
));
let events = mapper.map_event(tool_call_chunk(None, None, None, Some("tool_calls")));
let Ok(LanguageModelCompletionEvent::ToolUse(tool_use)) = &events[0] else {
panic!("Expected first event to be ToolUse, got: {:?}", events[0]);
};
assert_eq!(tool_use.id.to_string(), "real_id_123");
assert_eq!(tool_use.name.as_ref(), "read_file");
assert_eq!(
tool_use.input,
language_model::LanguageModelToolUseInput::Json(serde_json::json!({"path": "a.txt"}))
);
}
#[test]
fn test_into_mistral_basic_conversion() {
let request = |max_output_tokens| LanguageModelRequest {
messages: vec![
LanguageModelRequestMessage {
role: Role::System,
content: vec![MessageContent::Text("System prompt".into())],
cache: false,
reasoning_details: None,
},
LanguageModelRequestMessage {
role: Role::User,
content: vec![MessageContent::Text("Hello".into())],
cache: false,
reasoning_details: None,
},
// should skip empty assistant messages
LanguageModelRequestMessage {
role: Role::Assistant,
content: vec![MessageContent::Text("".into())],
cache: false,
reasoning_details: None,
},
],
temperature: Some(0.5),
tools: vec![],
tool_choice: None,
thread_id: Some("abcdef".into()),
prompt_cache_key: None,
prompt_id: None,
intent: None,
stop: vec![],
thinking_allowed: true,
thinking_effort: None,
speed: Default::default(),
compact_at_tokens: None,
max_output_tokens,
};
for (requested, maximum, expected) in [
(None, None, None),
(None, Some(4096), Some(4096)),
(Some(1024), Some(4096), Some(1024)),
(Some(8192), Some(4096), Some(4096)),
(Some(1024), None, Some(1024)),
] {
let (mistral_request, affinity) = into_mistral(
request(requested),
mistral::Model::MistralSmallLatest,
maximum,
)
.unwrap();
assert_eq!(mistral_request.model, "mistral-small-latest");
assert_eq!(mistral_request.temperature, Some(0.5));
assert_eq!(mistral_request.messages.len(), 2);
assert!(mistral_request.stream);
assert_eq!(affinity, Some("abcdef".into()));
assert_eq!(
serde_json::to_value(mistral_request).unwrap()["max_tokens"].as_u64(),
expected
);
}
}
#[test]
fn test_into_mistral_reasoning_effort() {
let request = |thinking_allowed| LanguageModelRequest {
messages: vec![LanguageModelRequestMessage {
role: Role::User,
content: vec![MessageContent::Text("Hello".into())],
cache: false,
reasoning_details: None,
}],
temperature: None,
tools: vec![],
tool_choice: None,
thread_id: None,
prompt_cache_key: None,
prompt_id: None,
intent: None,
stop: vec![],
thinking_allowed,
thinking_effort: None,
speed: Default::default(),
compact_at_tokens: None,
max_output_tokens: None,
};
let cases = vec![
(
mistral::Model::MistralSmallLatest,
true,
Some(mistral::ReasoningEffort::High),
),
(
mistral::Model::MistralSmallLatest,
false,
Some(mistral::ReasoningEffort::None),
),
(
mistral::Model::MistralMediumLatest,
true,
Some(mistral::ReasoningEffort::High),
),
(
mistral::Model::MistralMediumLatest,
false,
Some(mistral::ReasoningEffort::None),
),
(
mistral::Model::ZaiGlmLatest,
true,
Some(mistral::ReasoningEffort::High),
),
// Z.ai GLM always thinks and rejects "none", so the field is
// omitted when the toggle is off instead of sending an explicit
// value.
(mistral::Model::ZaiGlmLatest, false, None),
// Ensure that, for non-thinking models, `reasoning_effort` is
// always omitted.
(mistral::Model::CodestralLatest, true, None),
(mistral::Model::CodestralLatest, false, None),
];
for (model, thinking_allowed, reasoning_effort) in cases {
let (mistral_request, _) = into_mistral(request(thinking_allowed), model, None)
.expect("should be able to convert request");
assert_eq!(
mistral_request.reasoning_effort, reasoning_effort,
"reasoning_effort should match, expected {:?}, got {:?}",
reasoning_effort, mistral_request.reasoning_effort
)
}
}
#[test]
fn test_into_mistral_with_image() {
let request = LanguageModelRequest {
messages: vec![LanguageModelRequestMessage {
role: Role::User,
content: vec![
MessageContent::Text("What's in this image?".into()),
MessageContent::Image(LanguageModelImage {
source: "base64data".into(),
}),
],
cache: false,
reasoning_details: None,
}],
tools: vec![],
tool_choice: None,
temperature: None,
thread_id: None,
prompt_cache_key: None,
prompt_id: None,
intent: None,
stop: vec![],
thinking_allowed: true,
thinking_effort: None,
speed: None,
compact_at_tokens: None,
max_output_tokens: None,
};
let (mistral_request, _) =
into_mistral(request, mistral::Model::MistralSmallLatest, None).unwrap();
assert_eq!(mistral_request.messages.len(), 1);
assert!(matches!(
&mistral_request.messages[0],
mistral::RequestMessage::User {
content: mistral::MessageContent::Multipart { .. }
}
));
if let mistral::RequestMessage::User {
content: mistral::MessageContent::Multipart { content },
} = &mistral_request.messages[0]
{
assert_eq!(content.len(), 2);
assert!(matches!(
&content[0],
mistral::MessagePart::Text { text } if text == "What's in this image?"
));
assert!(matches!(
&content[1],
mistral::MessagePart::ImageUrl { image_url } if image_url.starts_with("data:image/png;base64,")
));
}
}
}