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

mistralai_azure/_version.py

@@ -3,10 +3,10 @@
 import importlib.metadata
 
 __title__: str = "mistralai_azure"
-__version__: str = "1.7.0"
+__version__: str = "1.8.1"
 __openapi_doc_version__: str = "1.0.0"
-__gen_version__: str = "2.687.13"
-__user_agent__: str = "speakeasy-sdk/python 1.7.0 2.687.13 1.0.0 mistralai_azure"
+__gen_version__: str = "2.794.1"
+__user_agent__: str = "speakeasy-sdk/python 1.8.1 2.794.1 1.0.0 mistralai_azure"
 
 try:
     if __package__ is not None:

mistralai_azure/basesdk.py

@@ -60,6 +60,7 @@ class BaseSDK:
         ] = None,
         url_override: Optional[str] = None,
         http_headers: Optional[Mapping[str, str]] = None,
+        allow_empty_value: Optional[List[str]] = None,
     ) -> httpx.Request:
         client = self.sdk_configuration.async_client
         return self._build_request_with_client(
@@ -80,6 +81,7 @@ class BaseSDK:
             get_serialized_body,
             url_override,
             http_headers,
+            allow_empty_value,
         )
 
     def _build_request(
@@ -102,6 +104,7 @@ class BaseSDK:
         ] = None,
         url_override: Optional[str] = None,
         http_headers: Optional[Mapping[str, str]] = None,
+        allow_empty_value: Optional[List[str]] = None,
     ) -> httpx.Request:
         client = self.sdk_configuration.client
         return self._build_request_with_client(
@@ -122,6 +125,7 @@ class BaseSDK:
             get_serialized_body,
             url_override,
             http_headers,
+            allow_empty_value,
         )
 
     def _build_request_with_client(
@@ -145,6 +149,7 @@ class BaseSDK:
         ] = None,
         url_override: Optional[str] = None,
         http_headers: Optional[Mapping[str, str]] = None,
+        allow_empty_value: Optional[List[str]] = None,
     ) -> httpx.Request:
         query_params = {}
 
@@ -160,6 +165,7 @@ class BaseSDK:
             query_params = utils.get_query_params(
                 request if request_has_query_params else None,
                 _globals if request_has_query_params else None,
+                allow_empty_value,
             )
         else:
             # Pick up the query parameter from the override so they can be

mistralai_azure/chat.py

@@ -6,7 +6,7 @@ from mistralai_azure._hooks import HookContext
 from mistralai_azure.types import OptionalNullable, UNSET
 from mistralai_azure.utils import eventstreaming
 from mistralai_azure.utils.unmarshal_json_response import unmarshal_json_response
-from typing import Any, List, Mapping, Optional, Union
+from typing import Any, Dict, List, Mapping, Optional, Union
 
 
 class Chat(BaseSDK):
@@ -23,6 +23,7 @@ class Chat(BaseSDK):
         stream: Optional[bool] = True,
         stop: Optional[Union[models.Stop, models.StopTypedDict]] = None,
         random_seed: OptionalNullable[int] = UNSET,
+        metadata: OptionalNullable[Dict[str, Any]] = UNSET,
         response_format: Optional[
             Union[models.ResponseFormat, models.ResponseFormatTypedDict]
         ] = None,
@@ -48,7 +49,7 @@ class Chat(BaseSDK):
         server_url: Optional[str] = None,
         timeout_ms: Optional[int] = None,
         http_headers: Optional[Mapping[str, str]] = None,
-    ) -> Optional[eventstreaming.EventStream[models.CompletionEvent]]:
+    ) -> eventstreaming.EventStream[models.CompletionEvent]:
         r"""Stream chat completion
 
         Mistral AI provides the ability to stream responses back to a client in order to allow partial results for certain requests. Tokens will be sent as data-only server-sent events as they become available, with the stream terminated by a data: [DONE] message. Otherwise, the server will hold the request open until the timeout or until completion, with the response containing the full result as JSON.
@@ -61,6 +62,7 @@ class Chat(BaseSDK):
         :param stream:
         :param stop: Stop generation if this token is detected. Or if one of these tokens is detected when providing an array
         :param random_seed: The seed to use for random sampling. If set, different calls will generate deterministic results.
+        :param metadata:
         :param response_format: 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.
         :param tools: A list of tools the model may call. Use this to provide a list of functions the model may generate JSON inputs for.
         :param tool_choice: 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.
@@ -94,6 +96,7 @@ class Chat(BaseSDK):
             stream=stream,
             stop=stop,
             random_seed=random_seed,
+            metadata=metadata,
             messages=utils.get_pydantic_model(messages, List[models.Messages]),
             response_format=utils.get_pydantic_model(
                 response_format, Optional[models.ResponseFormat]
@@ -129,6 +132,7 @@ class Chat(BaseSDK):
             get_serialized_body=lambda: utils.serialize_request_body(
                 request, False, False, "json", models.ChatCompletionStreamRequest
             ),
+            allow_empty_value=None,
             timeout_ms=timeout_ms,
         )
 
@@ -145,7 +149,7 @@ class Chat(BaseSDK):
                 config=self.sdk_configuration,
                 base_url=base_url or "",
                 operation_id="stream_chat",
-                oauth2_scopes=[],
+                oauth2_scopes=None,
                 security_source=self.sdk_configuration.security,
             ),
             request=req,
@@ -189,6 +193,7 @@ class Chat(BaseSDK):
         stream: Optional[bool] = True,
         stop: Optional[Union[models.Stop, models.StopTypedDict]] = None,
         random_seed: OptionalNullable[int] = UNSET,
+        metadata: OptionalNullable[Dict[str, Any]] = UNSET,
         response_format: Optional[
             Union[models.ResponseFormat, models.ResponseFormatTypedDict]
         ] = None,
@@ -214,7 +219,7 @@ class Chat(BaseSDK):
         server_url: Optional[str] = None,
         timeout_ms: Optional[int] = None,
         http_headers: Optional[Mapping[str, str]] = None,
-    ) -> Optional[eventstreaming.EventStreamAsync[models.CompletionEvent]]:
+    ) -> eventstreaming.EventStreamAsync[models.CompletionEvent]:
         r"""Stream chat completion
 
         Mistral AI provides the ability to stream responses back to a client in order to allow partial results for certain requests. Tokens will be sent as data-only server-sent events as they become available, with the stream terminated by a data: [DONE] message. Otherwise, the server will hold the request open until the timeout or until completion, with the response containing the full result as JSON.
@@ -227,6 +232,7 @@ class Chat(BaseSDK):
         :param stream:
         :param stop: Stop generation if this token is detected. Or if one of these tokens is detected when providing an array
         :param random_seed: The seed to use for random sampling. If set, different calls will generate deterministic results.
+        :param metadata:
         :param response_format: 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.
         :param tools: A list of tools the model may call. Use this to provide a list of functions the model may generate JSON inputs for.
         :param tool_choice: 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.
@@ -260,6 +266,7 @@ class Chat(BaseSDK):
             stream=stream,
             stop=stop,
             random_seed=random_seed,
+            metadata=metadata,
             messages=utils.get_pydantic_model(messages, List[models.Messages]),
             response_format=utils.get_pydantic_model(
                 response_format, Optional[models.ResponseFormat]
@@ -295,6 +302,7 @@ class Chat(BaseSDK):
             get_serialized_body=lambda: utils.serialize_request_body(
                 request, False, False, "json", models.ChatCompletionStreamRequest
             ),
+            allow_empty_value=None,
             timeout_ms=timeout_ms,
         )
 
@@ -311,7 +319,7 @@ class Chat(BaseSDK):
                 config=self.sdk_configuration,
                 base_url=base_url or "",
                 operation_id="stream_chat",
-                oauth2_scopes=[],
+                oauth2_scopes=None,
                 security_source=self.sdk_configuration.security,
             ),
             request=req,
@@ -363,6 +371,7 @@ class Chat(BaseSDK):
             ]
         ] = None,
         random_seed: OptionalNullable[int] = UNSET,
+        metadata: OptionalNullable[Dict[str, Any]] = UNSET,
         response_format: Optional[
             Union[models.ResponseFormat, models.ResponseFormatTypedDict]
         ] = None,
@@ -388,7 +397,7 @@ class Chat(BaseSDK):
         server_url: Optional[str] = None,
         timeout_ms: Optional[int] = None,
         http_headers: Optional[Mapping[str, str]] = None,
-    ) -> Optional[models.ChatCompletionResponse]:
+    ) -> models.ChatCompletionResponse:
         r"""Chat Completion
 
         :param messages: The prompt(s) to generate completions for, encoded as a list of dict with role and content.
@@ -399,6 +408,7 @@ class Chat(BaseSDK):
         :param stream: Whether to stream back partial progress. If set, tokens will be sent as data-only server-side events as they become available, with the stream terminated by a data: [DONE] message. Otherwise, the server will hold the request open until the timeout or until completion, with the response containing the full result as JSON.
         :param stop: Stop generation if this token is detected. Or if one of these tokens is detected when providing an array
         :param random_seed: The seed to use for random sampling. If set, different calls will generate deterministic results.
+        :param metadata:
         :param response_format: 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.
         :param tools: A list of tools the model may call. Use this to provide a list of functions the model may generate JSON inputs for.
         :param tool_choice: 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.
@@ -432,6 +442,7 @@ class Chat(BaseSDK):
             stream=stream,
             stop=stop,
             random_seed=random_seed,
+            metadata=metadata,
             messages=utils.get_pydantic_model(
                 messages, List[models.ChatCompletionRequestMessages]
             ),
@@ -469,6 +480,7 @@ class Chat(BaseSDK):
             get_serialized_body=lambda: utils.serialize_request_body(
                 request, False, False, "json", models.ChatCompletionRequest
             ),
+            allow_empty_value=None,
             timeout_ms=timeout_ms,
         )
 
@@ -485,7 +497,7 @@ class Chat(BaseSDK):
                 config=self.sdk_configuration,
                 base_url=base_url or "",
                 operation_id="chat_completion_v1_chat_completions_post",
-                oauth2_scopes=[],
+                oauth2_scopes=None,
                 security_source=self.sdk_configuration.security,
             ),
             request=req,
@@ -495,9 +507,7 @@ class Chat(BaseSDK):
 
         response_data: Any = None
         if utils.match_response(http_res, "200", "application/json"):
-            return unmarshal_json_response(
-                Optional[models.ChatCompletionResponse], http_res
-            )
+            return unmarshal_json_response(models.ChatCompletionResponse, http_res)
         if utils.match_response(http_res, "422", "application/json"):
             response_data = unmarshal_json_response(
                 models.HTTPValidationErrorData, http_res
@@ -531,6 +541,7 @@ class Chat(BaseSDK):
             ]
         ] = None,
         random_seed: OptionalNullable[int] = UNSET,
+        metadata: OptionalNullable[Dict[str, Any]] = UNSET,
         response_format: Optional[
             Union[models.ResponseFormat, models.ResponseFormatTypedDict]
         ] = None,
@@ -556,7 +567,7 @@ class Chat(BaseSDK):
         server_url: Optional[str] = None,
         timeout_ms: Optional[int] = None,
         http_headers: Optional[Mapping[str, str]] = None,
-    ) -> Optional[models.ChatCompletionResponse]:
+    ) -> models.ChatCompletionResponse:
         r"""Chat Completion
 
         :param messages: The prompt(s) to generate completions for, encoded as a list of dict with role and content.
@@ -567,6 +578,7 @@ class Chat(BaseSDK):
         :param stream: Whether to stream back partial progress. If set, tokens will be sent as data-only server-side events as they become available, with the stream terminated by a data: [DONE] message. Otherwise, the server will hold the request open until the timeout or until completion, with the response containing the full result as JSON.
         :param stop: Stop generation if this token is detected. Or if one of these tokens is detected when providing an array
         :param random_seed: The seed to use for random sampling. If set, different calls will generate deterministic results.
+        :param metadata:
         :param response_format: 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.
         :param tools: A list of tools the model may call. Use this to provide a list of functions the model may generate JSON inputs for.
         :param tool_choice: 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.
@@ -600,6 +612,7 @@ class Chat(BaseSDK):
             stream=stream,
             stop=stop,
             random_seed=random_seed,
+            metadata=metadata,
             messages=utils.get_pydantic_model(
                 messages, List[models.ChatCompletionRequestMessages]
             ),
@@ -637,6 +650,7 @@ class Chat(BaseSDK):
             get_serialized_body=lambda: utils.serialize_request_body(
                 request, False, False, "json", models.ChatCompletionRequest
             ),
+            allow_empty_value=None,
             timeout_ms=timeout_ms,
         )
 
@@ -653,7 +667,7 @@ class Chat(BaseSDK):
                 config=self.sdk_configuration,
                 base_url=base_url or "",
                 operation_id="chat_completion_v1_chat_completions_post",
-                oauth2_scopes=[],
+                oauth2_scopes=None,
                 security_source=self.sdk_configuration.security,
             ),
             request=req,
@@ -663,9 +677,7 @@ class Chat(BaseSDK):
 
         response_data: Any = None
         if utils.match_response(http_res, "200", "application/json"):
-            return unmarshal_json_response(
-                Optional[models.ChatCompletionResponse], http_res
-            )
+            return unmarshal_json_response(models.ChatCompletionResponse, http_res)
         if utils.match_response(http_res, "422", "application/json"):
             response_data = unmarshal_json_response(
                 models.HTTPValidationErrorData, http_res

mistralai_azure/httpclient.py

@@ -107,7 +107,6 @@ def close_clients(
     # to them from the owning SDK instance and they can be reaped.
     owner.client = None
     owner.async_client = None
-
     if sync_client is not None and not sync_client_supplied:
         try:
             sync_client.close()

mistralai_azure/models/__init__.py

@@ -86,8 +86,15 @@ if TYPE_CHECKING:
     from .ocrimageobject import OCRImageObject, OCRImageObjectTypedDict
     from .ocrpagedimensions import OCRPageDimensions, OCRPageDimensionsTypedDict
     from .ocrpageobject import OCRPageObject, OCRPageObjectTypedDict
-    from .ocrrequest import Document, DocumentTypedDict, OCRRequest, OCRRequestTypedDict
+    from .ocrrequest import (
+        Document,
+        DocumentTypedDict,
+        OCRRequest,
+        OCRRequestTypedDict,
+        TableFormat,
+    )
     from .ocrresponse import OCRResponse, OCRResponseTypedDict
+    from .ocrtableobject import Format, OCRTableObject, OCRTableObjectTypedDict
     from .ocrusageinfo import OCRUsageInfo, OCRUsageInfoTypedDict
     from .prediction import Prediction, PredictionTypedDict
     from .referencechunk import (
@@ -191,6 +198,7 @@ __all__ = [
     "FileChunk",
     "FileChunkTypedDict",
     "FinishReason",
+    "Format",
     "Function",
     "FunctionCall",
     "FunctionCallTypedDict",
@@ -225,6 +233,8 @@ __all__ = [
     "OCRRequestTypedDict",
     "OCRResponse",
     "OCRResponseTypedDict",
+    "OCRTableObject",
+    "OCRTableObjectTypedDict",
     "OCRUsageInfo",
     "OCRUsageInfoTypedDict",
     "Prediction",
@@ -248,6 +258,7 @@ __all__ = [
     "SystemMessageContentChunksTypedDict",
     "SystemMessageContentTypedDict",
     "SystemMessageTypedDict",
+    "TableFormat",
     "TextChunk",
     "TextChunkTypedDict",
     "ThinkChunk",
@@ -356,8 +367,12 @@ _dynamic_imports: dict[str, str] = {
     "DocumentTypedDict": ".ocrrequest",
     "OCRRequest": ".ocrrequest",
     "OCRRequestTypedDict": ".ocrrequest",
+    "TableFormat": ".ocrrequest",
     "OCRResponse": ".ocrresponse",
     "OCRResponseTypedDict": ".ocrresponse",
+    "Format": ".ocrtableobject",
+    "OCRTableObject": ".ocrtableobject",
+    "OCRTableObjectTypedDict": ".ocrtableobject",
     "OCRUsageInfo": ".ocrusageinfo",
     "OCRUsageInfoTypedDict": ".ocrusageinfo",
     "Prediction": ".prediction",

mistralai_azure/models/assistantmessage.py

@@ -25,7 +25,7 @@ AssistantMessageContent = TypeAliasType(
 )
 
 
-AssistantMessageRole = Literal["assistant"]
+AssistantMessageRole = Literal["assistant",]
 
 
 class AssistantMessageTypedDict(TypedDict):

mistralai_azure/models/chatcompletionchoice.py

@@ -3,14 +3,19 @@
 from __future__ import annotations
 from .assistantmessage import AssistantMessage, AssistantMessageTypedDict
 from mistralai_azure.types import BaseModel, UnrecognizedStr
-from mistralai_azure.utils import validate_open_enum
-from pydantic.functional_validators import PlainValidator
 from typing import Literal, Union
-from typing_extensions import Annotated, TypedDict
+from typing_extensions import TypedDict
 
 
 ChatCompletionChoiceFinishReason = Union[
-    Literal["stop", "length", "model_length", "error", "tool_calls"], UnrecognizedStr
+    Literal[
+        "stop",
+        "length",
+        "model_length",
+        "error",
+        "tool_calls",
+    ],
+    UnrecognizedStr,
 ]
 
 
@@ -25,6 +30,4 @@ class ChatCompletionChoice(BaseModel):
 
     message: AssistantMessage
 
-    finish_reason: Annotated[
-        ChatCompletionChoiceFinishReason, PlainValidator(validate_open_enum(False))
-    ]
+    finish_reason: ChatCompletionChoiceFinishReason

mistralai_azure/models/chatcompletionrequest.py

@@ -18,10 +18,9 @@ from mistralai_azure.types import (
     UNSET,
     UNSET_SENTINEL,
 )
-from mistralai_azure.utils import get_discriminator, validate_open_enum
+from mistralai_azure.utils import get_discriminator
 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
 
 
@@ -89,6 +88,7 @@ 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]]]
@@ -136,6 +136,8 @@ 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."""
 
@@ -160,9 +162,7 @@ class ChatCompletionRequest(BaseModel):
     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))
-    ] = UNSET
+    prompt_mode: OptionalNullable[MistralPromptMode] = UNSET
     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: Optional[bool] = None
@@ -178,6 +178,7 @@ class ChatCompletionRequest(BaseModel):
             "stream",
             "stop",
             "random_seed",
+            "metadata",
             "response_format",
             "tools",
             "tool_choice",
@@ -193,6 +194,7 @@ class ChatCompletionRequest(BaseModel):
             "temperature",
             "max_tokens",
             "random_seed",
+            "metadata",
             "tools",
             "n",
             "prompt_mode",

mistralai_azure/models/chatcompletionstreamrequest.py

@@ -18,10 +18,9 @@ from mistralai_azure.types import (
     UNSET,
     UNSET_SENTINEL,
 )
-from mistralai_azure.utils import get_discriminator, validate_open_enum
+from mistralai_azure.utils import get_discriminator
 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
 
 
@@ -84,6 +83,7 @@ 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]]]
@@ -130,6 +130,8 @@ 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."""
 
@@ -154,9 +156,7 @@ class ChatCompletionStreamRequest(BaseModel):
     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))
-    ] = UNSET
+    prompt_mode: OptionalNullable[MistralPromptMode] = UNSET
     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: Optional[bool] = None
@@ -172,6 +172,7 @@ class ChatCompletionStreamRequest(BaseModel):
             "stream",
             "stop",
             "random_seed",
+            "metadata",
             "response_format",
             "tools",
             "tool_choice",
@@ -187,6 +188,7 @@ class ChatCompletionStreamRequest(BaseModel):
             "temperature",
             "max_tokens",
             "random_seed",
+            "metadata",
             "tools",
             "n",
             "prompt_mode",

mistralai_azure/models/completionresponsestreamchoice.py

@@ -3,14 +3,20 @@
 from __future__ import annotations
 from .deltamessage import DeltaMessage, DeltaMessageTypedDict
 from mistralai_azure.types import BaseModel, Nullable, UNSET_SENTINEL, UnrecognizedStr
-from mistralai_azure.utils import validate_open_enum
 from pydantic import model_serializer
-from pydantic.functional_validators import PlainValidator
 from typing import Literal, Union
-from typing_extensions import Annotated, TypedDict
+from typing_extensions import TypedDict
 
 
-FinishReason = Union[Literal["stop", "length", "error", "tool_calls"], UnrecognizedStr]
+FinishReason = Union[
+    Literal[
+        "stop",
+        "length",
+        "error",
+        "tool_calls",
+    ],
+    UnrecognizedStr,
+]
 
 
 class CompletionResponseStreamChoiceTypedDict(TypedDict):
@@ -24,9 +30,7 @@ class CompletionResponseStreamChoice(BaseModel):
 
     delta: DeltaMessage
 
-    finish_reason: Annotated[
-        Nullable[FinishReason], PlainValidator(validate_open_enum(False))
-    ]
+    finish_reason: Nullable[FinishReason]
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):

mistralai_azure/models/documenturlchunk.py

@@ -13,7 +13,7 @@ from typing import Literal, Optional
 from typing_extensions import NotRequired, TypedDict
 
 
-DocumentURLChunkType = Literal["document_url"]
+DocumentURLChunkType = Literal["document_url",]
 
 
 class DocumentURLChunkTypedDict(TypedDict):

mistralai_azure/models/httpvalidationerror.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 from .validationerror import ValidationError
+from dataclasses import dataclass, field
 import httpx
 from mistralai_azure.models import MistralAzureError
 from mistralai_azure.types import BaseModel
@@ -12,8 +13,9 @@ class HTTPValidationErrorData(BaseModel):
     detail: Optional[List[ValidationError]] = None
 
 
+@dataclass(unsafe_hash=True)
 class HTTPValidationError(MistralAzureError):
-    data: HTTPValidationErrorData
+    data: HTTPValidationErrorData = field(hash=False)
 
     def __init__(
         self,
@@ -23,4 +25,4 @@ class HTTPValidationError(MistralAzureError):
     ):
         message = body or raw_response.text
         super().__init__(message, raw_response, body)
-        self.data = data
+        object.__setattr__(self, "data", data)

mistralai_azure/models/imageurlchunk.py

@@ -15,7 +15,7 @@ ImageURLChunkImageURLTypedDict = TypeAliasType(
 ImageURLChunkImageURL = TypeAliasType("ImageURLChunkImageURL", Union[ImageURL, str])
 
 
-ImageURLChunkType = Literal["image_url"]
+ImageURLChunkType = Literal["image_url",]
 
 
 class ImageURLChunkTypedDict(TypedDict):

mistralai_azure/models/mistralazureerror.py

@@ -2,25 +2,29 @@
 
 import httpx
 from typing import Optional
+from dataclasses import dataclass, field
 
 
+@dataclass(unsafe_hash=True)
 class MistralAzureError(Exception):
     """The base class for all HTTP error responses."""
 
     message: str
     status_code: int
     body: str
-    headers: httpx.Headers
-    raw_response: httpx.Response
+    headers: httpx.Headers = field(hash=False)
+    raw_response: httpx.Response = field(hash=False)
 
     def __init__(
         self, message: str, raw_response: httpx.Response, body: Optional[str] = None
     ):
-        self.message = message
-        self.status_code = raw_response.status_code
-        self.body = body if body is not None else raw_response.text
-        self.headers = raw_response.headers
-        self.raw_response = raw_response
+        object.__setattr__(self, "message", message)
+        object.__setattr__(self, "status_code", raw_response.status_code)
+        object.__setattr__(
+            self, "body", body if body is not None else raw_response.text
+        )
+        object.__setattr__(self, "headers", raw_response.headers)
+        object.__setattr__(self, "raw_response", raw_response)
 
     def __str__(self):
         return self.message

mistralai_azure/models/mistralpromptmode.py

@@ -5,4 +5,4 @@ from mistralai_azure.types import UnrecognizedStr
 from typing import Literal, Union
 
 
-MistralPromptMode = Union[Literal["reasoning"], UnrecognizedStr]
+MistralPromptMode = Union[Literal["reasoning",], UnrecognizedStr]

mistralai_azure/models/no_response_error.py

@@ -1,12 +1,16 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
+from dataclasses import dataclass
+
+
+@dataclass(unsafe_hash=True)
 class NoResponseError(Exception):
     """Error raised when no HTTP response is received from the server."""
 
     message: str
 
     def __init__(self, message: str = "No response received"):
-        self.message = message
+        object.__setattr__(self, "message", message)
         super().__init__(message)
 
     def __str__(self):