mistralai 1.5.2__py3-none-any.whl → 1.6.0__py3-none-any.whl

mistralai_gcp/models/chatcompletionrequest.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 from .assistantmessage import AssistantMessage, AssistantMessageTypedDict
+from .prediction import Prediction, PredictionTypedDict
 from .responseformat import ResponseFormat, ResponseFormatTypedDict
 from .systemmessage import SystemMessage, SystemMessageTypedDict
 from .tool import Tool, ToolTypedDict
@@ -68,7 +69,7 @@ ChatCompletionRequestToolChoice = TypeAliasType(
 
 
 class ChatCompletionRequestTypedDict(TypedDict):
-    model: Nullable[str]
+    model: str
     r"""ID of the model to use. You can use the [List Available Models](/api/#tag/models/operation/list_models_v1_models_get) API to see all of your available models, or see our [Model overview](/models) for model descriptions."""
     messages: List[ChatCompletionRequestMessagesTypedDict]
     r"""The prompt(s) to generate completions for, encoded as a list of dict with role and content."""
@@ -93,10 +94,12 @@ class ChatCompletionRequestTypedDict(TypedDict):
     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."""
     n: NotRequired[Nullable[int]]
     r"""Number of completions to return for each request, input tokens are only billed once."""
+    prediction: NotRequired[PredictionTypedDict]
+    parallel_tool_calls: NotRequired[bool]
 
 
 class ChatCompletionRequest(BaseModel):
-    model: Nullable[str]
+    model: str
     r"""ID of the model to use. You can use the [List Available Models](/api/#tag/models/operation/list_models_v1_models_get) API to see all of your available models, or see our [Model overview](/models) for model descriptions."""
 
     messages: List[ChatCompletionRequestMessages]
@@ -135,6 +138,10 @@ class ChatCompletionRequest(BaseModel):
     n: OptionalNullable[int] = UNSET
     r"""Number of completions to return for each request, input tokens are only billed once."""
 
+    prediction: Optional[Prediction] = None
+
+    parallel_tool_calls: Optional[bool] = None
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
         optional_fields = [
@@ -150,15 +157,10 @@ class ChatCompletionRequest(BaseModel):
             "presence_penalty",
             "frequency_penalty",
             "n",
+            "prediction",
+            "parallel_tool_calls",
         ]
-        nullable_fields = [
-            "model",
-            "temperature",
-            "max_tokens",
-            "random_seed",
-            "tools",
-            "n",
-        ]
+        nullable_fields = ["temperature", "max_tokens", "random_seed", "tools", "n"]
         null_default_fields = []
 
         serialized = handler(self)

mistralai_gcp/models/chatcompletionstreamrequest.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 from .assistantmessage import AssistantMessage, AssistantMessageTypedDict
+from .prediction import Prediction, PredictionTypedDict
 from .responseformat import ResponseFormat, ResponseFormatTypedDict
 from .systemmessage import SystemMessage, SystemMessageTypedDict
 from .tool import Tool, ToolTypedDict
@@ -64,7 +65,7 @@ ChatCompletionStreamRequestToolChoice = TypeAliasType(
 
 
 class ChatCompletionStreamRequestTypedDict(TypedDict):
-    model: Nullable[str]
+    model: str
     r"""ID of the model to use. You can use the [List Available Models](/api/#tag/models/operation/list_models_v1_models_get) API to see all of your available models, or see our [Model overview](/models) for model descriptions."""
     messages: List[MessagesTypedDict]
     r"""The prompt(s) to generate completions for, encoded as a list of dict with role and content."""
@@ -88,10 +89,12 @@ class ChatCompletionStreamRequestTypedDict(TypedDict):
     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."""
     n: NotRequired[Nullable[int]]
     r"""Number of completions to return for each request, input tokens are only billed once."""
+    prediction: NotRequired[PredictionTypedDict]
+    parallel_tool_calls: NotRequired[bool]
 
 
 class ChatCompletionStreamRequest(BaseModel):
-    model: Nullable[str]
+    model: str
     r"""ID of the model to use. You can use the [List Available Models](/api/#tag/models/operation/list_models_v1_models_get) API to see all of your available models, or see our [Model overview](/models) for model descriptions."""
 
     messages: List[Messages]
@@ -129,6 +132,10 @@ class ChatCompletionStreamRequest(BaseModel):
     n: OptionalNullable[int] = UNSET
     r"""Number of completions to return for each request, input tokens are only billed once."""
 
+    prediction: Optional[Prediction] = None
+
+    parallel_tool_calls: Optional[bool] = None
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
         optional_fields = [
@@ -144,15 +151,10 @@ class ChatCompletionStreamRequest(BaseModel):
             "presence_penalty",
             "frequency_penalty",
             "n",
+            "prediction",
+            "parallel_tool_calls",
         ]
-        nullable_fields = [
-            "model",
-            "temperature",
-            "max_tokens",
-            "random_seed",
-            "tools",
-            "n",
-        ]
+        nullable_fields = ["temperature", "max_tokens", "random_seed", "tools", "n"]
         null_default_fields = []
 
         serialized = handler(self)

mistralai_gcp/models/contentchunk.py

@@ -1,6 +1,7 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
+from .imageurlchunk import ImageURLChunk, ImageURLChunkTypedDict
 from .referencechunk import ReferenceChunk, ReferenceChunkTypedDict
 from .textchunk import TextChunk, TextChunkTypedDict
 from mistralai_gcp.utils import get_discriminator
@@ -10,13 +11,16 @@ from typing_extensions import Annotated, TypeAliasType
 
 
 ContentChunkTypedDict = TypeAliasType(
-    "ContentChunkTypedDict", Union[TextChunkTypedDict, ReferenceChunkTypedDict]
+    "ContentChunkTypedDict",
+    Union[TextChunkTypedDict, ImageURLChunkTypedDict, ReferenceChunkTypedDict],
 )
 
 
 ContentChunk = Annotated[
     Union[
-        Annotated[TextChunk, Tag("text")], Annotated[ReferenceChunk, Tag("reference")]
+        Annotated[ImageURLChunk, Tag("image_url")],
+        Annotated[TextChunk, Tag("text")],
+        Annotated[ReferenceChunk, Tag("reference")],
     ],
     Discriminator(lambda m: get_discriminator(m, "type", "type")),
 ]

mistralai_gcp/models/fimcompletionrequest.py

@@ -26,7 +26,7 @@ r"""Stop generation if this token is detected. Or if one of these tokens is dete
 
 
 class FIMCompletionRequestTypedDict(TypedDict):
-    model: Nullable[str]
+    model: str
     r"""ID of the model to use. Only compatible for now with:
     - `codestral-2405`
     - `codestral-latest`
@@ -52,7 +52,7 @@ class FIMCompletionRequestTypedDict(TypedDict):
 
 
 class FIMCompletionRequest(BaseModel):
-    model: Nullable[str]
+    model: str
     r"""ID of the model to use. Only compatible for now with:
     - `codestral-2405`
     - `codestral-latest`
@@ -98,7 +98,6 @@ class FIMCompletionRequest(BaseModel):
             "min_tokens",
         ]
         nullable_fields = [
-            "model",
             "temperature",
             "max_tokens",
             "random_seed",

mistralai_gcp/models/fimcompletionstreamrequest.py

@@ -26,7 +26,7 @@ r"""Stop generation if this token is detected. Or if one of these tokens is dete
 
 
 class FIMCompletionStreamRequestTypedDict(TypedDict):
-    model: Nullable[str]
+    model: str
     r"""ID of the model to use. Only compatible for now with:
     - `codestral-2405`
     - `codestral-latest`
@@ -51,7 +51,7 @@ class FIMCompletionStreamRequestTypedDict(TypedDict):
 
 
 class FIMCompletionStreamRequest(BaseModel):
-    model: Nullable[str]
+    model: str
     r"""ID of the model to use. Only compatible for now with:
     - `codestral-2405`
     - `codestral-latest`
@@ -96,7 +96,6 @@ class FIMCompletionStreamRequest(BaseModel):
             "min_tokens",
         ]
         nullable_fields = [
-            "model",
             "temperature",
             "max_tokens",
             "random_seed",

mistralai_gcp/models/function.py

@@ -10,6 +10,7 @@ class FunctionTypedDict(TypedDict):
     name: str
     parameters: Dict[str, Any]
     description: NotRequired[str]
+    strict: NotRequired[bool]
 
 
 class Function(BaseModel):
@@ -17,4 +18,6 @@ class Function(BaseModel):
 
     parameters: Dict[str, Any]
 
-    description: Optional[str] = ""
+    description: Optional[str] = None
+
+    strict: Optional[bool] = None

mistralai_gcp/models/imageurl.py

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

mistralai_gcp/models/imageurlchunk.py

@@ -0,0 +1,33 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .imageurl import ImageURL, ImageURLTypedDict
+from mistralai_gcp.types import BaseModel
+from typing import Literal, Optional, Union
+from typing_extensions import NotRequired, TypeAliasType, TypedDict
+
+
+ImageURLChunkImageURLTypedDict = TypeAliasType(
+    "ImageURLChunkImageURLTypedDict", Union[ImageURLTypedDict, str]
+)
+
+
+ImageURLChunkImageURL = TypeAliasType("ImageURLChunkImageURL", Union[ImageURL, str])
+
+
+ImageURLChunkType = Literal["image_url"]
+
+
+class ImageURLChunkTypedDict(TypedDict):
+    r"""{\"type\":\"image_url\",\"image_url\":{\"url\":\"data:image/png;base64,iVBORw0"""
+
+    image_url: ImageURLChunkImageURLTypedDict
+    type: NotRequired[ImageURLChunkType]
+
+
+class ImageURLChunk(BaseModel):
+    r"""{\"type\":\"image_url\",\"image_url\":{\"url\":\"data:image/png;base64,iVBORw0"""
+
+    image_url: ImageURLChunkImageURL
+
+    type: Optional[ImageURLChunkType] = "image_url"

mistralai_gcp/models/jsonschema.py

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

mistralai_gcp/models/prediction.py

@@ -0,0 +1,25 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai_gcp.types import BaseModel
+from mistralai_gcp.utils import validate_const
+import pydantic
+from pydantic.functional_validators import AfterValidator
+from typing import Literal, Optional
+from typing_extensions import Annotated, NotRequired, TypedDict
+
+
+class PredictionTypedDict(TypedDict):
+    type: Literal["content"]
+    content: NotRequired[str]
+
+
+class Prediction(BaseModel):
+    TYPE: Annotated[
+        Annotated[
+            Optional[Literal["content"]], AfterValidator(validate_const("content"))
+        ],
+        pydantic.Field(alias="type"),
+    ] = "content"
+
+    content: Optional[str] = ""

mistralai_gcp/models/responseformat.py

@@ -1,8 +1,16 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
+from .jsonschema import JSONSchema, JSONSchemaTypedDict
 from .responseformats import ResponseFormats
-from mistralai_gcp.types import BaseModel
+from mistralai_gcp.types import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UNSET,
+    UNSET_SENTINEL,
+)
+from pydantic import model_serializer
 from typing import Optional
 from typing_extensions import NotRequired, TypedDict
 
@@ -10,8 +18,41 @@ from typing_extensions import NotRequired, TypedDict
 class ResponseFormatTypedDict(TypedDict):
     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):
     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
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["type", "json_schema"]
+        nullable_fields = ["json_schema"]
+        null_default_fields = []
+
+        serialized = handler(self)
+
+        m = {}
+
+        for n, f in self.model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            serialized.pop(k, None)
+
+            optional_nullable = k in optional_fields and k in nullable_fields
+            is_set = (
+                self.__pydantic_fields_set__.intersection({n})
+                or k in null_default_fields
+            )  # pylint: disable=no-member
+
+            if val is not None and val != UNSET_SENTINEL:
+                m[k] = val
+            elif val != UNSET_SENTINEL and (
+                not k in optional_fields or (optional_nullable and is_set)
+            ):
+                m[k] = val
+
+        return m

mistralai_gcp/models/responseformats.py

@@ -4,5 +4,5 @@ from __future__ import annotations
 from typing import Literal
 
 
-ResponseFormats = Literal["text", "json_object"]
+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."""

mistralai_gcp/models/toolcall.py

@@ -14,6 +14,7 @@ class ToolCallTypedDict(TypedDict):
     function: FunctionCallTypedDict
     id: NotRequired[str]
     type: NotRequired[ToolTypes]
+    index: NotRequired[int]
 
 
 class ToolCall(BaseModel):
@@ -24,3 +25,5 @@ class ToolCall(BaseModel):
     type: Annotated[Optional[ToolTypes], PlainValidator(validate_open_enum(False))] = (
         None
     )
+
+    index: Optional[int] = 0