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

mistralai_gcp/fim.py

@@ -6,7 +6,7 @@ from mistralai_gcp._hooks import HookContext
 from mistralai_gcp.types import OptionalNullable, UNSET
 from mistralai_gcp.utils import eventstreaming
 from mistralai_gcp.utils.unmarshal_json_response import unmarshal_json_response
-from typing import Any, Mapping, Optional, Union
+from typing import Any, Dict, Mapping, Optional, Union
 
 
 class Fim(BaseSDK):
@@ -28,13 +28,14 @@ class Fim(BaseSDK):
             ]
         ] = None,
         random_seed: OptionalNullable[int] = UNSET,
+        metadata: OptionalNullable[Dict[str, Any]] = UNSET,
         suffix: OptionalNullable[str] = UNSET,
         min_tokens: OptionalNullable[int] = UNSET,
         retries: OptionalNullable[utils.RetryConfig] = UNSET,
         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 fim 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.
@@ -47,6 +48,7 @@ class Fim(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 suffix: Optional text/code that adds more context for the model. When given a `prompt` and a `suffix` the model will fill what is between them. When `suffix` is not provided, the model will simply execute completion starting with `prompt`.
         :param min_tokens: The minimum number of tokens to generate in the completion.
         :param retries: Override the default retry configuration for this method
@@ -72,6 +74,7 @@ class Fim(BaseSDK):
             stream=stream,
             stop=stop,
             random_seed=random_seed,
+            metadata=metadata,
             prompt=prompt,
             suffix=suffix,
             min_tokens=min_tokens,
@@ -93,6 +96,7 @@ class Fim(BaseSDK):
             get_serialized_body=lambda: utils.serialize_request_body(
                 request, False, False, "json", models.FIMCompletionStreamRequest
             ),
+            allow_empty_value=None,
             timeout_ms=timeout_ms,
         )
 
@@ -109,7 +113,7 @@ class Fim(BaseSDK):
                 config=self.sdk_configuration,
                 base_url=base_url or "",
                 operation_id="stream_fim",
-                oauth2_scopes=[],
+                oauth2_scopes=None,
                 security_source=self.sdk_configuration.security,
             ),
             request=req,
@@ -158,13 +162,14 @@ class Fim(BaseSDK):
             ]
         ] = None,
         random_seed: OptionalNullable[int] = UNSET,
+        metadata: OptionalNullable[Dict[str, Any]] = UNSET,
         suffix: OptionalNullable[str] = UNSET,
         min_tokens: OptionalNullable[int] = UNSET,
         retries: OptionalNullable[utils.RetryConfig] = UNSET,
         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 fim 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.
@@ -177,6 +182,7 @@ class Fim(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 suffix: Optional text/code that adds more context for the model. When given a `prompt` and a `suffix` the model will fill what is between them. When `suffix` is not provided, the model will simply execute completion starting with `prompt`.
         :param min_tokens: The minimum number of tokens to generate in the completion.
         :param retries: Override the default retry configuration for this method
@@ -202,6 +208,7 @@ class Fim(BaseSDK):
             stream=stream,
             stop=stop,
             random_seed=random_seed,
+            metadata=metadata,
             prompt=prompt,
             suffix=suffix,
             min_tokens=min_tokens,
@@ -223,6 +230,7 @@ class Fim(BaseSDK):
             get_serialized_body=lambda: utils.serialize_request_body(
                 request, False, False, "json", models.FIMCompletionStreamRequest
             ),
+            allow_empty_value=None,
             timeout_ms=timeout_ms,
         )
 
@@ -239,7 +247,7 @@ class Fim(BaseSDK):
                 config=self.sdk_configuration,
                 base_url=base_url or "",
                 operation_id="stream_fim",
-                oauth2_scopes=[],
+                oauth2_scopes=None,
                 security_source=self.sdk_configuration.security,
             ),
             request=req,
@@ -288,13 +296,14 @@ class Fim(BaseSDK):
             ]
         ] = None,
         random_seed: OptionalNullable[int] = UNSET,
+        metadata: OptionalNullable[Dict[str, Any]] = UNSET,
         suffix: OptionalNullable[str] = UNSET,
         min_tokens: OptionalNullable[int] = UNSET,
         retries: OptionalNullable[utils.RetryConfig] = UNSET,
         server_url: Optional[str] = None,
         timeout_ms: Optional[int] = None,
         http_headers: Optional[Mapping[str, str]] = None,
-    ) -> Optional[models.FIMCompletionResponse]:
+    ) -> models.FIMCompletionResponse:
         r"""Fim Completion
 
         FIM completion.
@@ -307,6 +316,7 @@ class Fim(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 suffix: Optional text/code that adds more context for the model. When given a `prompt` and a `suffix` the model will fill what is between them. When `suffix` is not provided, the model will simply execute completion starting with `prompt`.
         :param min_tokens: The minimum number of tokens to generate in the completion.
         :param retries: Override the default retry configuration for this method
@@ -332,6 +342,7 @@ class Fim(BaseSDK):
             stream=stream,
             stop=stop,
             random_seed=random_seed,
+            metadata=metadata,
             prompt=prompt,
             suffix=suffix,
             min_tokens=min_tokens,
@@ -353,6 +364,7 @@ class Fim(BaseSDK):
             get_serialized_body=lambda: utils.serialize_request_body(
                 request, False, False, "json", models.FIMCompletionRequest
             ),
+            allow_empty_value=None,
             timeout_ms=timeout_ms,
         )
 
@@ -369,7 +381,7 @@ class Fim(BaseSDK):
                 config=self.sdk_configuration,
                 base_url=base_url or "",
                 operation_id="fim_completion_v1_fim_completions_post",
-                oauth2_scopes=[],
+                oauth2_scopes=None,
                 security_source=self.sdk_configuration.security,
             ),
             request=req,
@@ -379,9 +391,7 @@ class Fim(BaseSDK):
 
         response_data: Any = None
         if utils.match_response(http_res, "200", "application/json"):
-            return unmarshal_json_response(
-                Optional[models.FIMCompletionResponse], http_res
-            )
+            return unmarshal_json_response(models.FIMCompletionResponse, http_res)
         if utils.match_response(http_res, "422", "application/json"):
             response_data = unmarshal_json_response(
                 models.HTTPValidationErrorData, http_res
@@ -412,13 +422,14 @@ class Fim(BaseSDK):
             ]
         ] = None,
         random_seed: OptionalNullable[int] = UNSET,
+        metadata: OptionalNullable[Dict[str, Any]] = UNSET,
         suffix: OptionalNullable[str] = UNSET,
         min_tokens: OptionalNullable[int] = UNSET,
         retries: OptionalNullable[utils.RetryConfig] = UNSET,
         server_url: Optional[str] = None,
         timeout_ms: Optional[int] = None,
         http_headers: Optional[Mapping[str, str]] = None,
-    ) -> Optional[models.FIMCompletionResponse]:
+    ) -> models.FIMCompletionResponse:
         r"""Fim Completion
 
         FIM completion.
@@ -431,6 +442,7 @@ class Fim(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 suffix: Optional text/code that adds more context for the model. When given a `prompt` and a `suffix` the model will fill what is between them. When `suffix` is not provided, the model will simply execute completion starting with `prompt`.
         :param min_tokens: The minimum number of tokens to generate in the completion.
         :param retries: Override the default retry configuration for this method
@@ -456,6 +468,7 @@ class Fim(BaseSDK):
             stream=stream,
             stop=stop,
             random_seed=random_seed,
+            metadata=metadata,
             prompt=prompt,
             suffix=suffix,
             min_tokens=min_tokens,
@@ -477,6 +490,7 @@ class Fim(BaseSDK):
             get_serialized_body=lambda: utils.serialize_request_body(
                 request, False, False, "json", models.FIMCompletionRequest
             ),
+            allow_empty_value=None,
             timeout_ms=timeout_ms,
         )
 
@@ -493,7 +507,7 @@ class Fim(BaseSDK):
                 config=self.sdk_configuration,
                 base_url=base_url or "",
                 operation_id="fim_completion_v1_fim_completions_post",
-                oauth2_scopes=[],
+                oauth2_scopes=None,
                 security_source=self.sdk_configuration.security,
             ),
             request=req,
@@ -503,9 +517,7 @@ class Fim(BaseSDK):
 
         response_data: Any = None
         if utils.match_response(http_res, "200", "application/json"):
-            return unmarshal_json_response(
-                Optional[models.FIMCompletionResponse], http_res
-            )
+            return unmarshal_json_response(models.FIMCompletionResponse, http_res)
         if utils.match_response(http_res, "422", "application/json"):
             response_data = unmarshal_json_response(
                 models.HTTPValidationErrorData, http_res

mistralai_gcp/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_gcp/models/assistantmessage.py

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

mistralai_gcp/models/chatcompletionchoice.py

@@ -3,14 +3,19 @@
 from __future__ import annotations
 from .assistantmessage import AssistantMessage, AssistantMessageTypedDict
 from mistralai_gcp.types import BaseModel, UnrecognizedStr
-from mistralai_gcp.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_gcp/models/chatcompletionrequest.py

@@ -18,10 +18,9 @@ from mistralai_gcp.types import (
     UNSET,
     UNSET_SENTINEL,
 )
-from mistralai_gcp.utils import get_discriminator, validate_open_enum
+from mistralai_gcp.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]]]
@@ -134,6 +134,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."""
 
@@ -158,9 +160,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."""
 
     @model_serializer(mode="wrap")
@@ -172,6 +172,7 @@ class ChatCompletionRequest(BaseModel):
             "stream",
             "stop",
             "random_seed",
+            "metadata",
             "response_format",
             "tools",
             "tool_choice",
@@ -186,6 +187,7 @@ class ChatCompletionRequest(BaseModel):
             "temperature",
             "max_tokens",
             "random_seed",
+            "metadata",
             "tools",
             "n",
             "prompt_mode",

mistralai_gcp/models/chatcompletionstreamrequest.py

@@ -18,10 +18,9 @@ from mistralai_gcp.types import (
     UNSET,
     UNSET_SENTINEL,
 )
-from mistralai_gcp.utils import get_discriminator, validate_open_enum
+from mistralai_gcp.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]]]
@@ -128,6 +128,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."""
 
@@ -152,9 +154,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."""
 
     @model_serializer(mode="wrap")
@@ -166,6 +166,7 @@ class ChatCompletionStreamRequest(BaseModel):
             "stream",
             "stop",
             "random_seed",
+            "metadata",
             "response_format",
             "tools",
             "tool_choice",
@@ -180,6 +181,7 @@ class ChatCompletionStreamRequest(BaseModel):
             "temperature",
             "max_tokens",
             "random_seed",
+            "metadata",
             "tools",
             "n",
             "prompt_mode",

mistralai_gcp/models/completionresponsestreamchoice.py

@@ -3,14 +3,20 @@
 from __future__ import annotations
 from .deltamessage import DeltaMessage, DeltaMessageTypedDict
 from mistralai_gcp.types import BaseModel, Nullable, UNSET_SENTINEL, UnrecognizedStr
-from mistralai_gcp.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_gcp/models/fimcompletionrequest.py

@@ -9,7 +9,7 @@ from mistralai_gcp.types import (
     UNSET_SENTINEL,
 )
 from pydantic import model_serializer
-from typing import List, Optional, Union
+from typing import Any, Dict, List, Optional, Union
 from typing_extensions import NotRequired, TypeAliasType, TypedDict
 
 
@@ -42,6 +42,7 @@ class FIMCompletionRequestTypedDict(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]]]
     suffix: NotRequired[Nullable[str]]
     r"""Optional text/code that adds more context for the model. When given a `prompt` and a `suffix` the model will fill what is between them. When `suffix` is not provided, the model will simply execute completion starting with `prompt`."""
     min_tokens: NotRequired[Nullable[int]]
@@ -73,6 +74,8 @@ class FIMCompletionRequest(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
+
     suffix: OptionalNullable[str] = UNSET
     r"""Optional text/code that adds more context for the model. When given a `prompt` and a `suffix` the model will fill what is between them. When `suffix` is not provided, the model will simply execute completion starting with `prompt`."""
 
@@ -88,6 +91,7 @@ class FIMCompletionRequest(BaseModel):
             "stream",
             "stop",
             "random_seed",
+            "metadata",
             "suffix",
             "min_tokens",
         ]
@@ -95,6 +99,7 @@ class FIMCompletionRequest(BaseModel):
             "temperature",
             "max_tokens",
             "random_seed",
+            "metadata",
             "suffix",
             "min_tokens",
         ]

mistralai_gcp/models/fimcompletionstreamrequest.py

@@ -9,7 +9,7 @@ from mistralai_gcp.types import (
     UNSET_SENTINEL,
 )
 from pydantic import model_serializer
-from typing import List, Optional, Union
+from typing import Any, Dict, List, Optional, Union
 from typing_extensions import NotRequired, TypeAliasType, TypedDict
 
 
@@ -41,6 +41,7 @@ class FIMCompletionStreamRequestTypedDict(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]]]
     suffix: NotRequired[Nullable[str]]
     r"""Optional text/code that adds more context for the model. When given a `prompt` and a `suffix` the model will fill what is between them. When `suffix` is not provided, the model will simply execute completion starting with `prompt`."""
     min_tokens: NotRequired[Nullable[int]]
@@ -71,6 +72,8 @@ class FIMCompletionStreamRequest(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
+
     suffix: OptionalNullable[str] = UNSET
     r"""Optional text/code that adds more context for the model. When given a `prompt` and a `suffix` the model will fill what is between them. When `suffix` is not provided, the model will simply execute completion starting with `prompt`."""
 
@@ -86,6 +89,7 @@ class FIMCompletionStreamRequest(BaseModel):
             "stream",
             "stop",
             "random_seed",
+            "metadata",
             "suffix",
             "min_tokens",
         ]
@@ -93,6 +97,7 @@ class FIMCompletionStreamRequest(BaseModel):
             "temperature",
             "max_tokens",
             "random_seed",
+            "metadata",
             "suffix",
             "min_tokens",
         ]

mistralai_gcp/models/httpvalidationerror.py

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

mistralai_gcp/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_gcp/models/mistralgcperror.py

@@ -2,25 +2,29 @@
 
 import httpx
 from typing import Optional
+from dataclasses import dataclass, field
 
 
+@dataclass(unsafe_hash=True)
 class MistralGcpError(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_gcp/models/mistralpromptmode.py

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

mistralai_gcp/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):

mistralai_gcp/models/referencechunk.py

@@ -6,7 +6,7 @@ from typing import List, Literal, Optional
 from typing_extensions import NotRequired, TypedDict
 
 
-ReferenceChunkType = Literal["reference"]
+ReferenceChunkType = Literal["reference",]
 
 
 class ReferenceChunkTypedDict(TypedDict):

mistralai_gcp/models/responseformats.py

@@ -4,4 +4,8 @@ from __future__ import annotations
 from typing import Literal
 
 
-ResponseFormats = Literal["text", "json_object", "json_schema"]
+ResponseFormats = Literal[
+    "text",
+    "json_object",
+    "json_schema",
+]

mistralai_gcp/models/responsevalidationerror.py

@@ -2,10 +2,12 @@
 
 import httpx
 from typing import Optional
+from dataclasses import dataclass
 
 from mistralai_gcp.models import MistralGcpError
 
 
+@dataclass(unsafe_hash=True)
 class ResponseValidationError(MistralGcpError):
     """Error raised when there is a type mismatch between the response data and the expected Pydantic model."""
 

mistralai_gcp/models/sdkerror.py

@@ -2,12 +2,14 @@
 
 import httpx
 from typing import Optional
+from dataclasses import dataclass
 
 from mistralai_gcp.models import MistralGcpError
 
 MAX_MESSAGE_LEN = 10_000
 
 
+@dataclass(unsafe_hash=True)
 class SDKError(MistralGcpError):
     """The fallback error class if no more specific error class is matched."""