gllm-inference-binary 0.5.55__cp312-cp312-macosx_13_0_arm64.whl

gllm_inference/realtime_chat/input_streamer/input_streamer.pyi

@@ -0,0 +1,36 @@
+import abc
+import asyncio
+from abc import ABC, abstractmethod
+from pydantic import BaseModel as BaseModel
+
+class BaseInputStreamer(ABC, metaclass=abc.ABCMeta):
+    """[BETA] A base class for input streamers.
+
+    Attributes:
+        state (BaseModel | None): The state of the input streamer.
+        input_queue (asyncio.Queue | None): The queue to put the input events.
+    """
+    state: BaseModel | None
+    input_queue: asyncio.Queue | None
+    async def initialize(self, state: BaseModel, input_queue: asyncio.Queue) -> None:
+        """Initializes the input streamer.
+
+        Args:
+            input_queue (asyncio.Queue): The queue to put the input events.
+            state (BaseModel): The state of the input streamer.
+        """
+    @abstractmethod
+    async def stream_input(self) -> None:
+        """Streams the input from a certain source.
+
+        This method must be implemented by subclasses to define the logic for streaming the input.
+
+        Raises:
+            NotImplementedError: If the method is not implemented in a subclass.
+        """
+    async def close(self) -> None:
+        """Closes the input streamer.
+
+        This method is used to close the input streamer.
+        It is used to clean up the input streamer.
+        """

gllm_inference/realtime_chat/input_streamer/keyboard_input_streamer.pyi

@@ -0,0 +1,27 @@
+import asyncio
+from _typeshed import Incomplete
+from gllm_inference.realtime_chat.input_streamer.input_streamer import BaseInputStreamer as BaseInputStreamer
+
+DEFAULT_QUIT_CMD: str
+
+class KeyboardInputStreamer(BaseInputStreamer):
+    """[BETA] A keyboard input streamer that reads the input text from the keyboard.
+
+    Attributes:
+        state (BaseModel): The state of the input streamer.
+        input_queue (asyncio.Queue): The queue to put the input events.
+        quit_cmd (str): The command to quit the conversation.
+    """
+    record_process: asyncio.subprocess.Process | None
+    quit_cmd: Incomplete
+    def __init__(self, quit_cmd: str = ...) -> None:
+        """Initializes the KeyboardInputStreamer.
+
+        Args:
+            quit_cmd (str, optional): The command to quit the conversation. Defaults to DEFAULT_QUIT_CMD.
+        """
+    async def stream_input(self) -> None:
+        """Streams the input from the keyboard.
+
+        This method is used to stream the input text from the keyboard to the input queue.
+        """

gllm_inference/realtime_chat/input_streamer/linux_mic_input_streamer.pyi

@@ -0,0 +1,36 @@
+import asyncio
+from _typeshed import Incomplete
+from gllm_inference.realtime_chat.input_streamer.input_streamer import BaseInputStreamer as BaseInputStreamer
+
+SEND_SAMPLE_RATE: int
+CHANNELS: int
+RECORD_CMD: Incomplete
+CHUNK_DURATION: float
+CHUNK_SIZE: Incomplete
+
+class LinuxMicInputStreamer(BaseInputStreamer):
+    """[BETA] A Linux microphone input streamer that reads the input audio from the microphone.
+
+    Attributes:
+        state (BaseModel): The state of the input streamer.
+        input_queue (asyncio.Queue): The queue to put the input events.
+        record_process (asyncio.subprocess.Process | None): The process to record the input audio.
+    """
+    record_process: asyncio.subprocess.Process | None
+    def __init__(self) -> None:
+        """Initializes the LinuxMicInputStreamer.
+
+        Raises:
+            OSError: If the current system is not Linux.
+        """
+    async def stream_input(self) -> None:
+        """Streams the input audio from the Linux system microphone.
+
+        This method is used to stream the recorded input audio from the Linux system microphone to the input queue.
+        """
+    async def close(self) -> None:
+        """Closes the LinuxMicInputStreamer.
+
+        This method is used to close the LinuxMicInputStreamer.
+        It is used to clean up the recording process.
+        """

gllm_inference/realtime_chat/output_streamer/__init__.pyi

@@ -0,0 +1,4 @@
+from gllm_inference.realtime_chat.output_streamer.console_output_streamer import ConsoleOutputStreamer as ConsoleOutputStreamer
+from gllm_inference.realtime_chat.output_streamer.linux_speaker_output_streamer import LinuxSpeakerOutputStreamer as LinuxSpeakerOutputStreamer
+
+__all__ = ['ConsoleOutputStreamer', 'LinuxSpeakerOutputStreamer']

gllm_inference/realtime_chat/output_streamer/console_output_streamer.pyi

@@ -0,0 +1,21 @@
+from gllm_inference.realtime_chat.output_streamer.output_streamer import BaseOutputStreamer as BaseOutputStreamer
+from typing import Any
+
+USER_HEADER: str
+ASSISTANT_HEADER: str
+FOOTER: str
+
+class ConsoleOutputStreamer(BaseOutputStreamer):
+    """[BETA] A console output streamer that prints the output to the console.
+
+    Attributes:
+        state (BaseModel): The state of the output streamer.
+    """
+    async def handle(self, data: dict[str, Any]) -> None:
+        """Handles the output events.
+
+        This method is used to handle the text output events and print them to the console.
+
+        Args:
+            data (dict[str, Any]): The output events.
+        """

gllm_inference/realtime_chat/output_streamer/linux_speaker_output_streamer.pyi

@@ -0,0 +1,42 @@
+import asyncio
+from _typeshed import Incomplete
+from gllm_inference.realtime_chat.output_streamer.output_streamer import BaseOutputStreamer as BaseOutputStreamer
+from pydantic import BaseModel as BaseModel
+from typing import Any
+
+PLAY_AUDIO_SAMPLE_RATE: int
+CHANNELS: int
+PLAY_CMD: Incomplete
+OUTPUT_AUDIO_DELAY: float
+
+class LinuxSpeakerOutputStreamer(BaseOutputStreamer):
+    """[BETA] A Linux speaker output streamer that plays the output audio through the speakers.
+
+    Attributes:
+        state (BaseModel): The state of the output streamer.
+        play_process (asyncio.subprocess.Process | None): The process to play the output audio.
+    """
+    play_process: asyncio.subprocess.Process | None
+    async def initialize(self, state: BaseModel) -> None:
+        """Initializes the LinuxSpeakerOutputStreamer.
+
+        Args:
+            state (BaseModel): The state of the output streamer.
+
+        Raises:
+            OSError: If the current system is not Linux.
+        """
+    async def handle(self, data: dict[str, Any]) -> None:
+        """Handles the output events.
+
+        This method is used to handle the audio output events and play them through the Linux system speakers.
+
+        Args:
+            data (dict[str, Any]): The output events.
+        """
+    async def close(self) -> None:
+        """Closes the LinuxSpeakerOutputStreamer.
+
+        This method is used to close the LinuxSpeakerOutputStreamer.
+        It is used to clean up playing process.
+        """

gllm_inference/realtime_chat/output_streamer/output_streamer.pyi

@@ -0,0 +1,33 @@
+import abc
+from abc import ABC, abstractmethod
+from pydantic import BaseModel as BaseModel
+from typing import Any
+
+class BaseOutputStreamer(ABC, metaclass=abc.ABCMeta):
+    """[BETA] A base class for output streamers.
+
+    Attributes:
+        state (BaseModel | None): The state of the output streamer.
+    """
+    state: BaseModel | None
+    async def initialize(self, state: BaseModel) -> None:
+        """Initializes the output streamer.
+
+        Args:
+            state (BaseModel): The state of the output streamer.
+        """
+    @abstractmethod
+    async def handle(self, data: dict[str, Any]) -> None:
+        """Handles output events streamed from the model.
+
+        This method must be implemented by subclasses to define the logic for handling the output events.
+
+        Raises:
+            NotImplementedError: If the method is not implemented in a subclass.
+        """
+    async def close(self) -> None:
+        """Closes the output streamer.
+
+        This method is used to close the output streamer.
+        It is used to clean up the output streamer.
+        """

gllm_inference/realtime_chat/realtime_chat.pyi

@@ -0,0 +1,28 @@
+import abc
+from abc import ABC, abstractmethod
+from gllm_inference.realtime_chat.input_streamer.input_streamer import BaseInputStreamer as BaseInputStreamer
+from gllm_inference.realtime_chat.output_streamer.output_streamer import BaseOutputStreamer as BaseOutputStreamer
+
+class BaseRealtimeChat(ABC, metaclass=abc.ABCMeta):
+    """[BETA] A base class for realtime chat modules.
+
+    The `BaseRealtimeChat` class provides a framework for processing real-time conversations.
+    """
+    def __init__(self) -> None:
+        """Initializes a new instance of the BaseRealtimeChat class."""
+    @abstractmethod
+    async def start(self, input_streamers: list[BaseInputStreamer] | None = None, output_streamers: list[BaseOutputStreamer] | None = None) -> None:
+        """Starts the real-time conversation using the provided input and output streamers.
+
+        This abstract method must be implemented by subclasses to define the logic
+        for starting the real-time conversation.
+
+        Args:
+            input_streamers (list[BaseInputStreamer] | None, optional): The input streamers to use.
+                Defaults to None.
+            output_streamers (list[BaseOutputStreamer] | None, optional): The output streamers to use.
+                Defaults to None.
+
+        Raises:
+            NotImplementedError: If the method is not implemented in a subclass.
+        """

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,18 @@
+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.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', '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,88 @@
+from _typeshed import Incomplete
+from pydantic import BaseModel
+
+HEX_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.
+    """
+    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]