gllm-inference-binary 0.5.9b1__cp311-cp311-macosx_10_9_universal2.macosx_13_0_x86_64.whl

gllm_inference/prompt_formatter/agnostic_prompt_formatter.pyi

@@ -0,0 +1,49 @@
+from _typeshed import Incomplete
+from gllm_inference.prompt_formatter.prompt_formatter import BasePromptFormatter as BasePromptFormatter
+from gllm_inference.schema import MessageRole as MessageRole
+
+class AgnosticPromptFormatter(BasePromptFormatter):
+    '''A prompt formatter that formats prompt without any specific model formatting.
+
+    The `AgnosticPromptFormatter` class formats a prompt by joining the content of the prompt templates using a
+    specified separator. It is designed to work independently of specific model types.
+
+    Attributes:
+        content_separator (str): A string used to separate each content in a message.
+        message_separator (str): A string used to separate each message.
+
+    Usage:
+        The `AgnosticPromptFormatter` can be used to format a prompt for any model.
+        The `content_separator` and `message_separator` can be customized to define the format of the prompt.
+
+        Usage example:
+        ```python
+        prompt = [
+            (MessageRole.USER, ["Hello", "how are you?"]),
+            (MessageRole.ASSISTANT, ["I\'m fine", "thank you!"]),
+            (MessageRole.USER, ["What is the capital of France?"]),
+        ]
+        prompt_formatter = AgnosticPromptFormatter(
+            message_separator="\\n###\\n",
+            content_separator="---"
+        )
+        print(prompt_formatter.format(prompt))
+        ```
+
+        Output example:
+        ```
+        Hello---how are you?
+        ###
+        I\'m fine---thank you!
+        ###
+        What is the capital of France?
+        ```
+    '''
+    message_separator: Incomplete
+    def __init__(self, message_separator: str = '\n', content_separator: str = '\n') -> None:
+        '''Initializes a new instance of the AgnosticPromptFormatter class.
+
+        Args:
+            message_separator (str, optional): A string used to separate each message. Defaults to "\\n".
+            content_separator (str, optional): A string used to separate each content in a message. Defaults to "\\n".
+        '''

gllm_inference/prompt_formatter/huggingface_prompt_formatter.pyi

@@ -0,0 +1,55 @@
+from gllm_inference.prompt_formatter.prompt_formatter import BasePromptFormatter as BasePromptFormatter
+from gllm_inference.schema import MessageRole as MessageRole
+
+TOKENIZER_LOAD_ERROR_MESSAGE: str
+
+class HuggingFacePromptFormatter(BasePromptFormatter):
+    '''A prompt formatter that formats prompt using HuggingFace model\'s specific formatting.
+
+    The `HuggingFacePromptFormatter` class is designed to format prompt using a HuggingFace model\'s specific formatting.
+    It does so by using the model\'s tokenizer\'s `apply_chat_template` method.
+
+    Attributes:
+        content_separator (str): A string used to separate each content in a message.
+        tokenizer (PreTrainedTokenizer): The HuggingFace model tokenizer used for chat templating.
+
+    Usage:
+        The `HuggingFacePromptFormatter` can be used to format a prompt using a HuggingFace model\'s specific formatting.
+        The `content_separator` and `model_name_or_path` can be customized to define the format of the prompt.
+        The `model_name_or_path` defines the name of the HuggingFace model whose tokenizer will be used to format
+        the prompt using the `apply_chat_template` method.
+
+        Usage example:
+        ```python
+        prompt = [
+            (MessageRole.USER, ["Hello", "how are you?"]),
+            (MessageRole.ASSISTANT, ["I\'m fine", "thank you!"]),
+            (MessageRole.USER, ["What is the capital of France?"]),
+        ]
+        prompt_formatter = HuggingFacePromptFormatter(
+            model_name_or_path="mistralai/Mistral-7B-Instruct-v0.1",
+            content_separator="---"
+        )
+        print(prompt_formatter.format(prompt))
+        ```
+
+        Output example:
+        ```
+        <s>[INST] Hello---how are you? [/INST]I\'m fine---thank you!</s> [INST] What is the capital of France? [/INST]
+        ```
+
+    Using a gated model:
+        If you\'re trying to access the prompt builder template of a gated model, you\'d need to:
+        1. Request access to the gated repo using your HuggingFace account.
+        2. Login to HuggingFace in your system. This can be done as follows:
+           2.1. Install huggingface-hub: ```pip install huggingface-hub```
+           2.2. Login to HuggingFace: ```huggingface-cli login```
+           2.3. Enter your HuggingFace token.
+    '''
+    def __init__(self, model_name_or_path: str, content_separator: str = '\n') -> None:
+        '''Initializes a new instance of the HuggingFacePromptFormatter class.
+
+        Args:
+            model_name_or_path (str): The model name or path of the HuggingFace model tokenizer to be loaded.
+            content_separator (str, optional): A string used to separate each content in a message. Defaults to "\\n".
+        '''

gllm_inference/prompt_formatter/llama_prompt_formatter.pyi

@@ -0,0 +1,59 @@
+from gllm_inference.prompt_formatter import HuggingFacePromptFormatter as HuggingFacePromptFormatter
+
+class LlamaPromptFormatter(HuggingFacePromptFormatter):
+    '''A prompt formatter that formats prompt using Llama model\'s specific formatting.
+
+    The `LlamaPromptFormatter` class is designed to format prompt using a Llama model\'s specific formatting.
+    It does so by using the model\'s tokenizer\'s `apply_chat_template` method.
+
+    Attributes:
+        content_separator (str): A string used to separate each content in a message.
+        tokenizer (PreTrainedTokenizer): The HuggingFace model tokenizer used for chat templating.
+
+    Usage:
+        The `LlamaPromptFormatter` can be used to format a prompt using a Llama model\'s specific formatting.
+        The `content_separator` and `model_name` can be customized to define the format of the prompt.
+        The `model_name` defines the name of the HuggingFace model whose tokenizer will be used to format
+        the prompt using the `apply_chat_template` method.
+
+        Usage example:
+        ```python
+        prompt = [
+            (MessageRole.USER, ["Hello", "how are you?"]),
+            (MessageRole.ASSISTANT, ["I\'m fine", "thank you!"]),
+            (MessageRole.USER, ["What is the capital of France?"]),
+        ]
+        prompt_formatter = LlamaPromptFormatter(
+            model_name_or_path="meta-llama/Meta-Llama-3.1-8B-Instruct",
+            content_separator="---"
+        )
+        print(prompt_formatter.format(prompt))
+        ```
+
+        Output example:
+        ```
+        <|begin_of_text|><|start_header_id|>user<|end_header_id|>
+
+        Hello---how are you?<|eot_id|><|start_header_id|>assistant<|end_header_id|>
+
+        I\'m fine---thank you!<|eot_id|><|start_header_id|>user<|end_header_id|>
+
+        What is the capital of France?<|eot_id|><|start_header_id|>assistant<|end_header_id|>
+        ```
+
+    Using a gated model:
+        If you\'re trying to access the prompt builder template of a gated model, you\'d need to:
+        1. Request access to the gated repo using your HuggingFace account.
+        2. Login to HuggingFace in your system. This can be done as follows:
+           2.1. Install huggingface-hub: ```pip install huggingface-hub```
+           2.2. Login to HuggingFace: ```huggingface-cli login```
+           2.3. Enter your HuggingFace token.
+    '''
+    def __init__(self, model_name: str = 'Meta-Llama-3.1-8B-Instruct', content_separator: str = '\n') -> None:
+        '''Initializes a new instance of the LlamaPromptFormatter class.
+
+        Args:
+            model_name (str, optional): The name of the Llama model tokenizer to be loaded. Defaults to
+                `Meta-Llama-3.1-8B-Instruct`.
+            content_separator (str, optional): A string used to separate each content in a message. Defaults to "\\n".
+        '''

gllm_inference/prompt_formatter/mistral_prompt_formatter.pyi

@@ -0,0 +1,53 @@
+from gllm_inference.prompt_formatter import HuggingFacePromptFormatter as HuggingFacePromptFormatter
+
+class MistralPromptFormatter(HuggingFacePromptFormatter):
+    '''A prompt formatter that formats prompt using Mistral model\'s specific formatting.
+
+    The `MistralPromptFormatter` class is designed to format prompt using a Mistral model\'s specific formatting.
+    It does so by using the model\'s tokenizer\'s `apply_chat_template` method.
+
+    Attributes:
+        content_separator (str): A string used to separate each content in a message.
+        tokenizer (PreTrainedTokenizer): The HuggingFace model tokenizer used for chat templating.
+
+    Usage:
+        The `MistralPromptFormatter` can be used to format a prompt using a Mistral model\'s specific formatting.
+        The `content_separator` and `model_name` can be customized to define the format of the prompt.
+        The `model_name` defines the name of the HuggingFace model whose tokenizer will be used to format
+        the prompt using the `apply_chat_template` method.
+
+        Usage example:
+        ```python
+        prompt = [
+            (MessageRole.USER, ["Hello", "how are you?"]),
+            (MessageRole.ASSISTANT, ["I\'m fine", "thank you!"]),
+            (MessageRole.USER, ["What is the capital of France?"]),
+        ]
+        prompt_formatter = MistralPromptFormatter(
+            model_name_or_path="mistralai/Mistral-7B-Instruct-v0.1",
+            content_separator="---"
+        )
+        print(prompt_formatter.format(prompt))
+        ```
+
+        Output example:
+        ```
+        <s>[INST] Hello---how are you? [/INST]I\'m fine---thank you!</s> [INST] What is the capital of France? [/INST]
+        ```
+
+    Using a gated model:
+        If you\'re trying to access the prompt builder template of a gated model, you\'d need to:
+        1. Request access to the gated repo using your HuggingFace account.
+        2. Login to HuggingFace in your system. This can be done as follows:
+           2.1. Install huggingface-hub: ```pip install huggingface-hub```
+           2.2. Login to HuggingFace: ```huggingface-cli login```
+           2.3. Enter your HuggingFace token.
+    '''
+    def __init__(self, model_name: str = 'Mistral-7B-Instruct-v0.3', content_separator: str = '\n') -> None:
+        '''Initializes a new instance of the MistralPromptFormatter class.
+
+        Args:
+            model_name (str, optional): The name of the Mistral model tokenizer to be loaded. Defaults to
+                `Mistral-7B-Instruct-v0.3`.
+            content_separator (str, optional): A string used to separate each content in a message. Defaults to "\\n".
+        '''

gllm_inference/prompt_formatter/openai_prompt_formatter.pyi

@@ -0,0 +1,35 @@
+from gllm_inference.prompt_formatter.prompt_formatter import BasePromptFormatter as BasePromptFormatter
+from gllm_inference.schema import MessageRole as MessageRole
+
+class OpenAIPromptFormatter(BasePromptFormatter):
+    '''A prompt formatter that formats prompt with OpenAI\'s specific formatting.
+
+    The `OpenAIPromptFormatter` class formats a prompt by utilizing OpenAI\'s specific formatting.
+
+    Attributes:
+        content_separator (str): A string used to separate each content in a message.
+
+    Usage:
+        The `OpenAIPromptFormatter` can be used to format a prompt for OpenAI\'s models.
+        The `content_separator` can be customized to define the format of the prompt.
+
+        Usage example:
+        ```python
+        prompt = [
+            (MessageRole.USER, ["Hello", "how are you?"]),
+            (MessageRole.ASSISTANT, ["I\'m fine", "thank you!"]),
+            (MessageRole.USER, ["What is the capital of France?"]),
+        ]
+        prompt_formatter = OpenAIPromptFormatter(
+            content_separator="---"
+        )
+        print(prompt_formatter.format(prompt))
+        ```
+
+        Output example:
+        ```
+        User: Hello---how are you?
+        Assistant: I\'m fine---thank you!
+        User: What is the capital of France?
+        ```
+    '''

gllm_inference/prompt_formatter/prompt_formatter.pyi

@@ -0,0 +1,30 @@
+import abc
+from _typeshed import Incomplete
+from abc import ABC
+from gllm_inference.schema import Message as Message, MessageContent as MessageContent, MessageRole as MessageRole
+
+class BasePromptFormatter(ABC, metaclass=abc.ABCMeta):
+    """A base class for prompt formatters used in Gen AI applications.
+
+    The prompt formatter class is used to format a prompt into a string with specific formatting.
+
+    Attributes:
+        content_separator (str): The separator to be used between the string in a single message.
+    """
+    content_separator: Incomplete
+    def __init__(self, content_separator: str = '\n') -> None:
+        '''Initializes a new instance of the BasePromptFormatter class.
+
+        Args:
+            content_separator (str, optional): The separator to be used between the string in a single message.
+                Defaults to "\\n".
+        '''
+    def format(self, messages: list[Message]) -> str:
+        """Formats the prompt as a string.
+
+        Args:
+            messages (list[Message]): The messages to be formatted as a string.
+
+        Returns:
+            str: The formatted messages as a string.
+        """

gllm_inference/request_processor/__init__.pyi

@@ -0,0 +1,4 @@
+from gllm_inference.request_processor.lm_request_processor import LMRequestProcessor as LMRequestProcessor
+from gllm_inference.request_processor.uses_lm_mixin import UsesLM as UsesLM
+
+__all__ = ['LMRequestProcessor', 'UsesLM']

gllm_inference/request_processor/lm_request_processor.pyi

@@ -0,0 +1,101 @@
+from _typeshed import Incomplete
+from gllm_core.event import EventEmitter as EventEmitter
+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.schema import LMOutput as LMOutput, Message as Message, MessageContent as MessageContent, ResponseSchema as ResponseSchema, ToolCall as ToolCall, ToolResult as ToolResult
+from langchain_core.tools import Tool as Tool
+from typing import Any
+
+class LMRequestProcessor:
+    """A request processor to perform language models inference.
+
+    The `LMRequestProcessor` class handles the process of building a prompt, invoking a language model, and optionally
+    parsing the output. It combines a prompt builder, language model invoker, and an optional output parser to manage
+    the inference process in Gen AI applications.
+
+    Attributes:
+        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 | None): The optional parser to process the model's output, if any.
+        tool_dict (dict[str, Tool]): A dictionary of tools provided to the language model to enable tool calling,
+            if any. The dictionary maps the tool name to the tools themselves.
+    """
+    prompt_builder: Incomplete
+    lm_invoker: Incomplete
+    output_parser: Incomplete
+    tool_dict: Incomplete
+    def __init__(self, prompt_builder: PromptBuilder, lm_invoker: BaseLMInvoker, output_parser: BaseOutputParser | None = None) -> None:
+        """Initializes a new instance of the LMRequestProcessor class.
+
+        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.
+        """
+    def set_tools(self, tools: list[Tool]) -> None:
+        """Sets the tools for the LM invoker.
+
+        This method sets the tools for the LM invoker. Any existing tools will be replaced.
+
+        Args:
+            tools (list[Tool]): The list of tools to be used.
+        """
+    def clear_tools(self) -> None:
+        """Clears the tools for the LM invoker.
+
+        This method clears the tools for the LM invoker.
+        """
+    def set_response_schema(self, response_schema: ResponseSchema | None) -> None:
+        """Sets the response schema for the LM invoker.
+
+        This method sets the response schema for the LM invoker. Any existing response schema will be replaced.
+
+        Args:
+            response_schema (ResponseSchema | None): The response schema to be used.
+        """
+    def clear_response_schema(self) -> None:
+        """Clears the response schema for the LM invoker.
+
+        This method clears the response schema for the LM invoker.
+        """
+    async def process(self, prompt_kwargs: dict[str, Any] | None = None, history: list[Message] | None = None, extra_contents: list[MessageContent] | None = None, hyperparameters: dict[str, Any] | None = None, event_emitter: EventEmitter | None = None, auto_execute_tools: bool = True, max_lm_calls: int = 5, **kwargs: Any) -> Any:
+        """Processes a language model inference request.
+
+        This method processes the language model inference request as follows:
+        1. Assembling the prompt using the provided keyword arguments.
+        2. Invoking the language model with the assembled prompt and optional hyperparameters.
+        3. If `auto_execute_tools` is True, the method will automatically execute tools if the LM output includes
+           tool calls.
+        4. Optionally parsing the model's output using the output parser if provided. If the model output is an
+           LMOutput object, the output parser will process the `response` attribute of the LMOutput object.
+
+        Args:
+            prompt_kwargs (dict[str, Any], optional): Deprecated parameter for passing prompt kwargs.
+                Replaced by **kwargs. Defaults to None
+            history (list[Message] | None, optional): A list of conversation history to be included in the prompt.
+                Defaults to None.
+            extra_contents (list[MessageContent] | None, optional): A list of extra contents to be included in the
+                user message. Defaults to None.
+            hyperparameters (dict[str, Any] | None, optional): A dictionary of hyperparameters for the model invocation.
+                Defaults to None.
+            event_emitter (EventEmitter | None, optional): An event emitter for streaming model outputs.
+                Defaults to None.
+            auto_execute_tools (bool, optional): Whether to automatically execute tools if the LM invokes output
+                tool calls. Defaults to True.
+            max_lm_calls (int, optional): The maximum number of times the language model can be invoked
+                when `auto_execute_tools` is True. Defaults to 5.
+            **kwargs (Any): Keyword arguments that will be passed to format the prompt builder.
+                Values must be either a string or an object that can be serialized to a string.
+                Reserved keyword arguments that cannot be passed to the prompt builder include:
+                1. `history`
+                2. `extra_contents`
+                3. `hyperparameters`
+                4. `event_emitter`
+                5. `auto_execute_tools`
+                6. `max_lm_calls`
+
+        Returns:
+            Any: The result of the language model invocation, optionally parsed by the output parser.
+        """

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,14 @@
+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, EmitDataType as EmitDataType, MessageRole as MessageRole, TruncateSide as TruncateSide
+from gllm_inference.schema.lm_output import LMOutput as LMOutput
+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__ = ['Attachment', 'AttachmentType', 'CodeExecResult', 'EMContent', 'EmitDataType', 'InputTokenDetails', 'MessageContent', 'LMOutput', 'ModelId', 'ModelProvider', 'Message', 'MessageRole', 'OutputTokenDetails', 'Reasoning', 'ResponseSchema', 'TokenUsage', 'ToolCall', 'ToolResult', 'TruncateSide', 'TruncationConfig', 'Vector']

gllm_inference/schema/attachment.pyi

@@ -0,0 +1,88 @@
+from _typeshed import Incomplete
+from gllm_inference.constants import HEX_REPR_LENGTH as HEX_REPR_LENGTH
+from pydantic import BaseModel
+
+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.
+    """
+    data: bytes
+    filename: str
+    mime_type: str
+    extension: str
+    url: str | None
+    @classmethod
+    def from_bytes(cls, bytes: bytes, filename: str | 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.
+
+        Returns:
+            Attachment: The instantiated Attachment.
+        """
+    @classmethod
+    def from_base64(cls, base64_data: str, filename: str | 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.
+
+        Returns:
+            Attachment: The instantiated Attachment.
+        """
+    @classmethod
+    def from_data_url(cls, data_url: str, filename: str | 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.
+
+        Returns:
+            Attachment: The instantiated Attachment.
+        """
+    @classmethod
+    def from_url(cls, url: str, filename: str | 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.
+
+        Returns:
+            Attachment: The instantiated Attachment.
+        """
+    @classmethod
+    def from_path(cls, path: str, filename: str | 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.
+
+        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