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

mistralai/models/agents_api_v1_conversations_listop.py

@@ -0,0 +1,37 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .agentconversation import AgentConversation, AgentConversationTypedDict
+from .modelconversation import ModelConversation, ModelConversationTypedDict
+from mistralai.types import BaseModel
+from mistralai.utils import FieldMetadata, QueryParamMetadata
+from typing import Optional, Union
+from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+
+
+class AgentsAPIV1ConversationsListRequestTypedDict(TypedDict):
+    page: NotRequired[int]
+    page_size: NotRequired[int]
+
+
+class AgentsAPIV1ConversationsListRequest(BaseModel):
+    page: Annotated[
+        Optional[int],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = 0
+
+    page_size: Annotated[
+        Optional[int],
+        FieldMetadata(query=QueryParamMetadata(style="form", explode=True)),
+    ] = 100
+
+
+ResponseBodyTypedDict = TypeAliasType(
+    "ResponseBodyTypedDict",
+    Union[AgentConversationTypedDict, ModelConversationTypedDict],
+)
+
+
+ResponseBody = TypeAliasType(
+    "ResponseBody", Union[AgentConversation, ModelConversation]
+)

mistralai/models/agents_api_v1_conversations_messagesop.py

@@ -0,0 +1,16 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai.types import BaseModel
+from mistralai.utils import FieldMetadata, PathParamMetadata
+from typing_extensions import Annotated, TypedDict
+
+
+class AgentsAPIV1ConversationsMessagesRequestTypedDict(TypedDict):
+    conversation_id: str
+
+
+class AgentsAPIV1ConversationsMessagesRequest(BaseModel):
+    conversation_id: Annotated[
+        str, FieldMetadata(path=PathParamMetadata(style="simple", explode=False))
+    ]

mistralai/models/agents_api_v1_conversations_restart_streamop.py

@@ -0,0 +1,26 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .conversationrestartstreamrequest import (
+    ConversationRestartStreamRequest,
+    ConversationRestartStreamRequestTypedDict,
+)
+from mistralai.types import BaseModel
+from mistralai.utils import FieldMetadata, PathParamMetadata, RequestMetadata
+from typing_extensions import Annotated, TypedDict
+
+
+class AgentsAPIV1ConversationsRestartStreamRequestTypedDict(TypedDict):
+    conversation_id: str
+    conversation_restart_stream_request: ConversationRestartStreamRequestTypedDict
+
+
+class AgentsAPIV1ConversationsRestartStreamRequest(BaseModel):
+    conversation_id: Annotated[
+        str, FieldMetadata(path=PathParamMetadata(style="simple", explode=False))
+    ]
+
+    conversation_restart_stream_request: Annotated[
+        ConversationRestartStreamRequest,
+        FieldMetadata(request=RequestMetadata(media_type="application/json")),
+    ]

mistralai/models/agents_api_v1_conversations_restartop.py

@@ -0,0 +1,26 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .conversationrestartrequest import (
+    ConversationRestartRequest,
+    ConversationRestartRequestTypedDict,
+)
+from mistralai.types import BaseModel
+from mistralai.utils import FieldMetadata, PathParamMetadata, RequestMetadata
+from typing_extensions import Annotated, TypedDict
+
+
+class AgentsAPIV1ConversationsRestartRequestTypedDict(TypedDict):
+    conversation_id: str
+    conversation_restart_request: ConversationRestartRequestTypedDict
+
+
+class AgentsAPIV1ConversationsRestartRequest(BaseModel):
+    conversation_id: Annotated[
+        str, FieldMetadata(path=PathParamMetadata(style="simple", explode=False))
+    ]
+
+    conversation_restart_request: Annotated[
+        ConversationRestartRequest,
+        FieldMetadata(request=RequestMetadata(media_type="application/json")),
+    ]

mistralai/models/agentupdaterequest.py

@@ -0,0 +1,111 @@
+"""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 .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, Optional, Union
+from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+
+
+AgentUpdateRequestToolsTypedDict = TypeAliasType(
+    "AgentUpdateRequestToolsTypedDict",
+    Union[
+        WebSearchToolTypedDict,
+        WebSearchPremiumToolTypedDict,
+        CodeInterpreterToolTypedDict,
+        ImageGenerationToolTypedDict,
+        FunctionToolTypedDict,
+        DocumentLibraryToolTypedDict,
+    ],
+)
+
+
+AgentUpdateRequestTools = 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 AgentUpdateRequestTypedDict(TypedDict):
+    instructions: NotRequired[Nullable[str]]
+    r"""Instruction prompt the model will follow during the conversation."""
+    tools: NotRequired[List[AgentUpdateRequestToolsTypedDict]]
+    r"""List of tools which are available to the model during the conversation."""
+    completion_args: NotRequired[CompletionArgsTypedDict]
+    r"""White-listed arguments from the completion API"""
+    model: NotRequired[Nullable[str]]
+    name: NotRequired[Nullable[str]]
+    description: NotRequired[Nullable[str]]
+    handoffs: NotRequired[Nullable[List[str]]]
+
+
+class AgentUpdateRequest(BaseModel):
+    instructions: OptionalNullable[str] = UNSET
+    r"""Instruction prompt the model will follow during the conversation."""
+
+    tools: Optional[List[AgentUpdateRequestTools]] = None
+    r"""List of tools which are available to the model during the conversation."""
+
+    completion_args: Optional[CompletionArgs] = None
+    r"""White-listed arguments from the completion API"""
+
+    model: OptionalNullable[str] = UNSET
+
+    name: OptionalNullable[str] = UNSET
+
+    description: OptionalNullable[str] = UNSET
+
+    handoffs: OptionalNullable[List[str]] = UNSET
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = [
+            "instructions",
+            "tools",
+            "completion_args",
+            "model",
+            "name",
+            "description",
+            "handoffs",
+        ]
+        nullable_fields = ["instructions", "model", "name", "description", "handoffs"]
+        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/builtinconnectors.py

@@ -0,0 +1,13 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from typing import Literal
+
+
+BuiltInConnectors = Literal[
+    "web_search",
+    "web_search_premium",
+    "code_interpreter",
+    "image_generation",
+    "document_library",
+]

mistralai/models/codeinterpretertool.py

@@ -0,0 +1,17 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from mistralai.types import BaseModel
+from typing import Literal, Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+CodeInterpreterToolType = Literal["code_interpreter"]
+
+
+class CodeInterpreterToolTypedDict(TypedDict):
+    type: NotRequired[CodeInterpreterToolType]
+
+
+class CodeInterpreterTool(BaseModel):
+    type: Optional[CodeInterpreterToolType] = "code_interpreter"

mistralai/models/completionargs.py

@@ -0,0 +1,100 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .completionargsstop import CompletionArgsStop, CompletionArgsStopTypedDict
+from .prediction import Prediction, PredictionTypedDict
+from .responseformat import ResponseFormat, ResponseFormatTypedDict
+from .toolchoiceenum import ToolChoiceEnum
+from mistralai.types import BaseModel, Nullable, OptionalNullable, UNSET, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class CompletionArgsTypedDict(TypedDict):
+    r"""White-listed arguments from the completion API"""
+
+    stop: NotRequired[Nullable[CompletionArgsStopTypedDict]]
+    presence_penalty: NotRequired[Nullable[float]]
+    frequency_penalty: NotRequired[Nullable[float]]
+    temperature: NotRequired[float]
+    top_p: NotRequired[Nullable[float]]
+    max_tokens: NotRequired[Nullable[int]]
+    random_seed: NotRequired[Nullable[int]]
+    prediction: NotRequired[Nullable[PredictionTypedDict]]
+    response_format: NotRequired[Nullable[ResponseFormatTypedDict]]
+    tool_choice: NotRequired[ToolChoiceEnum]
+
+
+class CompletionArgs(BaseModel):
+    r"""White-listed arguments from the completion API"""
+
+    stop: OptionalNullable[CompletionArgsStop] = UNSET
+
+    presence_penalty: OptionalNullable[float] = UNSET
+
+    frequency_penalty: OptionalNullable[float] = UNSET
+
+    temperature: Optional[float] = 0.3
+
+    top_p: OptionalNullable[float] = UNSET
+
+    max_tokens: OptionalNullable[int] = UNSET
+
+    random_seed: OptionalNullable[int] = UNSET
+
+    prediction: OptionalNullable[Prediction] = UNSET
+
+    response_format: OptionalNullable[ResponseFormat] = UNSET
+
+    tool_choice: Optional[ToolChoiceEnum] = None
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = [
+            "stop",
+            "presence_penalty",
+            "frequency_penalty",
+            "temperature",
+            "top_p",
+            "max_tokens",
+            "random_seed",
+            "prediction",
+            "response_format",
+            "tool_choice",
+        ]
+        nullable_fields = [
+            "stop",
+            "presence_penalty",
+            "frequency_penalty",
+            "top_p",
+            "max_tokens",
+            "random_seed",
+            "prediction",
+            "response_format",
+        ]
+        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/completionargsstop.py

@@ -0,0 +1,13 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from typing import List, Union
+from typing_extensions import TypeAliasType
+
+
+CompletionArgsStopTypedDict = TypeAliasType(
+    "CompletionArgsStopTypedDict", Union[str, List[str]]
+)
+
+
+CompletionArgsStop = TypeAliasType("CompletionArgsStop", Union[str, List[str]])

mistralai/models/completionjobout.py

@@ -28,7 +28,7 @@ Status = Literal[
 ]
 r"""The current status of the fine-tuning job."""
 
-Object = Literal["job"]
+CompletionJobOutObject = Literal["job"]
 r"""The object type of the fine-tuning job."""
 
 IntegrationsTypedDict = WandbIntegrationOutTypedDict
@@ -63,7 +63,7 @@ class CompletionJobOutTypedDict(TypedDict):
     hyperparameters: CompletionTrainingParametersTypedDict
     validation_files: NotRequired[Nullable[List[str]]]
     r"""A list containing the IDs of uploaded files that contain validation data."""
-    object: NotRequired[Object]
+    object: NotRequired[CompletionJobOutObject]
     r"""The object type of the fine-tuning job."""
     fine_tuned_model: NotRequired[Nullable[str]]
     r"""The name of the fine-tuned model that is being created. The value will be `null` if the fine-tuning job is still running."""
@@ -105,7 +105,7 @@ class CompletionJobOut(BaseModel):
     validation_files: OptionalNullable[List[str]] = UNSET
     r"""A list containing the IDs of uploaded files that contain validation data."""
 
-    object: Optional[Object] = "job"
+    object: Optional[CompletionJobOutObject] = "job"
     r"""The object type of the fine-tuning job."""
 
     fine_tuned_model: OptionalNullable[str] = UNSET

mistralai/models/conversationappendrequest.py

@@ -0,0 +1,35 @@
+"""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
+
+
+ConversationAppendRequestHandoffExecution = Literal["client", "server"]
+
+
+class ConversationAppendRequestTypedDict(TypedDict):
+    inputs: ConversationInputsTypedDict
+    stream: NotRequired[bool]
+    store: NotRequired[bool]
+    r"""Whether to store the results into our servers or not."""
+    handoff_execution: NotRequired[ConversationAppendRequestHandoffExecution]
+    completion_args: NotRequired[CompletionArgsTypedDict]
+    r"""White-listed arguments from the completion API"""
+
+
+class ConversationAppendRequest(BaseModel):
+    inputs: ConversationInputs
+
+    stream: Optional[bool] = False
+
+    store: Optional[bool] = True
+    r"""Whether to store the results into our servers or not."""
+
+    handoff_execution: Optional[ConversationAppendRequestHandoffExecution] = "server"
+
+    completion_args: Optional[CompletionArgs] = None
+    r"""White-listed arguments from the completion API"""

mistralai/models/conversationappendstreamrequest.py

@@ -0,0 +1,37 @@
+"""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
+
+
+ConversationAppendStreamRequestHandoffExecution = Literal["client", "server"]
+
+
+class ConversationAppendStreamRequestTypedDict(TypedDict):
+    inputs: ConversationInputsTypedDict
+    stream: NotRequired[bool]
+    store: NotRequired[bool]
+    r"""Whether to store the results into our servers or not."""
+    handoff_execution: NotRequired[ConversationAppendStreamRequestHandoffExecution]
+    completion_args: NotRequired[CompletionArgsTypedDict]
+    r"""White-listed arguments from the completion API"""
+
+
+class ConversationAppendStreamRequest(BaseModel):
+    inputs: ConversationInputs
+
+    stream: Optional[bool] = True
+
+    store: Optional[bool] = True
+    r"""Whether to store the results into our servers or not."""
+
+    handoff_execution: Optional[ConversationAppendStreamRequestHandoffExecution] = (
+        "server"
+    )
+
+    completion_args: Optional[CompletionArgs] = None
+    r"""White-listed arguments from the completion API"""

mistralai/models/conversationevents.py

@@ -0,0 +1,72 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .agenthandoffdoneevent import AgentHandoffDoneEvent, AgentHandoffDoneEventTypedDict
+from .agenthandoffstartedevent import (
+    AgentHandoffStartedEvent,
+    AgentHandoffStartedEventTypedDict,
+)
+from .functioncallevent import FunctionCallEvent, FunctionCallEventTypedDict
+from .messageoutputevent import MessageOutputEvent, MessageOutputEventTypedDict
+from .responsedoneevent import ResponseDoneEvent, ResponseDoneEventTypedDict
+from .responseerrorevent import ResponseErrorEvent, ResponseErrorEventTypedDict
+from .responsestartedevent import ResponseStartedEvent, ResponseStartedEventTypedDict
+from .ssetypes import SSETypes
+from .toolexecutiondoneevent import (
+    ToolExecutionDoneEvent,
+    ToolExecutionDoneEventTypedDict,
+)
+from .toolexecutionstartedevent import (
+    ToolExecutionStartedEvent,
+    ToolExecutionStartedEventTypedDict,
+)
+from mistralai.types import BaseModel
+from mistralai.utils import get_discriminator
+from pydantic import Discriminator, Tag
+from typing import Union
+from typing_extensions import Annotated, TypeAliasType, TypedDict
+
+
+ConversationEventsDataTypedDict = TypeAliasType(
+    "ConversationEventsDataTypedDict",
+    Union[
+        ResponseStartedEventTypedDict,
+        ResponseDoneEventTypedDict,
+        ResponseErrorEventTypedDict,
+        ToolExecutionStartedEventTypedDict,
+        ToolExecutionDoneEventTypedDict,
+        AgentHandoffStartedEventTypedDict,
+        AgentHandoffDoneEventTypedDict,
+        FunctionCallEventTypedDict,
+        MessageOutputEventTypedDict,
+    ],
+)
+
+
+ConversationEventsData = Annotated[
+    Union[
+        Annotated[AgentHandoffDoneEvent, Tag("agent.handoff.done")],
+        Annotated[AgentHandoffStartedEvent, Tag("agent.handoff.started")],
+        Annotated[ResponseDoneEvent, Tag("conversation.response.done")],
+        Annotated[ResponseErrorEvent, Tag("conversation.response.error")],
+        Annotated[ResponseStartedEvent, Tag("conversation.response.started")],
+        Annotated[FunctionCallEvent, Tag("function.call.delta")],
+        Annotated[MessageOutputEvent, Tag("message.output.delta")],
+        Annotated[ToolExecutionDoneEvent, Tag("tool.execution.done")],
+        Annotated[ToolExecutionStartedEvent, Tag("tool.execution.started")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+
+
+class ConversationEventsTypedDict(TypedDict):
+    event: SSETypes
+    r"""Server side events sent when streaming a conversation response."""
+    data: ConversationEventsDataTypedDict
+
+
+class ConversationEvents(BaseModel):
+    event: SSETypes
+    r"""Server side events sent when streaming a conversation response."""
+
+    data: ConversationEventsData

mistralai/models/conversationhistory.py

@@ -0,0 +1,58 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .agenthandoffentry import AgentHandoffEntry, AgentHandoffEntryTypedDict
+from .functioncallentry import FunctionCallEntry, FunctionCallEntryTypedDict
+from .functionresultentry import FunctionResultEntry, FunctionResultEntryTypedDict
+from .messageinputentry import MessageInputEntry, MessageInputEntryTypedDict
+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
+
+
+ConversationHistoryObject = Literal["conversation.history"]
+
+EntriesTypedDict = TypeAliasType(
+    "EntriesTypedDict",
+    Union[
+        MessageInputEntryTypedDict,
+        FunctionResultEntryTypedDict,
+        ToolExecutionEntryTypedDict,
+        FunctionCallEntryTypedDict,
+        MessageOutputEntryTypedDict,
+        AgentHandoffEntryTypedDict,
+    ],
+)
+
+
+Entries = TypeAliasType(
+    "Entries",
+    Union[
+        MessageInputEntry,
+        FunctionResultEntry,
+        ToolExecutionEntry,
+        FunctionCallEntry,
+        MessageOutputEntry,
+        AgentHandoffEntry,
+    ],
+)
+
+
+class ConversationHistoryTypedDict(TypedDict):
+    r"""Retrieve all entries in a conversation."""
+
+    conversation_id: str
+    entries: List[EntriesTypedDict]
+    object: NotRequired[ConversationHistoryObject]
+
+
+class ConversationHistory(BaseModel):
+    r"""Retrieve all entries in a conversation."""
+
+    conversation_id: str
+
+    entries: List[Entries]
+
+    object: Optional[ConversationHistoryObject] = "conversation.history"

mistralai/models/conversationinputs.py

@@ -0,0 +1,14 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .inputentries import InputEntries, InputEntriesTypedDict
+from typing import List, Union
+from typing_extensions import TypeAliasType
+
+
+ConversationInputsTypedDict = TypeAliasType(
+    "ConversationInputsTypedDict", Union[str, List[InputEntriesTypedDict]]
+)
+
+
+ConversationInputs = TypeAliasType("ConversationInputs", Union[str, List[InputEntries]])

mistralai/models/conversationmessages.py

@@ -0,0 +1,28 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from .messageentries import MessageEntries, MessageEntriesTypedDict
+from mistralai.types import BaseModel
+from typing import List, Literal, Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+ConversationMessagesObject = Literal["conversation.messages"]
+
+
+class ConversationMessagesTypedDict(TypedDict):
+    r"""Similar to the conversation history but only keep the messages"""
+
+    conversation_id: str
+    messages: List[MessageEntriesTypedDict]
+    object: NotRequired[ConversationMessagesObject]
+
+
+class ConversationMessages(BaseModel):
+    r"""Similar to the conversation history but only keep the messages"""
+
+    conversation_id: str
+
+    messages: List[MessageEntries]
+
+    object: Optional[ConversationMessagesObject] = "conversation.messages"