gllm-inference-binary 0.5.65__cp313-cp313-macosx_13_0_arm64.whl

gllm_inference/request_processor/uses_lm_mixin.pyi

@@ -0,0 +1,130 @@
+from gllm_inference.builder.build_lm_invoker import build_lm_invoker as build_lm_invoker
+from gllm_inference.lm_invoker.lm_invoker import BaseLMInvoker as BaseLMInvoker
+from gllm_inference.output_parser.output_parser import BaseOutputParser as BaseOutputParser
+from gllm_inference.prompt_builder.prompt_builder import PromptBuilder as PromptBuilder
+from gllm_inference.request_processor.lm_request_processor import LMRequestProcessor as LMRequestProcessor
+from gllm_inference.schema import LMOutput as LMOutput
+from pydantic import BaseModel as BaseModel
+from typing import Any
+
+class UsesLM:
+    '''A mixin to be extended by components that use LMRequestProcessor.
+
+    This mixin should be extended by components that use LMRequestProcessor. Components that extend this mixin
+    must have a constructor that accepts the LMRequestProcessor instance as its first argument.
+
+    LM based components can be categorized into two types:
+    1. Components that do not utilize structured output.
+    2. Components that utilize structured output.
+
+    Building a component without structured output:
+        As defined above, the component must accepts an LMRequestProcessor instance as its first argument, e.g.:
+        ```python
+        class LMBasedComponent(Component, UsesLM):
+            def __init__(self, lm_request_processor: LMRequestProcessor, custom_kwarg: str):
+                self.lm_request_processor = lm_request_processor
+                self.custom_kwarg = custom_kwarg
+        ```
+
+        Using the `from_lm_components` method provided by this mixin, the component can be instantiated as follows:
+        ```python
+        component = LMBasedComponent.from_lm_components(
+            prompt_builder,
+            lm_invoker,
+            output_parser,
+            custom_kwarg="custom_value",
+        )
+        ```
+
+    Building a component with structured output:
+        When the component utilizes structured output, the `_parse_structured_output` method can be used
+        to simplify the process of extracting the structured output in the component\'s runtime methods, e.g.:
+        ```python
+        class LMBasedComponent(Component, UsesLM):
+            def __init__(self, lm_request_processor: LMRequestProcessor, custom_kwarg: str):
+                self.lm_request_processor = lm_request_processor
+                self.custom_kwarg = custom_kwarg
+
+            def runtime_method(self, param1: str, param2: str) -> str:
+                lm_output = self.lm_request_processor.process(param1=param1, param2=param2)
+                return self._parse_structured_output(lm_output, "target_key", "fallback_output")
+        ```
+
+        Notice that in the above example, the LMRequestProcessor is configured to take `param1` and `param2`
+        as keyword arguments and output a structured output that contains the `target_key` key. Hence,
+        these conditions must be fulfilled when instantiating the component.
+
+        This mixin also provides the `with_structured_output` method to simplify the process of instantiating
+        the component with structured output. Let\'s take a look at an example that meets the above conditions:
+        ```python
+        class Schema(BaseModel):
+            target_key: str
+
+        component = LMBasedComponent.with_structured_output(
+            model_id="openai/gpt-4.1-mini",
+            response_schema=Schema,
+            system_template="system_template {param1}",
+            user_template="user_template {param2}",
+            custom_kwarg="custom_value",
+        )
+        ```
+
+    Building a structured output preset:
+        If desired, the component can also define a quick preset. This can be done by providing default prompts
+        as response schema. Here\'s an example:
+        ```python
+        class Schema(BaseModel):
+            target_key: str
+
+        @classmethod
+        def from_preset(cls, model_id: str, custom_kwarg: str) -> "LMBasedComponent":
+            return cls.with_structured_output(
+                model_id=model_id,
+                response_schema=Schema,
+                system_template=PRESET_SYSTEM_TEMPLATE,
+                user_template=PRESET_USER_TEMPLATE,
+                custom_kwarg=custom_kwarg,
+            )
+        )
+        ```
+
+        Then, the preset can be instantiated as follows:
+        ```python
+        component = LMBasedComponent.from_preset(
+            model_id="openai/gpt-4.1-mini",
+            custom_kwarg="custom_value",
+        )
+        ```
+    '''
+    @classmethod
+    def from_lm_components(cls, prompt_builder: PromptBuilder, lm_invoker: BaseLMInvoker, output_parser: BaseOutputParser | None = None, **kwargs: Any) -> UsesLM:
+        """Creates an instance from LMRequestProcessor components directly.
+
+        This method is a shortcut to initialize the class by providing the LMRequestProcessor components directly.
+
+        Args:
+            prompt_builder (PromptBuilder): The prompt builder used to format the prompt.
+            lm_invoker (BaseLMInvoker): The language model invoker that handles the model inference.
+            output_parser (BaseOutputParser, optional): An optional parser to process the model's output.
+                Defaults to None.
+            **kwargs (Any): Additional keyword arguments to be passed to the class constructor.
+
+        Returns:
+            UsesLM: An instance of the class that mixes in this mixin.
+        """
+    @classmethod
+    def with_structured_output(cls, model_id: str, response_schema: type[BaseModel], system_template: str = '', user_template: str = '', **kwargs: Any) -> UsesLM:
+        """Creates an instance with structured output configuration.
+
+        This method is a shortcut to initialize the class with structured output configuration.
+
+        Args:
+            model_id (str): The model ID of the language model.
+            response_schema (type[BaseModel]): The response schema of the language model.
+            system_template (str, optional): The system template of the language model. Defaults to an empty string.
+            user_template (str, optional): The user template of the language model. Defaults to an empty string.
+            **kwargs (Any): Additional keyword arguments to be passed to the class constructor.
+
+        Returns:
+            UsesLM: An instance of the class that mixes in this mixin with structured output configuration.
+        """

gllm_inference/schema/__init__.pyi

@@ -0,0 +1,19 @@
+from gllm_inference.schema.activity import Activity as Activity, MCPCallActivity as MCPCallActivity, MCPListToolsActivity as MCPListToolsActivity, WebSearchActivity as WebSearchActivity
+from gllm_inference.schema.attachment import Attachment as Attachment
+from gllm_inference.schema.code_exec_result import CodeExecResult as CodeExecResult
+from gllm_inference.schema.config import TruncationConfig as TruncationConfig
+from gllm_inference.schema.enums import AttachmentType as AttachmentType, BatchStatus as BatchStatus, EmitDataType as EmitDataType, JinjaEnvType as JinjaEnvType, LMEventType as LMEventType, LMEventTypeSuffix as LMEventTypeSuffix, LMOutputType as LMOutputType, MessageRole as MessageRole, TruncateSide as TruncateSide
+from gllm_inference.schema.events import ActivityEvent as ActivityEvent, CodeEvent as CodeEvent, ThinkingEvent as ThinkingEvent
+from gllm_inference.schema.formatter import HistoryFormatter as HistoryFormatter
+from gllm_inference.schema.lm_input import LMInput as LMInput
+from gllm_inference.schema.lm_output import LMOutput as LMOutput, LMOutputData as LMOutputData, LMOutputItem as LMOutputItem
+from gllm_inference.schema.mcp import MCPCall as MCPCall, MCPServer as MCPServer
+from gllm_inference.schema.message import Message as Message
+from gllm_inference.schema.model_id import ModelId as ModelId, ModelProvider as ModelProvider
+from gllm_inference.schema.reasoning import Reasoning as Reasoning
+from gllm_inference.schema.token_usage import InputTokenDetails as InputTokenDetails, OutputTokenDetails as OutputTokenDetails, TokenUsage as TokenUsage
+from gllm_inference.schema.tool_call import ToolCall as ToolCall
+from gllm_inference.schema.tool_result import ToolResult as ToolResult
+from gllm_inference.schema.type_alias import EMContent as EMContent, MessageContent as MessageContent, ResponseSchema as ResponseSchema, Vector as Vector
+
+__all__ = ['Activity', 'ActivityEvent', 'Attachment', 'AttachmentType', 'BatchStatus', 'CodeEvent', 'CodeExecResult', 'EMContent', 'EmitDataType', 'HistoryFormatter', 'InputTokenDetails', 'JinjaEnvType', 'LMEventType', 'LMEventTypeSuffix', 'LMInput', 'LMOutput', 'LMOutputItem', 'LMOutputData', 'LMOutputType', 'MCPCall', 'MCPCallActivity', 'MCPListToolsActivity', 'MCPServer', 'Message', 'MessageContent', 'MessageRole', 'ModelId', 'ModelProvider', 'OutputTokenDetails', 'Reasoning', 'ResponseSchema', 'ThinkingEvent', 'TokenUsage', 'ToolCall', 'ToolResult', 'TruncateSide', 'TruncationConfig', 'Vector', 'WebSearchActivity']

gllm_inference/schema/activity.pyi

@@ -0,0 +1,64 @@
+from _typeshed import Incomplete
+from gllm_inference.schema.enums import ActivityType as ActivityType, WebSearchKey as WebSearchKey
+from pydantic import BaseModel
+from typing import Literal
+
+WEB_SEARCH_VISIBLE_FIELDS: Incomplete
+WebSearchActivityTypes: Incomplete
+
+class Activity(BaseModel):
+    """Base schema for any activity.
+
+    Attributes:
+        type (str): The type of activity being performed. Defaults to an empty string.
+    """
+    type: str
+
+class MCPListToolsActivity(Activity):
+    """Schema for listing tools in MCP.
+
+    Attributes:
+        type (Literal[ActivityType.MCP_LIST_TOOLS]): The type of activity being performed.
+            Defaults to ActivityType.MCP_LIST_TOOLS.
+        server_name (str): The name of the MCP server. Defaults to an empty string.
+        tools (list[dict[str, str]] | None): The tools in the MCP server. Defaults to None.
+    """
+    type: Literal[ActivityType.MCP_LIST_TOOLS]
+    server_name: str
+    tools: list[dict[str, str]] | None
+
+class MCPCallActivity(Activity):
+    """Schema for MCP tool call.
+
+    Attributes:
+        type (Literal[ActivityType.MCP_CALL]): The type of activity being performed. Defaults to ActivityType.MCP_CALL.
+        server_name (str): The name of the MCP server.
+        tool_name (str): The name of the tool.
+        args (dict[str, str]): The arguments of the tool.
+    """
+    type: Literal[ActivityType.MCP_CALL]
+    server_name: str
+    tool_name: str
+    args: dict[str, str]
+
+class WebSearchActivity(Activity):
+    """Schema for web search tool call.
+
+    Attributes:
+        type (WebSearchActivityTypes): The type of activity being performed. Defaults to ActivityType.SEARCH.
+        query (str | None): The query of the web search. Defaults to None.
+        url (str | None): The URL of the page. Defaults to None.
+        pattern (str | None): The pattern of the web search. Defaults to None.
+        sources (list[dict[str, str]] | None): The sources of the web search.
+    """
+    type: WebSearchActivityTypes
+    query: str | None
+    url: str | None
+    pattern: str | None
+    sources: list[dict[str, str]] | None
+    def model_dump(self, *args, **kwargs) -> dict[str, str]:
+        """Serialize the activity for display.
+
+        Returns:
+            dict[str, str]: The serialized activity.
+        """

gllm_inference/schema/attachment.pyi

@@ -0,0 +1,102 @@
+from _typeshed import Incomplete
+from pydantic import BaseModel
+from typing import Any
+
+HEX_REPR_LENGTH: int
+METADATA_ITEM_REPR_LENGTH: int
+logger: Incomplete
+
+class Attachment(BaseModel):
+    """Defines a file attachment schema.
+
+    Attributes:
+        data (bytes): The content data of the file attachment.
+        filename (str): The filename of the file attachment.
+        mime_type (str): The mime type of the file attachment.
+        extension (str): The extension of the file attachment.
+        url (str | None): The URL of the file attachment. Defaults to None.
+        metadata (dict[str, Any]): The metadata of the file attachment. Defaults to an empty dictionary.
+    """
+    data: bytes
+    filename: str
+    mime_type: str
+    extension: str
+    url: str | None
+    metadata: dict[str, Any]
+    @classmethod
+    def from_bytes(cls, bytes: bytes, filename: str | None = None, metadata: dict[str, Any] | None = None) -> Attachment:
+        """Creates an Attachment from bytes.
+
+        Args:
+            bytes (bytes): The bytes of the file.
+            filename (str | None, optional): The filename of the file. Defaults to None,
+                in which case the filename will be derived from the extension.
+            metadata (dict[str, Any] | None, optional): The metadata of the file attachment. Defaults to None,
+                in which case an empty dictionary will be used.
+
+        Returns:
+            Attachment: The instantiated Attachment.
+        """
+    @classmethod
+    def from_base64(cls, base64_data: str, filename: str | None = None, metadata: dict[str, Any] | None = None) -> Attachment:
+        """Creates an Attachment from a base64 string.
+
+        Args:
+            base64_data (str): The base64 string of the file.
+            filename (str | None, optional): The filename of the file. Defaults to None,
+                in which case the filename will be derived from the mime type.
+            metadata (dict[str, Any] | None, optional): The metadata of the file attachment. Defaults to None,
+                in which case an empty dictionary will be used.
+
+        Returns:
+            Attachment: The instantiated Attachment.
+        """
+    @classmethod
+    def from_data_url(cls, data_url: str, filename: str | None = None, metadata: dict[str, Any] | None = None) -> Attachment:
+        """Creates an Attachment from a data URL (data:[mime/type];base64,[bytes]).
+
+        Args:
+            data_url (str): The data URL of the file.
+            filename (str | None, optional): The filename of the file. Defaults to None,
+                in which case the filename will be derived from the mime type.
+            metadata (dict[str, Any] | None, optional): The metadata of the file attachment. Defaults to None,
+                in which case an empty dictionary will be used.
+
+        Returns:
+            Attachment: The instantiated Attachment.
+        """
+    @classmethod
+    def from_url(cls, url: str, filename: str | None = None, metadata: dict[str, Any] | None = None) -> Attachment:
+        """Creates an Attachment from a URL.
+
+        Args:
+            url (str): The URL of the file.
+            filename (str | None, optional): The filename of the file. Defaults to None,
+                in which case the filename will be derived from the URL.
+            metadata (dict[str, Any] | None, optional): The metadata of the file attachment. Defaults to None,
+                in which case an empty dictionary will be used.
+
+        Returns:
+            Attachment: The instantiated Attachment.
+        """
+    @classmethod
+    def from_path(cls, path: str, filename: str | None = None, metadata: dict[str, Any] | None = None) -> Attachment:
+        """Creates an Attachment from a path.
+
+        Args:
+            path (str): The path to the file.
+            filename (str | None, optional): The filename of the file. Defaults to None,
+                in which case the filename will be derived from the path.
+            metadata (dict[str, Any] | None, optional): The metadata of the file attachment. Defaults to None,
+                in which case an empty dictionary will be used.
+
+        Returns:
+            Attachment: The instantiated Attachment.
+        """
+    def write_to_file(self, path: str | None = None) -> None:
+        """Writes the Attachment to a file.
+
+        Args:
+            path (str | None, optional): The path to the file. Defaults to None,
+                in which case the filename will be used as the path.
+        """

gllm_inference/schema/code_exec_result.pyi

@@ -0,0 +1,14 @@
+from gllm_inference.schema.attachment import Attachment as Attachment
+from pydantic import BaseModel
+
+class CodeExecResult(BaseModel):
+    """Defines a code execution result when a language model is configured to execute code.
+
+    Attributes:
+        id (str): The ID of the code execution. Defaults to an empty string.
+        code (str): The executed code. Defaults to an empty string.
+        output (list[str | Attachment]): The output of the executed code. Defaults to an empty list.
+    """
+    id: str
+    code: str
+    output: list[str | Attachment]

gllm_inference/schema/config.pyi

@@ -0,0 +1,15 @@
+from gllm_inference.schema.enums import TruncateSide as TruncateSide
+from pydantic import BaseModel
+
+class TruncationConfig(BaseModel):
+    """Configuration for text truncation behavior.
+
+    Attributes:
+        max_length (int): Maximum length of text content. Required.
+        truncate_side (TruncateSide | None): Side to truncate from when max_length is exceeded.
+            1. TruncateSide.RIGHT: Keep the beginning of the text, truncate from the end (default)
+            2. TruncateSide.LEFT: Keep the end of the text, truncate from the beginning
+            If None, defaults to TruncateSide.RIGHT
+    """
+    max_length: int
+    truncate_side: TruncateSide | None

gllm_inference/schema/enums.pyi

@@ -0,0 +1,82 @@
+from enum import StrEnum
+
+class AttachmentType(StrEnum):
+    """Defines valid attachment types."""
+    AUDIO = 'audio'
+    DOCUMENT = 'document'
+    IMAGE = 'image'
+    VIDEO = 'video'
+
+class BatchStatus(StrEnum):
+    """Defines the status of a batch job."""
+    IN_PROGRESS = 'in_progress'
+    FINISHED = 'finished'
+    FAILED = 'failed'
+    CANCELING = 'canceling'
+    EXPIRED = 'expired'
+    UNKNOWN = 'unknown'
+
+class LMEventType(StrEnum):
+    """Defines event types to be emitted by the LM invoker."""
+    ACTIVITY = 'activity'
+    CODE = 'code'
+    THINKING = 'thinking'
+
+class LMEventTypeSuffix(StrEnum):
+    """Defines suffixes for LM event types."""
+    START = '_start'
+    END = '_end'
+
+class EmitDataType(StrEnum):
+    """Defines valid data types for emitting events."""
+    ACTIVITY = 'activity'
+    CODE = 'code'
+    CODE_START = 'code_start'
+    CODE_END = 'code_end'
+    THINKING = 'thinking'
+    THINKING_START = 'thinking_start'
+    THINKING_END = 'thinking_end'
+
+class LMOutputType(StrEnum):
+    """Defines valid types for language model outputs."""
+    TEXT = 'text'
+    STRUCTURED = 'structured'
+    ATTACHMENT = 'attachment'
+    TOOL_CALL = 'tool_call'
+    THINKING = 'thinking'
+    CITATION = 'citation'
+    CODE_EXEC_RESULT = 'code_exec_result'
+    MCP_CALL = 'mcp_call'
+
+class ActivityType(StrEnum):
+    """Defines valid activity types."""
+    FIND_IN_PAGE = 'find_in_page'
+    MCP_CALL = 'mcp_call'
+    MCP_LIST_TOOLS = 'mcp_list_tools'
+    OPEN_PAGE = 'open_page'
+    SEARCH = 'search'
+    WEB_SEARCH = 'web_search'
+
+class MessageRole(StrEnum):
+    """Defines valid message roles."""
+    SYSTEM = 'system'
+    USER = 'user'
+    ASSISTANT = 'assistant'
+
+class TruncateSide(StrEnum):
+    """Enumeration for truncation sides."""
+    RIGHT = 'RIGHT'
+    LEFT = 'LEFT'
+
+class JinjaEnvType(StrEnum):
+    """Enumeration for Jinja environment types."""
+    JINJA_DEFAULT = 'jinja_default'
+    RESTRICTED = 'restricted'
+
+class WebSearchKey(StrEnum):
+    """Defines valid web search keys."""
+    PATTERN = 'pattern'
+    QUERY = 'query'
+    SOURCES = 'sources'
+    TYPE = 'type'
+    URL = 'url'

gllm_inference/schema/events.pyi

@@ -0,0 +1,105 @@
+from _typeshed import Incomplete
+from gllm_core.constants import EventType
+from gllm_core.schema import Event
+from gllm_inference.schema.activity import Activity as Activity
+from typing import Any, Literal, Self
+
+CodeEventType: Incomplete
+ThinkingEventType: Incomplete
+
+class ActivityEvent(Event):
+    """Event schema for model-triggered activities (e.g. web search, MCP call, etc.).
+
+    Attributes:
+        id (str): The ID of the activity event. Defaults to None.
+        value (dict[str, Any]): The value of the activity event.
+        level (EventLevel): The severity level of the activity event. Defaults to EventLevel.INFO.
+        type (Literal[EventType.ACTIVITY]): The type of the activity event. Defaults to EventType.ACTIVITY.
+        timestamp (datetime): The timestamp of the activity event. Defaults to the current timestamp.
+        metadata (dict[str, Any]): The metadata of the activity event. Defaults to an empty dictionary.
+    """
+    value: dict[str, Any]
+    type: Literal[EventType.ACTIVITY]
+    @classmethod
+    def from_activity(cls, id_: str | None = None, activity: Activity | None = None) -> ActivityEvent:
+        """Create an activity event from an Activity object.
+
+        Args:
+            id_ (str | None, optional): The ID of the activity event. Defaults to None.
+            activity (Activity | None, optional): The activity object to create the event from.
+                Defaults to None, in which case the value will be an empty dictionary.
+
+        Returns:
+            ActivityEvent: The activity event.
+        """
+
+class BlockBasedEvent(Event):
+    """Event schema block-based events, which are limited by start and end events.
+
+    Attributes:
+        id (str): The ID of the block-based event. Defaults to None.
+        value (str): The value of the block-based event. Defaults to an empty string.
+        level (EventLevel): The severity level of the block-based event. Defaults to EventLevel.INFO.
+        type (str): The type of the block-based event. Defaults to an empty string.
+        timestamp (datetime): The timestamp of the block-based event. Defaults to the current timestamp.
+        metadata (dict[str, Any]): The metadata of the block-based event. Defaults to an empty dictionary.
+    """
+    value: str
+    type: str
+    @classmethod
+    def start(cls, id_: str | None = None) -> Self:
+        """Create a block-based start event.
+
+        Args:
+            id_ (str | None, optional): The ID of the block-based event. Defaults to None.
+
+        Returns:
+            Self: The block-based start event.
+        """
+    @classmethod
+    def content(cls, id_: str | None = None, value: str = '') -> Self:
+        """Create a block-based content event.
+
+        Args:
+            id_ (str | None, optional): The ID of the block-based event. Defaults to None.
+            value (str, optional): The block-based content. Defaults to an empty string.
+
+        Returns:
+            Self: The block-based content event.
+        """
+    @classmethod
+    def end(cls, id_: str | None = None) -> Self:
+        """Create a block-based end event.
+
+        Args:
+            id_ (str | None, optional): The ID of the block-based event. Defaults to None.
+
+        Returns:
+            Self: The block-based end event.
+        """
+
+class CodeEvent(BlockBasedEvent):
+    """Event schema for model-generated code to be executed.
+
+    Attributes:
+        id (str): The ID of the code event. Defaults to None.
+        value (str): The value of the code event. Defaults to an empty string.
+        level (EventLevel): The severity level of the code event. Defaults to EventLevel.INFO.
+        type (CodeEventType): The type of the code event. Defaults to EventType.CODE.
+        timestamp (datetime): The timestamp of the code event. Defaults to the current timestamp.
+        metadata (dict[str, Any]): The metadata of the code event. Defaults to an empty dictionary.
+    """
+    type: CodeEventType
+
+class ThinkingEvent(BlockBasedEvent):
+    """Event schema for model-generated thinking.
+
+    Attributes:
+        id (str): The ID of the thinking event. Defaults to None.
+        value (str): The value of the thinking event. Defaults to an empty string.
+        level (EventLevel): The severity level of the thinking event. Defaults to EventLevel.INFO.
+        type (ThinkingEventType): The type of the thinking event. Defaults to EventType.THINKING.
+        timestamp (datetime): The timestamp of the thinking event. Defaults to the current timestamp.
+        metadata (dict[str, Any]): The metadata of the thinking event. Defaults to an empty dictionary.
+    """
+    type: ThinkingEventType

gllm_inference/schema/formatter.pyi

@@ -0,0 +1,31 @@
+from gllm_inference.schema.enums import MessageRole as MessageRole
+from gllm_inference.schema.message import Message as Message
+from gllm_inference.schema.type_alias import MessageContent as MessageContent
+from pydantic import BaseModel
+
+class HistoryFormatter(BaseModel):
+    """Configuration for history formatting.
+
+    Attributes:
+        prefix_user_message (str): Prefix for user messages.
+        suffix_user_message (str): Suffix for user messages.
+        prefix_assistant_message (str): Prefix for assistant messages.
+        suffix_assistant_message (str): Suffix for assistant messages.
+    """
+    prefix_user_message: str
+    suffix_user_message: str
+    prefix_assistant_message: str
+    suffix_assistant_message: str
+    def format_history(self, history: list[Message]) -> list[Message]:
+        """Formats a list of messages based on their roles.
+
+        This method formats each message in the history list by applying the appropriate
+        formatting based on the message role (user or assistant). Other message types
+        are added to the result without modification.
+
+        Args:
+            history (list[Message]): The list of messages to format.
+
+        Returns:
+            list[Message]: A new list containing the formatted messages.
+        """

gllm_inference/schema/lm_input.pyi

@@ -0,0 +1,4 @@
+from gllm_inference.schema.message import Message as Message
+from gllm_inference.schema.type_alias import MessageContent as MessageContent
+
+LMInput = list[Message] | list[MessageContent] | str