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

gllm_inference/schema/config.pyi

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

gllm_inference/schema/enums.pyi

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

gllm_inference/schema/events.pyi

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

gllm_inference/schema/lm_input.pyi

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

gllm_inference/schema/lm_output.pyi

@@ -0,0 +1,188 @@
+from _typeshed import Incomplete
+from gllm_core.schema import Chunk
+from gllm_inference.schema.attachment import Attachment as Attachment
+from gllm_inference.schema.code_exec_result import CodeExecResult as CodeExecResult
+from gllm_inference.schema.enums import LMOutputType as LMOutputType
+from gllm_inference.schema.mcp import MCPCall as MCPCall
+from gllm_inference.schema.reasoning import Reasoning as Reasoning
+from gllm_inference.schema.token_usage import TokenUsage as TokenUsage
+from gllm_inference.schema.tool_call import ToolCall as ToolCall
+from pydantic import BaseModel
+from typing import Any
+
+LMOutputData = str | dict[str, Any] | BaseModel | Attachment | ToolCall | Reasoning | Chunk | CodeExecResult | MCPCall
+logger: Incomplete
+
+class LMOutputItem(BaseModel):
+    """Defines the output item of a language model.
+
+    Attributes:
+        type (str): The type of the output item.
+        output (LMOutputData): The output data of the output item.
+    """
+    type: str
+    output: LMOutputData
+
+class LMOutput(BaseModel):
+    """Defines the output of a language model.
+
+    Attributes:
+        outputs (list[LMOutputItem]): The outputs of the language model in sequential order. Defaults to an empty list.
+        token_usage (TokenUsage | None): The token usage analytics, if requested. Defaults to None.
+        duration (float | None): The duration of the invocation in seconds, if requested. Defaults to None.
+        finish_details (dict[str, Any]): The details about how the generation finished, if requested.
+            Defaults to an empty dictionary.
+
+        text (str): The first text response.
+        structured_output (dict[str, Any] | BaseModel | None): The first structured output.
+
+        texts (list[str]): The texts from the outputs.
+        structured_outputs (list[dict[str, Any] | BaseModel]): The structured outputs from the outputs.
+        attachments (list[Attachment]): The attachments from the outputs.
+        tool_calls (list[ToolCall]): The tool calls from the outputs.
+        thinkings (list[Reasoning]): The thinkings from the outputs.
+        citations (list[Chunk]): The citations from the outputs.
+        code_exec_results (list[CodeExecResult]): The code exec results from the outputs.
+        mcp_calls (list[MCPCall]): The MCP calls from the outputs.
+
+        response (str): Deprecated. Replaced by `text`.
+        reasoning (list[Reasoning]): Deprecated. Replaced by `thinkings`.
+    """
+    outputs: list[LMOutputItem]
+    token_usage: TokenUsage | None
+    duration: float | None
+    finish_details: dict[str, Any]
+    @property
+    def response(self) -> str:
+        """Deprecated property to get the first text response from the LMOutput.
+
+        Returns:
+            str: The first text response from the LMOutput.
+        """
+    @property
+    def text(self) -> str:
+        """Get the first text from the LMOutput.
+
+        Returns:
+            str: The first text from the LMOutput.
+        """
+    @property
+    def structured_output(self) -> dict[str, Any] | BaseModel | None:
+        """Deprecated property to get the first structured output from the LMOutput.
+
+        Returns:
+            dict[str, Any] | BaseModel | None: The first structured output from the LMOutput.
+        """
+    @property
+    def texts(self) -> list[str]:
+        """Get the texts from the LMOutput.
+
+        Returns:
+            list[str]: The texts from the LMOutput.
+        """
+    @property
+    def structured_outputs(self) -> list[dict[str, Any] | BaseModel]:
+        """Get the structured outputs from the LMOutput.
+
+        Returns:
+            list[dict[str, Any] | BaseModel]: The structured outputs from the LMOutput.
+        """
+    @property
+    def attachments(self) -> list[Attachment]:
+        """Get the attachments from the LMOutput.
+
+        Returns:
+            list[Attachment]: The attachments from the LMOutput.
+        """
+    @property
+    def tool_calls(self) -> list[ToolCall]:
+        """Get the tool calls from the LMOutput.
+
+        Returns:
+            list[ToolCall]: The tool calls from the LMOutput.
+        """
+    @property
+    def reasoning(self) -> list[Reasoning]:
+        """Deprecated property to get the thinkings from the LMOutput.
+
+        Returns:
+            list[Reasoning]: The thinkings from the LMOutput.
+        """
+    @property
+    def thinkings(self) -> list[Reasoning]:
+        """Get the thinkings from the LMOutput.
+
+        Returns:
+            list[Reasoning]: The thinkings from the LMOutput.
+        """
+    @property
+    def citations(self) -> list[Chunk]:
+        """Get the citations from the LMOutput.
+
+        Returns:
+            list[Chunk]: The citations from the LMOutput.
+        """
+    @property
+    def code_exec_results(self) -> list[CodeExecResult]:
+        """Get the code exec results from the LMOutput.
+
+        Returns:
+            list[CodeExecResult]: The code exec results from the LMOutput.
+        """
+    @property
+    def mcp_calls(self) -> list[MCPCall]:
+        """Get the MCP calls from the LMOutput.
+
+        Returns:
+            list[MCPCall]: The MCP calls from the LMOutput.
+        """
+    def add_text(self, text: str | list[str]) -> None:
+        """Add an output or a list of outputs to the LMOutput.
+
+        Args:
+            text (str | list[str]): The text or a list of texts to add.
+        """
+    def add_attachment(self, attachment: Attachment | list[Attachment]) -> None:
+        """Add an attachment or a list of attachments to the LMOutput.
+
+        Args:
+            attachment (Attachment | list[Attachment]): The attachment or a list of attachments to add.
+        """
+    def add_tool_call(self, tool_call: ToolCall | list[ToolCall]) -> None:
+        """Add a tool call or a list of tool calls to the LMOutput.
+
+        Args:
+            tool_call (ToolCall | list[ToolCall]): The tool call or a list of tool calls to add.
+        """
+    def add_structured(self, structured: dict[str, Any] | BaseModel | list[dict[str, Any] | BaseModel]) -> None:
+        """Add a structured output or a list of structured outputs to the LMOutput.
+
+        Args:
+            structured (dict[str, Any] | BaseModel | list[dict[str, Any] | BaseModel]): The structured output
+                or a list of structured outputs to add.
+        """
+    def add_thinking(self, thinking: Reasoning | list[Reasoning]) -> None:
+        """Add a thinking or a list of thoughts to the LMOutput.
+
+        Args:
+            thinking (Reasoning | list[Reasoning]): The thinking or a list of thoughts to add.
+        """
+    def add_citation(self, citation: Chunk | list[Chunk]) -> None:
+        """Add a citation or a list of citations to the LMOutput.
+
+        Args:
+            citation (Chunk | list[Chunk]): The citation or a list of citations to add.
+        """
+    def add_code_exec_result(self, code_exec_result: CodeExecResult | list[CodeExecResult]) -> None:
+        """Add a code exec result or a list of code exec results to the LMOutput.
+
+        Args:
+            code_exec_result (CodeExecResult | list[CodeExecResult]): The code exec result or a list of code exec
+                results to add.
+        """
+    def add_mcp_call(self, mcp_call: MCPCall | list[MCPCall]) -> None:
+        """Add an MCP call or a list of MCP calls to the LMOutput.
+
+        Args:
+            mcp_call (MCPCall | list[MCPCall]): The MCP call or a list of MCP calls to add.
+        """

gllm_inference/schema/mcp.pyi

@@ -0,0 +1,31 @@
+from pydantic import BaseModel
+from typing import Any
+
+class MCPServer(BaseModel):
+    """Defines an MCP server.
+
+    Attributes:
+        url (str): The URL of the MCP server.
+        name (str): The name of the MCP server.
+        allowed_tools (list[str] | None): The allowed tools of the MCP server.
+            Defaults to None, in which case all tools are allowed.
+    """
+    url: str
+    name: str
+    allowed_tools: list[str] | None
+
+class MCPCall(BaseModel):
+    """Defines an MCP call.
+
+    Attributes:
+        id (str): The ID of the MCP call. Defaults to an empty string.
+        server_name (str): The name of the MCP server. Defaults to an empty string.
+        tool_name (str): The name of the tool. Defaults to an empty string.
+        args (dict[str, Any]): The arguments of the tool. Defaults to an empty dictionary.
+        output (str | None): The output of the tool. Defaults to None.
+    """
+    id: str
+    server_name: str
+    tool_name: str
+    args: dict[str, Any]
+    output: str | None

gllm_inference/schema/message.pyi

@@ -0,0 +1,52 @@
+from gllm_inference.schema.enums import MessageRole as MessageRole
+from gllm_inference.schema.type_alias import MessageContent as MessageContent
+from pydantic import BaseModel
+from typing import Any
+
+class Message(BaseModel):
+    """Defines a message schema to be used as inputs for a language model.
+
+    Attributes:
+        role (MessageRole): The role of the message.
+        contents (list[MessageContent]): The contents of the message.
+        metadata (dict[str, Any]): The metadata of the message.
+    """
+    role: MessageRole
+    contents: list[MessageContent]
+    metadata: dict[str, Any]
+    @classmethod
+    def system(cls, contents: MessageContent | list[MessageContent], metadata: dict[str, Any] | None = None) -> Message:
+        """Create a system message.
+
+        Args:
+            contents (MessageContent | list[MessageContent]): The message contents.
+                If a single content is provided, it will be wrapped in a list.
+            metadata (dict[str, Any], optional): Additional metadata for the message. Defaults to None.
+
+        Returns:
+            Message: A new message with SYSTEM role.
+        """
+    @classmethod
+    def user(cls, contents: MessageContent | list[MessageContent], metadata: dict[str, Any] | None = None) -> Message:
+        """Create a user message.
+
+        Args:
+            contents (MessageContent | list[MessageContent]): The message contents.
+                If a single content is provided, it will be wrapped in a list.
+            metadata (dict[str, Any], optional): Additional metadata for the message. Defaults to None.
+
+        Returns:
+            Message: A new message with USER role.
+        """
+    @classmethod
+    def assistant(cls, contents: MessageContent | list[MessageContent], metadata: dict[str, Any] | None = None) -> Message:
+        """Create an assistant message.
+
+        Args:
+            contents (MessageContent | list[MessageContent]): The message contents.
+                If a single content is provided, it will be wrapped in a list.
+            metadata (dict[str, Any], optional): Additional metadata for the message. Defaults to None.
+
+        Returns:
+            Message: A new message with ASSISTANT role.
+        """

gllm_inference/schema/model_id.pyi

@@ -0,0 +1,176 @@
+from _typeshed import Incomplete
+from enum import StrEnum
+from gllm_inference.utils import validate_string_enum as validate_string_enum
+from pydantic import BaseModel
+
+PROVIDER_SEPARATOR: str
+PATH_SEPARATOR: str
+URL_NAME_REGEX_PATTERN: str
+
+class ModelProvider(StrEnum):
+    """Defines the supported model providers."""
+    ANTHROPIC = 'anthropic'
+    AZURE_OPENAI = 'azure-openai'
+    BEDROCK = 'bedrock'
+    COHERE = 'cohere'
+    DATASAUR = 'datasaur'
+    GOOGLE = 'google'
+    JINA = 'jina'
+    LANGCHAIN = 'langchain'
+    LITELLM = 'litellm'
+    OPENAI = 'openai'
+    PORTKEY = 'portkey'
+    OPENAI_CHAT_COMPLETIONS = 'openai-chat-completions'
+    OPENAI_COMPATIBLE = 'openai-compatible'
+    TWELVELABS = 'twelvelabs'
+    VOYAGE = 'voyage'
+    XAI = 'xai'
+
+PROVIDERS_OPTIONAL_PATH: Incomplete
+PROVIDERS_SUPPORT_PATH: Incomplete
+
+class ModelId(BaseModel):
+    '''Defines a representation of a valid model id.
+
+    Attributes:
+        provider (ModelProvider): The provider of the model.
+        name (str | None): The name of the model.
+        path (str | None): The path of the model.
+
+    Provider-specific examples:
+        # Using Anthropic
+        ```python
+        model_id = ModelId.from_string("anthropic/claude-sonnet-4-20250514")
+        ```
+
+        # Using Bedrock
+        ```python
+        model_id = ModelId.from_string("bedrock/us.anthropic.claude-sonnet-4-20250514-v1:0")
+        ```
+
+        # Using Cohere
+        ```python
+        model_id = ModelId.from_string("cohere/embed-english-v3.0")
+        ```
+
+        # Using Cohere with custom endpoint
+        ```python
+        model_id = ModelId.from_string("cohere/https://my-cohere-url:8000/v1:my-model-name")
+        ```
+
+        # Using Datasaur
+        ```python
+        model_id = ModelId.from_string("datasaur/https://deployment.datasaur.ai/api/deployment/teamId/deploymentId/")
+        ```
+
+        # Using Google
+        ```python
+        model_id = ModelId.from_string("google/gemini-2.5-flash-lite")
+        ```
+
+        # Using Jina
+        ```python
+        model_id = ModelId.from_string("jina/jina-embeddings-v2-large")
+        ```
+
+        # Using Jina with custom endpoint
+        ```python
+        model_id = ModelId.from_string("jina/https://my-jina-url:8000/v1:my-model-name")
+        ```
+
+        # Using OpenAI
+        ```python
+        model_id = ModelId.from_string("openai/gpt-5-nano")
+        ```
+
+        # Using OpenAI with Chat Completions API
+        ```python
+        model_id = ModelId.from_string("openai-chat-completions/gpt-5-nano")
+        ```
+
+        # Using OpenAI Responses API-compatible endpoints (e.g. SGLang)
+        ```python
+        model_id = ModelId.from_string("openai/https://my-sglang-url:8000/v1:my-model-name")
+        ```
+
+        # Using OpenAI Chat Completions API-compatible endpoints (e.g. Groq)
+        ```python
+        model_id = ModelId.from_string("openai-chat-completions/https://api.groq.com/openai/v1:llama3-8b-8192")
+        ```
+
+        # Using Azure OpenAI
+        ```python
+        model_id = ModelId.from_string("azure-openai/https://my-resource.openai.azure.com/openai/v1:my-deployment")
+        ```
+
+        # Using Voyage
+        ```python
+        model_id = ModelId.from_string("voyage/voyage-3.5-lite")
+        ```
+
+        # Using TwelveLabs
+        ```python
+        model_id = ModelId.from_string("twelvelabs/Marengo-retrieval-2.7")
+        ```
+
+        # Using LangChain
+        ```python
+        model_id = ModelId.from_string("langchain/langchain_openai.ChatOpenAI:gpt-4o-mini")
+        ```
+
+        For the list of supported providers, please refer to the following table:
+        https://python.langchain.com/docs/integrations/chat/#featured-providers
+
+        # Using LiteLLM
+        ```python
+        model_id = ModelId.from_string("litellm/openai/gpt-4o-mini")
+        ```
+        For the list of supported providers, please refer to the following page:
+        https://docs.litellm.ai/docs/providers/
+
+        # Using xAI
+        ```python
+        model_id = ModelId.from_string("xai/grok-4-0709")
+        ```
+        For the list of supported models, please refer to the following page:
+        https://docs.x.ai/docs/models
+
+    Custom model name validation example:
+        ```python
+        validation_map = {
+            ModelProvider.ANTHROPIC: {"claude-sonnet-4-20250514"},
+            ModelProvider.GOOGLE: {"gemini-2.5-flash-lite"},
+            ModelProvider.OPENAI: {"gpt-4.1-nano", "gpt-5-nano"},
+        }
+
+        model_id = ModelId.from_string("...", validation_map)
+        ```
+    '''
+    provider: ModelProvider
+    name: str | None
+    path: str | None
+    @classmethod
+    def from_string(cls, model_id: str, validation_map: dict[str, set[str]] | None = None) -> ModelId:
+        """Parse a model id string into a ModelId object.
+
+        Args:
+            model_id (str): The model id to parse. Must be in the format defined in the following page:
+                https://gdplabs.gitbook.io/sdk/resources/supported-models
+            validation_map (dict[str, set[str]] | None, optional): An optional dictionary that maps provider names to
+                sets of valid model names. For the defined model providers, the model names will be validated against
+                the set of valid model names. For the undefined model providers, the model name will not be validated.
+                Defaults to None.
+
+        Returns:
+            ModelId: The parsed ModelId object.
+
+        Raises:
+            ValueError: If the provided model id is invalid or if the model name is not valid for the provider.
+        """
+    def to_string(self) -> str:
+        """Convert the ModelId object to a string.
+
+        Returns:
+            str: The string representation of the ModelId object. The format is defined in the following page:
+                https://gdplabs.gitbook.io/sdk/resources/supported-models
+        """

gllm_inference/schema/reasoning.pyi

@@ -0,0 +1,15 @@
+from pydantic import BaseModel
+
+class Reasoning(BaseModel):
+    """Defines a reasoning output when a language model is configured to use reasoning.
+
+    Attributes:
+        id (str): The ID of the reasoning output. Defaults to an empty string.
+        reasoning (str): The reasoning text. Defaults to an empty string.
+        type (str): The type of the reasoning output. Defaults to an empty string.
+        data (str): The additional data of the reasoning output. Defaults to an empty string.
+    """
+    id: str
+    reasoning: str
+    type: str
+    data: str