feat(mistral): migrate LLM to Conversations API with provider tools support

livekit-agents/livekit/agents/llm/_provider_format/mistralai.py

@@ -1,17 +1,109 @@
 from __future__ import annotations
 
-from typing import Literal
+import base64
+from dataclasses import dataclass
+from typing import Any
 
 from livekit.agents import llm
 
-from .openai import to_chat_ctx as openai_to_chat_ctx
+from .utils import group_tool_calls
 
 
-def to_chat_ctx(
-    chat_ctx: llm.ChatContext, *, inject_dummy_user_message: bool = True
-) -> tuple[list[dict], Literal[None]]:
-    messages, _ = openai_to_chat_ctx(chat_ctx, inject_dummy_user_message=inject_dummy_user_message)
+@dataclass
+class MistralFormatData:
+    instructions: str | None
 
-    if inject_dummy_user_message and (not messages or messages[-1]["role"] not in ["user", "tool"]):
-        messages.append({"role": "user", "content": ""})
-    return messages, None
+
+def to_conversations_ctx(
+    chat_ctx: llm.ChatContext,
+) -> tuple[list[dict], MistralFormatData]:
+    """Convert ChatContext to Mistral Conversations API entry format.
+
+    Returns:
+        A tuple of (entries, instructions) where instructions is the extracted
+        system/developer message content (or None if absent).
+    """
+    item_groups = group_tool_calls(chat_ctx)
+    entries: list[dict[str, Any]] = []
+    instructions: str | None = None
+
+    for group in item_groups:
+        if not group.message and not group.tool_calls and not group.tool_outputs:
+            continue
+
+        if group.message:
+            item = group.message
+            if isinstance(item, llm.ChatMessage) and item.role in ("system", "developer"):
+                text_parts = [c for c in item.content if isinstance(c, str)]
+                instructions = "\n".join(text_parts) if text_parts else None
+                continue
+
+            entry = _to_entry(item)
+            if entry is not None:
+                entries.append(entry)
+
+        for tool_call in group.tool_calls:
+            entries.append(
+                {
+                    "type": "function.call",
+                    "tool_call_id": tool_call.call_id,
+                    "name": tool_call.name,
+                    "arguments": tool_call.arguments,
+                }
+            )
+
+        for tool_output in group.tool_outputs:
+            entries.append(
+                {
+                    "type": "function.result",
+                    "tool_call_id": tool_output.call_id,
+                    "result": tool_output.output,
+                }
+            )
+
+    return entries, MistralFormatData(instructions=instructions)
+
+
+def _to_entry(item: llm.ChatItem) -> dict[str, Any] | None:
+    if not isinstance(item, llm.ChatMessage):
+        return None
+
+    content = _build_content(item)
+
+    if item.role == "user":
+        return {"type": "message.input", "role": "user", "content": content}
+    elif item.role == "assistant":
+        return {"type": "message.output", "role": "assistant", "content": content}
+
+    return None
+
+
+def _build_content(msg: llm.ChatMessage) -> str | list[dict[str, Any]]:
+    list_content: list[dict[str, Any]] = []
+    text_content = ""
+
+    for content in msg.content:
+        if isinstance(content, str):
+            if text_content:
+                text_content += "\n"
+            text_content += content
+        elif isinstance(content, llm.ImageContent):
+            list_content.append(_to_image_content(content))
+
+    if not list_content:
+        return text_content
+
+    if text_content:
+        list_content.append({"type": "text", "text": text_content})
+
+    return list_content
+
+
+def _to_image_content(image: llm.ImageContent) -> dict[str, Any]:
+    img = llm.utils.serialize_image(image)
+    if img.external_url:
+        return {"type": "image_url", "image_url": img.external_url}
+
+    assert img.data_bytes is not None
+    b64_data = base64.b64encode(img.data_bytes).decode("utf-8")
+    return {"type": "image_url", "image_url": f"data:{img.mime_type};base64,{b64_data}"}

livekit-agents/livekit/agents/llm/chat_context.py

@@ -663,8 +663,8 @@ def to_provider_format(
 
     @overload
     def to_provider_format(
-        self, format: Literal["mistralai"], *, inject_dummy_user_message: bool = True
-    ) -> tuple[list[dict], Literal[None]]: ...
+        self, format: Literal["mistralai"]
+    ) -> tuple[list[dict], _provider_format.mistralai.MistralFormatData]: ...
 
     @overload
     def to_provider_format(self, format: str, **kwargs: Any) -> tuple[list[dict], Any]: ...
@@ -698,7 +698,7 @@ def to_provider_format(
         elif format == "anthropic":
             return _provider_format.anthropic.to_chat_ctx(self, **kwargs)
         elif format == "mistralai":
-            return _provider_format.mistralai.to_chat_ctx(self, **kwargs)
+            return _provider_format.mistralai.to_conversations_ctx(self)
         else:
             raise ValueError(f"Unsupported provider format: {format}")
 

livekit-plugins/livekit-plugins-mistralai/README.md

@@ -82,10 +82,25 @@ from livekit.plugins import mistralai
 
 llm = mistralai.LLM()
 
-# With custom temperature/max. tokens
+# With all available options
 llm = mistralai.LLM(
     model="mistral-large-latest",
     temperature=0.7,
-    max_completion_tokens=150
+    top_p=0.9,
+    max_completion_tokens=150,
+    presence_penalty=0.1,
+    frequency_penalty=0.1,
+    random_seed=42,
+    tool_choice="auto",
+)
+
+# With provider tools
+agent = Agent(
+    llm=llm,
+    tools=[
+        mistralai.tools.WebSearch(),
+        mistralai.tools.CodeInterpreter(),
+        mistralai.tools.DocumentLibrary(library_ids=["<your-library-id>"]),
+    ]
 )
 ```

livekit-plugins/livekit-plugins-mistralai/livekit/plugins/mistralai/__init__.py

@@ -2,13 +2,14 @@
 
 from livekit.agents import Plugin
 
+from . import tools
 from .llm import LLM
 from .log import logger
 from .stt import STT
 from .tts import TTS
 from .version import __version__
 
-__all__ = ["LLM", "STT", "TTS", "__version__"]
+__all__ = ["LLM", "STT", "TTS", "tools", "__version__"]
 
 
 class MistralAIPlugin(Plugin):