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

mistralai/models/chatcompletionstreamrequest.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
 
 
@@ -57,11 +57,13 @@ ChatCompletionStreamRequestToolChoiceTypedDict = TypeAliasType(
     "ChatCompletionStreamRequestToolChoiceTypedDict",
     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."""
 
 
 ChatCompletionStreamRequestToolChoice = TypeAliasType(
     "ChatCompletionStreamRequestToolChoice", 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 ChatCompletionStreamRequestTypedDict(TypedDict):
@@ -80,17 +82,23 @@ class ChatCompletionStreamRequestTypedDict(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[ChatCompletionStreamRequestToolChoiceTypedDict]
+    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]
@@ -121,24 +129,31 @@ class ChatCompletionStreamRequest(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[ChatCompletionStreamRequestToolChoice] = 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))
@@ -157,6 +172,7 @@ class ChatCompletionStreamRequest(BaseModel):
             "stream",
             "stop",
             "random_seed",
+            "metadata",
             "response_format",
             "tools",
             "tool_choice",
@@ -172,6 +188,7 @@ class ChatCompletionStreamRequest(BaseModel):
             "temperature",
             "max_tokens",
             "random_seed",
+            "metadata",
             "tools",
             "n",
             "prompt_mode",

mistralai/models/classificationrequest.py

@@ -1,10 +1,11 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from mistralai.types import BaseModel
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
 import pydantic
-from typing import List, Union
-from typing_extensions import Annotated, TypeAliasType, TypedDict
+from pydantic import model_serializer
+from typing import Any, Dict, List, Union
+from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
 
 
 ClassificationRequestInputsTypedDict = TypeAliasType(
@@ -24,6 +25,7 @@ class ClassificationRequestTypedDict(TypedDict):
     r"""ID of the model to use."""
     inputs: ClassificationRequestInputsTypedDict
     r"""Text to classify."""
+    metadata: NotRequired[Nullable[Dict[str, Any]]]
 
 
 class ClassificationRequest(BaseModel):
@@ -32,3 +34,35 @@ class ClassificationRequest(BaseModel):
 
     inputs: Annotated[ClassificationRequestInputs, pydantic.Field(alias="input")]
     r"""Text to classify."""
+
+    metadata: OptionalNullable[Dict[str, Any]] = UNSET
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["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

mistralai/models/conversationrequest.py

@@ -12,7 +12,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, Literal, Optional, Union
+from typing import Any, Dict, List, Literal, Optional, Union
 from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
 
 
@@ -50,11 +50,14 @@ class ConversationRequestTypedDict(TypedDict):
     store: NotRequired[Nullable[bool]]
     handoff_execution: NotRequired[Nullable[HandoffExecution]]
     instructions: NotRequired[Nullable[str]]
-    tools: NotRequired[Nullable[List[ToolsTypedDict]]]
+    tools: NotRequired[List[ToolsTypedDict]]
+    r"""List of tools which are available to the model during the conversation."""
     completion_args: NotRequired[Nullable[CompletionArgsTypedDict]]
     name: NotRequired[Nullable[str]]
     description: NotRequired[Nullable[str]]
+    metadata: NotRequired[Nullable[Dict[str, Any]]]
     agent_id: NotRequired[Nullable[str]]
+    agent_version: NotRequired[Nullable[int]]
     model: NotRequired[Nullable[str]]
 
 
@@ -69,7 +72,8 @@ class ConversationRequest(BaseModel):
 
     instructions: OptionalNullable[str] = UNSET
 
-    tools: OptionalNullable[List[Tools]] = UNSET
+    tools: Optional[List[Tools]] = None
+    r"""List of tools which are available to the model during the conversation."""
 
     completion_args: OptionalNullable[CompletionArgs] = UNSET
 
@@ -77,8 +81,12 @@ class ConversationRequest(BaseModel):
 
     description: OptionalNullable[str] = UNSET
 
+    metadata: OptionalNullable[Dict[str, Any]] = UNSET
+
     agent_id: OptionalNullable[str] = UNSET
 
+    agent_version: OptionalNullable[int] = UNSET
+
     model: OptionalNullable[str] = UNSET
 
     @model_serializer(mode="wrap")
@@ -92,18 +100,21 @@ class ConversationRequest(BaseModel):
             "completion_args",
             "name",
             "description",
+            "metadata",
             "agent_id",
+            "agent_version",
             "model",
         ]
         nullable_fields = [
             "store",
             "handoff_execution",
             "instructions",
-            "tools",
             "completion_args",
             "name",
             "description",
+            "metadata",
             "agent_id",
+            "agent_version",
             "model",
         ]
         null_default_fields = []

mistralai/models/conversationrestartrequest.py

@@ -3,8 +3,9 @@
 from __future__ import annotations
 from .completionargs import CompletionArgs, CompletionArgsTypedDict
 from .conversationinputs import ConversationInputs, ConversationInputsTypedDict
-from mistralai.types import BaseModel
-from typing import Literal, Optional
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import Any, Dict, Literal, Optional
 from typing_extensions import NotRequired, TypedDict
 
 
@@ -22,6 +23,10 @@ class ConversationRestartRequestTypedDict(TypedDict):
     handoff_execution: NotRequired[ConversationRestartRequestHandoffExecution]
     completion_args: NotRequired[CompletionArgsTypedDict]
     r"""White-listed arguments from the completion API"""
+    metadata: NotRequired[Nullable[Dict[str, Any]]]
+    r"""Custom metadata for the conversation."""
+    agent_version: NotRequired[Nullable[int]]
+    r"""Specific version of the agent to use when restarting. If not provided, uses the current version."""
 
 
 class ConversationRestartRequest(BaseModel):
@@ -40,3 +45,46 @@ class ConversationRestartRequest(BaseModel):
 
     completion_args: Optional[CompletionArgs] = None
     r"""White-listed arguments from the completion API"""
+
+    metadata: OptionalNullable[Dict[str, Any]] = UNSET
+    r"""Custom metadata for the conversation."""
+
+    agent_version: OptionalNullable[int] = UNSET
+    r"""Specific version of the agent to use when restarting. If not provided, uses the current version."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = [
+            "stream",
+            "store",
+            "handoff_execution",
+            "completion_args",
+            "metadata",
+            "agent_version",
+        ]
+        nullable_fields = ["metadata", "agent_version"]
+        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/conversationrestartstreamrequest.py

@@ -3,8 +3,9 @@
 from __future__ import annotations
 from .completionargs import CompletionArgs, CompletionArgsTypedDict
 from .conversationinputs import ConversationInputs, ConversationInputsTypedDict
-from mistralai.types import BaseModel
-from typing import Literal, Optional
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import Any, Dict, Literal, Optional
 from typing_extensions import NotRequired, TypedDict
 
 
@@ -22,6 +23,10 @@ class ConversationRestartStreamRequestTypedDict(TypedDict):
     handoff_execution: NotRequired[ConversationRestartStreamRequestHandoffExecution]
     completion_args: NotRequired[CompletionArgsTypedDict]
     r"""White-listed arguments from the completion API"""
+    metadata: NotRequired[Nullable[Dict[str, Any]]]
+    r"""Custom metadata for the conversation."""
+    agent_version: NotRequired[Nullable[int]]
+    r"""Specific version of the agent to use when restarting. If not provided, uses the current version."""
 
 
 class ConversationRestartStreamRequest(BaseModel):
@@ -42,3 +47,46 @@ class ConversationRestartStreamRequest(BaseModel):
 
     completion_args: Optional[CompletionArgs] = None
     r"""White-listed arguments from the completion API"""
+
+    metadata: OptionalNullable[Dict[str, Any]] = UNSET
+    r"""Custom metadata for the conversation."""
+
+    agent_version: OptionalNullable[int] = UNSET
+    r"""Specific version of the agent to use when restarting. If not provided, uses the current version."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = [
+            "stream",
+            "store",
+            "handoff_execution",
+            "completion_args",
+            "metadata",
+            "agent_version",
+        ]
+        nullable_fields = ["metadata", "agent_version"]
+        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/conversationstreamrequest.py

@@ -12,7 +12,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, Literal, Optional, Union
+from typing import Any, Dict, List, Literal, Optional, Union
 from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
 
 
@@ -50,11 +50,14 @@ class ConversationStreamRequestTypedDict(TypedDict):
     store: NotRequired[Nullable[bool]]
     handoff_execution: NotRequired[Nullable[ConversationStreamRequestHandoffExecution]]
     instructions: NotRequired[Nullable[str]]
-    tools: NotRequired[Nullable[List[ConversationStreamRequestToolsTypedDict]]]
+    tools: NotRequired[List[ConversationStreamRequestToolsTypedDict]]
+    r"""List of tools which are available to the model during the conversation."""
     completion_args: NotRequired[Nullable[CompletionArgsTypedDict]]
     name: NotRequired[Nullable[str]]
     description: NotRequired[Nullable[str]]
+    metadata: NotRequired[Nullable[Dict[str, Any]]]
     agent_id: NotRequired[Nullable[str]]
+    agent_version: NotRequired[Nullable[int]]
     model: NotRequired[Nullable[str]]
 
 
@@ -71,7 +74,8 @@ class ConversationStreamRequest(BaseModel):
 
     instructions: OptionalNullable[str] = UNSET
 
-    tools: OptionalNullable[List[ConversationStreamRequestTools]] = UNSET
+    tools: Optional[List[ConversationStreamRequestTools]] = None
+    r"""List of tools which are available to the model during the conversation."""
 
     completion_args: OptionalNullable[CompletionArgs] = UNSET
 
@@ -79,8 +83,12 @@ class ConversationStreamRequest(BaseModel):
 
     description: OptionalNullable[str] = UNSET
 
+    metadata: OptionalNullable[Dict[str, Any]] = UNSET
+
     agent_id: OptionalNullable[str] = UNSET
 
+    agent_version: OptionalNullable[int] = UNSET
+
     model: OptionalNullable[str] = UNSET
 
     @model_serializer(mode="wrap")
@@ -94,18 +102,21 @@ class ConversationStreamRequest(BaseModel):
             "completion_args",
             "name",
             "description",
+            "metadata",
             "agent_id",
+            "agent_version",
             "model",
         ]
         nullable_fields = [
             "store",
             "handoff_execution",
             "instructions",
-            "tools",
             "completion_args",
             "name",
             "description",
+            "metadata",
             "agent_id",
+            "agent_version",
             "model",
         ]
         null_default_fields = []

mistralai/models/documentout.py

@@ -4,20 +4,21 @@ from __future__ import annotations
 from datetime import datetime
 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 DocumentOutTypedDict(TypedDict):
     id: str
     library_id: str
-    hash: str
-    mime_type: str
-    extension: str
-    size: int
+    hash: Nullable[str]
+    mime_type: Nullable[str]
+    extension: Nullable[str]
+    size: Nullable[int]
     name: str
     created_at: datetime
     processing_status: str
-    uploaded_by_id: str
+    uploaded_by_id: Nullable[str]
     uploaded_by_type: str
     tokens_processing_total: int
     summary: NotRequired[Nullable[str]]
@@ -25,6 +26,8 @@ class DocumentOutTypedDict(TypedDict):
     number_of_pages: NotRequired[Nullable[int]]
     tokens_processing_main_content: NotRequired[Nullable[int]]
     tokens_processing_summary: NotRequired[Nullable[int]]
+    url: NotRequired[Nullable[str]]
+    attributes: NotRequired[Nullable[Dict[str, Any]]]
 
 
 class DocumentOut(BaseModel):
@@ -32,13 +35,13 @@ class DocumentOut(BaseModel):
 
     library_id: str
 
-    hash: str
+    hash: Nullable[str]
 
-    mime_type: str
+    mime_type: Nullable[str]
 
-    extension: str
+    extension: Nullable[str]
 
-    size: int
+    size: Nullable[int]
 
     name: str
 
@@ -46,7 +49,7 @@ class DocumentOut(BaseModel):
 
     processing_status: str
 
-    uploaded_by_id: str
+    uploaded_by_id: Nullable[str]
 
     uploaded_by_type: str
 
@@ -62,6 +65,10 @@ class DocumentOut(BaseModel):
 
     tokens_processing_summary: OptionalNullable[int] = UNSET
 
+    url: OptionalNullable[str] = UNSET
+
+    attributes: OptionalNullable[Dict[str, Any]] = UNSET
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
         optional_fields = [
@@ -70,13 +77,22 @@ class DocumentOut(BaseModel):
             "number_of_pages",
             "tokens_processing_main_content",
             "tokens_processing_summary",
+            "url",
+            "attributes",
         ]
         nullable_fields = [
+            "hash",
+            "mime_type",
+            "extension",
+            "size",
             "summary",
             "last_processed_at",
             "number_of_pages",
+            "uploaded_by_id",
             "tokens_processing_main_content",
             "tokens_processing_summary",
+            "url",
+            "attributes",
         ]
         null_default_fields = []
 

mistralai/models/documentupdatein.py

@@ -1,22 +1,43 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
+from datetime import datetime
 from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
 from pydantic import model_serializer
-from typing_extensions import NotRequired, TypedDict
+from typing import Dict, List, Union
+from typing_extensions import NotRequired, TypeAliasType, TypedDict
+
+
+AttributesTypedDict = TypeAliasType(
+    "AttributesTypedDict",
+    Union[
+        bool, str, int, float, datetime, List[str], List[int], List[float], List[bool]
+    ],
+)
+
+
+Attributes = TypeAliasType(
+    "Attributes",
+    Union[
+        bool, str, int, float, datetime, List[str], List[int], List[float], List[bool]
+    ],
+)
 
 
 class DocumentUpdateInTypedDict(TypedDict):
     name: NotRequired[Nullable[str]]
+    attributes: NotRequired[Nullable[Dict[str, AttributesTypedDict]]]
 
 
 class DocumentUpdateIn(BaseModel):
     name: OptionalNullable[str] = UNSET
 
+    attributes: OptionalNullable[Dict[str, Attributes]] = UNSET
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["name"]
-        nullable_fields = ["name"]
+        optional_fields = ["name", "attributes"]
+        nullable_fields = ["name", "attributes"]
         null_default_fields = []
 
         serialized = handler(self)

mistralai/models/embeddingrequest.py

@@ -6,40 +6,43 @@ from .encodingformat import EncodingFormat
 from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
 import pydantic
 from pydantic import model_serializer
-from typing import List, Optional, Union
+from typing import Any, Dict, List, Optional, Union
 from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
 
 
 EmbeddingRequestInputsTypedDict = TypeAliasType(
     "EmbeddingRequestInputsTypedDict", Union[str, List[str]]
 )
-r"""Text to embed."""
+r"""The text content to be embedded, can be a string or an array of strings for fast processing in bulk."""
 
 
 EmbeddingRequestInputs = TypeAliasType("EmbeddingRequestInputs", Union[str, List[str]])
-r"""Text to embed."""
+r"""The text content to be embedded, can be a string or an array of strings for fast processing in bulk."""
 
 
 class EmbeddingRequestTypedDict(TypedDict):
     model: str
-    r"""ID of the model to use."""
+    r"""The ID of the model to be used for embedding."""
     inputs: EmbeddingRequestInputsTypedDict
-    r"""Text to embed."""
+    r"""The text content to be embedded, can be a string or an array of strings for fast processing in bulk."""
+    metadata: NotRequired[Nullable[Dict[str, Any]]]
     output_dimension: NotRequired[Nullable[int]]
-    r"""The dimension of the output embeddings."""
+    r"""The dimension of the output embeddings when feature available. If not provided, a default output dimension will be used."""
     output_dtype: NotRequired[EmbeddingDtype]
     encoding_format: NotRequired[EncodingFormat]
 
 
 class EmbeddingRequest(BaseModel):
     model: str
-    r"""ID of the model to use."""
+    r"""The ID of the model to be used for embedding."""
 
     inputs: Annotated[EmbeddingRequestInputs, pydantic.Field(alias="input")]
-    r"""Text to embed."""
+    r"""The text content to be embedded, can be a string or an array of strings for fast processing in bulk."""
+
+    metadata: OptionalNullable[Dict[str, Any]] = UNSET
 
     output_dimension: OptionalNullable[int] = UNSET
-    r"""The dimension of the output embeddings."""
+    r"""The dimension of the output embeddings when feature available. If not provided, a default output dimension will be used."""
 
     output_dtype: Optional[EmbeddingDtype] = None
 
@@ -47,8 +50,13 @@ class EmbeddingRequest(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["output_dimension", "output_dtype", "encoding_format"]
-        nullable_fields = ["output_dimension"]
+        optional_fields = [
+            "metadata",
+            "output_dimension",
+            "output_dtype",
+            "encoding_format",
+        ]
+        nullable_fields = ["metadata", "output_dimension"]
         null_default_fields = []
 
         serialized = handler(self)