gllm-inference-binary 0.4.61__cp311-cp311-win_amd64.whl → 0.5.0__cp311-cp311-win_amd64.whl

gllm_inference/lm_invoker/bedrock_lm_invoker.pyi

@@ -3,11 +3,11 @@ from gllm_core.event import EventEmitter as EventEmitter
 from gllm_core.utils.retry import RetryConfig as RetryConfig
 from gllm_inference.lm_invoker.lm_invoker import BaseLMInvoker as BaseLMInvoker
 from gllm_inference.lm_invoker.schema.bedrock import InputType as InputType, Key as Key, OutputType as OutputType
-from gllm_inference.schema import Attachment as Attachment, AttachmentType as AttachmentType, LMOutput as LMOutput, ModelId as ModelId, ModelProvider as ModelProvider, MultimodalPrompt as MultimodalPrompt, ResponseSchema as ResponseSchema, TokenUsage as TokenUsage, ToolCall as ToolCall, ToolResult as ToolResult
+from gllm_inference.schema import Attachment as Attachment, AttachmentType as AttachmentType, LMOutput as LMOutput, Message as Message, ModelId as ModelId, ModelProvider as ModelProvider, ResponseSchema as ResponseSchema, TokenUsage as TokenUsage, ToolCall as ToolCall, ToolResult as ToolResult
 from langchain_core.tools import Tool as Tool
 from typing import Any
 
-VALID_EXTENSIONS_MAP: Incomplete
+SUPPORTED_ATTACHMENTS: Incomplete
 
 class BedrockLMInvoker(BaseLMInvoker):
     '''A language model invoker to interact with AWS Bedrock language models.
@@ -37,22 +37,14 @@ class BedrockLMInvoker(BaseLMInvoker):
         ```
 
     Input types:
-        The `BedrockLMInvoker` supports the following input types:
-        1. Text.
-        2. Document: ".pdf", ".csv", ".doc", ".docx", ".xls", ".xlsx", ".html", ".txt", ".md".
-        3. Image: ".png", ".jpeg", ".gif", ".webp".
-        4. Video: ".mkv", ".mov", ".mp4", ".webm", ".flv", ".mpeg", ".mpg", ".wmv", ".three_gp".
-        Non-text inputs must be of valid file extensions and can be passed as an `Attachment` object.
-
-        Non-text inputs can only be passed with the `user` role.
+        The `BedrockLMInvoker` supports the following input types: text, document, image, and video.
+        Non-text inputs can be passed as an `Attachment` object with the `user` role.
 
         Usage example:
         ```python
         text = "What animal is in this image?"
         image = Attachment.from_path("path/to/local/image.png")
-
-        prompt = [(PromptRole.USER, [text, image])]
-        result = await lm_invoker.invoke(prompt)
+        result = await lm_invoker.invoke([text, image])
         ```
 
     Tool calling:
@@ -166,7 +158,7 @@ class BedrockLMInvoker(BaseLMInvoker):
         ```
 
     Output types:
-        The output of the `BedrockLMInvoker` is of type `MultimodalOutput`, which is a type alias that can represent:
+        The output of the `BedrockLMInvoker` can either be:
         1. `str`: The text response if no additional output is needed.
         2. `LMOutput`: A Pydantic model with the following attributes if any additional output is needed:
             2.1. response (str): The text response.

gllm_inference/lm_invoker/datasaur_lm_invoker.pyi

@@ -1,14 +1,14 @@
 from _typeshed import Incomplete
 from gllm_core.event import EventEmitter as EventEmitter
 from gllm_core.utils.retry import RetryConfig as RetryConfig
-from gllm_inference.constants import ALL_EXTENSIONS as ALL_EXTENSIONS, DOCUMENT_MIME_TYPES as DOCUMENT_MIME_TYPES
+from gllm_inference.constants import DOCUMENT_MIME_TYPES as DOCUMENT_MIME_TYPES
 from gllm_inference.lm_invoker.openai_compatible_lm_invoker import OpenAICompatibleLMInvoker as OpenAICompatibleLMInvoker
 from gllm_inference.lm_invoker.schema.datasaur import InputType as InputType, Key as Key
-from gllm_inference.schema import Attachment as Attachment, AttachmentType as AttachmentType, LMOutput as LMOutput, ModelId as ModelId, ModelProvider as ModelProvider, MultimodalPrompt as MultimodalPrompt, ResponseSchema as ResponseSchema, ToolCall as ToolCall, ToolResult as ToolResult
+from gllm_inference.schema import Attachment as Attachment, AttachmentType as AttachmentType, LMOutput as LMOutput, Message as Message, ModelId as ModelId, ModelProvider as ModelProvider, ResponseSchema as ResponseSchema, ToolCall as ToolCall, ToolResult as ToolResult
 from langchain_core.tools import Tool as Tool
 from typing import Any
 
-VALID_EXTENSIONS_MAP: Incomplete
+SUPPORTED_ATTACHMENTS: Incomplete
 
 class DatasaurLMInvoker(OpenAICompatibleLMInvoker):
     '''A language model invoker to interact with Datasaur LLM Projects Deployment API.
@@ -33,21 +33,14 @@ class DatasaurLMInvoker(OpenAICompatibleLMInvoker):
         ```
 
     Input types:
-        1. Text.
-        2. Audio, with extensions depending on the language model\'s capabilities.
-        3. Image, with extensions depending on the language model\'s capabilities.
-        4. Document, with extensions depending on the language model\'s capabilities.
-        Non-text inputs must be of valid file extensions and can be passed as an `Attachment` object.
-
-        Non-text inputs can only be passed with the `user` role.
+        The `DatasaurLMInvoker` supports the following input types: text, audio, image, and document.
+        Non-text inputs can be passed as an `Attachment` object with the `user` role.
 
         Usage example:
         ```python
         text = "What animal is in this image?"
         image = Attachment.from_path("path/to/local/image.png")
-
-        prompt = [(PromptRole.USER, [text, image])]
-        result = await lm_invoker.invoke(prompt)
+        result = await lm_invoker.invoke([text, image])
         ```
 
     Analytics tracking:
@@ -108,7 +101,7 @@ class DatasaurLMInvoker(OpenAICompatibleLMInvoker):
         ```
 
     Output types:
-        The output of the `DatasaurLMInvoker` is of type `MultimodalOutput`, which is a type alias that can represent:
+        The output of the `DatasaurLMInvoker` can either be:
         1. `str`: The text response if no additional output is needed.
         2. `LMOutput`: A Pydantic model with the following attributes if any additional output is needed:
             2.1. response (str): The text response.

gllm_inference/lm_invoker/google_lm_invoker.pyi

@@ -4,11 +4,11 @@ from gllm_core.utils.retry import RetryConfig as RetryConfig
 from gllm_inference.constants import GOOGLE_SCOPES as GOOGLE_SCOPES
 from gllm_inference.lm_invoker.lm_invoker import BaseLMInvoker as BaseLMInvoker
 from gllm_inference.lm_invoker.schema.google import InputType as InputType, Key as Key
-from gllm_inference.schema import Attachment as Attachment, AttachmentType as AttachmentType, EmitDataType as EmitDataType, LMOutput as LMOutput, ModelId as ModelId, ModelProvider as ModelProvider, MultimodalPrompt as MultimodalPrompt, PromptRole as PromptRole, Reasoning as Reasoning, ResponseSchema as ResponseSchema, TokenUsage as TokenUsage, ToolCall as ToolCall, ToolResult as ToolResult
+from gllm_inference.schema import Attachment as Attachment, AttachmentType as AttachmentType, EmitDataType as EmitDataType, LMOutput as LMOutput, Message as Message, MessageRole as MessageRole, ModelId as ModelId, ModelProvider as ModelProvider, Reasoning as Reasoning, ResponseSchema as ResponseSchema, TokenUsage as TokenUsage, ToolCall as ToolCall, ToolResult as ToolResult
 from langchain_core.tools import Tool
 from typing import Any
 
-VALID_EXTENSIONS_MAP: Incomplete
+SUPPORTED_ATTACHMENTS: Incomplete
 DEFAULT_THINKING_BUDGET: int
 REQUIRE_THINKING_MODEL_PREFIX: Incomplete
 YOUTUBE_URL_PATTERN: Incomplete
@@ -67,22 +67,14 @@ class GoogleLMInvoker(BaseLMInvoker):
         The `GOOGLE_API_KEY` environment variable will be used for authentication.
 
     Input types:
-        1. Text.
-        2. Audio: ".aac", ".flac", ".mp3", and ".wav".
-        3. Document: ".pdf", ".txt", ".csv", ".md", ".css", ".html", and ".xml".
-        4. Image: ".jpg", ".jpeg", ".png", and ".webp".
-        5. Video: ".x-flv", ".mpeg", ".mpg", ".mp4", ".webm", ".wmv", and ".3gpp".
-        Non-text inputs must be of valid file extensions and can be passed as an `Attachment` object.
-
-        Non-text inputs can be passed with either the `user` or `assistant` role.
+        The `GoogleLMInvoker` supports the following input types: text, audio, document, image, and video.
+        Non-text inputs can be passed as an `Attachment` object with either the `user` or `assistant` role.
 
         Usage example:
         ```python
         text = "What animal is in this image?"
         image = Attachment.from_path("path/to/local/image.png")
-
-        prompt = [(PromptRole.USER, [text, image])]
-        result = await lm_invoker.invoke(prompt)
+        result = await lm_invoker.invoke([text, image])
         ```
 
     Tool calling:
@@ -235,7 +227,7 @@ class GoogleLMInvoker(BaseLMInvoker):
         For more details, please refer to https://ai.google.dev/gemini-api/docs/thinking
 
     Output types:
-        The output of the `GoogleLMInvoker` is of type `MultimodalOutput`, which is a type alias that can represent:
+        The output of the `GoogleLMInvoker` can either be:
         1. `str`: The text response if no additional output is needed.
         2. `LMOutput`: A Pydantic model with the following attributes if any additional output is needed:
             2.1. response (str): The text response.
@@ -258,7 +250,7 @@ class GoogleLMInvoker(BaseLMInvoker):
     client_params: Incomplete
     thinking: Incomplete
     thinking_budget: Incomplete
-    def __init__(self, model_name: str, api_key: str | None = None, credentials_path: str | None = None, project_id: str | None = None, location: str = 'us-central1', model_kwargs: dict[str, Any] | None = None, default_hyperparameters: dict[str, Any] | None = None, tools: list[Tool] | None = None, response_schema: ResponseSchema | None = None, output_analytics: bool = False, retry_config: RetryConfig | None = None, thinking: bool | None = None, thinking_budget: int = ..., bind_tools_params: dict[str, Any] | None = None, with_structured_output_params: dict[str, Any] | None = None) -> None:
+    def __init__(self, model_name: str, api_key: str | None = None, credentials_path: str | None = None, project_id: str | None = None, location: str = 'us-central1', model_kwargs: dict[str, Any] | None = None, default_hyperparameters: dict[str, Any] | None = None, tools: list[Tool] | None = None, response_schema: ResponseSchema | None = None, output_analytics: bool = False, retry_config: RetryConfig | None = None, thinking: bool | None = None, thinking_budget: int = ...) -> None:
         '''Initializes a new instance of the GoogleLMInvoker class.
 
         Args:
@@ -287,12 +279,6 @@ class GoogleLMInvoker(BaseLMInvoker):
                 Defaults to True for Gemini 2.5 Pro models and False for other models.
             thinking_budget (int, optional): The tokens allowed for thinking process. Only allowed for thinking models.
                 Defaults to -1, in which case the model will control the budget automatically.
-            bind_tools_params (dict[str, Any] | None, optional): Deprecated parameter to add tool calling capability.
-                If provided, must at least include the `tools` key that is equivalent to the `tools` parameter.
-                Retained for backward compatibility. Defaults to None.
-            with_structured_output_params (dict[str, Any] | None, optional): Deprecated parameter to instruct the
-                model to produce output with a certain schema. If provided, must at least include the `schema` key that
-                is equivalent to the `response_schema` parameter. Retained for backward compatibility. Defaults to None.
 
         Note:
             If neither `api_key` nor `credentials_path` is provided, Google Gen AI will be used by default.

gllm_inference/lm_invoker/langchain_lm_invoker.pyi

@@ -1,17 +1,16 @@
 from _typeshed import Incomplete
 from gllm_core.event import EventEmitter as EventEmitter
 from gllm_core.utils.retry import RetryConfig as RetryConfig
-from gllm_inference.constants import ALL_EXTENSIONS as ALL_EXTENSIONS
 from gllm_inference.lm_invoker.lm_invoker import BaseLMInvoker as BaseLMInvoker
 from gllm_inference.lm_invoker.schema.langchain import InputType as InputType, Key as Key
-from gllm_inference.schema import Attachment as Attachment, AttachmentType as AttachmentType, LMOutput as LMOutput, ModelId as ModelId, ModelProvider as ModelProvider, MultimodalPrompt as MultimodalPrompt, PromptRole as PromptRole, ResponseSchema as ResponseSchema, TokenUsage as TokenUsage, ToolCall as ToolCall, ToolResult as ToolResult
+from gllm_inference.schema import Attachment as Attachment, AttachmentType as AttachmentType, LMOutput as LMOutput, Message as Message, MessageRole as MessageRole, ModelId as ModelId, ModelProvider as ModelProvider, ResponseSchema as ResponseSchema, TokenUsage as TokenUsage, ToolCall as ToolCall, ToolResult as ToolResult
 from gllm_inference.utils import load_langchain_model as load_langchain_model, parse_model_data as parse_model_data
 from langchain_core.language_models import BaseChatModel as BaseChatModel
 from langchain_core.messages import BaseMessage as BaseMessage
 from langchain_core.tools import Tool as Tool
 from typing import Any
 
-VALID_EXTENSIONS_MAP: Incomplete
+SUPPORTED_ATTACHMENTS: Incomplete
 MESSAGE_CLASS_MAP: Incomplete
 
 class LangChainLMInvoker(BaseLMInvoker):
@@ -64,19 +63,15 @@ class LangChainLMInvoker(BaseLMInvoker):
         https://python.langchain.com/docs/integrations/chat/#featured-providers
 
     Input types:
-        1. Text.
-        2. Image, with extensions depending on the language model\'s capabilities.
-        Non-text inputs must be of valid file extensions and can be passed as an `Attachment` object.
-
-        Non-text inputs can only be passed with specific roles, depending on the language model\'s capabilities.
+        The `LangChainLMInvoker` supports the following input types: text and image.
+        Non-text inputs can be passed as an `Attachment` object and with specific roles,
+        depending on the language model\'s capabilities.
 
         Usage example:
         ```python
         text = "What animal is in this image?"
         image = Attachment.from_path("path/to/local/image.png")
-
-        prompt = [(PromptRole.USER, [text, image])]
-        result = await lm_invoker.invoke(prompt)
+        result = await lm_invoker.invoke([text, image])
         ```
 
     Tool calling:
@@ -188,7 +183,7 @@ class LangChainLMInvoker(BaseLMInvoker):
         ```
 
     Output types:
-        The output of the `LangChainLMInvoker` is of type `MultimodalOutput`, which is a type alias that can represent:
+        The output of the `LangChainLMInvoker` can either be:
         1. `str`: The text response if no additional output is needed.
         2. `LMOutput`: A Pydantic model with the following attributes if any additional output is needed:
             2.1. response (str): The text response.
@@ -208,7 +203,7 @@ class LangChainLMInvoker(BaseLMInvoker):
                 Defaults to an empty list.
     '''
     model: Incomplete
-    def __init__(self, model: BaseChatModel | None = None, model_class_path: str | None = None, model_name: str | None = None, model_kwargs: dict[str, Any] | None = None, default_hyperparameters: dict[str, Any] | None = None, tools: list[Tool] | None = None, response_schema: ResponseSchema | None = None, output_analytics: bool = False, retry_config: RetryConfig | None = None, llm: BaseChatModel | None = None, bind_tools_params: dict[str, Any] | None = None, with_structured_output_params: dict[str, Any] | None = None) -> None:
+    def __init__(self, model: BaseChatModel | None = None, model_class_path: str | None = None, model_name: str | None = None, model_kwargs: dict[str, Any] | None = None, default_hyperparameters: dict[str, Any] | None = None, tools: list[Tool] | None = None, response_schema: ResponseSchema | None = None, output_analytics: bool = False, retry_config: RetryConfig | None = None) -> None:
         '''Initializes a new instance of the LangChainLMInvoker class.
 
         Args:
@@ -230,14 +225,6 @@ class LangChainLMInvoker(BaseLMInvoker):
             output_analytics (bool, optional): Whether to output the invocation analytics. Defaults to False.
             retry_config (RetryConfig | None, optional): The retry configuration for the language model.
                 Defaults to None, in which case a default config with no retry and 30.0 seconds timeout is used.
-            llm (BaseChatModel | None, optional): Deprecated parameter to pass the LangChain\'s BaseChatModel instance.
-                Equivalent to the `model` parameter. Retained for backward compatibility. Defaults to None.
-            bind_tools_params (dict[str, Any] | None, optional): Deprecated parameter to add tool calling capability.
-                If provided, must at least include the `tools` key that is equivalent to the `tools` parameter.
-                Retained for backward compatibility. Defaults to None.
-            with_structured_output_params (dict[str, Any] | None, optional): Deprecated parameter to instruct the
-                model to produce output with a certain schema. If provided, must at least include the `schema` key that
-                is equivalent to the `response_schema` parameter. Retained for backward compatibility. Defaults to None.
 
         Raises:
             ValueError: If `response_schema` is provided, but `tools` are also provided.

gllm_inference/lm_invoker/litellm_lm_invoker.pyi

@@ -1,14 +1,13 @@
 from _typeshed import Incomplete
 from gllm_core.event import EventEmitter as EventEmitter
 from gllm_core.utils.retry import RetryConfig as RetryConfig
-from gllm_inference.constants import ALL_EXTENSIONS as ALL_EXTENSIONS
 from gllm_inference.lm_invoker.openai_compatible_lm_invoker import OpenAICompatibleLMInvoker as OpenAICompatibleLMInvoker
 from gllm_inference.lm_invoker.openai_lm_invoker import ReasoningEffort as ReasoningEffort
-from gllm_inference.schema import AttachmentType as AttachmentType, ModelId as ModelId, ModelProvider as ModelProvider, MultimodalOutput as MultimodalOutput, ResponseSchema as ResponseSchema
+from gllm_inference.schema import AttachmentType as AttachmentType, LMOutput as LMOutput, ModelId as ModelId, ModelProvider as ModelProvider, ResponseSchema as ResponseSchema
 from langchain_core.tools import Tool as Tool
 from typing import Any
 
-VALID_EXTENSIONS_MAP: Incomplete
+SUPPORTED_ATTACHMENTS: Incomplete
 
 class LiteLLMLMInvoker(OpenAICompatibleLMInvoker):
     '''A language model invoker to interact with language models using LiteLLM.
@@ -47,20 +46,14 @@ class LiteLLMLMInvoker(OpenAICompatibleLMInvoker):
         LiteLLM documentation: https://docs.litellm.ai/docs/providers/
 
     Input types:
-        1. Text.
-        2. Audio, with extensions depending on the language model\'s capabilities.
-        3. Image, with extensions depending on the language model\'s capabilities.
-        Non-text inputs must be of valid file extensions and can be passed as a `Attachment` object.
-
-        Non-text inputs can only be passed with the `user` role.
+        The `LiteLLMLMInvoker` supports the following input types: text, audio, and image.
+        Non-text inputs can be passed as a `Attachment` object with the `user` role.
 
         Usage example:
         ```python
         text = "What animal is in this image?"
         image = Attachment.from_path("path/to/local/image.png")
-
-        prompt = [(PromptRole.USER, [text, image])]
-        result = await lm_invoker.invoke(prompt)
+        result = await lm_invoker.invoke([text, image])
         ```
 
     Tool calling:
@@ -214,7 +207,7 @@ class LiteLLMLMInvoker(OpenAICompatibleLMInvoker):
 
 
     Output types:
-        The output of the `LiteLLMLMInvoker` is of type `MultimodalOutput`, which is a type alias that can represent:
+        The output of the `LiteLLMLMInvoker` can either be:
         1. `str`: The text response if no additional output is needed.
         2. `LMOutput`: A Pydantic model with the following attributes if any additional output is needed:
             2.1. response (str): The text response.

gllm_inference/lm_invoker/lm_invoker.pyi

@@ -3,10 +3,9 @@ from _typeshed import Incomplete
 from abc import ABC
 from gllm_core.event import EventEmitter as EventEmitter
 from gllm_core.utils.retry import RetryConfig
-from gllm_inference.constants import ALL_EXTENSIONS as ALL_EXTENSIONS, DOCUMENT_MIME_TYPES as DOCUMENT_MIME_TYPES, MESSAGE_TUPLE_LENGTH as MESSAGE_TUPLE_LENGTH
+from gllm_inference.constants import DOCUMENT_MIME_TYPES as DOCUMENT_MIME_TYPES
 from gllm_inference.exceptions import parse_error_message as parse_error_message
-from gllm_inference.schema import Attachment as Attachment, AttachmentType as AttachmentType, ContentPlaceholder as ContentPlaceholder, EmitDataType as EmitDataType, LMOutput as LMOutput, ModelId as ModelId, MultimodalContent as MultimodalContent, MultimodalOutput as MultimodalOutput, MultimodalPrompt as MultimodalPrompt, PromptRole as PromptRole, Reasoning as Reasoning, ResponseSchema as ResponseSchema, ToolCall as ToolCall, ToolResult as ToolResult
-from gllm_inference.utils import is_local_file_path as is_local_file_path, is_remote_file_path as is_remote_file_path, validate_string_enum as validate_string_enum
+from gllm_inference.schema import Attachment as Attachment, AttachmentType as AttachmentType, EmitDataType as EmitDataType, LMOutput as LMOutput, Message as Message, MessageContent as MessageContent, MessageRole as MessageRole, ModelId as ModelId, Reasoning as Reasoning, ResponseSchema as ResponseSchema, ToolCall as ToolCall, ToolResult as ToolResult
 from langchain_core.tools import Tool as Tool
 from typing import Any
 
@@ -28,7 +27,7 @@ class _InputType:
 class BaseLMInvoker(ABC, metaclass=abc.ABCMeta):
     """A base class for language model invokers used in Gen AI applications.
 
-    The `BaseLMInvoker` class provides a framework for invoking language models with prompts and hyperparameters.
+    The `BaseLMInvoker` class provides a framework for invoking language models.
     It handles both standard and streaming invocation.
 
     Attributes:
@@ -47,17 +46,15 @@ class BaseLMInvoker(ABC, metaclass=abc.ABCMeta):
     response_schema: Incomplete
     output_analytics: Incomplete
     retry_config: Incomplete
-    def __init__(self, model_id: ModelId, default_hyperparameters: dict[str, Any] | None = None, valid_extensions_map: dict[str, set[str]] | None = None, tools: list[Tool] | None = None, response_schema: ResponseSchema | None = None, output_analytics: bool = False, retry_config: RetryConfig | None = None) -> None:
-        '''Initializes a new instance of the BaseLMInvoker class.
+    def __init__(self, model_id: ModelId, default_hyperparameters: dict[str, Any] | None = None, supported_attachments: set[str] | None = None, tools: list[Tool] | None = None, response_schema: ResponseSchema | None = None, output_analytics: bool = False, retry_config: RetryConfig | None = None) -> None:
+        """Initializes a new instance of the BaseLMInvoker class.
 
         Args:
             model_id (ModelId): The model ID of the language model.
             default_hyperparameters (dict[str, Any] | None, optional): Default hyperparameters for invoking the
                 language model. Defaults to None, in which case an empty dictionary is used.
-            valid_extensions_map (dict[str, set[str]] | None, optional): A dictionary mapping for validating the
-                content type of the multimodal inputs. They keys are the mime types (e.g. "image") and the values are
-                the set of valid file extensions for the corresponding mime type. Defaults to None, in which case an
-                empty dictionary is used.
+            supported_attachments (set[str] | None, optional): A set of supported attachment types. Defaults to None,
+                in which case an empty set is used (indicating that no attachments are supported).
             tools (list[Tool] | None, optional): Tools provided to the language model to enable tool calling.
                 Defaults to None, in which case an empty list is used.
             response_schema (ResponseSchema | None, optional): The schema of the response. If provided, the model will
@@ -66,7 +63,7 @@ class BaseLMInvoker(ABC, metaclass=abc.ABCMeta):
             output_analytics (bool, optional): Whether to output the invocation analytics. Defaults to False.
             retry_config (RetryConfig | None, optional): The retry configuration for the language model.
                 Defaults to None, in which case a default config with no retry and 30.0 seconds timeout is used.
-        '''
+        """
     @property
     def model_id(self) -> str:
         """The model ID of the language model.
@@ -115,22 +112,24 @@ class BaseLMInvoker(ABC, metaclass=abc.ABCMeta):
         This method clears the response schema for the language model by calling the `set_response_schema` method with
         None.
         """
-    async def invoke(self, prompt: MultimodalPrompt | str, hyperparameters: dict[str, Any] | None = None, event_emitter: EventEmitter | None = None) -> MultimodalOutput:
-        """Invokes the language model with the provided prompt and hyperparameters.
+    async def invoke(self, messages: list[Message] | list[MessageContent] | str, hyperparameters: dict[str, Any] | None = None, event_emitter: EventEmitter | None = None) -> str | LMOutput:
+        """Invokes the language model.
 
-        This method validates the prompt and invokes the language model with the provided prompt and hyperparameters.
-        It handles both standard and streaming invocation. Streaming mode is enabled if an event emitter is provided.
+        This method validates the messages and invokes the language model. It handles both standard
+        and streaming invocation. Streaming mode is enabled if an event emitter is provided.
         The method includes retry logic with exponential backoff for transient failures.
 
         Args:
-            prompt (MultimodalPrompt | str): The input prompt for the language model.
+            messages (list[Message] | list[MessageContent] | str): The input messages for the language model.
+                1. If a list of Message objects is provided, it is used as is.
+                2. If a list of MessageContent or a string is provided, it is converted into a user message.
             hyperparameters (dict[str, Any] | None, optional): A dictionary of hyperparameters for the language model.
                 Defaults to None, in which case the default hyperparameters are used.
             event_emitter (EventEmitter | None, optional): The event emitter for streaming tokens. If provided,
                 streaming invocation is enabled. Defaults to None.
 
         Returns:
-            MultimodalOutput: The generated response from the language model.
+            str | LMOutput: The generated response from the language model.
 
         Raises:
             CancelledError: If the invocation is cancelled.
@@ -141,5 +140,5 @@ class BaseLMInvoker(ABC, metaclass=abc.ABCMeta):
             ProviderOverloadedError: If the model is overloaded.
             ProviderRateLimitError: If the model rate limit is exceeded.
             TimeoutError: If the invocation times out.
-            ValueError: If the prompt is not in the correct format.
+            ValueError: If the messages are not in the correct format.
         """

gllm_inference/lm_invoker/openai_compatible_lm_invoker.pyi

@@ -1,15 +1,14 @@
 from _typeshed import Incomplete
 from gllm_core.event import EventEmitter as EventEmitter
 from gllm_core.utils.retry import RetryConfig as RetryConfig
-from gllm_inference.constants import ALL_EXTENSIONS as ALL_EXTENSIONS
 from gllm_inference.lm_invoker.lm_invoker import BaseLMInvoker as BaseLMInvoker
 from gllm_inference.lm_invoker.schema.openai_compatible import InputType as InputType, Key as Key, ReasoningEffort as ReasoningEffort
-from gllm_inference.schema import Attachment as Attachment, AttachmentType as AttachmentType, EmitDataType as EmitDataType, LMOutput as LMOutput, ModelId as ModelId, ModelProvider as ModelProvider, MultimodalPrompt as MultimodalPrompt, PromptRole as PromptRole, Reasoning as Reasoning, ResponseSchema as ResponseSchema, TokenUsage as TokenUsage, ToolCall as ToolCall, ToolResult as ToolResult
-from gllm_inference.utils.utils import validate_string_enum as validate_string_enum
+from gllm_inference.schema import Attachment as Attachment, AttachmentType as AttachmentType, EmitDataType as EmitDataType, LMOutput as LMOutput, Message as Message, MessageRole as MessageRole, ModelId as ModelId, ModelProvider as ModelProvider, Reasoning as Reasoning, ResponseSchema as ResponseSchema, TokenUsage as TokenUsage, ToolCall as ToolCall, ToolResult as ToolResult
+from gllm_inference.utils import validate_string_enum as validate_string_enum
 from langchain_core.tools import Tool as Tool
 from typing import Any
 
-VALID_EXTENSIONS_MAP: Incomplete
+SUPPORTED_ATTACHMENTS: Incomplete
 
 class OpenAICompatibleLMInvoker(BaseLMInvoker):
     '''A language model invoker to interact with endpoints compatible with OpenAI\'s chat completion API contract.
@@ -51,20 +50,14 @@ class OpenAICompatibleLMInvoker(BaseLMInvoker):
         ```
 
     Input types:
-        1. Text.
-        2. Audio, with extensions depending on the language model\'s capabilities.
-        3. Image, with extensions depending on the language model\'s capabilities.
-        Non-text inputs must be of valid file extensions and can be passed as an `Attachment` object.
-
-        Non-text inputs can only be passed with the `user` role.
+        The `OpenAICompatibleLMInvoker` supports the following input types: text, audio, and image.
+        Non-text inputs can be passed as an `Attachment` object with the `user` role.
 
         Usage example:
         ```python
         text = "What animal is in this image?"
         image = Attachment.from_path("path/to/local/image.png")
-
-        prompt = [(PromptRole.USER, [text, image])]
-        result = await lm_invoker.invoke(prompt)
+        result = await lm_invoker.invoke([text, image])
         ```
 
     Tool calling:
@@ -217,8 +210,7 @@ class OpenAICompatibleLMInvoker(BaseLMInvoker):
         Setting reasoning-related parameters for non-reasoning models will raise an error.
 
     Output types:
-        The output of the `OpenAICompatibleLMInvoker` is of type `MultimodalOutput`, which is a type alias that can
-        represent:
+        The output of the `OpenAICompatibleLMInvoker` can either be:
         1. `str`: The text response if no additional output is needed.
         2. `LMOutput`: A Pydantic model with the following attributes if any additional output is needed:
             2.1. response (str): The text response.
@@ -238,7 +230,7 @@ class OpenAICompatibleLMInvoker(BaseLMInvoker):
                 Defaults to an empty list.
     '''
     client: Incomplete
-    def __init__(self, model_name: str, base_url: str, api_key: str | None = None, model_kwargs: dict[str, Any] | None = None, default_hyperparameters: dict[str, Any] | None = None, tools: list[Tool] | None = None, response_schema: ResponseSchema | None = None, output_analytics: bool = False, retry_config: RetryConfig | None = None, reasoning_effort: ReasoningEffort | None = None, bind_tools_params: dict[str, Any] | None = None, with_structured_output_params: dict[str, Any] | None = None) -> None:
+    def __init__(self, model_name: str, base_url: str, api_key: str | None = None, model_kwargs: dict[str, Any] | None = None, default_hyperparameters: dict[str, Any] | None = None, tools: list[Tool] | None = None, response_schema: ResponseSchema | None = None, output_analytics: bool = False, retry_config: RetryConfig | None = None, reasoning_effort: ReasoningEffort | None = None) -> None:
         """Initializes a new instance of the OpenAICompatibleLMInvoker class.
 
         Args:
@@ -258,12 +250,6 @@ class OpenAICompatibleLMInvoker(BaseLMInvoker):
             retry_config (RetryConfig | None, optional): The retry configuration for the language model.
                 Defaults to None, in which case a default config with no retry and 30.0 seconds timeout is used.
             reasoning_effort (str | None, optional): The reasoning effort for the language model. Defaults to None.
-            bind_tools_params (dict[str, Any] | None, optional): Deprecated parameter to add tool calling capability.
-                If provided, must at least include the `tools` key that is equivalent to the `tools` parameter.
-                Retained for backward compatibility. Defaults to None.
-            with_structured_output_params (dict[str, Any] | None, optional): Deprecated parameter to instruct the
-                model to produce output with a certain schema. If provided, must at least include the `schema` key that
-                is equivalent to the `response_schema` parameter. Retained for backward compatibility. Defaults to None.
         """
     def set_response_schema(self, response_schema: ResponseSchema | None) -> None:
         """Sets the response schema for the language model hosted on the OpenAI compatible endpoint.

gllm_inference/lm_invoker/openai_lm_invoker.pyi

@@ -3,12 +3,12 @@ from gllm_core.event import EventEmitter as EventEmitter
 from gllm_core.utils.retry import RetryConfig as RetryConfig
 from gllm_inference.lm_invoker.lm_invoker import BaseLMInvoker as BaseLMInvoker
 from gllm_inference.lm_invoker.schema.openai import InputType as InputType, Key as Key, OutputType as OutputType, ReasoningEffort as ReasoningEffort, ReasoningSummary as ReasoningSummary
-from gllm_inference.schema import Attachment as Attachment, AttachmentType as AttachmentType, CodeExecResult as CodeExecResult, EmitDataType as EmitDataType, LMOutput as LMOutput, ModelId as ModelId, ModelProvider as ModelProvider, MultimodalPrompt as MultimodalPrompt, PromptRole as PromptRole, Reasoning as Reasoning, ResponseSchema as ResponseSchema, TokenUsage as TokenUsage, ToolCall as ToolCall, ToolResult as ToolResult
+from gllm_inference.schema import Attachment as Attachment, AttachmentType as AttachmentType, CodeExecResult as CodeExecResult, EmitDataType as EmitDataType, LMOutput as LMOutput, Message as Message, MessageRole as MessageRole, ModelId as ModelId, ModelProvider as ModelProvider, Reasoning as Reasoning, ResponseSchema as ResponseSchema, TokenUsage as TokenUsage, ToolCall as ToolCall, ToolResult as ToolResult
 from gllm_inference.utils import validate_string_enum as validate_string_enum
 from langchain_core.tools import Tool as Tool
 from typing import Any
 
-VALID_EXTENSIONS_MAP: Incomplete
+SUPPORTED_ATTACHMENTS: Incomplete
 
 class OpenAILMInvoker(BaseLMInvoker):
     '''A language model invoker to interact with OpenAI language models.
@@ -39,20 +39,14 @@ class OpenAILMInvoker(BaseLMInvoker):
         ```
 
     Input types:
-        1. Text.
-        2. Document: ".pdf".
-        3. Image: ".jpg", ".jpeg", ".png", ".gif", and ".webp".
-        Non-text inputs must be of valid file extensions and can be passed as an `Attachment` object.
-
-        Non-text inputs can only be passed with the `user` role.
+        The `OpenAILMInvoker` supports the following input types: text, document, and image.
+        Non-text inputs can be passed as an `Attachment` object with the `user` role.
 
         Usage example:
         ```python
         text = "What animal is in this image?"
         image = Attachment.from_path("path/to/local/image.png")
-
-        prompt = [(PromptRole.USER, [text, image])]
-        result = await lm_invoker.invoke(prompt)
+        result = await lm_invoker.invoke([text, image])
         ```
 
     Tool calling:
@@ -168,7 +162,7 @@ class OpenAILMInvoker(BaseLMInvoker):
         complex problem solving, coding, scientific reasoning, and multi-step planning for agentic workflows.
 
         The reasoning effort of reasoning models can be set via the `reasoning_effort` parameter. This parameter
-        will guide the models on how many reasoning tokens it should generate before creating a response to the prompt.
+        will guide the models on how many reasoning tokens it should generate before creating a response.
         Available options include:
         1. "low": Favors speed and economical token usage.
         2. "medium": Favors a balance between speed and reasoning accuracy.
@@ -218,11 +212,17 @@ class OpenAILMInvoker(BaseLMInvoker):
         When code interpreter is enabled, it is highly recommended to instruct the model to use the "python tool"
         in the system message, as "python tool" is the term recognized by the model to refer to the code interpreter.
 
-        Prompt example:
+        Messages example:
         ```python
-        prompt = [
-            ("system", ["You are a data analyst. Use the python tool to generate a file."]),
-            ("user", ["Show an histogram of the following data: [1, 2, 1, 4, 1, 2, 4, 2, 3, 1]"]),
+        messages = [
+            Message(
+                role=MessageRole.SYSTEM,
+                contents=["You are a data analyst. Use the python tool to generate a file."],
+            ),
+            Message(
+                role=MessageRole.USER,
+                contents=["Show an histogram of the following data: [1, 2, 1, 4, 1, 2, 4, 2, 3, 1]"],
+            ),
         ]
         ```
 
@@ -296,7 +296,7 @@ class OpenAILMInvoker(BaseLMInvoker):
         ```
 
     Output types:
-        The output of the `OpenAILMInvoker` is of type `MultimodalOutput`, which is a type alias that can represent:
+        The output of the `OpenAILMInvoker` can either be:
         1. `str`: The text response if no additional output is needed.
         2. `LMOutput`: A Pydantic model with the following attributes if any additional output is needed:
             2.1. response (str): The text response.
@@ -318,7 +318,7 @@ class OpenAILMInvoker(BaseLMInvoker):
                 enabled and the language model decides to execute any codes. Defaults to an empty list.
     '''
     client: Incomplete
-    def __init__(self, model_name: str, api_key: str | None = None, model_kwargs: dict[str, Any] | None = None, default_hyperparameters: dict[str, Any] | None = None, tools: list[Tool] | None = None, response_schema: ResponseSchema | None = None, output_analytics: bool = False, retry_config: RetryConfig | None = None, reasoning_effort: ReasoningEffort | None = None, reasoning_summary: ReasoningSummary | None = None, code_interpreter: bool = False, web_search: bool = False, bind_tools_params: dict[str, Any] | None = None, with_structured_output_params: dict[str, Any] | None = None) -> None:
+    def __init__(self, model_name: str, api_key: str | None = None, model_kwargs: dict[str, Any] | None = None, default_hyperparameters: dict[str, Any] | None = None, tools: list[Tool] | None = None, response_schema: ResponseSchema | None = None, output_analytics: bool = False, retry_config: RetryConfig | None = None, reasoning_effort: ReasoningEffort | None = None, reasoning_summary: ReasoningSummary | None = None, code_interpreter: bool = False, web_search: bool = False) -> None:
         """Initializes a new instance of the OpenAILMInvoker class.
 
         Args:
@@ -342,12 +342,6 @@ class OpenAILMInvoker(BaseLMInvoker):
                 Not allowed for non-reasoning models. If None, no summary will be generated. Defaults to None.
             code_interpreter (bool, optional): Whether to enable the code interpreter. Defaults to False.
             web_search (bool, optional): Whether to enable the web search. Defaults to False.
-            bind_tools_params (dict[str, Any] | None, optional): Deprecated parameter to add tool calling capability.
-                If provided, must at least include the `tools` key that is equivalent to the `tools` parameter.
-                Retained for backward compatibility. Defaults to None.
-            with_structured_output_params (dict[str, Any] | None, optional): Deprecated parameter to instruct the
-                model to produce output with a certain schema. If provided, must at least include the `schema` key that
-                is equivalent to the `response_schema` parameter. Retained for backward compatibility. Defaults to None.
 
         Raises:
             ValueError:

gllm_inference/prompt_builder/__init__.pyi

@@ -1,8 +1,3 @@
-from gllm_inference.prompt_builder.agnostic_prompt_builder import AgnosticPromptBuilder as AgnosticPromptBuilder
-from gllm_inference.prompt_builder.huggingface_prompt_builder import HuggingFacePromptBuilder as HuggingFacePromptBuilder
-from gllm_inference.prompt_builder.llama_prompt_builder import LlamaPromptBuilder as LlamaPromptBuilder
-from gllm_inference.prompt_builder.mistral_prompt_builder import MistralPromptBuilder as MistralPromptBuilder
-from gllm_inference.prompt_builder.openai_prompt_builder import OpenAIPromptBuilder as OpenAIPromptBuilder
 from gllm_inference.prompt_builder.prompt_builder import PromptBuilder as PromptBuilder
 
-__all__ = ['AgnosticPromptBuilder', 'HuggingFacePromptBuilder', 'LlamaPromptBuilder', 'MistralPromptBuilder', 'OpenAIPromptBuilder', 'PromptBuilder']
+__all__ = ['PromptBuilder']