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

mistralai_gcp/models/chatcompletionstreamrequest.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 from .assistantmessage import AssistantMessage, AssistantMessageTypedDict
+from .mistralpromptmode import MistralPromptMode
 from .prediction import Prediction, PredictionTypedDict
 from .responseformat import ResponseFormat, ResponseFormatTypedDict
 from .systemmessage import SystemMessage, SystemMessageTypedDict
@@ -19,7 +20,7 @@ from mistralai_gcp.types import (
 )
 from mistralai_gcp.utils import get_discriminator
 from pydantic import Discriminator, Tag, model_serializer
-from typing import List, Optional, Union
+from typing import Any, Dict, List, Optional, Union
 from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
 
 
@@ -57,11 +58,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 +83,25 @@ 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."""
 
 
 class ChatCompletionStreamRequest(BaseModel):
@@ -117,24 +128,34 @@ 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: 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")
     def serialize_model(self, handler):
@@ -145,6 +166,7 @@ class ChatCompletionStreamRequest(BaseModel):
             "stream",
             "stop",
             "random_seed",
+            "metadata",
             "response_format",
             "tools",
             "tool_choice",
@@ -153,15 +175,24 @@ class ChatCompletionStreamRequest(BaseModel):
             "n",
             "prediction",
             "parallel_tool_calls",
+            "prompt_mode",
+        ]
+        nullable_fields = [
+            "temperature",
+            "max_tokens",
+            "random_seed",
+            "metadata",
+            "tools",
+            "n",
+            "prompt_mode",
         ]
-        nullable_fields = ["temperature", "max_tokens", "random_seed", "tools", "n"]
         null_default_fields = []
 
         serialized = handler(self)
 
         m = {}
 
-        for n, f in self.model_fields.items():
+        for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k)
             serialized.pop(k, None)

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):
@@ -38,7 +42,7 @@ class CompletionResponseStreamChoice(BaseModel):
 
         m = {}
 
-        for n, f in self.model_fields.items():
+        for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k)
             serialized.pop(k, None)

mistralai_gcp/models/deltamessage.py

@@ -46,7 +46,7 @@ class DeltaMessage(BaseModel):
 
         m = {}
 
-        for n, f in self.model_fields.items():
+        for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k)
             serialized.pop(k, None)

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
 
 
@@ -27,10 +27,7 @@ r"""Stop generation if this token is detected. Or if one of these tokens is dete
 
 class FIMCompletionRequestTypedDict(TypedDict):
     model: str
-    r"""ID of the model to use. Only compatible for now with:
-    - `codestral-2405`
-    - `codestral-latest`
-    """
+    r"""ID of the model with FIM to use."""
     prompt: str
     r"""The text/code to complete."""
     temperature: NotRequired[Nullable[float]]
@@ -45,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]]
@@ -53,10 +51,7 @@ class FIMCompletionRequestTypedDict(TypedDict):
 
 class FIMCompletionRequest(BaseModel):
     model: str
-    r"""ID of the model to use. Only compatible for now with:
-    - `codestral-2405`
-    - `codestral-latest`
-    """
+    r"""ID of the model with FIM to use."""
 
     prompt: str
     r"""The text/code to complete."""
@@ -79,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`."""
 
@@ -94,6 +91,7 @@ class FIMCompletionRequest(BaseModel):
             "stream",
             "stop",
             "random_seed",
+            "metadata",
             "suffix",
             "min_tokens",
         ]
@@ -101,6 +99,7 @@ class FIMCompletionRequest(BaseModel):
             "temperature",
             "max_tokens",
             "random_seed",
+            "metadata",
             "suffix",
             "min_tokens",
         ]
@@ -110,7 +109,7 @@ class FIMCompletionRequest(BaseModel):
 
         m = {}
 
-        for n, f in self.model_fields.items():
+        for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k)
             serialized.pop(k, None)

mistralai_gcp/models/fimcompletionresponse.py

@@ -4,8 +4,8 @@ from __future__ import annotations
 from .chatcompletionchoice import ChatCompletionChoice, ChatCompletionChoiceTypedDict
 from .usageinfo import UsageInfo, UsageInfoTypedDict
 from mistralai_gcp.types import BaseModel
-from typing import List, Optional
-from typing_extensions import NotRequired, TypedDict
+from typing import List
+from typing_extensions import TypedDict
 
 
 class FIMCompletionResponseTypedDict(TypedDict):
@@ -13,8 +13,8 @@ class FIMCompletionResponseTypedDict(TypedDict):
     object: str
     model: str
     usage: UsageInfoTypedDict
-    created: NotRequired[int]
-    choices: NotRequired[List[ChatCompletionChoiceTypedDict]]
+    created: int
+    choices: List[ChatCompletionChoiceTypedDict]
 
 
 class FIMCompletionResponse(BaseModel):
@@ -26,6 +26,6 @@ class FIMCompletionResponse(BaseModel):
 
     usage: UsageInfo
 
-    created: Optional[int] = None
+    created: int
 
-    choices: Optional[List[ChatCompletionChoice]] = None
+    choices: List[ChatCompletionChoice]

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
 
 
@@ -27,10 +27,7 @@ r"""Stop generation if this token is detected. Or if one of these tokens is dete
 
 class FIMCompletionStreamRequestTypedDict(TypedDict):
     model: str
-    r"""ID of the model to use. Only compatible for now with:
-    - `codestral-2405`
-    - `codestral-latest`
-    """
+    r"""ID of the model with FIM to use."""
     prompt: str
     r"""The text/code to complete."""
     temperature: NotRequired[Nullable[float]]
@@ -44,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]]
@@ -52,10 +50,7 @@ class FIMCompletionStreamRequestTypedDict(TypedDict):
 
 class FIMCompletionStreamRequest(BaseModel):
     model: str
-    r"""ID of the model to use. Only compatible for now with:
-    - `codestral-2405`
-    - `codestral-latest`
-    """
+    r"""ID of the model with FIM to use."""
 
     prompt: str
     r"""The text/code to complete."""
@@ -77,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`."""
 
@@ -92,6 +89,7 @@ class FIMCompletionStreamRequest(BaseModel):
             "stream",
             "stop",
             "random_seed",
+            "metadata",
             "suffix",
             "min_tokens",
         ]
@@ -99,6 +97,7 @@ class FIMCompletionStreamRequest(BaseModel):
             "temperature",
             "max_tokens",
             "random_seed",
+            "metadata",
             "suffix",
             "min_tokens",
         ]
@@ -108,7 +107,7 @@ class FIMCompletionStreamRequest(BaseModel):
 
         m = {}
 
-        for n, f in self.model_fields.items():
+        for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k)
             serialized.pop(k, None)

mistralai_gcp/models/httpvalidationerror.py

@@ -2,7 +2,9 @@
 
 from __future__ import annotations
 from .validationerror import ValidationError
-from mistralai_gcp import utils
+from dataclasses import dataclass, field
+import httpx
+from mistralai_gcp.models import MistralGcpError
 from mistralai_gcp.types import BaseModel
 from typing import List, Optional
 
@@ -11,11 +13,16 @@ class HTTPValidationErrorData(BaseModel):
     detail: Optional[List[ValidationError]] = None
 
 
-class HTTPValidationError(Exception):
-    data: HTTPValidationErrorData
+@dataclass(unsafe_hash=True)
+class HTTPValidationError(MistralGcpError):
+    data: HTTPValidationErrorData = field(hash=False)
 
-    def __init__(self, data: HTTPValidationErrorData):
-        self.data = data
-
-    def __str__(self) -> str:
-        return utils.marshal_json(self.data, HTTPValidationErrorData)
+    def __init__(
+        self,
+        data: HTTPValidationErrorData,
+        raw_response: httpx.Response,
+        body: Optional[str] = None,
+    ):
+        message = body or raw_response.text
+        super().__init__(message, raw_response, body)
+        object.__setattr__(self, "data", data)

mistralai_gcp/models/imageurl.py

@@ -32,7 +32,7 @@ class ImageURL(BaseModel):
 
         m = {}
 
-        for n, f in self.model_fields.items():
+        for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k)
             serialized.pop(k, None)

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/jsonschema.py

@@ -40,7 +40,7 @@ class JSONSchema(BaseModel):
 
         m = {}
 
-        for n, f in self.model_fields.items():
+        for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k)
             serialized.pop(k, None)

mistralai_gcp/models/mistralgcperror.py

@@ -0,0 +1,30 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+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 = field(hash=False)
+    raw_response: httpx.Response = field(hash=False)
+
+    def __init__(
+        self, message: str, raw_response: httpx.Response, body: Optional[str] = None
+    ):
+        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

@@ -0,0 +1,8 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai_gcp.types import UnrecognizedStr
+from typing import Literal, Union
+
+
+MistralPromptMode = Union[Literal["reasoning",], UnrecognizedStr]

mistralai_gcp/models/no_response_error.py

@@ -0,0 +1,17 @@
+"""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"):
+        object.__setattr__(self, "message", message)
+        super().__init__(message)
+
+    def __str__(self):
+        return self.message

mistralai_gcp/models/prediction.py

@@ -10,11 +10,15 @@ from typing_extensions import Annotated, NotRequired, TypedDict
 
 
 class PredictionTypedDict(TypedDict):
+    r"""Enable users to specify an expected completion, optimizing response times by leveraging known or predictable content."""
+
     type: Literal["content"]
     content: NotRequired[str]
 
 
 class Prediction(BaseModel):
+    r"""Enable users to specify an expected completion, optimizing response times by leveraging known or predictable content."""
+
     TYPE: Annotated[
         Annotated[
             Optional[Literal["content"]], AfterValidator(validate_const("content"))

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/responseformat.py

@@ -16,14 +16,16 @@ from typing_extensions import NotRequired, TypedDict
 
 
 class ResponseFormatTypedDict(TypedDict):
+    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."""
+
     type: NotRequired[ResponseFormats]
-    r"""An object specifying the format that the model must output. 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."""
     json_schema: NotRequired[Nullable[JSONSchemaTypedDict]]
 
 
 class ResponseFormat(BaseModel):
+    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."""
+
     type: Optional[ResponseFormats] = None
-    r"""An object specifying the format that the model must output. 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."""
 
     json_schema: OptionalNullable[JSONSchema] = UNSET
 
@@ -37,7 +39,7 @@ class ResponseFormat(BaseModel):
 
         m = {}
 
-        for n, f in self.model_fields.items():
+        for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k)
             serialized.pop(k, None)

mistralai_gcp/models/responseformats.py

@@ -4,5 +4,8 @@ from __future__ import annotations
 from typing import Literal
 
 
-ResponseFormats = Literal["text", "json_object", "json_schema"]
-r"""An object specifying the format that the model must output. 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."""
+ResponseFormats = Literal[
+    "text",
+    "json_object",
+    "json_schema",
+]

mistralai_gcp/models/responsevalidationerror.py

@@ -0,0 +1,27 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+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."""
+
+    def __init__(
+        self,
+        message: str,
+        raw_response: httpx.Response,
+        cause: Exception,
+        body: Optional[str] = None,
+    ):
+        message = f"{message}: {cause}"
+        super().__init__(message, raw_response, body)
+
+    @property
+    def cause(self):
+        """Normally the Pydantic ValidationError"""
+        return self.__cause__

mistralai_gcp/models/sdkerror.py

@@ -1,22 +1,40 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
-from dataclasses import dataclass
-from typing import Optional
 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."""
+
+    def __init__(
+        self, message: str, raw_response: httpx.Response, body: Optional[str] = None
+    ):
+        body_display = body or raw_response.text or '""'
 
+        if message:
+            message += ": "
+        message += f"Status {raw_response.status_code}"
 
-@dataclass
-class SDKError(Exception):
-    """Represents an error returned by the API."""
+        headers = raw_response.headers
+        content_type = headers.get("content-type", '""')
+        if content_type != "application/json":
+            if " " in content_type:
+                content_type = f'"{content_type}"'
+            message += f" Content-Type {content_type}"
 
-    message: str
-    status_code: int = -1
-    body: str = ""
-    raw_response: Optional[httpx.Response] = None
+        if len(body_display) > MAX_MESSAGE_LEN:
+            truncated = body_display[:MAX_MESSAGE_LEN]
+            remaining = len(body_display) - MAX_MESSAGE_LEN
+            body_display = f"{truncated}...and {remaining} more chars"
 
-    def __str__(self):
-        body = ""
-        if len(self.body) > 0:
-            body = f"\n{self.body}"
+        message += f". Body: {body_display}"
+        message = message.strip()
 
-        return f"{self.message}: Status {self.status_code}{body}"
+        super().__init__(message, raw_response, body)