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

gllm_inference/schema/lm_output.pyi

@@ -0,0 +1,266 @@
+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]
+    def __init__(self, *, outputs: list[LMOutputItem] | None = None, token_usage: TokenUsage | None = None, duration: float | None = None, finish_details: dict[str, Any] | None = None, response: str = '', structured_output: dict[str, Any] | BaseModel | None = None, tool_calls: list[ToolCall] | None = None, reasoning: list[Reasoning] | None = None, attachments: list[Attachment] | None = None, citations: list[Chunk] | None = None, code_exec_results: list[CodeExecResult] | None = None, mcp_calls: list[MCPCall] | None = None) -> None:
+        """Initialize the LMOutput.
+
+        This constructor is created for backward compatibility with the legacy method to initialize the LMOutput.
+        This constructor will be removed in v0.6.
+
+        Args:
+            outputs (list[LMOutputItem] | None, optional): The output items. Defaults to an empty list.
+            token_usage (TokenUsage | None, optional): The token usage analytics. Defaults to None.
+            duration (float | None, optional): The duration of the invocation in seconds. Defaults to None.
+            finish_details (dict[str, Any] | None, optional): The details about how the generation finished.
+                Defaults to an empty dictionary.
+            response (str, optional): The first text response. Defaults to an empty string.
+            structured_output (dict[str, Any] | BaseModel | None, optional): The first structured output.
+                Defaults to None.
+            tool_calls (list[ToolCall] | None, optional): The tool calls. Defaults to None.
+            reasoning (list[Reasoning] | None, optional): The thinkings. Defaults to None.
+            attachments (list[Attachment] | None, optional): The attachments. Defaults to None.
+            citations (list[Chunk] | None, optional): The citations. Defaults to None.
+            code_exec_results (list[CodeExecResult] | None, optional): The code exec results. Defaults to None.
+            mcp_calls (list[MCPCall] | None, optional): The MCP calls. Defaults to None.
+        """
+    @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.
+        """
+    @response.setter
+    def response(self, value: str) -> None:
+        """Deprecated setter to set the first text response to the LMOutput.
+
+        Args:
+            value (str): The first text response to set.
+        """
+    @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.
+        """
+    @structured_output.setter
+    def structured_output(self, value: dict[str, Any] | BaseModel) -> None:
+        """Deprecated setter to set the first structured output to the LMOutput.
+
+        Args:
+            value (dict[str, Any] | BaseModel): The first structured output to set.
+        """
+    @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.
+        """
+    @attachments.setter
+    def attachments(self, value: list[Attachment]) -> None:
+        """Deprecated setter to set the attachments to the LMOutput.
+
+        Args:
+            value (list[Attachment]): The attachments to set.
+        """
+    @property
+    def tool_calls(self) -> list[ToolCall]:
+        """Get the tool calls from the LMOutput.
+
+        Returns:
+            list[ToolCall]: The tool calls from the LMOutput.
+        """
+    @tool_calls.setter
+    def tool_calls(self, value: list[ToolCall]) -> None:
+        """Deprecated setter to set the tool calls to the LMOutput.
+
+        Args:
+            value (list[ToolCall]): The tool calls to set.
+        """
+    @property
+    def reasoning(self) -> list[Reasoning]:
+        """Deprecated property to get the thinkings from the LMOutput.
+
+        Returns:
+            list[Reasoning]: The thinkings from the LMOutput.
+        """
+    @reasoning.setter
+    def reasoning(self, value: list[Reasoning]) -> None:
+        """Deprecated setter to set the thinkings to the LMOutput.
+
+        Args:
+            value (list[Reasoning]): The thinkings to set.
+        """
+    @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.
+        """
+    @citations.setter
+    def citations(self, value: list[Chunk]) -> None:
+        """Deprecated setter to set the citations to the LMOutput.
+
+        Args:
+            value (list[Chunk]): The citations to set.
+        """
+    @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.
+        """
+    @code_exec_results.setter
+    def code_exec_results(self, value: list[CodeExecResult]) -> None:
+        """Deprecated setter to set the code exec results to the LMOutput.
+
+        Args:
+            value (list[CodeExecResult]): The code exec results to set.
+        """
+    @property
+    def mcp_calls(self) -> list[MCPCall]:
+        """Get the MCP calls from the LMOutput.
+
+        Returns:
+            list[MCPCall]: The MCP calls from the LMOutput.
+        """
+    @mcp_calls.setter
+    def mcp_calls(self, value: list[MCPCall]) -> None:
+        """Deprecated setter to set the MCP calls to the LMOutput.
+
+        Args:
+            value (list[MCPCall]): The MCP calls to set.
+        """
+    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 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'
+    SEA_LION = 'sea-lion'
+    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

gllm_inference/schema/token_usage.pyi

@@ -0,0 +1,75 @@
+from pydantic import BaseModel
+
+class InputTokenDetails(BaseModel):
+    """Defines the input token details schema.
+
+    Attributes:
+        cached_tokens (int): The number of cached tokens. Defaults to 0.
+        uncached_tokens (int): The number of uncached tokens. Defaults to 0.
+    """
+    cached_tokens: int
+    uncached_tokens: int
+    def __add__(self, other: InputTokenDetails) -> InputTokenDetails:
+        """Add two InputTokenDetails objects together.
+
+        Args:
+            other (InputTokenDetails): The other InputTokenDetails object to add.
+
+        Returns:
+            InputTokenDetails: A new InputTokenDetails object with summed values.
+        """
+
+class OutputTokenDetails(BaseModel):
+    """Defines the output token details schema.
+
+    Attributes:
+        reasoning_tokens (int): The number of reasoning tokens. Defaults to 0.
+        response_tokens (int): The number of response tokens. Defaults to 0.
+    """
+    reasoning_tokens: int
+    response_tokens: int
+    def __add__(self, other: OutputTokenDetails) -> OutputTokenDetails:
+        """Add two OutputTokenDetails objects together.
+
+        Args:
+            other (OutputTokenDetails): The other OutputTokenDetails object to add.
+
+        Returns:
+            OutputTokenDetails: A new OutputTokenDetails object with summed values.
+        """
+
+class TokenUsage(BaseModel):
+    """Defines the token usage data structure of a language model.
+
+    Attributes:
+        input_tokens (int): The number of input tokens. Defaults to 0.
+        output_tokens (int): The number of output tokens. Defaults to 0.
+        input_token_details (InputTokenDetails | None): The details of the input tokens. Defaults to None.
+        output_token_details (OutputTokenDetails | None): The details of the output tokens. Defaults to None.
+    """
+    input_tokens: int
+    output_tokens: int
+    input_token_details: InputTokenDetails | None
+    output_token_details: OutputTokenDetails | None
+    @classmethod
+    def from_token_details(cls, input_tokens: int | None = None, output_tokens: int | None = None, cached_tokens: int | None = None, reasoning_tokens: int | None = None) -> TokenUsage:
+        """Creates a TokenUsage from token details.
+
+        Args:
+            input_tokens (int | None): The number of input tokens. Defaults to None.
+            output_tokens (int | None): The number of output tokens. Defaults to None.
+            cached_tokens (int | None): The number of cached tokens. Defaults to None.
+            reasoning_tokens (int | None): The number of reasoning tokens. Defaults to None.
+
+        Returns:
+            TokenUsage: The instantiated TokenUsage.
+        """
+    def __add__(self, other: TokenUsage) -> TokenUsage:
+        """Add two TokenUsage objects together.
+
+        Args:
+            other (TokenUsage): The other TokenUsage object to add.
+
+        Returns:
+            TokenUsage: A new TokenUsage object with summed values.
+        """

gllm_inference/schema/tool_call.pyi

@@ -0,0 +1,14 @@
+from pydantic import BaseModel
+from typing import Any
+
+class ToolCall(BaseModel):
+    """Defines a tool call request when a language model decides to invoke a tool.
+
+    Attributes:
+        id (str): The ID of the tool call.
+        name (str): The name of the tool.
+        args (dict[str, Any]): The arguments of the tool call.
+    """
+    id: str
+    name: str
+    args: dict[str, Any]

gllm_inference/schema/tool_result.pyi

@@ -0,0 +1,11 @@
+from pydantic import BaseModel
+
+class ToolResult(BaseModel):
+    """Defines a tool result to be sent back to the language model.
+
+    Attributes:
+        id (str): The ID of the tool call.
+        output (str): The output of the tool call.
+    """
+    id: str
+    output: str

gllm_inference/schema/type_alias.pyi

@@ -0,0 +1,11 @@
+from gllm_inference.schema.attachment import Attachment as Attachment
+from gllm_inference.schema.reasoning import Reasoning as Reasoning
+from gllm_inference.schema.tool_call import ToolCall as ToolCall
+from gllm_inference.schema.tool_result import ToolResult as ToolResult
+from pydantic import BaseModel
+from typing import Any
+
+ResponseSchema = dict[str, Any] | type[BaseModel]
+MessageContent = str | Attachment | ToolCall | ToolResult | Reasoning
+EMContent = str | Attachment | tuple[str | Attachment, ...]
+Vector = list[float]

gllm_inference/utils/__init__.pyi

@@ -0,0 +1,5 @@
+from gllm_inference.utils.io_utils import base64_to_bytes as base64_to_bytes
+from gllm_inference.utils.langchain import load_langchain_model as load_langchain_model, parse_model_data as parse_model_data
+from gllm_inference.utils.validation import validate_string_enum as validate_string_enum
+
+__all__ = ['base64_to_bytes', 'load_langchain_model', 'parse_model_data', 'validate_string_enum']