mistralai 1.9.11__py3-none-any.whl → 1.10.1__py3-none-any.whl

mistralai/models/agents_api_v1_conversations_listop.py

@@ -3,15 +3,17 @@
 from __future__ import annotations
 from .agentconversation import AgentConversation, AgentConversationTypedDict
 from .modelconversation import ModelConversation, ModelConversationTypedDict
-from mistralai.types import BaseModel
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
 from mistralai.utils import FieldMetadata, QueryParamMetadata
-from typing import Optional, Union
+from pydantic import model_serializer
+from typing import Any, Dict, Optional, Union
 from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
 
 
 class AgentsAPIV1ConversationsListRequestTypedDict(TypedDict):
     page: NotRequired[int]
     page_size: NotRequired[int]
+    metadata: NotRequired[Nullable[Dict[str, Any]]]
 
 
 class AgentsAPIV1ConversationsListRequest(BaseModel):
@@ -25,6 +27,41 @@ class AgentsAPIV1ConversationsListRequest(BaseModel):
         FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
     ] = 100
 
+    metadata: Annotated[
+        OptionalNullable[Dict[str, Any]],
+        FieldMetadata(query=QueryParamMetadata(serialization="json")),
+    ] = UNSET
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["page", "page_size", "metadata"]
+        nullable_fields = ["metadata"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m
+
 
 ResponseBodyTypedDict = TypeAliasType(
     "ResponseBodyTypedDict",

mistralai/models/agentscompletionrequest.py

@@ -15,7 +15,7 @@ from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_
 from mistralai.utils import get_discriminator, validate_open_enum
 from pydantic import Discriminator, Tag, model_serializer
 from pydantic.functional_validators import PlainValidator
-from typing import List, Optional, Union
+from typing import Any, Dict, List, Optional, Union
 from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
 
 
@@ -77,16 +77,19 @@ class AgentsCompletionRequestTypedDict(TypedDict):
     r"""Stop generation if this token is detected. Or if one of these tokens is detected when providing an array"""
     random_seed: NotRequired[Nullable[int]]
     r"""The seed to use for random sampling. If set, different calls will generate deterministic results."""
+    metadata: NotRequired[Nullable[Dict[str, Any]]]
     response_format: NotRequired[ResponseFormatTypedDict]
+    r"""Specify the format that the model must output. By default it will use `{ \"type\": \"text\" }`. Setting to `{ \"type\": \"json_object\" }` enables JSON mode, which guarantees the message the model generates is in JSON. When using JSON mode you MUST also instruct the model to produce JSON yourself with a system or a user message. Setting to `{ \"type\": \"json_schema\" }` enables JSON schema mode, which guarantees the message the model generates is in JSON and follows the schema you provide."""
     tools: NotRequired[Nullable[List[ToolTypedDict]]]
     tool_choice: NotRequired[AgentsCompletionRequestToolChoiceTypedDict]
     presence_penalty: NotRequired[float]
-    r"""presence_penalty determines how much the model penalizes the repetition of words or phrases. A higher presence penalty encourages the model to use a wider variety of words and phrases, making the output more diverse and creative."""
+    r"""The `presence_penalty` determines how much the model penalizes the repetition of words or phrases. A higher presence penalty encourages the model to use a wider variety of words and phrases, making the output more diverse and creative."""
     frequency_penalty: NotRequired[float]
-    r"""frequency_penalty penalizes the repetition of words based on their frequency in the generated text. A higher frequency penalty discourages the model from repeating words that have already appeared frequently in the output, promoting diversity and reducing repetition."""
+    r"""The `frequency_penalty` penalizes the repetition of words based on their frequency in the generated text. A higher frequency penalty discourages the model from repeating words that have already appeared frequently in the output, promoting diversity and reducing repetition."""
     n: NotRequired[Nullable[int]]
     r"""Number of completions to return for each request, input tokens are only billed once."""
     prediction: NotRequired[PredictionTypedDict]
+    r"""Enable users to specify an expected completion, optimizing response times by leveraging known or predictable content."""
     parallel_tool_calls: NotRequired[bool]
     prompt_mode: NotRequired[Nullable[MistralPromptMode]]
     r"""Allows toggling between the reasoning mode and no system prompt. When set to `reasoning` the system prompt for reasoning models will be used."""
@@ -111,22 +114,26 @@ class AgentsCompletionRequest(BaseModel):
     random_seed: OptionalNullable[int] = UNSET
     r"""The seed to use for random sampling. If set, different calls will generate deterministic results."""
 
+    metadata: OptionalNullable[Dict[str, Any]] = UNSET
+
     response_format: Optional[ResponseFormat] = None
+    r"""Specify the format that the model must output. By default it will use `{ \"type\": \"text\" }`. Setting to `{ \"type\": \"json_object\" }` enables JSON mode, which guarantees the message the model generates is in JSON. When using JSON mode you MUST also instruct the model to produce JSON yourself with a system or a user message. Setting to `{ \"type\": \"json_schema\" }` enables JSON schema mode, which guarantees the message the model generates is in JSON and follows the schema you provide."""
 
     tools: OptionalNullable[List[Tool]] = UNSET
 
     tool_choice: Optional[AgentsCompletionRequestToolChoice] = None
 
     presence_penalty: Optional[float] = None
-    r"""presence_penalty determines how much the model penalizes the repetition of words or phrases. A higher presence penalty encourages the model to use a wider variety of words and phrases, making the output more diverse and creative."""
+    r"""The `presence_penalty` determines how much the model penalizes the repetition of words or phrases. A higher presence penalty encourages the model to use a wider variety of words and phrases, making the output more diverse and creative."""
 
     frequency_penalty: Optional[float] = None
-    r"""frequency_penalty penalizes the repetition of words based on their frequency in the generated text. A higher frequency penalty discourages the model from repeating words that have already appeared frequently in the output, promoting diversity and reducing repetition."""
+    r"""The `frequency_penalty` penalizes the repetition of words based on their frequency in the generated text. A higher frequency penalty discourages the model from repeating words that have already appeared frequently in the output, promoting diversity and reducing repetition."""
 
     n: OptionalNullable[int] = UNSET
     r"""Number of completions to return for each request, input tokens are only billed once."""
 
     prediction: Optional[Prediction] = None
+    r"""Enable users to specify an expected completion, optimizing response times by leveraging known or predictable content."""
 
     parallel_tool_calls: Optional[bool] = None
 
@@ -142,6 +149,7 @@ class AgentsCompletionRequest(BaseModel):
             "stream",
             "stop",
             "random_seed",
+            "metadata",
             "response_format",
             "tools",
             "tool_choice",
@@ -152,7 +160,14 @@ class AgentsCompletionRequest(BaseModel):
             "parallel_tool_calls",
             "prompt_mode",
         ]
-        nullable_fields = ["max_tokens", "random_seed", "tools", "n", "prompt_mode"]
+        nullable_fields = [
+            "max_tokens",
+            "random_seed",
+            "metadata",
+            "tools",
+            "n",
+            "prompt_mode",
+        ]
         null_default_fields = []
 
         serialized = handler(self)

mistralai/models/agentscompletionstreamrequest.py

@@ -15,7 +15,7 @@ from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_
 from mistralai.utils import get_discriminator, validate_open_enum
 from pydantic import Discriminator, Tag, model_serializer
 from pydantic.functional_validators import PlainValidator
-from typing import List, Optional, Union
+from typing import Any, Dict, List, Optional, Union
 from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
 
 
@@ -76,16 +76,19 @@ class AgentsCompletionStreamRequestTypedDict(TypedDict):
     r"""Stop generation if this token is detected. Or if one of these tokens is detected when providing an array"""
     random_seed: NotRequired[Nullable[int]]
     r"""The seed to use for random sampling. If set, different calls will generate deterministic results."""
+    metadata: NotRequired[Nullable[Dict[str, Any]]]
     response_format: NotRequired[ResponseFormatTypedDict]
+    r"""Specify the format that the model must output. By default it will use `{ \"type\": \"text\" }`. Setting to `{ \"type\": \"json_object\" }` enables JSON mode, which guarantees the message the model generates is in JSON. When using JSON mode you MUST also instruct the model to produce JSON yourself with a system or a user message. Setting to `{ \"type\": \"json_schema\" }` enables JSON schema mode, which guarantees the message the model generates is in JSON and follows the schema you provide."""
     tools: NotRequired[Nullable[List[ToolTypedDict]]]
     tool_choice: NotRequired[AgentsCompletionStreamRequestToolChoiceTypedDict]
     presence_penalty: NotRequired[float]
-    r"""presence_penalty determines how much the model penalizes the repetition of words or phrases. A higher presence penalty encourages the model to use a wider variety of words and phrases, making the output more diverse and creative."""
+    r"""The `presence_penalty` determines how much the model penalizes the repetition of words or phrases. A higher presence penalty encourages the model to use a wider variety of words and phrases, making the output more diverse and creative."""
     frequency_penalty: NotRequired[float]
-    r"""frequency_penalty penalizes the repetition of words based on their frequency in the generated text. A higher frequency penalty discourages the model from repeating words that have already appeared frequently in the output, promoting diversity and reducing repetition."""
+    r"""The `frequency_penalty` penalizes the repetition of words based on their frequency in the generated text. A higher frequency penalty discourages the model from repeating words that have already appeared frequently in the output, promoting diversity and reducing repetition."""
     n: NotRequired[Nullable[int]]
     r"""Number of completions to return for each request, input tokens are only billed once."""
     prediction: NotRequired[PredictionTypedDict]
+    r"""Enable users to specify an expected completion, optimizing response times by leveraging known or predictable content."""
     parallel_tool_calls: NotRequired[bool]
     prompt_mode: NotRequired[Nullable[MistralPromptMode]]
     r"""Allows toggling between the reasoning mode and no system prompt. When set to `reasoning` the system prompt for reasoning models will be used."""
@@ -109,22 +112,26 @@ class AgentsCompletionStreamRequest(BaseModel):
     random_seed: OptionalNullable[int] = UNSET
     r"""The seed to use for random sampling. If set, different calls will generate deterministic results."""
 
+    metadata: OptionalNullable[Dict[str, Any]] = UNSET
+
     response_format: Optional[ResponseFormat] = None
+    r"""Specify the format that the model must output. By default it will use `{ \"type\": \"text\" }`. Setting to `{ \"type\": \"json_object\" }` enables JSON mode, which guarantees the message the model generates is in JSON. When using JSON mode you MUST also instruct the model to produce JSON yourself with a system or a user message. Setting to `{ \"type\": \"json_schema\" }` enables JSON schema mode, which guarantees the message the model generates is in JSON and follows the schema you provide."""
 
     tools: OptionalNullable[List[Tool]] = UNSET
 
     tool_choice: Optional[AgentsCompletionStreamRequestToolChoice] = None
 
     presence_penalty: Optional[float] = None
-    r"""presence_penalty determines how much the model penalizes the repetition of words or phrases. A higher presence penalty encourages the model to use a wider variety of words and phrases, making the output more diverse and creative."""
+    r"""The `presence_penalty` determines how much the model penalizes the repetition of words or phrases. A higher presence penalty encourages the model to use a wider variety of words and phrases, making the output more diverse and creative."""
 
     frequency_penalty: Optional[float] = None
-    r"""frequency_penalty penalizes the repetition of words based on their frequency in the generated text. A higher frequency penalty discourages the model from repeating words that have already appeared frequently in the output, promoting diversity and reducing repetition."""
+    r"""The `frequency_penalty` penalizes the repetition of words based on their frequency in the generated text. A higher frequency penalty discourages the model from repeating words that have already appeared frequently in the output, promoting diversity and reducing repetition."""
 
     n: OptionalNullable[int] = UNSET
     r"""Number of completions to return for each request, input tokens are only billed once."""
 
     prediction: Optional[Prediction] = None
+    r"""Enable users to specify an expected completion, optimizing response times by leveraging known or predictable content."""
 
     parallel_tool_calls: Optional[bool] = None
 
@@ -140,6 +147,7 @@ class AgentsCompletionStreamRequest(BaseModel):
             "stream",
             "stop",
             "random_seed",
+            "metadata",
             "response_format",
             "tools",
             "tool_choice",
@@ -150,7 +158,14 @@ class AgentsCompletionStreamRequest(BaseModel):
             "parallel_tool_calls",
             "prompt_mode",
         ]
-        nullable_fields = ["max_tokens", "random_seed", "tools", "n", "prompt_mode"]
+        nullable_fields = [
+            "max_tokens",
+            "random_seed",
+            "metadata",
+            "tools",
+            "n",
+            "prompt_mode",
+        ]
         null_default_fields = []
 
         serialized = handler(self)

mistralai/models/agentupdaterequest.py

@@ -11,7 +11,7 @@ from .websearchtool import WebSearchTool, WebSearchToolTypedDict
 from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
 from mistralai.utils import get_discriminator
 from pydantic import Discriminator, Tag, model_serializer
-from typing import List, Optional, Union
+from typing import Any, Dict, List, Optional, Union
 from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
 
 
@@ -52,6 +52,8 @@ class AgentUpdateRequestTypedDict(TypedDict):
     name: NotRequired[Nullable[str]]
     description: NotRequired[Nullable[str]]
     handoffs: NotRequired[Nullable[List[str]]]
+    deployment_chat: NotRequired[Nullable[bool]]
+    metadata: NotRequired[Nullable[Dict[str, Any]]]
 
 
 class AgentUpdateRequest(BaseModel):
@@ -72,6 +74,10 @@ class AgentUpdateRequest(BaseModel):
 
     handoffs: OptionalNullable[List[str]] = UNSET
 
+    deployment_chat: OptionalNullable[bool] = UNSET
+
+    metadata: OptionalNullable[Dict[str, Any]] = UNSET
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
         optional_fields = [
@@ -82,8 +88,18 @@ class AgentUpdateRequest(BaseModel):
             "name",
             "description",
             "handoffs",
+            "deployment_chat",
+            "metadata",
+        ]
+        nullable_fields = [
+            "instructions",
+            "model",
+            "name",
+            "description",
+            "handoffs",
+            "deployment_chat",
+            "metadata",
         ]
-        nullable_fields = ["instructions", "model", "name", "description", "handoffs"]
         null_default_fields = []
 
         serialized = handler(self)

mistralai/models/audioencoding.py

@@ -0,0 +1,13 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai.types import UnrecognizedStr
+from typing import Literal, Union
+
+
+AudioEncoding = Union[
+    Literal[
+        "pcm_s16le", "pcm_s32le", "pcm_f16le", "pcm_f32le", "pcm_mulaw", "pcm_alaw"
+    ],
+    UnrecognizedStr,
+]

mistralai/models/audioformat.py

@@ -0,0 +1,19 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .audioencoding import AudioEncoding
+from mistralai.types import BaseModel
+from mistralai.utils import validate_open_enum
+from pydantic.functional_validators import PlainValidator
+from typing_extensions import Annotated, TypedDict
+
+
+class AudioFormatTypedDict(TypedDict):
+    encoding: AudioEncoding
+    sample_rate: int
+
+
+class AudioFormat(BaseModel):
+    encoding: Annotated[AudioEncoding, PlainValidator(validate_open_enum(False))]
+
+    sample_rate: int

mistralai/models/audiotranscriptionrequest.py

@@ -14,6 +14,7 @@ from typing_extensions import Annotated, NotRequired, TypedDict
 
 class AudioTranscriptionRequestTypedDict(TypedDict):
     model: str
+    r"""ID of the model to be used."""
     file: NotRequired[FileTypedDict]
     file_url: NotRequired[Nullable[str]]
     r"""Url of a file to be transcribed"""
@@ -29,6 +30,7 @@ class AudioTranscriptionRequestTypedDict(TypedDict):
 
 class AudioTranscriptionRequest(BaseModel):
     model: Annotated[str, FieldMetadata(multipart=True)]
+    r"""ID of the model to be used."""
 
     file: Annotated[
         Optional[File], FieldMetadata(multipart=MultipartFormMetadata(file=True))

mistralai/models/batchjobin.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 from .apiendpoint import APIEndpoint
+from .batchrequest import BatchRequest, BatchRequestTypedDict
 from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
 from mistralai.utils import validate_open_enum
 from pydantic import model_serializer
@@ -11,31 +12,51 @@ from typing_extensions import Annotated, NotRequired, TypedDict
 
 
 class BatchJobInTypedDict(TypedDict):
-    input_files: List[str]
     endpoint: APIEndpoint
+    input_files: NotRequired[Nullable[List[str]]]
+    r"""The list of input files to be used for batch inference, these files should be `jsonl` files, containing the input data corresponding to the bory request for the batch inference in a \"body\" field. An example of such file is the following: ```json {\"custom_id\": \"0\", \"body\": {\"max_tokens\": 100, \"messages\": [{\"role\": \"user\", \"content\": \"What is the best French cheese?\"}]}} {\"custom_id\": \"1\", \"body\": {\"max_tokens\": 100, \"messages\": [{\"role\": \"user\", \"content\": \"What is the best French wine?\"}]}} ```"""
+    requests: NotRequired[Nullable[List[BatchRequestTypedDict]]]
     model: NotRequired[Nullable[str]]
+    r"""The model to be used for batch inference."""
     agent_id: NotRequired[Nullable[str]]
+    r"""In case you want to use a specific agent from the **deprecated** agents api for batch inference, you can specify the agent ID here."""
     metadata: NotRequired[Nullable[Dict[str, str]]]
+    r"""The metadata of your choice to be associated with the batch inference job."""
     timeout_hours: NotRequired[int]
+    r"""The timeout in hours for the batch inference job."""
 
 
 class BatchJobIn(BaseModel):
-    input_files: List[str]
-
     endpoint: Annotated[APIEndpoint, PlainValidator(validate_open_enum(False))]
 
+    input_files: OptionalNullable[List[str]] = UNSET
+    r"""The list of input files to be used for batch inference, these files should be `jsonl` files, containing the input data corresponding to the bory request for the batch inference in a \"body\" field. An example of such file is the following: ```json {\"custom_id\": \"0\", \"body\": {\"max_tokens\": 100, \"messages\": [{\"role\": \"user\", \"content\": \"What is the best French cheese?\"}]}} {\"custom_id\": \"1\", \"body\": {\"max_tokens\": 100, \"messages\": [{\"role\": \"user\", \"content\": \"What is the best French wine?\"}]}} ```"""
+
+    requests: OptionalNullable[List[BatchRequest]] = UNSET
+
     model: OptionalNullable[str] = UNSET
+    r"""The model to be used for batch inference."""
 
     agent_id: OptionalNullable[str] = UNSET
+    r"""In case you want to use a specific agent from the **deprecated** agents api for batch inference, you can specify the agent ID here."""
 
     metadata: OptionalNullable[Dict[str, str]] = UNSET
+    r"""The metadata of your choice to be associated with the batch inference job."""
 
     timeout_hours: Optional[int] = 24
+    r"""The timeout in hours for the batch inference job."""
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["model", "agent_id", "metadata", "timeout_hours"]
-        nullable_fields = ["model", "agent_id", "metadata"]
+        optional_fields = [
+            "input_files",
+            "requests",
+            "model",
+            "agent_id",
+            "metadata",
+            "timeout_hours",
+        ]
+        nullable_fields = ["input_files", "requests", "model", "agent_id", "metadata"]
         null_default_fields = []
 
         serialized = handler(self)

mistralai/models/batchjobout.py

@@ -29,6 +29,7 @@ class BatchJobOutTypedDict(TypedDict):
     agent_id: NotRequired[Nullable[str]]
     output_file: NotRequired[Nullable[str]]
     error_file: NotRequired[Nullable[str]]
+    outputs: NotRequired[Nullable[List[Dict[str, Any]]]]
     started_at: NotRequired[Nullable[int]]
     completed_at: NotRequired[Nullable[int]]
 
@@ -66,6 +67,8 @@ class BatchJobOut(BaseModel):
 
     error_file: OptionalNullable[str] = UNSET
 
+    outputs: OptionalNullable[List[Dict[str, Any]]] = UNSET
+
     started_at: OptionalNullable[int] = UNSET
 
     completed_at: OptionalNullable[int] = UNSET
@@ -79,6 +82,7 @@ class BatchJobOut(BaseModel):
             "agent_id",
             "output_file",
             "error_file",
+            "outputs",
             "started_at",
             "completed_at",
         ]
@@ -88,6 +92,7 @@ class BatchJobOut(BaseModel):
             "agent_id",
             "output_file",
             "error_file",
+            "outputs",
             "started_at",
             "completed_at",
         ]

mistralai/models/batchrequest.py

@@ -0,0 +1,48 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import Any, Dict
+from typing_extensions import NotRequired, TypedDict
+
+
+class BatchRequestTypedDict(TypedDict):
+    body: Dict[str, Any]
+    custom_id: NotRequired[Nullable[str]]
+
+
+class BatchRequest(BaseModel):
+    body: Dict[str, Any]
+
+    custom_id: OptionalNullable[str] = UNSET
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["custom_id"]
+        nullable_fields = ["custom_id"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m

mistralai/models/chatcompletionrequest.py

@@ -15,7 +15,7 @@ from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_
 from mistralai.utils import get_discriminator, validate_open_enum
 from pydantic import Discriminator, Tag, model_serializer
 from pydantic.functional_validators import PlainValidator
-from typing import List, Optional, Union
+from typing import Any, Dict, List, Optional, Union
 from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
 
 
@@ -53,11 +53,13 @@ ChatCompletionRequestToolChoiceTypedDict = TypeAliasType(
     "ChatCompletionRequestToolChoiceTypedDict",
     Union[ToolChoiceTypedDict, ToolChoiceEnum],
 )
+r"""Controls which (if any) tool is called by the model. `none` means the model will not call any tool and instead generates a message. `auto` means the model can pick between generating a message or calling one or more tools. `any` or `required` means the model must call one or more tools. Specifying a particular tool via `{\"type\": \"function\", \"function\": {\"name\": \"my_function\"}}` forces the model to call that tool."""
 
 
 ChatCompletionRequestToolChoice = TypeAliasType(
     "ChatCompletionRequestToolChoice", Union[ToolChoice, ToolChoiceEnum]
 )
+r"""Controls which (if any) tool is called by the model. `none` means the model will not call any tool and instead generates a message. `auto` means the model can pick between generating a message or calling one or more tools. `any` or `required` means the model must call one or more tools. Specifying a particular tool via `{\"type\": \"function\", \"function\": {\"name\": \"my_function\"}}` forces the model to call that tool."""
 
 
 class ChatCompletionRequestTypedDict(TypedDict):
@@ -77,17 +79,23 @@ class ChatCompletionRequestTypedDict(TypedDict):
     r"""Stop generation if this token is detected. Or if one of these tokens is detected when providing an array"""
     random_seed: NotRequired[Nullable[int]]
     r"""The seed to use for random sampling. If set, different calls will generate deterministic results."""
+    metadata: NotRequired[Nullable[Dict[str, Any]]]
     response_format: NotRequired[ResponseFormatTypedDict]
+    r"""Specify the format that the model must output. By default it will use `{ \"type\": \"text\" }`. Setting to `{ \"type\": \"json_object\" }` enables JSON mode, which guarantees the message the model generates is in JSON. When using JSON mode you MUST also instruct the model to produce JSON yourself with a system or a user message. Setting to `{ \"type\": \"json_schema\" }` enables JSON schema mode, which guarantees the message the model generates is in JSON and follows the schema you provide."""
     tools: NotRequired[Nullable[List[ToolTypedDict]]]
+    r"""A list of tools the model may call. Use this to provide a list of functions the model may generate JSON inputs for."""
     tool_choice: NotRequired[ChatCompletionRequestToolChoiceTypedDict]
+    r"""Controls which (if any) tool is called by the model. `none` means the model will not call any tool and instead generates a message. `auto` means the model can pick between generating a message or calling one or more tools. `any` or `required` means the model must call one or more tools. Specifying a particular tool via `{\"type\": \"function\", \"function\": {\"name\": \"my_function\"}}` forces the model to call that tool."""
     presence_penalty: NotRequired[float]
-    r"""presence_penalty determines how much the model penalizes the repetition of words or phrases. A higher presence penalty encourages the model to use a wider variety of words and phrases, making the output more diverse and creative."""
+    r"""The `presence_penalty` determines how much the model penalizes the repetition of words or phrases. A higher presence penalty encourages the model to use a wider variety of words and phrases, making the output more diverse and creative."""
     frequency_penalty: NotRequired[float]
-    r"""frequency_penalty penalizes the repetition of words based on their frequency in the generated text. A higher frequency penalty discourages the model from repeating words that have already appeared frequently in the output, promoting diversity and reducing repetition."""
+    r"""The `frequency_penalty` penalizes the repetition of words based on their frequency in the generated text. A higher frequency penalty discourages the model from repeating words that have already appeared frequently in the output, promoting diversity and reducing repetition."""
     n: NotRequired[Nullable[int]]
     r"""Number of completions to return for each request, input tokens are only billed once."""
     prediction: NotRequired[PredictionTypedDict]
+    r"""Enable users to specify an expected completion, optimizing response times by leveraging known or predictable content."""
     parallel_tool_calls: NotRequired[bool]
+    r"""Whether to enable parallel function calling during tool use, when enabled the model can call multiple tools in parallel."""
     prompt_mode: NotRequired[Nullable[MistralPromptMode]]
     r"""Allows toggling between the reasoning mode and no system prompt. When set to `reasoning` the system prompt for reasoning models will be used."""
     safe_prompt: NotRequired[bool]
@@ -119,24 +127,31 @@ class ChatCompletionRequest(BaseModel):
     random_seed: OptionalNullable[int] = UNSET
     r"""The seed to use for random sampling. If set, different calls will generate deterministic results."""
 
+    metadata: OptionalNullable[Dict[str, Any]] = UNSET
+
     response_format: Optional[ResponseFormat] = None
+    r"""Specify the format that the model must output. By default it will use `{ \"type\": \"text\" }`. Setting to `{ \"type\": \"json_object\" }` enables JSON mode, which guarantees the message the model generates is in JSON. When using JSON mode you MUST also instruct the model to produce JSON yourself with a system or a user message. Setting to `{ \"type\": \"json_schema\" }` enables JSON schema mode, which guarantees the message the model generates is in JSON and follows the schema you provide."""
 
     tools: OptionalNullable[List[Tool]] = UNSET
+    r"""A list of tools the model may call. Use this to provide a list of functions the model may generate JSON inputs for."""
 
     tool_choice: Optional[ChatCompletionRequestToolChoice] = None
+    r"""Controls which (if any) tool is called by the model. `none` means the model will not call any tool and instead generates a message. `auto` means the model can pick between generating a message or calling one or more tools. `any` or `required` means the model must call one or more tools. Specifying a particular tool via `{\"type\": \"function\", \"function\": {\"name\": \"my_function\"}}` forces the model to call that tool."""
 
     presence_penalty: Optional[float] = None
-    r"""presence_penalty determines how much the model penalizes the repetition of words or phrases. A higher presence penalty encourages the model to use a wider variety of words and phrases, making the output more diverse and creative."""
+    r"""The `presence_penalty` determines how much the model penalizes the repetition of words or phrases. A higher presence penalty encourages the model to use a wider variety of words and phrases, making the output more diverse and creative."""
 
     frequency_penalty: Optional[float] = None
-    r"""frequency_penalty penalizes the repetition of words based on their frequency in the generated text. A higher frequency penalty discourages the model from repeating words that have already appeared frequently in the output, promoting diversity and reducing repetition."""
+    r"""The `frequency_penalty` penalizes the repetition of words based on their frequency in the generated text. A higher frequency penalty discourages the model from repeating words that have already appeared frequently in the output, promoting diversity and reducing repetition."""
 
     n: OptionalNullable[int] = UNSET
     r"""Number of completions to return for each request, input tokens are only billed once."""
 
     prediction: Optional[Prediction] = None
+    r"""Enable users to specify an expected completion, optimizing response times by leveraging known or predictable content."""
 
     parallel_tool_calls: Optional[bool] = None
+    r"""Whether to enable parallel function calling during tool use, when enabled the model can call multiple tools in parallel."""
 
     prompt_mode: Annotated[
         OptionalNullable[MistralPromptMode], PlainValidator(validate_open_enum(False))
@@ -155,6 +170,7 @@ class ChatCompletionRequest(BaseModel):
             "stream",
             "stop",
             "random_seed",
+            "metadata",
             "response_format",
             "tools",
             "tool_choice",
@@ -170,6 +186,7 @@ class ChatCompletionRequest(BaseModel):
             "temperature",
             "max_tokens",
             "random_seed",
+            "metadata",
             "tools",
             "n",
             "prompt_mode",