The agent engineering platform.
Python agentsaiai-agentsanthropicchatgptdeepagentsenterpriseframeworkgeminigenerative-ailangchainlanggraphllmmultiagentopen-sourceopenaipydanticpythonragtypescript
feat(mistralai): support reasoning feature and v1 content (#33485)
ccurme9f4366bc9d2d
diff --git a/libs/partners/mistralai/langchain_mistralai/_compat.py b/libs/partners/mistralai/langchain_mistralai/_compat.pynew file mode 100644index 0000000000..f716300dcc--- /dev/null+++ b/libs/partners/mistralai/langchain_mistralai/_compat.py@@ -0,0 +1,125 @@+"""Derivations of standard content blocks from mistral content."""++from __future__ import annotations++from langchain_core.messages import AIMessage, AIMessageChunk+from langchain_core.messages import content as types+from langchain_core.messages.block_translators import register_translator+++def _convert_from_v1_to_mistral(+ content: list[types.ContentBlock],+ model_provider: str | None,+) -> str | list[str | dict]:+ new_content: list = []+ for block in content:+ if block["type"] == "text":+ new_content.append({"text": block.get("text", ""), "type": "text"})++ elif (+ block["type"] == "reasoning"+ and (reasoning := block.get("reasoning"))+ and isinstance(reasoning, str)+ and model_provider == "mistralai"+ ):+ new_content.append(+ {+ "type": "thinking",+ "thinking": [{"type": "text", "text": reasoning}],+ }+ )++ elif (+ block["type"] == "non_standard"+ and "value" in block+ and model_provider == "mistralai"+ ):+ new_content.append(block["value"])+ elif block["type"] == "tool_call":+ continue+ else:+ new_content.append(block)++ return new_content+++def _convert_to_v1_from_mistral(message: AIMessage) -> list[types.ContentBlock]:+ """Convert mistral message content to v1 format."""+ if isinstance(message.content, str):+ content_blocks: list[types.ContentBlock] = [+ {"type": "text", "text": message.content}+ ]++ else:+ content_blocks = []+ for block in message.content:+ if isinstance(block, str):+ content_blocks.append({"type": "text", "text": block})++ elif isinstance(block, dict):+ if block.get("type") == "text" and isinstance(block.get("text"), str):+ text_block: types.TextContentBlock = {+ "type": "text",+ "text": block["text"],+ }+ if "index" in block:+ text_block["index"] = block["index"]+ content_blocks.append(text_block)++ elif block.get("type") == "thinking" and isinstance(+ block.get("thinking"), list+ ):+ for sub_block in block["thinking"]:+ if (+ isinstance(sub_block, dict)+ and sub_block.get("type") == "text"+ ):+ reasoning_block: types.ReasoningContentBlock = {+ "type": "reasoning",+ "reasoning": sub_block.get("text", ""),+ }+ if "index" in block:+ reasoning_block["index"] = block["index"]+ content_blocks.append(reasoning_block)++ else:+ non_standard_block: types.NonStandardContentBlock = {+ "type": "non_standard",+ "value": block,+ }+ content_blocks.append(non_standard_block)+ else:+ continue++ if (+ len(content_blocks) == 1+ and content_blocks[0].get("type") == "text"+ and content_blocks[0].get("text") == ""+ and message.tool_calls+ ):+ content_blocks = []++ for tool_call in message.tool_calls:+ content_blocks.append(+ {+ "type": "tool_call",+ "name": tool_call["name"],+ "args": tool_call["args"],+ "id": tool_call.get("id"),+ }+ )++ return content_blocks+++def translate_content(message: AIMessage) -> list[types.ContentBlock]:+ """Derive standard content blocks from a message with mistral content."""+ return _convert_to_v1_from_mistral(message)+++def translate_content_chunk(message: AIMessageChunk) -> list[types.ContentBlock]:+ """Derive standard content blocks from a message chunk with mistral content."""+ return _convert_to_v1_from_mistral(message)+++register_translator("mistralai", translate_content, translate_content_chunk)diff --git a/libs/partners/mistralai/langchain_mistralai/chat_models.py b/libs/partners/mistralai/langchain_mistralai/chat_models.pyindex 578f0acdaa..c9ca6c02ca 100644--- a/libs/partners/mistralai/langchain_mistralai/chat_models.py+++ b/libs/partners/mistralai/langchain_mistralai/chat_models.py@@ -24,12 +24,7 @@ from langchain_core.callbacks import (CallbackManagerForLLMRun,)from langchain_core.language_models import LanguageModelInput-from langchain_core.language_models.chat_models import (- BaseChatModel,- LangSmithParams,- agenerate_from_stream,- generate_from_stream,-)+from langchain_core.language_models.chat_models import BaseChatModel, LangSmithParamsfrom langchain_core.language_models.llms import create_base_retry_decoratorfrom langchain_core.messages import (AIMessage,@@ -74,6 +69,8 @@ from pydantic import ()from typing_extensions import Self+from langchain_mistralai._compat import _convert_from_v1_to_mistral+if TYPE_CHECKING:from collections.abc import AsyncIterator, Iterator, Sequencefrom contextlib import AbstractAsyncContextManager@@ -160,6 +157,7 @@ def _convert_mistral_chat_message_to_message(additional_kwargs=additional_kwargs,tool_calls=tool_calls,invalid_tool_calls=invalid_tool_calls,+ response_metadata={"model_provider": "mistralai"},)@@ -231,14 +229,34 @@ async def acompletion_with_retry(def _convert_chunk_to_message_chunk(- chunk: dict, default_class: type[BaseMessageChunk]-) -> BaseMessageChunk:+ chunk: dict,+ default_class: type[BaseMessageChunk],+ index: int,+ index_type: str,+ output_version: str | None,+) -> tuple[BaseMessageChunk, int, str]:_choice = chunk["choices"][0]_delta = _choice["delta"]role = _delta.get("role")content = _delta.get("content") or ""+ if output_version == "v1" and isinstance(content, str):+ content = [{"type": "text", "text": content}]+ if isinstance(content, list):+ for block in content:+ if isinstance(block, dict):+ if "type" in block and block["type"] != index_type:+ index_type = block["type"]+ index = index + 1+ if "index" not in block:+ block["index"] = index+ if block.get("type") == "thinking" and isinstance(+ block.get("thinking"), list+ ):+ for sub_block in block["thinking"]:+ if isinstance(sub_block, dict) and "index" not in sub_block:+ sub_block["index"] = 0if role == "user" or default_class == HumanMessageChunk:- return HumanMessageChunk(content=content)+ return HumanMessageChunk(content=content), index, index_typeif role == "assistant" or default_class == AIMessageChunk:additional_kwargs: dict = {}response_metadata = {}@@ -276,18 +294,22 @@ def _convert_chunk_to_message_chunk():response_metadata["model_name"] = chunk["model"]response_metadata["finish_reason"] = _choice["finish_reason"]- return AIMessageChunk(- content=content,- additional_kwargs=additional_kwargs,- tool_call_chunks=tool_call_chunks, # type: ignore[arg-type]- usage_metadata=usage_metadata, # type: ignore[arg-type]- response_metadata=response_metadata,+ return (+ AIMessageChunk(+ content=content,+ additional_kwargs=additional_kwargs,+ tool_call_chunks=tool_call_chunks, # type: ignore[arg-type]+ usage_metadata=usage_metadata, # type: ignore[arg-type]+ response_metadata={"model_provider": "mistralai", **response_metadata},+ ),+ index,+ index_type,)if role == "system" or default_class == SystemMessageChunk:- return SystemMessageChunk(content=content)+ return SystemMessageChunk(content=content), index, index_typeif role or default_class == ChatMessageChunk:- return ChatMessageChunk(content=content, role=role)- return default_class(content=content) # type: ignore[call-arg]+ return ChatMessageChunk(content=content, role=role), index, index_type+ return default_class(content=content), index, index_type # type: ignore[call-arg]def _format_tool_call_for_mistral(tool_call: ToolCall) -> dict:@@ -318,6 +340,21 @@ def _format_invalid_tool_call_for_mistral(invalid_tool_call: InvalidToolCall) ->return result+def _clean_block(block: dict) -> dict:+ # Remove "index" key added for message aggregation in langchain-core+ new_block = {k: v for k, v in block.items() if k != "index"}+ if block.get("type") == "thinking" and isinstance(block.get("thinking"), list):+ new_block["thinking"] = [+ (+ {k: v for k, v in sb.items() if k != "index"}+ if isinstance(sb, dict) and "index" in sb+ else sb+ )+ for sb in block["thinking"]+ ]+ return new_block++def _convert_message_to_mistral_chat_message(message: BaseMessage,) -> dict:@@ -356,13 +393,40 @@ def _convert_message_to_mistral_chat_message(passif tool_calls: # do not populate empty list tool_callsmessage_dict["tool_calls"] = tool_calls- if tool_calls and message.content:++ # Message content+ # Translate v1 content+ if message.response_metadata.get("output_version") == "v1":+ content = _convert_from_v1_to_mistral(+ message.content_blocks, message.response_metadata.get("model_provider")+ )+ else:+ content = message.content++ if tool_calls and content:# Assistant message must have either content or tool_calls, but not both.# Some providers may not support tool_calls in the same message as content.# This is done to ensure compatibility with messages from other providers.- message_dict["content"] = ""+ content = ""++ elif isinstance(content, list):+ content = [+ _clean_block(block)+ if isinstance(block, dict) and "index" in block+ else block+ for block in content+ ]else:- message_dict["content"] = message.content+ content = message.content++ # if any blocks are dicts, cast strings to text blocks+ if any(isinstance(block, dict) for block in content):+ content = [+ block if isinstance(block, dict) else {"type": "text", "text": block}+ for block in content+ ]+ message_dict["content"] = content+if "prefix" in message.additional_kwargs:message_dict["prefix"] = message.additional_kwargs["prefix"]return message_dict@@ -564,13 +628,6 @@ class ChatMistralAI(BaseChatModel):stream: bool | None = None, # noqa: FBT001**kwargs: Any,) -> ChatResult:- should_stream = stream if stream is not None else self.streaming- if should_stream:- stream_iter = self._stream(- messages, stop=stop, run_manager=run_manager, **kwargs- )- return generate_from_stream(stream_iter)-message_dicts, params = self._create_message_dicts(messages, stop)params = {**params, **kwargs}response = self.completion_with_retry(@@ -627,12 +684,16 @@ class ChatMistralAI(BaseChatModel):params = {**params, **kwargs, "stream": True}default_chunk_class: type[BaseMessageChunk] = AIMessageChunk+ index = -1+ index_type = ""for chunk in self.completion_with_retry(messages=message_dicts, run_manager=run_manager, **params):if len(chunk.get("choices", [])) == 0:continue- new_chunk = _convert_chunk_to_message_chunk(chunk, default_chunk_class)+ new_chunk, index, index_type = _convert_chunk_to_message_chunk(+ chunk, default_chunk_class, index, index_type, self.output_version+ )# make future chunks same type as first chunkdefault_chunk_class = new_chunk.__class__gen_chunk = ChatGenerationChunk(message=new_chunk)@@ -653,12 +714,16 @@ class ChatMistralAI(BaseChatModel):params = {**params, **kwargs, "stream": True}default_chunk_class: type[BaseMessageChunk] = AIMessageChunk+ index = -1+ index_type = ""async for chunk in await acompletion_with_retry(self, messages=message_dicts, run_manager=run_manager, **params):if len(chunk.get("choices", [])) == 0:continue- new_chunk = _convert_chunk_to_message_chunk(chunk, default_chunk_class)+ new_chunk, index, index_type = _convert_chunk_to_message_chunk(+ chunk, default_chunk_class, index, index_type, self.output_version+ )# make future chunks same type as first chunkdefault_chunk_class = new_chunk.__class__gen_chunk = ChatGenerationChunk(message=new_chunk)@@ -676,13 +741,6 @@ class ChatMistralAI(BaseChatModel):stream: bool | None = None, # noqa: FBT001**kwargs: Any,) -> ChatResult:- should_stream = stream if stream is not None else self.streaming- if should_stream:- stream_iter = self._astream(- messages=messages, stop=stop, run_manager=run_manager, **kwargs- )- return await agenerate_from_stream(stream_iter)-message_dicts, params = self._create_message_dicts(messages, stop)params = {**params, **kwargs}response = await acompletion_with_retry(diff --git a/libs/partners/mistralai/tests/integration_tests/test_chat_models.py b/libs/partners/mistralai/tests/integration_tests/test_chat_models.pyindex e4a956e269..bef96ae3e1 100644--- a/libs/partners/mistralai/tests/integration_tests/test_chat_models.py+++ b/libs/partners/mistralai/tests/integration_tests/test_chat_models.py@@ -28,7 +28,9 @@ async def test_astream() -> None:full = token if full is None else full + tokenif token.usage_metadata is not None:chunks_with_token_counts += 1- if token.response_metadata:+ if token.response_metadata and not set(token.response_metadata.keys()).issubset(+ {"model_provider", "output_version"}+ ):chunks_with_response_metadata += 1if chunks_with_token_counts != 1 or chunks_with_response_metadata != 1:msg = (@@ -143,3 +145,51 @@ def test_retry_parameters(caplog: pytest.LogCaptureFixture) -> None:except Exception:logger.exception("Unexpected exception")raise+++def test_reasoning() -> None:+ model = ChatMistralAI(model="magistral-medium-latest") # type: ignore[call-arg]+ input_message = {+ "role": "user",+ "content": "Hello, my name is Bob.",+ }+ full: AIMessageChunk | None = None+ for chunk in model.stream([input_message]):+ assert isinstance(chunk, AIMessageChunk)+ full = chunk if full is None else full + chunk+ assert isinstance(full, AIMessageChunk)+ thinking_blocks = 0+ for i, block in enumerate(full.content):+ if isinstance(block, dict) and block.get("type") == "thinking":+ thinking_blocks += 1+ reasoning_block = full.content_blocks[i]+ assert reasoning_block["type"] == "reasoning"+ assert isinstance(reasoning_block.get("reasoning"), str)+ assert thinking_blocks > 0++ next_message = {"role": "user", "content": "What is my name?"}+ _ = model.invoke([input_message, full, next_message])+++def test_reasoning_v1() -> None:+ model = ChatMistralAI(model="magistral-medium-latest", output_version="v1") # type: ignore[call-arg]+ input_message = {+ "role": "user",+ "content": "Hello, my name is Bob.",+ }+ full: AIMessageChunk | None = None+ chunks = []+ for chunk in model.stream([input_message]):+ assert isinstance(chunk, AIMessageChunk)+ full = chunk if full is None else full + chunk+ chunks.append(chunk)+ assert isinstance(full, AIMessageChunk)+ reasoning_blocks = 0+ for block in full.content:+ if isinstance(block, dict) and block.get("type") == "reasoning":+ reasoning_blocks += 1+ assert isinstance(block.get("reasoning"), str)+ assert reasoning_blocks > 0++ next_message = {"role": "user", "content": "What is my name?"}+ _ = model.invoke([input_message, full, next_message])diff --git a/libs/partners/mistralai/tests/unit_tests/test_chat_models.py b/libs/partners/mistralai/tests/unit_tests/test_chat_models.pyindex 7851275ed9..e582d12156 100644--- a/libs/partners/mistralai/tests/unit_tests/test_chat_models.py+++ b/libs/partners/mistralai/tests/unit_tests/test_chat_models.py@@ -188,6 +188,7 @@ def test__convert_dict_to_message_tool_call() -> None:type="tool_call",)],+ response_metadata={"model_provider": "mistralai"},)assert result == expected_outputassert _convert_message_to_mistral_chat_message(expected_output) == message@@ -231,6 +232,7 @@ def test__convert_dict_to_message_tool_call() -> None:type="tool_call",),],+ response_metadata={"model_provider": "mistralai"},)assert result == expected_outputassert _convert_message_to_mistral_chat_message(expected_output) == message