mistralai 1.7.1__py3-none-any.whl → 1.8.1__py3-none-any.whl

mistralai/models/conversationrequest.py

@@ -0,0 +1,133 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .codeinterpretertool import CodeInterpreterTool, CodeInterpreterToolTypedDict
+from .completionargs import CompletionArgs, CompletionArgsTypedDict
+from .conversationinputs import ConversationInputs, ConversationInputsTypedDict
+from .documentlibrarytool import DocumentLibraryTool, DocumentLibraryToolTypedDict
+from .functiontool import FunctionTool, FunctionToolTypedDict
+from .imagegenerationtool import ImageGenerationTool, ImageGenerationToolTypedDict
+from .websearchpremiumtool import WebSearchPremiumTool, WebSearchPremiumToolTypedDict
+from .websearchtool import WebSearchTool, WebSearchToolTypedDict
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from mistralai.utils import get_discriminator
+from pydantic import Discriminator, Tag, model_serializer
+from typing import List, Literal, Optional, Union
+from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+
+
+HandoffExecution = Literal["client", "server"]
+
+ToolsTypedDict = TypeAliasType(
+    "ToolsTypedDict",
+    Union[
+        WebSearchToolTypedDict,
+        WebSearchPremiumToolTypedDict,
+        CodeInterpreterToolTypedDict,
+        ImageGenerationToolTypedDict,
+        FunctionToolTypedDict,
+        DocumentLibraryToolTypedDict,
+    ],
+)
+
+
+Tools = Annotated[
+    Union[
+        Annotated[CodeInterpreterTool, Tag("code_interpreter")],
+        Annotated[DocumentLibraryTool, Tag("document_library")],
+        Annotated[FunctionTool, Tag("function")],
+        Annotated[ImageGenerationTool, Tag("image_generation")],
+        Annotated[WebSearchTool, Tag("web_search")],
+        Annotated[WebSearchPremiumTool, Tag("web_search_premium")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+
+
+class ConversationRequestTypedDict(TypedDict):
+    inputs: ConversationInputsTypedDict
+    stream: NotRequired[bool]
+    store: NotRequired[Nullable[bool]]
+    handoff_execution: NotRequired[Nullable[HandoffExecution]]
+    instructions: NotRequired[Nullable[str]]
+    tools: NotRequired[Nullable[List[ToolsTypedDict]]]
+    completion_args: NotRequired[Nullable[CompletionArgsTypedDict]]
+    name: NotRequired[Nullable[str]]
+    description: NotRequired[Nullable[str]]
+    agent_id: NotRequired[Nullable[str]]
+    model: NotRequired[Nullable[str]]
+
+
+class ConversationRequest(BaseModel):
+    inputs: ConversationInputs
+
+    stream: Optional[bool] = False
+
+    store: OptionalNullable[bool] = UNSET
+
+    handoff_execution: OptionalNullable[HandoffExecution] = UNSET
+
+    instructions: OptionalNullable[str] = UNSET
+
+    tools: OptionalNullable[List[Tools]] = UNSET
+
+    completion_args: OptionalNullable[CompletionArgs] = UNSET
+
+    name: OptionalNullable[str] = UNSET
+
+    description: OptionalNullable[str] = UNSET
+
+    agent_id: OptionalNullable[str] = UNSET
+
+    model: OptionalNullable[str] = UNSET
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = [
+            "stream",
+            "store",
+            "handoff_execution",
+            "instructions",
+            "tools",
+            "completion_args",
+            "name",
+            "description",
+            "agent_id",
+            "model",
+        ]
+        nullable_fields = [
+            "store",
+            "handoff_execution",
+            "instructions",
+            "tools",
+            "completion_args",
+            "name",
+            "description",
+            "agent_id",
+            "model",
+        ]
+        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/models/conversationresponse.py

@@ -0,0 +1,51 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .agenthandoffentry import AgentHandoffEntry, AgentHandoffEntryTypedDict
+from .conversationusageinfo import ConversationUsageInfo, ConversationUsageInfoTypedDict
+from .functioncallentry import FunctionCallEntry, FunctionCallEntryTypedDict
+from .messageoutputentry import MessageOutputEntry, MessageOutputEntryTypedDict
+from .toolexecutionentry import ToolExecutionEntry, ToolExecutionEntryTypedDict
+from mistralai.types import BaseModel
+from typing import List, Literal, Optional, Union
+from typing_extensions import NotRequired, TypeAliasType, TypedDict
+
+
+ConversationResponseObject = Literal["conversation.response"]
+
+OutputsTypedDict = TypeAliasType(
+    "OutputsTypedDict",
+    Union[
+        ToolExecutionEntryTypedDict,
+        FunctionCallEntryTypedDict,
+        MessageOutputEntryTypedDict,
+        AgentHandoffEntryTypedDict,
+    ],
+)
+
+
+Outputs = TypeAliasType(
+    "Outputs",
+    Union[ToolExecutionEntry, FunctionCallEntry, MessageOutputEntry, AgentHandoffEntry],
+)
+
+
+class ConversationResponseTypedDict(TypedDict):
+    r"""The response after appending new entries to the conversation."""
+
+    conversation_id: str
+    outputs: List[OutputsTypedDict]
+    usage: ConversationUsageInfoTypedDict
+    object: NotRequired[ConversationResponseObject]
+
+
+class ConversationResponse(BaseModel):
+    r"""The response after appending new entries to the conversation."""
+
+    conversation_id: str
+
+    outputs: List[Outputs]
+
+    usage: ConversationUsageInfo
+
+    object: Optional[ConversationResponseObject] = "conversation.response"

mistralai/models/conversationrestartrequest.py

@@ -0,0 +1,42 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .completionargs import CompletionArgs, CompletionArgsTypedDict
+from .conversationinputs import ConversationInputs, ConversationInputsTypedDict
+from mistralai.types import BaseModel
+from typing import Literal, Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+ConversationRestartRequestHandoffExecution = Literal["client", "server"]
+
+
+class ConversationRestartRequestTypedDict(TypedDict):
+    r"""Request to restart a new conversation from a given entry in the conversation."""
+
+    inputs: ConversationInputsTypedDict
+    from_entry_id: str
+    stream: NotRequired[bool]
+    store: NotRequired[bool]
+    r"""Whether to store the results into our servers or not."""
+    handoff_execution: NotRequired[ConversationRestartRequestHandoffExecution]
+    completion_args: NotRequired[CompletionArgsTypedDict]
+    r"""White-listed arguments from the completion API"""
+
+
+class ConversationRestartRequest(BaseModel):
+    r"""Request to restart a new conversation from a given entry in the conversation."""
+
+    inputs: ConversationInputs
+
+    from_entry_id: str
+
+    stream: Optional[bool] = False
+
+    store: Optional[bool] = True
+    r"""Whether to store the results into our servers or not."""
+
+    handoff_execution: Optional[ConversationRestartRequestHandoffExecution] = "server"
+
+    completion_args: Optional[CompletionArgs] = None
+    r"""White-listed arguments from the completion API"""

mistralai/models/conversationrestartstreamrequest.py

@@ -0,0 +1,44 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .completionargs import CompletionArgs, CompletionArgsTypedDict
+from .conversationinputs import ConversationInputs, ConversationInputsTypedDict
+from mistralai.types import BaseModel
+from typing import Literal, Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+ConversationRestartStreamRequestHandoffExecution = Literal["client", "server"]
+
+
+class ConversationRestartStreamRequestTypedDict(TypedDict):
+    r"""Request to restart a new conversation from a given entry in the conversation."""
+
+    inputs: ConversationInputsTypedDict
+    from_entry_id: str
+    stream: NotRequired[bool]
+    store: NotRequired[bool]
+    r"""Whether to store the results into our servers or not."""
+    handoff_execution: NotRequired[ConversationRestartStreamRequestHandoffExecution]
+    completion_args: NotRequired[CompletionArgsTypedDict]
+    r"""White-listed arguments from the completion API"""
+
+
+class ConversationRestartStreamRequest(BaseModel):
+    r"""Request to restart a new conversation from a given entry in the conversation."""
+
+    inputs: ConversationInputs
+
+    from_entry_id: str
+
+    stream: Optional[bool] = True
+
+    store: Optional[bool] = True
+    r"""Whether to store the results into our servers or not."""
+
+    handoff_execution: Optional[ConversationRestartStreamRequestHandoffExecution] = (
+        "server"
+    )
+
+    completion_args: Optional[CompletionArgs] = None
+    r"""White-listed arguments from the completion API"""

mistralai/models/conversationstreamrequest.py

@@ -0,0 +1,135 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .codeinterpretertool import CodeInterpreterTool, CodeInterpreterToolTypedDict
+from .completionargs import CompletionArgs, CompletionArgsTypedDict
+from .conversationinputs import ConversationInputs, ConversationInputsTypedDict
+from .documentlibrarytool import DocumentLibraryTool, DocumentLibraryToolTypedDict
+from .functiontool import FunctionTool, FunctionToolTypedDict
+from .imagegenerationtool import ImageGenerationTool, ImageGenerationToolTypedDict
+from .websearchpremiumtool import WebSearchPremiumTool, WebSearchPremiumToolTypedDict
+from .websearchtool import WebSearchTool, WebSearchToolTypedDict
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from mistralai.utils import get_discriminator
+from pydantic import Discriminator, Tag, model_serializer
+from typing import List, Literal, Optional, Union
+from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+
+
+ConversationStreamRequestHandoffExecution = Literal["client", "server"]
+
+ConversationStreamRequestToolsTypedDict = TypeAliasType(
+    "ConversationStreamRequestToolsTypedDict",
+    Union[
+        WebSearchToolTypedDict,
+        WebSearchPremiumToolTypedDict,
+        CodeInterpreterToolTypedDict,
+        ImageGenerationToolTypedDict,
+        FunctionToolTypedDict,
+        DocumentLibraryToolTypedDict,
+    ],
+)
+
+
+ConversationStreamRequestTools = Annotated[
+    Union[
+        Annotated[CodeInterpreterTool, Tag("code_interpreter")],
+        Annotated[DocumentLibraryTool, Tag("document_library")],
+        Annotated[FunctionTool, Tag("function")],
+        Annotated[ImageGenerationTool, Tag("image_generation")],
+        Annotated[WebSearchTool, Tag("web_search")],
+        Annotated[WebSearchPremiumTool, Tag("web_search_premium")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+
+
+class ConversationStreamRequestTypedDict(TypedDict):
+    inputs: ConversationInputsTypedDict
+    stream: NotRequired[bool]
+    store: NotRequired[Nullable[bool]]
+    handoff_execution: NotRequired[Nullable[ConversationStreamRequestHandoffExecution]]
+    instructions: NotRequired[Nullable[str]]
+    tools: NotRequired[Nullable[List[ConversationStreamRequestToolsTypedDict]]]
+    completion_args: NotRequired[Nullable[CompletionArgsTypedDict]]
+    name: NotRequired[Nullable[str]]
+    description: NotRequired[Nullable[str]]
+    agent_id: NotRequired[Nullable[str]]
+    model: NotRequired[Nullable[str]]
+
+
+class ConversationStreamRequest(BaseModel):
+    inputs: ConversationInputs
+
+    stream: Optional[bool] = True
+
+    store: OptionalNullable[bool] = UNSET
+
+    handoff_execution: OptionalNullable[ConversationStreamRequestHandoffExecution] = (
+        UNSET
+    )
+
+    instructions: OptionalNullable[str] = UNSET
+
+    tools: OptionalNullable[List[ConversationStreamRequestTools]] = UNSET
+
+    completion_args: OptionalNullable[CompletionArgs] = UNSET
+
+    name: OptionalNullable[str] = UNSET
+
+    description: OptionalNullable[str] = UNSET
+
+    agent_id: OptionalNullable[str] = UNSET
+
+    model: OptionalNullable[str] = UNSET
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = [
+            "stream",
+            "store",
+            "handoff_execution",
+            "instructions",
+            "tools",
+            "completion_args",
+            "name",
+            "description",
+            "agent_id",
+            "model",
+        ]
+        nullable_fields = [
+            "store",
+            "handoff_execution",
+            "instructions",
+            "tools",
+            "completion_args",
+            "name",
+            "description",
+            "agent_id",
+            "model",
+        ]
+        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/models/conversationusageinfo.py

@@ -0,0 +1,63 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import Dict, Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class ConversationUsageInfoTypedDict(TypedDict):
+    prompt_tokens: NotRequired[int]
+    completion_tokens: NotRequired[int]
+    total_tokens: NotRequired[int]
+    connector_tokens: NotRequired[Nullable[int]]
+    connectors: NotRequired[Nullable[Dict[str, int]]]
+
+
+class ConversationUsageInfo(BaseModel):
+    prompt_tokens: Optional[int] = 0
+
+    completion_tokens: Optional[int] = 0
+
+    total_tokens: Optional[int] = 0
+
+    connector_tokens: OptionalNullable[int] = UNSET
+
+    connectors: OptionalNullable[Dict[str, int]] = UNSET
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = [
+            "prompt_tokens",
+            "completion_tokens",
+            "total_tokens",
+            "connector_tokens",
+            "connectors",
+        ]
+        nullable_fields = ["connector_tokens", "connectors"]
+        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/models/documentlibrarytool.py

@@ -0,0 +1,22 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai.types import BaseModel
+from typing import List, Literal, Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+DocumentLibraryToolType = Literal["document_library"]
+
+
+class DocumentLibraryToolTypedDict(TypedDict):
+    library_ids: List[str]
+    r"""Ids of the library in which to search."""
+    type: NotRequired[DocumentLibraryToolType]
+
+
+class DocumentLibraryTool(BaseModel):
+    library_ids: List[str]
+    r"""Ids of the library in which to search."""
+
+    type: Optional[DocumentLibraryToolType] = "document_library"

mistralai/models/embeddingdtype.py

@@ -0,0 +1,7 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from typing import Literal
+
+
+EmbeddingDtype = Literal["float", "int8", "uint8", "binary", "ubinary"]

mistralai/models/embeddingrequest.py

@@ -1,10 +1,12 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from mistralai.types import BaseModel
+from .embeddingdtype import EmbeddingDtype
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
 import pydantic
-from typing import List, Union
-from typing_extensions import Annotated, TypeAliasType, TypedDict
+from pydantic import model_serializer
+from typing import List, Optional, Union
+from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
 
 
 EmbeddingRequestInputsTypedDict = TypeAliasType(
@@ -22,6 +24,9 @@ class EmbeddingRequestTypedDict(TypedDict):
     r"""ID of the model to use."""
     inputs: EmbeddingRequestInputsTypedDict
     r"""Text to embed."""
+    output_dimension: NotRequired[Nullable[int]]
+    r"""The dimension of the output embeddings."""
+    output_dtype: NotRequired[EmbeddingDtype]
 
 
 class EmbeddingRequest(BaseModel):
@@ -30,3 +35,38 @@ class EmbeddingRequest(BaseModel):
 
     inputs: Annotated[EmbeddingRequestInputs, pydantic.Field(alias="input")]
     r"""Text to embed."""
+
+    output_dimension: OptionalNullable[int] = UNSET
+    r"""The dimension of the output embeddings."""
+
+    output_dtype: Optional[EmbeddingDtype] = None
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["output_dimension", "output_dtype"]
+        nullable_fields = ["output_dimension"]
+        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/models/fimcompletionresponse.py

@@ -4,8 +4,8 @@ from __future__ import annotations
 from .chatcompletionchoice import ChatCompletionChoice, ChatCompletionChoiceTypedDict
 from .usageinfo import UsageInfo, UsageInfoTypedDict
 from mistralai.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/models/functioncallentry.py

@@ -0,0 +1,76 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .functioncallentryarguments import (
+    FunctionCallEntryArguments,
+    FunctionCallEntryArgumentsTypedDict,
+)
+from datetime import datetime
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import Literal, Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+FunctionCallEntryObject = Literal["entry"]
+
+FunctionCallEntryType = Literal["function.call"]
+
+
+class FunctionCallEntryTypedDict(TypedDict):
+    tool_call_id: str
+    name: str
+    arguments: FunctionCallEntryArgumentsTypedDict
+    object: NotRequired[FunctionCallEntryObject]
+    type: NotRequired[FunctionCallEntryType]
+    created_at: NotRequired[datetime]
+    completed_at: NotRequired[Nullable[datetime]]
+    id: NotRequired[str]
+
+
+class FunctionCallEntry(BaseModel):
+    tool_call_id: str
+
+    name: str
+
+    arguments: FunctionCallEntryArguments
+
+    object: Optional[FunctionCallEntryObject] = "entry"
+
+    type: Optional[FunctionCallEntryType] = "function.call"
+
+    created_at: Optional[datetime] = None
+
+    completed_at: OptionalNullable[datetime] = UNSET
+
+    id: Optional[str] = None
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = ["object", "type", "created_at", "completed_at", "id"]
+        nullable_fields = ["completed_at"]
+        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/models/functioncallentryarguments.py

@@ -0,0 +1,15 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from typing import Any, Dict, Union
+from typing_extensions import TypeAliasType
+
+
+FunctionCallEntryArgumentsTypedDict = TypeAliasType(
+    "FunctionCallEntryArgumentsTypedDict", Union[Dict[str, Any], str]
+)
+
+
+FunctionCallEntryArguments = TypeAliasType(
+    "FunctionCallEntryArguments", Union[Dict[str, Any], str]
+)