mistralai 1.0.0rc1__py3-none-any.whl → 1.0.1__py3-none-any.whl

mistralai_gcp/models/chatcompletionrequest.py

@@ -14,13 +14,27 @@ from typing import List, Literal, Optional, TypedDict, Union
 from typing_extensions import Annotated, NotRequired
 
 
+ChatCompletionRequestStopTypedDict = Union[str, List[str]]
+r"""Stop generation if this token is detected. Or if one of these tokens is detected when providing an array"""
+
+
+ChatCompletionRequestStop = Union[str, List[str]]
+r"""Stop generation if this token is detected. Or if one of these tokens is detected when providing an array"""
+
+
+ChatCompletionRequestMessagesTypedDict = Union[SystemMessageTypedDict, UserMessageTypedDict, AssistantMessageTypedDict, ToolMessageTypedDict]
+
+
+ChatCompletionRequestMessages = Annotated[Union[Annotated[AssistantMessage, Tag("assistant")], Annotated[SystemMessage, Tag("system")], Annotated[ToolMessage, Tag("tool")], Annotated[UserMessage, Tag("user")]], Discriminator(lambda m: get_discriminator(m, "role", "role"))]
+
+
 ChatCompletionRequestToolChoice = Literal["auto", "none", "any"]
 
 class ChatCompletionRequestTypedDict(TypedDict):
+    model: Nullable[str]
+    r"""ID of the model to use. You can use the [List Available Models](/api#operation/listModels) 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."""
-    model: NotRequired[Nullable[str]]
-    r"""ID of the model to use. You can use the [List Available Models](/api#operation/listModels) API to see all of your available models, or see our [Model overview](/models) for model descriptions."""
     temperature: NotRequired[float]
     r"""What sampling temperature to use, between 0.0 and 1.0. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic. We generally recommend altering this or `top_p` but not both."""
     top_p: NotRequired[float]
@@ -41,10 +55,10 @@ class ChatCompletionRequestTypedDict(TypedDict):
     
 
 class ChatCompletionRequest(BaseModel):
+    model: Nullable[str]
+    r"""ID of the model to use. You can use the [List Available Models](/api#operation/listModels) API to see all of your available models, or see our [Model overview](/models) for model descriptions."""
     messages: List[ChatCompletionRequestMessages]
     r"""The prompt(s) to generate completions for, encoded as a list of dict with role and content."""
-    model: OptionalNullable[str] = UNSET
-    r"""ID of the model to use. You can use the [List Available Models](/api#operation/listModels) API to see all of your available models, or see our [Model overview](/models) for model descriptions."""
     temperature: Optional[float] = 0.7
     r"""What sampling temperature to use, between 0.0 and 1.0. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic. We generally recommend altering this or `top_p` but not both."""
     top_p: Optional[float] = 1
@@ -65,7 +79,7 @@ class ChatCompletionRequest(BaseModel):
     
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["model", "temperature", "top_p", "max_tokens", "min_tokens", "stream", "stop", "random_seed", "response_format", "tools", "tool_choice"]
+        optional_fields = ["temperature", "top_p", "max_tokens", "min_tokens", "stream", "stop", "random_seed", "response_format", "tools", "tool_choice"]
         nullable_fields = ["model", "max_tokens", "min_tokens", "random_seed", "tools"]
         null_default_fields = []
 
@@ -77,34 +91,15 @@ class ChatCompletionRequest(BaseModel):
             k = f.alias or n
             val = serialized.get(k)
 
+            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 (
-                    k in optional_fields
-                    and k in nullable_fields
-                    and (
-                        self.__pydantic_fields_set__.intersection({n})
-                        or k in null_default_fields
-                    )  # pylint: disable=no-member
-                )
+                not k in optional_fields or (optional_nullable and is_set)
             ):
                 m[k] = val
 
         return m
         
-
-ChatCompletionRequestStopTypedDict = Union[str, List[str]]
-r"""Stop generation if this token is detected. Or if one of these tokens is detected when providing an array"""
-
-
-ChatCompletionRequestStop = Union[str, List[str]]
-r"""Stop generation if this token is detected. Or if one of these tokens is detected when providing an array"""
-
-
-ChatCompletionRequestMessagesTypedDict = Union[SystemMessageTypedDict, UserMessageTypedDict, AssistantMessageTypedDict, ToolMessageTypedDict]
-
-
-ChatCompletionRequestMessages = Annotated[Union[Annotated[AssistantMessage, Tag("assistant")], Annotated[SystemMessage, Tag("system")], Annotated[ToolMessage, Tag("tool")], Annotated[UserMessage, Tag("user")]], Discriminator(lambda m: get_discriminator(m, "role", "role"))]
-

mistralai_gcp/models/chatcompletionstreamrequest.py

@@ -14,13 +14,27 @@ from typing import List, Literal, Optional, TypedDict, Union
 from typing_extensions import Annotated, NotRequired
 
 
+StopTypedDict = Union[str, List[str]]
+r"""Stop generation if this token is detected. Or if one of these tokens is detected when providing an array"""
+
+
+Stop = Union[str, List[str]]
+r"""Stop generation if this token is detected. Or if one of these tokens is detected when providing an array"""
+
+
+MessagesTypedDict = Union[SystemMessageTypedDict, UserMessageTypedDict, AssistantMessageTypedDict, ToolMessageTypedDict]
+
+
+Messages = Annotated[Union[Annotated[AssistantMessage, Tag("assistant")], Annotated[SystemMessage, Tag("system")], Annotated[ToolMessage, Tag("tool")], Annotated[UserMessage, Tag("user")]], Discriminator(lambda m: get_discriminator(m, "role", "role"))]
+
+
 ToolChoice = Literal["auto", "none", "any"]
 
 class ChatCompletionStreamRequestTypedDict(TypedDict):
+    model: Nullable[str]
+    r"""ID of the model to use. You can use the [List Available Models](/api#operation/listModels) 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."""
-    model: NotRequired[Nullable[str]]
-    r"""ID of the model to use. You can use the [List Available Models](/api#operation/listModels) API to see all of your available models, or see our [Model overview](/models) for model descriptions."""
     temperature: NotRequired[float]
     r"""What sampling temperature to use, between 0.0 and 1.0. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic. We generally recommend altering this or `top_p` but not both."""
     top_p: NotRequired[float]
@@ -40,10 +54,10 @@ class ChatCompletionStreamRequestTypedDict(TypedDict):
     
 
 class ChatCompletionStreamRequest(BaseModel):
+    model: Nullable[str]
+    r"""ID of the model to use. You can use the [List Available Models](/api#operation/listModels) API to see all of your available models, or see our [Model overview](/models) for model descriptions."""
     messages: List[Messages]
     r"""The prompt(s) to generate completions for, encoded as a list of dict with role and content."""
-    model: OptionalNullable[str] = UNSET
-    r"""ID of the model to use. You can use the [List Available Models](/api#operation/listModels) API to see all of your available models, or see our [Model overview](/models) for model descriptions."""
     temperature: Optional[float] = 0.7
     r"""What sampling temperature to use, between 0.0 and 1.0. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic. We generally recommend altering this or `top_p` but not both."""
     top_p: Optional[float] = 1
@@ -63,7 +77,7 @@ class ChatCompletionStreamRequest(BaseModel):
     
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["model", "temperature", "top_p", "max_tokens", "min_tokens", "stream", "stop", "random_seed", "response_format", "tools", "tool_choice"]
+        optional_fields = ["temperature", "top_p", "max_tokens", "min_tokens", "stream", "stop", "random_seed", "response_format", "tools", "tool_choice"]
         nullable_fields = ["model", "max_tokens", "min_tokens", "random_seed", "tools"]
         null_default_fields = []
 
@@ -75,34 +89,15 @@ class ChatCompletionStreamRequest(BaseModel):
             k = f.alias or n
             val = serialized.get(k)
 
+            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 (
-                    k in optional_fields
-                    and k in nullable_fields
-                    and (
-                        self.__pydantic_fields_set__.intersection({n})
-                        or k in null_default_fields
-                    )  # pylint: disable=no-member
-                )
+                not k in optional_fields or (optional_nullable and is_set)
             ):
                 m[k] = val
 
         return m
         
-
-StopTypedDict = Union[str, List[str]]
-r"""Stop generation if this token is detected. Or if one of these tokens is detected when providing an array"""
-
-
-Stop = Union[str, List[str]]
-r"""Stop generation if this token is detected. Or if one of these tokens is detected when providing an array"""
-
-
-MessagesTypedDict = Union[SystemMessageTypedDict, UserMessageTypedDict, AssistantMessageTypedDict, ToolMessageTypedDict]
-
-
-Messages = Annotated[Union[Annotated[AssistantMessage, Tag("assistant")], Annotated[SystemMessage, Tag("system")], Annotated[ToolMessage, Tag("tool")], Annotated[UserMessage, Tag("user")]], Discriminator(lambda m: get_discriminator(m, "role", "role"))]
-

mistralai_gcp/models/completionresponsestreamchoice.py

@@ -34,18 +34,13 @@ class CompletionResponseStreamChoice(BaseModel):
             k = f.alias or n
             val = serialized.get(k)
 
+            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 (
-                    k in optional_fields
-                    and k in nullable_fields
-                    and (
-                        self.__pydantic_fields_set__.intersection({n})
-                        or k in null_default_fields
-                    )  # pylint: disable=no-member
-                )
+                not k in optional_fields or (optional_nullable and is_set)
             ):
                 m[k] = val
 

mistralai_gcp/models/deltamessage.py

@@ -4,20 +4,20 @@ from __future__ import annotations
 from .toolcall import ToolCall, ToolCallTypedDict
 from mistralai_gcp.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
 from pydantic import model_serializer
-from typing import Optional, TypedDict
+from typing import List, Optional, TypedDict
 from typing_extensions import NotRequired
 
 
 class DeltaMessageTypedDict(TypedDict):
     role: NotRequired[str]
     content: NotRequired[str]
-    tool_calls: NotRequired[Nullable[ToolCallTypedDict]]
+    tool_calls: NotRequired[Nullable[List[ToolCallTypedDict]]]
     
 
 class DeltaMessage(BaseModel):
     role: Optional[str] = None
     content: Optional[str] = None
-    tool_calls: OptionalNullable[ToolCall] = UNSET
+    tool_calls: OptionalNullable[List[ToolCall]] = UNSET
     
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
@@ -33,18 +33,13 @@ class DeltaMessage(BaseModel):
             k = f.alias or n
             val = serialized.get(k)
 
+            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 (
-                    k in optional_fields
-                    and k in nullable_fields
-                    and (
-                        self.__pydantic_fields_set__.intersection({n})
-                        or k in null_default_fields
-                    )  # pylint: disable=no-member
-                )
+                not k in optional_fields or (optional_nullable and is_set)
             ):
                 m[k] = val
 

mistralai_gcp/models/fimcompletionrequest.py

@@ -7,14 +7,22 @@ from typing import List, Optional, TypedDict, Union
 from typing_extensions import NotRequired
 
 
+FIMCompletionRequestStopTypedDict = Union[str, List[str]]
+r"""Stop generation if this token is detected. Or if one of these tokens is detected when providing an array"""
+
+
+FIMCompletionRequestStop = Union[str, List[str]]
+r"""Stop generation if this token is detected. Or if one of these tokens is detected when providing an array"""
+
+
 class FIMCompletionRequestTypedDict(TypedDict):
-    prompt: str
-    r"""The text/code to complete."""
-    model: NotRequired[Nullable[str]]
+    model: Nullable[str]
     r"""ID of the model to use. Only compatible for now with:
     - `codestral-2405`
     - `codestral-latest`
     """
+    prompt: str
+    r"""The text/code to complete."""
     temperature: NotRequired[float]
     r"""What sampling temperature to use, between 0.0 and 1.0. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic. We generally recommend altering this or `top_p` but not both."""
     top_p: NotRequired[float]
@@ -34,13 +42,13 @@ class FIMCompletionRequestTypedDict(TypedDict):
     
 
 class FIMCompletionRequest(BaseModel):
-    prompt: str
-    r"""The text/code to complete."""
-    model: OptionalNullable[str] = UNSET
+    model: Nullable[str]
     r"""ID of the model to use. Only compatible for now with:
     - `codestral-2405`
     - `codestral-latest`
     """
+    prompt: str
+    r"""The text/code to complete."""
     temperature: Optional[float] = 0.7
     r"""What sampling temperature to use, between 0.0 and 1.0. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic. We generally recommend altering this or `top_p` but not both."""
     top_p: Optional[float] = 1
@@ -60,7 +68,7 @@ class FIMCompletionRequest(BaseModel):
     
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["model", "temperature", "top_p", "max_tokens", "min_tokens", "stream", "stop", "random_seed", "suffix"]
+        optional_fields = ["temperature", "top_p", "max_tokens", "min_tokens", "stream", "stop", "random_seed", "suffix"]
         nullable_fields = ["model", "max_tokens", "min_tokens", "random_seed", "suffix"]
         null_default_fields = []
 
@@ -72,28 +80,15 @@ class FIMCompletionRequest(BaseModel):
             k = f.alias or n
             val = serialized.get(k)
 
+            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 (
-                    k in optional_fields
-                    and k in nullable_fields
-                    and (
-                        self.__pydantic_fields_set__.intersection({n})
-                        or k in null_default_fields
-                    )  # pylint: disable=no-member
-                )
+                not k in optional_fields or (optional_nullable and is_set)
             ):
                 m[k] = val
 
         return m
         
-
-FIMCompletionRequestStopTypedDict = Union[str, List[str]]
-r"""Stop generation if this token is detected. Or if one of these tokens is detected when providing an array"""
-
-
-FIMCompletionRequestStop = Union[str, List[str]]
-r"""Stop generation if this token is detected. Or if one of these tokens is detected when providing an array"""
-

mistralai_gcp/models/fimcompletionstreamrequest.py

@@ -7,14 +7,22 @@ from typing import List, Optional, TypedDict, Union
 from typing_extensions import NotRequired
 
 
+FIMCompletionStreamRequestStopTypedDict = Union[str, List[str]]
+r"""Stop generation if this token is detected. Or if one of these tokens is detected when providing an array"""
+
+
+FIMCompletionStreamRequestStop = Union[str, List[str]]
+r"""Stop generation if this token is detected. Or if one of these tokens is detected when providing an array"""
+
+
 class FIMCompletionStreamRequestTypedDict(TypedDict):
-    prompt: str
-    r"""The text/code to complete."""
-    model: NotRequired[Nullable[str]]
+    model: Nullable[str]
     r"""ID of the model to use. Only compatible for now with:
     - `codestral-2405`
     - `codestral-latest`
     """
+    prompt: str
+    r"""The text/code to complete."""
     temperature: NotRequired[float]
     r"""What sampling temperature to use, between 0.0 and 1.0. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic. We generally recommend altering this or `top_p` but not both."""
     top_p: NotRequired[float]
@@ -33,13 +41,13 @@ class FIMCompletionStreamRequestTypedDict(TypedDict):
     
 
 class FIMCompletionStreamRequest(BaseModel):
-    prompt: str
-    r"""The text/code to complete."""
-    model: OptionalNullable[str] = UNSET
+    model: Nullable[str]
     r"""ID of the model to use. Only compatible for now with:
     - `codestral-2405`
     - `codestral-latest`
     """
+    prompt: str
+    r"""The text/code to complete."""
     temperature: Optional[float] = 0.7
     r"""What sampling temperature to use, between 0.0 and 1.0. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic. We generally recommend altering this or `top_p` but not both."""
     top_p: Optional[float] = 1
@@ -58,7 +66,7 @@ class FIMCompletionStreamRequest(BaseModel):
     
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["model", "temperature", "top_p", "max_tokens", "min_tokens", "stream", "stop", "random_seed", "suffix"]
+        optional_fields = ["temperature", "top_p", "max_tokens", "min_tokens", "stream", "stop", "random_seed", "suffix"]
         nullable_fields = ["model", "max_tokens", "min_tokens", "random_seed", "suffix"]
         null_default_fields = []
 
@@ -70,28 +78,15 @@ class FIMCompletionStreamRequest(BaseModel):
             k = f.alias or n
             val = serialized.get(k)
 
+            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 (
-                    k in optional_fields
-                    and k in nullable_fields
-                    and (
-                        self.__pydantic_fields_set__.intersection({n})
-                        or k in null_default_fields
-                    )  # pylint: disable=no-member
-                )
+                not k in optional_fields or (optional_nullable and is_set)
             ):
                 m[k] = val
 
         return m
         
-
-FIMCompletionStreamRequestStopTypedDict = Union[str, List[str]]
-r"""Stop generation if this token is detected. Or if one of these tokens is detected when providing an array"""
-
-
-FIMCompletionStreamRequestStop = Union[str, List[str]]
-r"""Stop generation if this token is detected. Or if one of these tokens is detected when providing an array"""
-

mistralai_gcp/models/functioncall.py

@@ -2,15 +2,21 @@
 
 from __future__ import annotations
 from mistralai_gcp.types import BaseModel
-from typing import TypedDict
+from typing import Any, Dict, TypedDict, Union
+
+
+ArgumentsTypedDict = Union[Dict[str, Any], str]
+
+
+Arguments = Union[Dict[str, Any], str]
 
 
 class FunctionCallTypedDict(TypedDict):
     name: str
-    arguments: str
+    arguments: ArgumentsTypedDict
     
 
 class FunctionCall(BaseModel):
     name: str
-    arguments: str
+    arguments: Arguments
     

mistralai_gcp/models/httpvalidationerror.py

@@ -2,8 +2,8 @@
 
 from __future__ import annotations
 from .validationerror import ValidationError
+from mistralai_gcp import utils
 from mistralai_gcp.types import BaseModel
-import mistralai_gcp.utils as utils
 from typing import List, Optional
 
 class HTTPValidationErrorData(BaseModel):

mistralai_gcp/models/systemmessage.py

@@ -7,6 +7,12 @@ from typing import List, Literal, Optional, TypedDict, Union
 from typing_extensions import NotRequired
 
 
+ContentTypedDict = Union[str, List[ContentChunkTypedDict]]
+
+
+Content = Union[str, List[ContentChunk]]
+
+
 Role = Literal["system"]
 
 class SystemMessageTypedDict(TypedDict):
@@ -18,9 +24,3 @@ class SystemMessage(BaseModel):
     content: Content
     role: Optional[Role] = "system"
     
-
-ContentTypedDict = Union[str, List[ContentChunkTypedDict]]
-
-
-Content = Union[str, List[ContentChunk]]
-

mistralai_gcp/models/toolmessage.py

@@ -36,18 +36,13 @@ class ToolMessage(BaseModel):
             k = f.alias or n
             val = serialized.get(k)
 
+            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 (
-                    k in optional_fields
-                    and k in nullable_fields
-                    and (
-                        self.__pydantic_fields_set__.intersection({n})
-                        or k in null_default_fields
-                    )  # pylint: disable=no-member
-                )
+                not k in optional_fields or (optional_nullable and is_set)
             ):
                 m[k] = val
 

mistralai_gcp/models/usermessage.py

@@ -7,6 +7,12 @@ from typing import List, Literal, Optional, TypedDict, Union
 from typing_extensions import NotRequired
 
 
+UserMessageContentTypedDict = Union[str, List[TextChunkTypedDict]]
+
+
+UserMessageContent = Union[str, List[TextChunk]]
+
+
 UserMessageRole = Literal["user"]
 
 class UserMessageTypedDict(TypedDict):
@@ -18,9 +24,3 @@ class UserMessage(BaseModel):
     content: UserMessageContent
     role: Optional[UserMessageRole] = "user"
     
-
-UserMessageContentTypedDict = Union[str, List[TextChunkTypedDict]]
-
-
-UserMessageContent = Union[str, List[TextChunk]]
-

mistralai_gcp/models/validationerror.py

@@ -5,6 +5,12 @@ from mistralai_gcp.types import BaseModel
 from typing import List, TypedDict, Union
 
 
+LocTypedDict = Union[str, int]
+
+
+Loc = Union[str, int]
+
+
 class ValidationErrorTypedDict(TypedDict):
     loc: List[LocTypedDict]
     msg: str
@@ -16,9 +22,3 @@ class ValidationError(BaseModel):
     msg: str
     type: str
     
-
-LocTypedDict = Union[str, int]
-
-
-Loc = Union[str, int]
-

mistralai_gcp/sdk.py

@@ -11,11 +11,13 @@ import httpx
 from mistralai_gcp import models
 from mistralai_gcp._hooks import BeforeRequestHook, SDKHooks
 from mistralai_gcp.chat import Chat
+from mistralai_gcp.fim import Fim
 from mistralai_gcp.types import Nullable
 
 from .basesdk import BaseSDK
 from .httpclient import AsyncHttpClient, HttpClient
 from .sdkconfiguration import SDKConfiguration
+from .utils.logger import Logger, NoOpLogger
 from .utils.retries import RetryConfig
 
 
@@ -23,6 +25,7 @@ class MistralGoogleCloud(BaseSDK):
     r"""Mistral AI API: Our Chat Completion and Embeddings APIs specification. Create your account on [La Plateforme](https://console.mistral.ai) to get access and read the [docs](https://docs.mistral.ai) to learn how to use it."""
 
     chat: Chat
+    fim: Fim
     r"""Chat Completion API"""
 
     def __init__(
@@ -32,6 +35,7 @@ class MistralGoogleCloud(BaseSDK):
         client: Optional[HttpClient] = None,
         async_client: Optional[AsyncHttpClient] = None,
         retry_config: Optional[Nullable[RetryConfig]] = None,
+        debug_logger: Optional[Logger] = None,
     ) -> None:
         r"""Instantiates the SDK configuring it with the provided parameters.
 
@@ -73,6 +77,9 @@ class MistralGoogleCloud(BaseSDK):
         if async_client is None:
             async_client = httpx.AsyncClient()
 
+        if debug_logger is None:
+            debug_logger = NoOpLogger()
+
         assert issubclass(
             type(async_client), AsyncHttpClient
         ), "The provided async_client must implement the AsyncHttpClient protocol."
@@ -94,6 +101,7 @@ class MistralGoogleCloud(BaseSDK):
                 server_url=f"https://{region}-aiplatform.googleapis.com",
                 server=None,
                 retry_config=retry_config,
+                debug_logger=debug_logger,
             ),
         )
 
@@ -116,6 +124,7 @@ class MistralGoogleCloud(BaseSDK):
 
     def _init_sdks(self):
         self.chat = Chat(self.sdk_configuration)
+        self.fim = Fim(self.sdk_configuration)
 
 
 class GoogleCloudBeforeRequestHook(BeforeRequestHook):

mistralai_gcp/sdkconfiguration.py

@@ -3,7 +3,7 @@
 
 from ._hooks import SDKHooks
 from .httpclient import AsyncHttpClient, HttpClient
-from .utils import RetryConfig, remove_suffix
+from .utils import Logger, RetryConfig, remove_suffix
 from dataclasses import dataclass
 from mistralai_gcp import models
 from mistralai_gcp.types import OptionalNullable, UNSET
@@ -23,14 +23,15 @@ SERVERS = {
 class SDKConfiguration:
     client: HttpClient
     async_client: AsyncHttpClient
+    debug_logger: Logger
     security: Optional[Union[models.Security,Callable[[], models.Security]]] = None
     server_url: Optional[str] = ""
     server: Optional[str] = ""
     language: str = "python"
     openapi_doc_version: str = "0.0.2"
-    sdk_version: str = "1.0.0rc1"
-    gen_version: str = "2.382.2"
-    user_agent: str = "speakeasy-sdk/python 1.0.0rc1 2.382.2 0.0.2 mistralai-gcp"
+    sdk_version: str = "1.0.0-rc.4"
+    gen_version: str = "2.390.6"
+    user_agent: str = "speakeasy-sdk/python 1.0.0-rc.4 2.390.6 0.0.2 mistralai-gcp"
     retry_config: OptionalNullable[RetryConfig] = Field(default_factory=lambda: UNSET)
     timeout_ms: Optional[int] = None
 

mistralai_gcp/types/basemodel.py

@@ -2,8 +2,8 @@
 
 from pydantic import ConfigDict, model_serializer
 from pydantic import BaseModel as PydanticBaseModel
-from typing import Literal, Optional, TypeVar, Union, NewType
-from typing_extensions import TypeAliasType
+from typing import TYPE_CHECKING, Literal, Optional, TypeVar, Union, NewType
+from typing_extensions import TypeAliasType, TypeAlias
 
 
 class BaseModel(PydanticBaseModel):
@@ -26,10 +26,14 @@ UNSET_SENTINEL = "~?~unset~?~sentinel~?~"
 
 
 T = TypeVar("T")
-Nullable = TypeAliasType("Nullable", Union[T, None], type_params=(T,))
-OptionalNullable = TypeAliasType(
-    "OptionalNullable", Union[Optional[Nullable[T]], Unset], type_params=(T,)
-)
+if TYPE_CHECKING:
+    Nullable: TypeAlias = Union[T, None]
+    OptionalNullable: TypeAlias = Union[Optional[Nullable[T]], Unset]
+else:
+    Nullable = TypeAliasType("Nullable", Union[T, None], type_params=(T,))
+    OptionalNullable = TypeAliasType(
+        "OptionalNullable", Union[Optional[Nullable[T]], Unset], type_params=(T,)
+    )
 
 UnrecognizedInt = NewType("UnrecognizedInt", int)
 UnrecognizedStr = NewType("UnrecognizedStr", str)